C Piscine — C 10

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).

La introducción — El enunciado abre con una tanda de preguntas absurdas sacadas de ¿Qué pasaría si...? de Randall Munroe (el autor de xkcd): desde tirar un filete desde tan alto que se cocine al caer, hasta cuándo el ancho de banda de Internet superará al de una furgoneta de FedEx cargada de discos. La última pregunta — qué pasaría si todos los aspirantes al carnet respondieran al azar — es un guiño a la evaluación automática: la Moulinette no responde al azar, compara byte a byte.

GGlosario de teoría

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.

Hablar con el sistema

Llamada al sistema (syscall)

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.

Descriptor de fichero (fd)

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.

Entrada estándar, salida estándar y salida de error (0, 1, 2)

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).

Redirección y tubería (>, 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_RDONLY

open(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 parciales

read(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.

Buffer de tamaño fijo y la pila

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 strerror

Cuando 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.

basename

Devuelve 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>.

Código de salida

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 argv

Los 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.

Bytes

Byte y hexadecimal

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
Desplazamiento (offset)

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.

Endianness: little-endian

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.

Líneas repetidas: el * de hexdump

Si 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.

ex00display_file

Entregable: Makefile + programaFunciones: open, read, write, close

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.

Descriptores de fichero y syscalls — Un descriptor de fichero (fd) es un simple entero con el que el kernel identifica algo abierto: un archivo, la terminal, un socket. Tres están abiertos siempre al arrancar: 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.

ex01cat

Entregable: Makefile + programaFunciones: open, read, write, close, strerror, basename

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.

ex02tail

Entregable: Makefile + programaFunciones: + malloc, free

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).

Buffers y el problema de "los últimos N" — 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.

ex03hexdump

Entregable: Makefile + programaFunciones: + malloc, free

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
Bytes, endianness y coincidir al byte — El formato por defecto de 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.

?Preguntas probables de la evaluación

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ú.

Descriptores y lectura

¿Qué es un descriptor de fichero y qué son el 0, el 1 y el 2?

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

¿Por qué 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

¿Por qué un buffer de tamaño fijo y de qué tamaño?

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

¿Qué hace tu 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

¿Por qué cierras cada archivo?

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

Errores

¿Por qué los errores van por la salida 2?

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

¿Cómo construyes el mensaje 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

Si un archivo falla, ¿qué devuelve 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

tail y hexdump

¿Qué hace 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

¿Por qué 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

¿Qué casos especiales tiene la salida de 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