El módulo de los archivos y las llamadas al sistema. Se reimplementan
utilidades de Unix (cat, tail, hexdump) usando solo
open, read, write y close. Se aprende qué es un
descriptor de fichero, cómo se gestionan los errores y los códigos de salida. 4 ejercicios
(ex00–ex03).
C 10 es la primera vez que tu programa habla directamente con el sistema operativo: abre
archivos, lee bytes y escribe errores. Las palabras vienen de Unix y de cómo se guardan los datos.
Aquí está cada una explicada desde cero y con un ejemplo sacado del propio módulo. En el resto de la
página, la primera vez que sale uno de estos términos en cada tarjeta lleva un enlace a su entrada.
Las salidas de ejemplo son las de los comandos del sistema (cat, tail,
hexdump) que los ejercicios tienen que imitar, ejecutados en Linux.
Un programa no puede tocar el disco ni la pantalla por su cuenta: se lo pide al núcleo
(kernel) del sistema operativo, que es quien controla el hardware y decide si tienes
permiso. Cada una de esas peticiones es una llamada al sistema. open,
read, write y close son envoltorios finos de las syscalls del
mismo nombre.
Frente a ellas, printf o fopen son funciones de la biblioteca de C que,
por debajo, acaban llamando a write o open. En C 10 solo están autorizadas
las de abajo, así que haces tú lo que la biblioteca hace por ti.
Un entero pequeño que identifica algo abierto por tu proceso. open lo devuelve y
read, write y close lo reciben: no trabajan con nombres de
archivo, sino con ese número. El núcleo da siempre el más bajo libre, así que el primer
open de un programa que no ha cerrado nada suele dar 3.
Cada proceso tiene un límite de descriptores abiertos a la vez (lo dice ulimit -n).
Un ft_cat con cientos de archivos que nunca hiciera close acabaría
recibiendo -1 de open aunque los archivos existan.
Tres descriptores que todo programa recibe ya abiertos: 0 es la entrada estándar
(stdin, normalmente el teclado), 1 la salida estándar (stdout, la
pantalla) y 2 la salida de error (stderr, también la pantalla). Se separan los
resultados de los avisos para que se puedan redirigir por separado.
En C 10: ft_display_file escribe el archivo por 1 y File name missing.
por 2; ft_cat sin argumentos lee del 0 hasta el fin de archivo (en el teclado,
Ctrl+D).
>, 2>, |)La shell puede cambiar a dónde apuntan los descriptores antes de arrancar el programa:
> f pone el 1 en el archivo f, 2> f hace lo mismo con
el 2, < f pone el 0 en f y a | b conecta el 1 de
a con el 0 de b. El programa no se entera: sigue escribiendo en «el 1».
Por eso importa escribir cada cosa por su descriptor. Con ./ft_cat a nofile > todo,
el contenido de a va al archivo y el error de nofile sale en pantalla; si
lo hubieras escrito por el 1, acabaría mezclado dentro de todo.
open y O_RDONLYopen(ruta, modo) abre un archivo y devuelve su descriptor, o -1 si no
puede (no existe, no hay permiso, es un directorio y pides escribir…). O_RDONLY es el
modo «solo lectura», una constante de <fcntl.h>. Comprobar el -1 es
obligatorio: un read sobre -1 no lee nada y falla.
Ese -1 es el que convierte ft_display_file en Cannot read
file., y en ft_cat el mensaje con strerror(errno).
read, fin de archivo y lecturas parcialesread(fd, buf, n) copia como mucho n bytes al buffer y devuelve cuántos
copió de verdad: 0 significa fin de archivo y -1, error. Cada llamada sigue
donde se quedó la anterior, porque el descriptor recuerda la posición.
Que devuelva menos de n es normal: la última lectura de un archivo, o cualquier lectura de la
terminal o de una tubería. Por eso se lee en bucle hasta el 0 y se escribe solo lo leído,
write(1, buf, n) con la n devuelta y no con el tamaño del buffer. Si
escribieras el buffer entero, la última vuelta sacaría basura de la vuelta anterior.
Un buffer es una zona de memoria donde dejas los datos de paso, entre leerlos y
escribirlos. «De tamaño fijo» quiere decir un array declarado con su tamaño, como
char buf[4096];, sin malloc. El archivo puede medir lo que sea: se procesa
a trozos de ese tamaño.
Ese array local vive en la pila, que tiene un tamaño limitado (en Linux suele ser de
8 MB; se ve con ulimit -s, en KB). Por eso el enunciado de ex01 limita el buffer a «algo
menos de unos 30 ko» y propone probarlo con ulimit: con una pila pequeña, un buffer
grande hace que el programa muera al entrar en la función.
errno y strerrorCuando una llamada al sistema falla, devuelve -1 y deja en la variable global
errno (de <errno.h>) un número que dice por qué: ENOENT
(no existe), EACCES (sin permiso), EISDIR (es un directorio).
strerror(errno) devuelve el texto de ese número.
Así se construye el mensaje de cat. El de verdad, con un archivo que no existe:
$ cat nofile
cat: nofile: No such file or directory
Hay que leer errno justo después del fallo: la siguiente llamada que falle lo
sobrescribe, y una que vaya bien no tiene por qué ponerlo a 0.
basenameDevuelve el último componente de una ruta: de /home/yo/ex01/ft_cat, o de
./ft_cat, devuelve ft_cat. Se aplica a argv[0], que es el
nombre con el que se lanzó el programa, para que el mensaje de error empiece por
ft_cat: como el de cat empieza por cat:, se lance como se
lance. Está en <libgen.h>.
El número que un programa devuelve al terminar: el return de main. 0
significa que fue bien y cualquier otro valor, que algo falló. La shell lo guarda en
$? y lo usan &&, || y los scripts.
cat sigue con los demás archivos aunque uno falle, pero al final devuelve 1:
$ cat nofile; echo $?
cat: nofile: No such file or directory
1
argc y argvLos parámetros de main: argc es cuántas palabras hay en la línea de
comandos, contando el nombre del programa, y argv un array con ellas, terminado en
NULL. ./ft_display_file texto da argc == 2,
argv[0] == "./ft_display_file" y argv[1] == "texto".
ex00 decide sus errores mirando solo argc: 1 es «falta el nombre», más de 2 es
«demasiados argumentos». En ex02, -c y el número también llegan como elementos de
argv, y separarlos de los nombres de archivo es parte del ejercicio.
Un byte son 8 bits, un número de 0 a 255; un archivo es una fila de bytes, sea texto o
no. El hexadecimal escribe los números en base 16, con cifras 0–9 y a–f: cada cifra son 4
bits, así que un byte son siempre dos cifras, de 00 a ff.
En ASCII, H es 72, que en hexadecimal es 48, y e es 101,
65. Es lo que enseña hexdump -C, byte a byte y con el texto al lado:
00000000 48 65 6c 6c 6f 20 77 6f 72 6c 64 21 |Hello world!|
0000000c
La posición de un byte contada desde el principio del archivo, empezando en 0. hexdump
lo imprime en hexadecimal al principio de cada línea: la primera es 0000000, la segunda
0000010 (16 en decimal) y así. La última línea es solo un desplazamiento: el del byte que
vendría después del último, es decir, el tamaño del archivo. Hello world! tiene 12
bytes y acaba en 000000c.
tail -c N es una cuestión de desplazamientos: hay que escribir desde el
desplazamiento tamaño − N hasta el final.
Cuando un número ocupa varios bytes, hay que decidir en qué orden se guardan. En
little-endian, el de las máquinas x86 y la mayoría de ARM, el byte menos significativo va
primero; en big-endian, el más significativo. El número de 16 bits 0x6548 se
guarda como 48 65 en little-endian.
El formato por defecto de hexdump lee los bytes de dos en dos como números de 16 bits
y los escribe en hexadecimal, así que los bytes 48 65 («He») salen como
6548. Un byte suelto al final se completa con un 00 como byte alto:
abcde sale como 6261 6463 0065.
* de hexdumpSi varias líneas seguidas de 16 bytes son idénticas a la anterior, hexdump no las
repite: escribe una sola línea con * y sigue en la siguiente que cambie. Con 48 letras
a:
0000000 6161 6161 6161 6161 6161 6161 6161 6161
*
0000030
Para coincidir con el original, ft_hexdump tiene que recordar la última línea
escrita y comparar cada línea nueva con ella.
Un programa ft_display_file que vuelca a la salida estándar el contenido del archivo
que se le pasa. Sin malloc: buffer de tamaño fijo. Y con los errores exactos que pide
el enunciado:
fd = open(argv[1], O_RDONLY);
if (fd < 0)
{
ft_putstr_fd("Cannot read file.\n", 2);
return (1);
}
while ((n = read(fd, buf, 4096)) > 0)
write(1, buf, n);
close(fd);
Sin argumentos imprime File name missing.; con demasiados,
Too many arguments.; si el archivo no se puede leer, Cannot read file. —
todos por la salida de error y con salto de línea.
0 es la entrada estándar,
1 la salida estándar, 2 la salida de error. open devuelve un
fd nuevo (o -1 si falla); read copia bytes del fd a un buffer y devuelve
cuántos leyó (0 = fin de archivo); write los vuelca a otro fd;
close libera el descriptor. Estas son llamadas al sistema: no las
resuelve tu programa, sino el núcleo del sistema operativo. Aquí, por primera vez, no se usa
printf ni buffers automáticos: se habla con el disco directamente, en trozos de un
buffer fijo, que es como funciona todo por debajo.Un ft_cat que hace lo mismo que el cat del sistema: concatena los
archivos que se le pasen (o lee de la entrada estándar si no hay ninguno) y, ante un archivo que
falla, imprime un error con el formato de cat y sigue con el resto.
ft_cat: nofile: No such file or directory
El mensaje se construye con basename(argv[0]) (el nombre del programa),
strerror(errno) (la descripción del error del sistema) y se escribe a la salida de
error. El código de salida es 1 si algún archivo falló.
stderr vs stdout, errno y códigos
de salida — La razón de tener dos salidas separadas es poder redirigir el resultado
sin mezclarlo con los avisos: ft_cat *.txt > todo.txt manda el contenido al archivo
(fd 1) mientras los errores siguen apareciendo en pantalla (fd 2). errno es una
variable global que el sistema pone al fallar una llamada (por ejemplo, "no existe"); no es legible
por sí sola, así que strerror(errno) la traduce a texto. basename recorta
la ruta del programa a solo su nombre, para que el error diga ft_cat: y no la ruta
entera. Y el código de salida (el return del main) es el
canal por el que un programa le dice a la shell si fue bien (0) o mal (distinto de
cero): eso es lo que encadenan los && del módulo de shell.Un ft_tail que replica tail, gestionando solo la opción -c
(los últimos N bytes). Con varios archivos, antepone la cabecera ==> nombre <==
como el tail real.
$ ft_tail -c 5 archivo
$ ft_tail -c 3 a b
==> a <==
...
==> b <==
...
La solución mide primero el tamaño del archivo leyéndolo entero, calcula cuántos bytes saltar
(tamaño − N), y en una segunda pasada escribe solo la cola. Acepta la opción pegada
(-c5) o separada (-c 5).
tail tiene una
dificultad de fondo: para dar los últimos bytes hay que llegar primero al final, y un
archivo se lee de principio a fin. Sin poder saltar directamente (aquí no se usa
lseek), la vía es leer en bloques con un buffer fijo llevando la cuenta de la posición,
y empezar a escribir solo cuando se cruza el umbral tamaño − N. Es el primer ejercicio
que obliga a razonar sobre cuánto se ha leído y no solo qué: el buffer no es el
archivo entero, es una ventana que se va deslizando. Que read pueda devolver menos
bytes de los pedidos (y haya que llamarlo en bucle) es la lección que se arrastra desde ex00.Un ft_hexdump que reproduce el hexdump del sistema (formato por
defecto, sin opciones): el desplazamiento en hexadecimal y, por cada 16 bytes, grupos de dos bytes
en hexadecimal.
$ ft_hexdump saludo.txt
0000000 6548 6c6c 206f 6f77 6c72 2164
000000c
hexdump esconde un detalle revelador: cada grupo son dos bytes leídos como un
número de 16 bits, y como la máquina es little-endian (el byte menos significativo
va primero en memoria), los dos bytes salen con el orden invertido. Por eso "He" (bytes
48 65) se imprime 6548: el programa lee el par y lo muestra como una
palabra, byte alto primero. Un byte suelto al final se completa con 00. El
desplazamiento va en hexadecimal, y la línea final repite el total de bytes. Reproducir esto
exactamente — incluido el relleno con espacios de la última línea para que quede alineada —
es lo que hace que la salida coincida byte a byte con la herramienta real: la lección de fondo es
que un archivo no es "texto", es una secuencia de bytes, y ver esos bytes en crudo es lo que
permite entender formatos, cabeceras y los "números mágicos" del ft_magic de Shell 00.Lo que es fácil que pregunte quien te evalúe, con una respuesta corta y el enlace a la sección
donde está explicado a fondo. Están agrupadas en: descriptores y lectura, errores, y
tail y hexdump. La forma más rápida de comprobar tus programas en la
evaluación es compararlos con el comando del sistema: diff <(./ft_tail -c 5 f) <(tail -c 5 f).
Antes de mirar la respuesta, intenta contestar tú.
Un entero con el que el núcleo identifica algo abierto por el proceso; open lo da y
read/write/close lo usan. El 0 es la entrada estándar, el 1
la salida estándar y el 2 la de error, abiertos ya al arrancar. El primer open suele
devolver 3. → descriptor, 0, 1 y 2
read va en un bucle y por qué escribes n bytes y no el buffer entero?Porque el archivo puede ser más grande que el buffer y read devuelve como mucho lo
que cabe: se repite hasta que devuelve 0. Y porque puede devolver menos de lo pedido, sobre todo en la
última vuelta; escribir el buffer entero sacaría restos de la vuelta anterior.
→ ex00, read
Porque malloc está prohibido en ex00 y ex01 y el enunciado pide un array de tamaño
fijo, de menos de unos 30 KB en ex01. Es un array local, así que vive en la pila: con un límite de
pila pequeño (ulimit -s), un buffer demasiado grande mata el programa. Con 1 MB y
ulimit -s 512, sale con 139 (señal de violación de segmento). Un tamaño como 4096 cumple
de sobra. → buffer
ft_cat sin argumentos?Lo mismo que cat: leer de la entrada estándar (fd 0) y copiarla a la salida hasta el
fin de archivo, que en la terminal se manda con Ctrl+D. Se prueba también con
una tubería: echo hola | ./ft_cat. → ex01
Porque cada proceso tiene un número máximo de descriptores abiertos a la vez. Un
ft_cat que abriera muchos archivos sin close acabaría recibiendo
-1 de open con archivos que existen. → descriptor
Para que redirigir el resultado no se lleve los errores: con ./ft_cat a nofile > todo
el contenido va al archivo y el error se sigue viendo. El enunciado lo exige («en la salida que les
haya sido reservada»).
→ ex01, redirección
ft_cat: nofile: No such file or directory?Tres trozos por el fd 2: basename(argv[0]), el nombre del archivo tal como se pasó y
strerror(errno), leído justo después del open que falló, separados por
": " y con salto de línea. Es el formato de cat, que da
cat: nofile: No such file or directory. → errno,
basename
ft_cat y sigue con los demás?Sigue con los demás y al final devuelve 1, como cat: cat nofile; echo $?
imprime el error y 1. Devuelve 0 solo si todo fue bien.
→ código de salida
ft_tail -c N si el archivo tiene menos de N bytes? ¿Y con varios archivos?Si N es mayor que el tamaño, saca el archivo entero (tail -c 100 sobre un archivo de
3 bytes da los 3). Con varios archivos, antes de cada uno escribe ==> nombre <==
y separa un bloque del siguiente con una línea en blanco; un archivo que no existe da un error por
la salida 2 y el resto sigue. → ex02, desplazamiento
hexdump enseña 6548 para «He» y no 4865?Porque el formato por defecto lee los bytes de dos en dos como enteros de 16 bits, y la máquina es
little-endian: el primer byte (48, la H) es el de menos peso y se escribe a la derecha.
hexdump -C sí enseña los bytes en orden, 48 65.
→ ex03, little-endian
hexdump?Tres que hay que imitar al byte: un número impar de bytes completa el último grupo con
00 (abcde acaba en 0065); las líneas idénticas seguidas se
sustituyen por un *; y la última línea es solo el desplazamiento final, el tamaño en
hexadecimal (000000c para 12 bytes). Un archivo vacío no imprime nada.
→ líneas repetidas, desplazamiento