Lección 25 de 31 · Varios ficheros y salida✦ WebMCP implementado
getline, > y tuberías
10 min de lectura3 retos
Hasta ahora todo lo que imprimías salía por la pantalla. En esta lección awk escribe en ficheros (print > "fichero"), los cierra con close() y los vuelve a leer con getline. Al final ves, solo para leer, cómo awk habla con otros programas de tu servidor y por qué ahí hay que ir con mucho cuidado.
¿De dónde vienen los nombres?
> y >> = los símbolos de redirección de la terminal
awk los copió de la shell de Unix: una flecha que dice «esto va hacia allí». > empieza el fichero de cero y >> añade al final. Son los modos "w" y "a" del fopen() de PHP.
close() = inglés close (cerrar)
Cierra un fichero que awk abrió para escribir o para leer. Es tu fclose().
getline = inglés get line (trae una línea)
Lee una línea cuando tú se lo pides, sin esperar al bucle de awk. Es tu fgets().
tubería = inglés pipe (tubo), el símbolo |
Un tubo que conecta la salida de un programa con la entrada de otro. En PHP lo más parecido es popen().
system() = inglés system (el sistema operativo)
Le pide al sistema que ejecute un comando, igual que si lo escribieras en la terminal. Es el system() o el exec() de PHP.
En 4 ideas
1/4
print … > "fichero" escribe en un fichero en vez de en la pantalla. Es tu fwrite(), pero sin fopen(): awk abre el fichero solo la primera vez.
El fichero se vacía una vez, al abrirlo; los print siguientes van añadiendo. >> no lo vacía nunca: es el modo "a" de fopen().
close("fichero") es tu fclose(). Hasta que no cierras, lo escrito puede no estar en el disco y no se puede volver a leer.
getline linea < "fichero" es tu fgets(): devuelve 1 si leyó una línea, 0 si se acabó y -1 si no pudo abrir el fichero.
1 · print a un fichero
Un log mezcla de todo: visitas normales, páginas que no existen, intentos de entrar sin permiso. Muchas veces lo que quieres es repartirlo: los 404 a un fichero, los 401 a otro. Es como separar la ropa antes de poner la lavadora.
En awk basta con añadir al print una flecha y un nombre de fichero entre comillas. A la izquierda, lo mismo en PHP:
PHP 8.5repartir.php
<?php// "w": crea el fichero, o lo vacía si ya existe$salida = fopen("no-encontradas.log", "w");
$guardadas = 0;
foreach (file("access.log", FILE_IGNORE_NEW_LINES) as$linea) {
$campos = preg_split('/\s+/', trim($linea));
if ($campos[8] === "404") {
fwrite($salida, "{$campos[0]} {$campos[6]}\n");
$guardadas++;
}
}
fclose($salida);
echo"{$guardadas} líneas guardadas en no-encontradas.log", PHP_EOL;
awkprograma.awk
# En PHP: fwrite($salida, "$ip $url\n"); $guardadas++;$9 == 404 { print$1, $7 > "no-encontradas.log"; guardadas++ }
# En PHP: echo "$guardadas líneas guardadas en no-encontradas.log", PHP_EOL;END { print guardadas " líneas guardadas en no-encontradas.log" }
$ awk -f programa.awk access.log
¿Qué significa esta línea?
awk: el programa que lee el fichero. En tu servidor puede ser gawk (el de este curso) o mawk (el de Debian y Ubuntu).
-f programa.awk: f de file (fichero). El programa no va escrito en la línea, está guardado en el fichero programa.awk: es lo que ves en la pestaña del mismo nombre. Sin -f, el programa se escribe entre comillas simples: awk '{ print $1 }' access.log.
access.log: los datos, el fichero que awk lee línea a línea. Va siempre al final y puede haber varios: los lee uno detrás de otro.
Las variantes (una línea, varios ficheros, tuberías con |) y qué formatos puede leer awk: lección Una línea o un fichero.
⏱ Medido en el servidor del curso con access.log multiplicado hasta 1.000.000 líneas: PHP 8.5: 1,40 s · gawk: 620 ms · mawk: 569 ms. awk tarda 2,5 veces menos que PHP.
En la pantalla solo ha salido la línea del END. Las tres líneas de los 404 no están: se han ido al fichero no-encontradas.log. Todo lo que hay entre print y > es lo que se escribe; lo de después de > es el destino.
¿Por qué? · En PHP no existe
¿Por qué > si en awk eso ya significa «mayor que»?
Porque awk nació en la terminal de Unix, y allí > es la flecha de «manda la salida a este fichero»: ls > lista.txt. Sus autores quisieron que se escribiera igual para que no hubiera nada nuevo que aprender.
El precio es una confusión que en PHP no existe. Detrás de un print, > es siempre la flecha. print $9 > 400 no imprime si el estado es mayor que 400: crea un fichero que se llama 400 y escribe dentro el estado.
Si de verdad quieres imprimir el resultado de una comparación, enciérrala entre paréntesis: print ($9 > 400). En PHP no pasa porque para escribir en un fichero llamas a una función, fwrite(), y no hay símbolo que confundir.
2 · close() y volver a leer con getline
Para comprobar qué hay en el fichero lo vamos a leer desde el mismo programa, al final. Hacen falta dos piezas nuevas:
close("no-encontradas.log")cierra el fichero. Es tu fclose().
getline linea < "no-encontradas.log"lee una línea del fichero y la guarda en la variable linea. Es tu fgets(). La flecha ahora mira hacia el otro lado: los datos salen del fichero.
PHP 8.5repartir-y-leer.php
<?php$salida = fopen("no-encontradas.log", "w");
foreach (file("access.log", FILE_IGNORE_NEW_LINES) as$linea) {
$campos = preg_split('/\s+/', trim($linea));
if ($campos[8] === "404") {
fwrite($salida, "{$campos[0]} {$campos[6]}\n");
}
}
// cerrar: lo escrito baja al discofclose($salida);
// abrirlo otra vez, ahora para leer$entrada = fopen("no-encontradas.log", "r");
while (($linea = fgets($entrada)) !== false) {
echo"leída: ", $linea;
}
fclose($entrada);
awkprograma.awk
$9 == 404 { print$1, $7 > "no-encontradas.log" }
END {
# En PHP: fclose($salida);close("no-encontradas.log")
# En PHP: while (($linea = fgets($entrada)) !== false) { echo "leída: ", $linea; }while ((getline linea < "no-encontradas.log") == 1) {
print"leída: " linea
}
}
$ awk -f programa.awk access.log
¿Qué significa esta línea?
awk: el programa que lee el fichero. En tu servidor puede ser gawk (el de este curso) o mawk (el de Debian y Ubuntu).
-f programa.awk: f de file (fichero). El programa no va escrito en la línea, está guardado en el fichero programa.awk: es lo que ves en la pestaña del mismo nombre. Sin -f, el programa se escribe entre comillas simples: awk '{ print $1 }' access.log.
access.log: los datos, el fichero que awk lee línea a línea. Va siempre al final y puede haber varios: los lee uno detrás de otro.
Las variantes (una línea, varios ficheros, tuberías con |) y qué formatos puede leer awk: lección Una línea o un fichero.
⏱ Medido en el servidor del curso con access.log multiplicado hasta 1.000.000 líneas: PHP 8.5: 1,50 s · gawk: 669 ms · mawk: 570 ms. awk tarda 2,6 veces menos que PHP.
getline devuelve un número, y el while lo usa para saber cuándo parar:
getline devuelve
Significa
fgets() en PHP
1
He leído una línea
Devuelve la línea
0
No quedan más líneas
Devuelve false
-1
No he podido abrir el fichero (no existe, no hay permiso)
fopen() ya habría devuelto false con un aviso
¿Y si se te olvida el close()? Este es el mismo programa sin él. Cuenta las líneas que consigue leer:
awk: el programa que lee el fichero. En tu servidor puede ser gawk (el de este curso) o mawk (el de Debian y Ubuntu).
-f programa.awk: f de file (fichero). El programa no va escrito en la línea, está guardado en el fichero programa.awk: es lo que ves en la pestaña del mismo nombre. Sin -f, el programa se escribe entre comillas simples: awk '{ print $1 }' access.log.
access.log: los datos, el fichero que awk lee línea a línea. Va siempre al final y puede haber varios: los lee uno detrás de otro.
Las variantes (una línea, varios ficheros, tuberías con |) y qué formatos puede leer awk: lección Una línea o un fichero.
Cero. No hay ningún error en pantalla y el fichero «tiene» tres líneas, pero awk todavía no las había escrito de verdad.
¿Por qué? · En PHP no existe
¿Por qué hay que cerrar el fichero antes de leerlo?
Porque escribir en el disco es lento, y awk hace trampa para ir rápido: va apuntando las líneas en una libreta que tiene en la memoria (el buffer) y solo las pasa al disco cuando la libreta se llena o cuando cierras el fichero.
Si lees antes de cerrar, lees el disco, y en el disco aún no hay nada. close() hace dos cosas: vuelca la libreta y deja el fichero listo para abrirlo otra vez desde el principio.
PHP hace la misma trampa con fwrite(), y por eso también tiene fclose() y fflush(). La diferencia es que en PHP el fopen() lo escribes tú y el fclose() te sale solo. En awk, como nunca abres nada, cerrar se olvida.
3 · > frente a >>, y un fichero por estado
Si vienes de la terminal, hay una diferencia que sorprende. En la terminal, cada echo hola > ficherovacía el fichero. En awk, > lo vacía solo la primera vez, al abrirlo. Los demás print del programa van añadiendo, aunque estén en otra regla:
awkprograma.awk
# En PHP: los dos fwrite() usan el mismo $salida, abierto una sola vez con "w"$9 == 404 { print"404", $1, $7 > "sospechosas.log" }
$9 == 401 { print"401", $1, $7 > "sospechosas.log" }
END {
close("sospechosas.log")
while ((getline linea < "sospechosas.log") == 1) {
print linea
}
}
$ awk -f programa.awk access.log
¿Qué significa esta línea?
awk: el programa que lee el fichero. En tu servidor puede ser gawk (el de este curso) o mawk (el de Debian y Ubuntu).
-f programa.awk: f de file (fichero). El programa no va escrito en la línea, está guardado en el fichero programa.awk: es lo que ves en la pestaña del mismo nombre. Sin -f, el programa se escribe entre comillas simples: awk '{ print $1 }' access.log.
access.log: los datos, el fichero que awk lee línea a línea. Va siempre al final y puede haber varios: los lee uno detrás de otro.
Las variantes (una línea, varios ficheros, tuberías con |) y qué formatos puede leer awk: lección Una línea o un fichero.
Están las seis líneas, en el orden del log. La segunda regla no ha borrado lo que escribió la primera: las dos usan el mismo fichero, que ya estaba abierto.
awk
fopen() en PHP
Si el fichero ya existía de antes
print … > "f"
fopen("f", "w"), una vez
Se vacía al abrirlo y se empieza de cero
print … >> "f"
fopen("f", "a"), una vez
Se conserva y se añade al final
>> es lo que quieres para un fichero que crece día a día: cada vez que lanzas el programa, añade. Con > cada ejecución borra lo de la anterior. En el navegador no notarás la diferencia, porque el disco de mentira empieza vacío en cada ejecución.
El nombre del fichero no tiene por qué ser fijo: puede ser un texto que montas con los datos de la línea. Así se reparte el log en un fichero por estado con una sola regla:
wc -l es un comando de la terminal que cuenta líneas (word count, lines). Han salido siete ficheros y entre todos suman las 20 líneas del log.
4 · Las formas de getline
getline tiene varias formas, y cada una toca cosas distintas. Por eso tiene fama de liosa. Esta es la chuleta:
Forma
De dónde lee
Dónde deja la línea
Además cambia
getline linea < "fichero"
De ese fichero
En la variable linea
Nada
getline < "fichero"
De ese fichero
En $0, y la trocea en $1, $2…
NF
getline linea
Del fichero que awk está recorriendo
En la variable linea
NR y FNR
getline
Del fichero que awk está recorriendo
En $0, troceada
NF, NR y FNR
La primera es la más segura: no toca nada más que tu variable. La segunda es cómoda cuando quieres los campos ya partidos, pero pisa $0: la línea que tenías se pierde. En END da igual, porque ya no queda ninguna línea por tratar:
awkprograma.awk
$9 == 401 { print$1, $7 > "sin-permiso.log" }
END {
close("sin-permiso.log")
# sin variable: la linea leida cae en $0 y awk la trocea como siemprewhile ((getline < "sin-permiso.log") == 1) {
print"ip="$1, "url="$2, "campos="NF
}
}
$ awk -f programa.awk access.log
¿Qué significa esta línea?
awk: el programa que lee el fichero. En tu servidor puede ser gawk (el de este curso) o mawk (el de Debian y Ubuntu).
-f programa.awk: f de file (fichero). El programa no va escrito en la línea, está guardado en el fichero programa.awk: es lo que ves en la pestaña del mismo nombre. Sin -f, el programa se escribe entre comillas simples: awk '{ print $1 }' access.log.
access.log: los datos, el fichero que awk lee línea a línea. Va siempre al final y puede haber varios: los lee uno detrás de otro.
Las variantes (una línea, varios ficheros, tuberías con |) y qué formatos puede leer awk: lección Una línea o un fichero.
Las dos últimas formas, sin < "fichero", le quitan una línea al bucle de awk: leen la siguiente línea del log antes de que le toque. Sirven para cosas como «cuando veas un 500, tráeme también la línea de después», pero se saltan esa línea para el resto de reglas. Úsalas poco.
5 · Tuberías y system(): hablar con otros programas
En tu servidor awk no está solo: tiene al lado sort (ordena líneas), date (da la fecha) y cientos de programas más. Puede usarlos de tres formas. Ninguna funciona en el navegador, porque aquí no hay otros programas, así que las ves con la salida que dan en una terminal de verdad.
1. Mandar la salida a un programa, con una tubería después del print. En vez de un nombre de fichero, entre comillas va un comando. Es la forma clásica de ordenar que viste en el módulo 05:
awkprograma.awkSolo lectura: necesita la terminal
{ visitas[$1]++ }
END {
for (ip in visitas) {
# En PHP: arsort($visitas); aqui lo ordena el programa sortprint visitas[ip], ip | "sort -rn"
}
}
¿Por qué hay que tener tanto cuidado con system()?
Porque el comando es un texto, y si pegas en ese texto algo que viene del log, lo escribe quien visita tu web. La URL, el navegador y el referer los elige el visitante. Mira este programa, que parece inofensivo:
awkprograma.awkSolo lectura: necesita la terminal
# En PHP: system("echo Visita a " . $url);
{ system("echo Visita a "$7) }
Ahora alguien pide a propósito la página /a;uname. En la terminal, el punto y coma separa dos comandos. Y uname es un comando que dice el nombre del sistema:
$ awk '{ system("echo Visita a " $7) }' trampa.log
Visita a /a
Linux
Tu servidor ha ejecutado un comando que eligió el visitante. Aquí fue uname; podría haber sido uno que borra ficheros o que le manda tus contraseñas. Se llama inyección de comandos y es el primo de la inyección SQL: en los dos casos, un dato acaba convertido en código.
En PHP tienes escapeshellarg() para envolver el dato. awk no tiene nada parecido. La regla es simple: nunca metas un campo del log dentro del texto de un comando. Si otro programa necesita esos datos, mándaselos por la tubería (print $7 | "sort"): por ahí viajan como datos y nadie los ejecuta.
La pregunta que te vas a hacer
¿Y en mi servidor? ¿Dónde aparecen los ficheros y quién puede escribirlos?
Un nombre sin carpeta, como "no-encontradas.log", se crea en la carpeta desde la que lanzas awk, no en la del programa ni en la del log. Si quieres otro sitio, escribe la ruta entera: print > "/home/tu-usuario/informes/no-encontradas.log".
awk escribe con los permisos del usuario que lo lanza, igual que un script de PHP por consola. Si ese usuario no puede escribir en la carpeta, verás un error del estilo cannot redirect to… y el programa se para.
> vacía el fichero sin preguntar. Nunca escribas en el mismo fichero que estás leyendo (print > FILENAME): te quedas sin log.
Para sacar un aviso por la salida de errores, como el error_log() de PHP, existe un nombre especial: print "línea rara" > "/dev/stderr".
Si el script lo va a lanzar cron (el programador de tareas de Linux), usa siempre rutas enteras: cron arranca en otra carpeta.
Manual de GNU awk: busca «Redirecting Output» y «Explicit Input with getline».
El programa guarda en no-encontradas.log las visitas con estado 404 y al final las vuelve a leer, con guardada: delante. Pero guarda la línea entera del log, navegador incluido. Cámbialo para que en el fichero solo entren la IP y la página (campos 1 y 7), separadas por un espacio. Debe salir, por ejemplo, guardada: 198.51.100.4 /wp-login.php. En PHP: cambiar el fwrite($salida, $linea) por un fwrite($salida, "$ip $url\n").
Al pulsar Comprobar, tu programa se ejecuta en tu navegador con el fichero que ves y con otro distinto que no ves: tiene que acertar con los dos.
awkprograma.awk · editable
$ awk -f programa.awk access.log
¿Qué significa esta línea?
awk: el programa que lee el fichero. En tu servidor puede ser gawk (el de este curso) o mawk (el de Debian y Ubuntu).
-f programa.awk: f de file (fichero). El programa no va escrito en la línea, está guardado en el fichero programa.awk: es lo que ves en la pestaña del mismo nombre. Sin -f, el programa se escribe entre comillas simples: awk '{ print $1 }' access.log.
access.log: los datos, el fichero que awk lee línea a línea. Va siempre al final y puede haber varios: los lee uno detrás de otro.
Las variantes (una línea, varios ficheros, tuberías con |) y qué formatos puede leer awk: lección Una línea o un fichero.
Pista. Lo que va entre print y > es lo que se escribe en el fichero. Ahora no hay nada, y print a secas escribe la línea entera. Pon ahí los dos campos, con una coma entre ellos.
Reto 2 de 3 · ✓ Resuelto
Dos ficheros, dos lecturas
Hay que repartir el log en dos ficheros: los 404 en no-encontradas.log y los 401 en sin-permiso.log, con la IP y la página en cada línea. El programa solo escribe el primero, y en el END solo imprime los dos títulos. Complétalo: añade la regla de los 401 y haz que debajo de cada título salgan las líneas de su fichero, tal cual. Debajo de == no-encontradas.log == va 198.51.100.4 /wp-login.php y las demás, y debajo de == sin-permiso.log == va 198.51.100.4 /login y las suyas. En PHP: dos fopen(), dos fclose() y dos bucles while (($linea = fgets($f)) !== false).
Al pulsar Comprobar, tu programa se ejecuta en tu navegador con el fichero que ves y con otro distinto que no ves: tiene que acertar con los dos.
awkprograma.awk · editable
$ awk -f programa.awk access.log
¿Qué significa esta línea?
awk: el programa que lee el fichero. En tu servidor puede ser gawk (el de este curso) o mawk (el de Debian y Ubuntu).
-f programa.awk: f de file (fichero). El programa no va escrito en la línea, está guardado en el fichero programa.awk: es lo que ves en la pestaña del mismo nombre. Sin -f, el programa se escribe entre comillas simples: awk '{ print $1 }' access.log.
access.log: los datos, el fichero que awk lee línea a línea. Va siempre al final y puede haber varios: los lee uno detrás de otro.
Las variantes (una línea, varios ficheros, tuberías con |) y qué formatos puede leer awk: lección Una línea o un fichero.
Pista. Copia la primera regla y cambia el estado y el nombre del fichero. En el END, primero cierra los dos ficheros con close(): sin eso no se puede leer lo escrito. Después, debajo de cada título, un while ((getline linea < "nombre") == 1) { print linea }.
Reto 3 de 3 · ✓ Resuelto
IP para revisar
La primera regla apunta en sospechosas.txt, una sola vez por IP, cada IP que recibe un error (estado 4xx o 5xx) junto al estado de ese primer error. El END lo lee y lo imprime tal cual. Cámbialo para que cada línea salga así: Revisar 198.51.100.4 (primer error: 403), y la última con el total: 2 IP sospechosas. Necesitas la IP y el estado por separado: la forma de getline sin variable te los deja en $1 y $2. En PHP: [$ip, $estado] = explode(" ", trim($linea));.
Al pulsar Comprobar, tu programa se ejecuta en tu navegador con el fichero que ves y con otro distinto que no ves: tiene que acertar con los dos.
awkprograma.awk · editable
$ awk -f programa.awk access.log
¿Qué significa esta línea?
awk: el programa que lee el fichero. En tu servidor puede ser gawk (el de este curso) o mawk (el de Debian y Ubuntu).
-f programa.awk: f de file (fichero). El programa no va escrito en la línea, está guardado en el fichero programa.awk: es lo que ves en la pestaña del mismo nombre. Sin -f, el programa se escribe entre comillas simples: awk '{ print $1 }' access.log.
access.log: los datos, el fichero que awk lee línea a línea. Va siempre al final y puede haber varios: los lee uno detrás de otro.
Las variantes (una línea, varios ficheros, tuberías con |) y qué formatos puede leer awk: lección Una línea o un fichero.
Pista. Quita la variable: getline < "sospechosas.txt" deja la línea leída en $0 y la trocea. Dentro del bucle, $1 es la IP y $2 el estado. Los paréntesis del texto van dentro de las comillas.
Resumen
Lo que te llevas de esta lección
print … > "fichero" escribe en el fichero y no en la pantalla. Es fwrite() sin fopen(). Detrás de un print, > nunca es «mayor que».
> vacía el fichero solo al abrirlo; los demás print añaden. >> conserva lo que hubiera de otras ejecuciones: modos "w" y "a" de fopen().
close("fichero") es fclose(): vuelca lo pendiente al disco. Sin cerrar no se puede volver a leer, y awk no avisa.
while ((getline linea < "fichero") == 1) es el while (($linea = fgets($f)) !== false) de PHP. Compara siempre el resultado: -1 también es «verdadero».
getline < "fichero" sin variable deja la línea en $0 y la trocea. Sin fichero, le quita una línea al bucle de awk.
Tuberías y system() son el popen() y el exec() de PHP. Nunca un campo del log dentro del texto de un comando: awk no tiene escapeshellarg().
Para recordarlo: «Escribe, Cierra, Lee»
EEscribe print … > "f"
CCierra close("f")
LLee getline linea < "f"
Siempre en ese orden, y el paso que se olvida es el de en medio. Para las flechas, míralas como lo que son: > apunta hacia el fichero (escribir) y <sale del fichero (leer).