Cursus — get_next_line

Una función, char *get_next_line(int fd), que cada vez que la llamas devuelve la siguiente línea de un descriptor. Sin libft, sin lseek, sin variables globales y leyendo de BUFFER_SIZE en BUFFER_SIZE bytes. El proyecto que enseña las variables static y que castiga cualquier descuido con la memoria.

El problema de fondo — read(fd, buf, n) no sabe nada de líneas: devuelve hasta n bytes, los que haya, y le da igual dónde caigan los '\n'. Un solo read puede traer media línea, o una línea y media, o diez líneas. Así que lo que sobre después del '\n' no se puede tirar: hay que guardarlo para la siguiente llamada. Y como la función se llama una vez por línea y entre llamada y llamada sus variables locales desaparecen, el enunciado da la pista: «un buen comienzo sería saber qué es una variable estática». Además pide leer lo menos posible: nada de cargar el fichero entero y luego trocearlo. Es la versión hecha a mano de lo que hacen fgets o getline en la libc, y la usarás en casi todos los proyectos que lean ficheros.

GGlosario de teoría

La página usa palabras que vienen de cómo el sistema da los datos de un fichero, de dónde vive cada variable en memoria y de cómo trabaja el preprocesador. Aquí está cada una explicada desde cero y con un ejemplo sacado del propio get_next_line. 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.

Ficheros y lectura

Descriptor de fichero

El número entero con el que un proceso se refiere a algo abierto: un fichero, una tubería, la terminal. Todo proceso empieza con tres: 0 (entrada estándar), 1 (salida estándar) y 2 (salida de errores). open devuelve el menor número libre, normalmente el 3, y −1 si falla.

get_next_line usa el número tal cual como índice de su array: buf[fd]. Por eso rechaza los negativos y los que no caben en el array (fd >= MAX_FD, con MAX_FD a 1024). get_next_line(-1) y get_next_line(4242) sin abrir devuelven NULL.

read y lo que devuelve

read(fd, buf, n) pide hasta n bytes y devuelve cuántos ha leído de verdad: puede ser menos de n aunque no se haya acabado nada (una tubería o la terminal dan lo que haya en ese momento). Devuelve 0 en fin de fichero y −1 si hay un error. No añade '\0': lo que deja en buf son bytes, no una cadena.

Con el fichero "hola\nmundo\nfin" (14 bytes) y BUFFER_SIZE=8, el primer read devuelve 8 ("hola\nmun"), el segundo 6 ("do\nfin") y el tercero 0. Por eso el código escribe a mano buf[bytes_read] = '\0'.

Fin de fichero (EOF)

EOF (end of file) no es un carácter guardado al final del fichero: es la situación de no quedar nada que leer, y read la indica devolviendo 0. En la terminal se provoca con Ctrl-D al principio de una línea.

En get_next_line, si al llegar a EOF hay algo acumulado se devuelve como última línea, sin '\n' ("fin"). Si no queda nada, se libera el buffer del fd y se devuelve NULL.

Entrada estándar y tuberías

La entrada estándar es el descriptor 0. Por defecto es el teclado, pero la shell la puede conectar a un fichero (./prog < f.txt) o a la salida de otro programa con una tubería (cat f.txt | ./prog). Para el programa es lo mismo: lee del 0.

get_next_line(0) funciona igual que con un fichero. El tester del repo lo prueba con stdin y con una tubería que escribe a trozos, que es justo cuando read devuelve menos de lo pedido.

Flujo (stream)

Una fuente de datos que se lee en orden, por trozos, sin saber de antemano cuánto mide y, en general, sin poder volver atrás. Un fichero se puede rebobinar con lseek; una tubería o la terminal, no.

El enunciado prohíbe lseek, así que get_next_line tiene que tratar todo como un flujo: lo que lee de más después del '\n' no se puede «devolver» al fichero y hay que guardarlo para la siguiente llamada.

Buffer

Una zona de memoria donde se dejan los datos entre quien los produce y quien los usa. Leer de uno en uno sería una llamada al sistema por byte; con un buffer se pide un bloque de una vez.

Aquí hay uno por fd, buf[fd], de BUFFER_SIZE + 1 bytes: el + 1 deja sitio para el '\0'. Entre llamadas guarda el resto que sobró detrás del último '\n'.

Fichero de texto y fichero binario

Un fichero de texto es una secuencia de caracteres separada en líneas por '\n'. Un binario (una imagen, un ejecutable) puede contener cualquier byte, incluido el 0, que en C es el fin de una cadena.

El enunciado declara indeterminado leer un binario, y se ve por qué: las funciones gnl_ miden con gnl_strlen, que se para en el primer '\0'. Con el contenido ab\0cd\nef\n el resultado depende del BUFFER_SIZE: con 1 salen "abcd\n" y "ef\n" (el 0 se pierde); con 8 solo "ab\n"; con 42 solo "ab".

Memoria y variables

Variable static local

Una variable declarada con static dentro de una función. Solo se ve desde esa función, como una local, pero existe durante todo el programa, como una global: se inicializa una vez (a cero si no se le da valor) y conserva su contenido entre llamadas.

static char *buf[MAX_FD] es la única de get_next_line. Empieza con los 1024 punteros a NULL y cada buf[fd] guarda el resto de ese fd de una llamada a la siguiente. En nm aparece como b buf.0: la b minúscula es «en .bss y local al fichero».

Ámbito y duración

El ámbito de una variable es desde dónde se puede nombrar; la duración, cuánto tiempo existe. Son cosas independientes:

VariableÁmbitoDuración
localla funciónuna llamada
globaltodo el programatodo el programa
static localla funcióntodo el programa

get_next_line necesita la tercera fila: duración larga para recordar el resto y ámbito corto para no ser una global.

Variable global

Una variable declarada fuera de toda función. Cualquier fichero del programa puede leerla y cambiarla, y por eso es fácil que alguien la toque sin querer. En 42 están prohibidas casi siempre, y este enunciado lo dice expresamente.

El tester del repo lo comprueba con nm: una global sale con letra mayúscula (B, D), y la static de get_next_line sale con b minúscula, que no cuenta.

Pila, heap y .bss

Tres zonas de la memoria de un proceso. La pila guarda las variables locales y se recoge sola al salir de cada función; en Linux suele medir 8 MB (ulimit -s da 8192 KB). El heap es la memoria de malloc, que vive hasta el free. .bss es la zona de las globales y static que empiezan a cero, y dura todo el programa.

En get_next_line, el array buf está en .bss (1024 punteros, 8 KB) y los buffers a los que apunta, en el heap. Un char buf[BUFFER_SIZE] local con BUFFER_SIZE=10000000 pediría 10 MB de pila y el programa reventaría.

malloc y free

malloc(n) reserva n bytes en el heap y devuelve su dirección, o NULL si no puede. free(p) los devuelve. Cada bloque reservado tiene que liberarse una vez, ni cero ni dos.

Las únicas funciones autorizadas son read, malloc y free. Cada línea devuelta sale de un malloc, y cada vuelta de gnl_strncat reserva una copia nueva y libera la anterior; con BUFFER_SIZE=1 eso es una reserva por byte de la línea.

Terminador nulo

En C una cadena es una fila de char que acaba en el byte '\0'. No se guarda la longitud: el final está donde está el cero, y strlen lo busca contando.

read no lo pone, así que gnl_read_loop hace buf[bytes_read] = '\0' tras cada lectura. Por eso el buffer mide BUFFER_SIZE + 1: con BUFFER_SIZE bytes leídos, el cero va en la posición BUFFER_SIZE.

NULL frente a cadena vacía

NULL es un puntero que no apunta a nada; "" es una cadena de verdad, un bloque de memoria con un solo byte, el '\0'. A la primera no se le puede leer nada; la segunda tiene longitud 0 y hay que liberarla si salió de malloc.

get_next_line usa las dos: dentro, r[0] == '\0' significa «no queda nada»; fuera, lo que ve quien llama es NULL. Una línea vacía del fichero no es ninguna de las dos: es "\n".

Aritmética de punteros

Sumar un entero a un puntero lo avanza ese número de elementos, y restar dos punteros del mismo bloque da cuántos elementos hay entre ellos. Con char, un elemento es un byte.

En gnl_split, p apunta al '\n' dentro de buf: p - buf es su posición y p - buf + 1 la longitud de la línea con su salto. p + 1 es donde empieza el resto. Con buf = "hola\nmun", p - buf vale 4.

Propiedad de la memoria

Quién es responsable de liberar cada bloque. No lo comprueba C; es un contrato que hay que respetar de memoria: quien recibe la propiedad libera, y quien la cede no vuelve a tocar el puntero.

La línea devuelta pasa a ser de quien llama. gnl_strncat se queda con su primer argumento y lo libera, por eso siempre se usa como r = gnl_strncat(r, …). El buffer de cada fd es de get_next_line.

realloc

La función de la libc que agranda (o encoge) un bloque del heap: reserva uno nuevo del tamaño pedido, copia el contenido, libera el viejo y devuelve el nuevo. Si falla, devuelve NULL y el viejo sigue vivo.

No está autorizada, y gnl_strncat hace su papel a mano, con una diferencia: si la reserva falla, el original ya está liberado. Eso simplifica los caminos de error, porque nunca queda nada que liberar después.

Fuga de memoria, «definitely lost» y «still reachable»

Una fuga es memoria reservada que no se libera. Valgrind distingue dos casos al final: definitely lost, bloques a los que ya no apunta nada (una fuga de verdad), y still reachable, bloques a los que todavía apunta algo, por ejemplo una static, pero que nadie liberó.

Si se lee un fd hasta NULL, get_next_line lo deja todo liberado: «in use at exit: 0 bytes». Si se deja un fd a medias, su buffer queda como still reachable.

Compilación y coste

Preprocesador, macros y -D

El preprocesador trabaja sobre el texto del código antes de que el compilador lo vea: copia los #include y sustituye las macros (#define NOMBRE valor) por su valor. -D NOMBRE=valor en la línea de órdenes define una macro como si estuviera escrita al principio del fichero.

cc -D BUFFER_SIZE=42 … hace que cada BUFFER_SIZE del código se convierta en 42. El header da un valor por defecto con #ifndef, así que compila también sin la flag; el tester lo comprueba («sin -D BUFFER_SIZE vale 42»).

Guarda de inclusión

El trío #ifndef X_H / #define X_H / #endif que rodea un header. La primera vez que se incluye, X_H no existe, se define y se copia el contenido; si se vuelve a incluir en el mismo .c, ya existe y se salta todo.

get_next_line.h usa GET_NEXT_LINE_H. El mismo #ifndef, sin el #define de guarda, es el que pone los valores por defecto de BUFFER_SIZE, MAX_FD y CHAR_SEP.

Funciones static y visibilidad

Una función normal tiene enlace externo: cualquier otro .c del programa puede llamarla y su nombre ocupa sitio en el espacio común. Con static delante solo existe dentro de su fichero.

Las auxiliares de get_next_line.c no son static: en nm salen con T mayúscula (T gnl_split, T gnl_read…). Funciona, pero si el programa que la usa tuviera otra función gnl_read, el enlazado fallaría.

Coste cuadrático

Un coste es cuadrático cuando crece con el cuadrado del tamaño: el doble de datos, cuatro veces el trabajo. Suele salir de repetir, para cada elemento nuevo, un trabajo proporcional a todo lo anterior.

Le pasa a get_next_line con líneas largas: cada gnl_strncat copia la línea acumulada entera para añadir BUFFER_SIZE bytes. Con BUFFER_SIZE=1 y una línea de 20 000 bytes son unas 20 000²/2 = 200 millones de bytes copiados. El tester incluye ese caso y pasa, pero se nota.

Comportamiento indeterminado

Lo que el enunciado declara fuera de contrato: puedes hacer cualquier cosa y no se evalúa. Equivale al comportamiento indefinido del estándar de C, pero decidido por el enunciado.

Aquí son dos casos: que el fichero cambie entre llamadas antes de llegar a EOF, y que sea binario. Fuera de ellos, la función no puede terminar de forma inesperada: ni segfault ni doble free.

staticLa memoria entre llamadas

Entrega: get_next_line.c, get_next_line_utils.c, get_next_line.hAutorizado: read, malloc, free
char	*get_next_line(int fd)
{
	static char	*buf[MAX_FD];
	char		*p;
	char		*r;

	if (fd < 0 || fd >= MAX_FD || BUFFER_SIZE <= 0 || !gnl_set_buffer(buf, fd))
		return (NULL);
	r = NULL;
	p = gnl_strchr(buf[fd], CHAR_SEP);
	if (!p)
		r = gnl_read(buf[fd], fd);
	else
		r = gnl_split(buf[fd], p, r);
	if (!r || r[0] == '\0')
	{
		free(r);
		free(buf[fd]);
		buf[fd] = NULL;
		return (NULL);
	}
	return (r);
}

Una variable local normal vive en la pila y muere al salir de la función. Una static declarada dentro de la función vive lo que dura el programa: se inicializa una sola vez (a cero, si no le das valor) y conserva su contenido de una llamada a la siguiente. Pero solo es visible dentro de get_next_line, así que no es una variable global y cumple la prohibición del enunciado.

Aquí la static es un array de punteros, uno por descriptor: buf[fd] es el «resto» pendiente de ese fd. Empiezan todos a NULL, y el primer uso de cada fd reserva su buffer:

void	*gnl_set_buffer(char **buf, int fd)
{
	if (!buf[fd])
	{
		buf[fd] = (char *)malloc(sizeof(char) * (BUFFER_SIZE + 1));
		if (!buf[fd])
			return (NULL);
		buf[fd][0] = '\0';
		buf[fd][BUFFER_SIZE] = '\0';
	}
	return (buf[fd]);
}

La lógica de la función principal tiene dos ramas: si el resto guardado ya contiene un salto de línea, no hace falta leer nada — basta con cortar (gnl_split). Si no, hay que leer más (gnl_read).

Ojo: las funciones auxiliares de get_next_line.c (gnl_split, gnl_read_loop, gnl_read, gnl_set_buffer) no están declaradas static ni en el header, así que son visibles desde fuera del fichero. Funciona igual; solo significa que ocupan esos nombres en el programa que enlace con ellas.

Qué te obliga a aprender — La diferencia entre ámbito (quién puede ver una variable) y duración (cuánto tiempo existe). Una local tiene ámbito de función y duración de una llamada; una global, ámbito de todo el programa y duración de todo el programa; una static local combina ámbito de función con duración de programa. Vive en el segmento de datos (.bss, por estar a cero), no en la pila, y por eso sobrevive. Es la forma que tiene C de darle «memoria» a una función sin exponer ese estado al resto del código.

-DBUFFER_SIZE y el preprocesador

Entrega: get_next_line.hCompilación: cc -Wall -Werror -Wextra -D BUFFER_SIZE=42 <archivos>.c
# ifndef BUFFER_SIZE
#  define BUFFER_SIZE 42
# endif

# ifndef MAX_FD
#  define MAX_FD 1024
# endif

# ifndef CHAR_SEP
#  define CHAR_SEP '\n'
# endif

-D BUFFER_SIZE=42 equivale a poner #define BUFFER_SIZE 42 al principio de cada fichero compilado. El evaluador y la Moulinette lo cambian para probar tu función con 1, con 9999, con 10000000. El #ifndef da un valor por defecto para que el proyecto compile también sin la flag, como exige el enunciado, sin pisar el valor si viene de fuera.

El usuario usa el mismo patrón para dos macros más: MAX_FD, el tamaño del array de buffers, y CHAR_SEP, el carácter que corta las líneas. Esta última es una rareza simpática: compilando con -D CHAR_SEP="' '" la función devolvería palabras en vez de líneas. Ojo con MAX_FD: un fd mayor o igual que 1024 devuelve NULL aunque esté abierto; en Linux el límite de descriptores por proceso puede ser mayor (ulimit -n).

La comprobación BUFFER_SIZE <= 0 al principio de get_next_line cubre a quien compile con -D BUFFER_SIZE=0 o negativo: se devuelve NULL antes de reservar nada. Y como el buffer se reserva con malloc en el heap, un BUFFER_SIZE de 10000000 no revienta la pila, que es lo que pasaría con un char buf[BUFFER_SIZE] local.

Qué te obliga a aprender — Que el preprocesador actúa antes que el compilador y que se le puede hablar desde la línea de órdenes. Y responde a la pregunta del enunciado («¿funciona si es 1? ¿y 10000000? ¿sabes por qué?»): con 1, la función tiene que ser correcta cuando cada read trae un solo byte, y será lenta; con 10000000, tiene que tolerar un buffer enorme, que en la pila no cabría. El tamaño del buffer no debe cambiar el resultado, solo el número de lecturas.

readLeer, acumular, cortar, guardar

Entrega: get_next_line.cAutorizado: read, malloc, free

Cuando el resto no tiene '\n', gnl_read lo copia a la línea en construcción r, vacía el buffer y empieza a leer:

char	*gnl_read(char *buf, int fd)
{
	char	*r;

	r = gnl_strdup(buf, BUFFER_SIZE + 1);
	if (!r)
		return (NULL);
	buf[0] = '\0';
	r = gnl_read_loop(buf, fd, r, read(fd, buf, BUFFER_SIZE));
	return (r);
}

char	*gnl_read_loop(char *buf, int fd, char *r, ssize_t bytes_read)
{
	char	*p;

	while (r && bytes_read > 0)
	{
		buf[bytes_read] = '\0';
		p = gnl_strchr(buf, CHAR_SEP);
		if (p)
		{
			r = gnl_split(buf, p, r);
			break ;
		}
		else
		{
			r = gnl_strncat(r, buf, gnl_strlen(r) + bytes_read);
			buf[0] = '\0';
			bytes_read = read(fd, buf, BUFFER_SIZE);
		}
	}
	if (bytes_read < 0)
	{
		free(r);
		return (NULL);
	}
	return (r);
}

Cada vuelta: read no pone '\0', así que se añade a mano en buf[bytes_read] (para eso el buffer mide BUFFER_SIZE + 1). Si en lo leído no hay salto, todo se acumula en r y se lee otra vez. Si lo hay, se corta:

char	*gnl_split(char *buf, char *p, char *r)
{
	char	*q;

	if (!r)
	{
		r = gnl_strdup("", 0);
		if (!r)
			return (NULL);
	}
	q = gnl_strdup(p + 1, gnl_strlen(p));
	if (!q)
	{
		free(r);
		return (NULL);
	}
	r = gnl_strncat(r, buf, gnl_strlen(r) + (p - buf + 1));
	gnl_strncpy(buf, q, BUFFER_SIZE + 1);
	free(q);
	return (r);
}

p apunta al '\n' dentro de buf. Lo que va después (p + 1) se copia aparte en q; a r se le añaden los p - buf + 1 primeros bytes (la línea con su '\n'), y luego q se vuelve a copiar al principio de buf: ese es el resto que se guarda para la próxima llamada. La copia intermedia en q evita copiar el buffer sobre sí mismo.

El estado entre llamadas, con un fichero "hola\nmundo\nfin" (sin salto final) y BUFFER_SIZE=8:

llamada   buf[fd] al entrar   read(fd, buf, 8)      devuelve     buf[fd] al salir
-------   -----------------   -------------------   ----------   ----------------
   1      ""   (recién         "hola\nmun"  (8)     "hola\n"     "mun"
                malloc)
   2      "mun"  sin '\n'      "do\nfin"    (6)     "mundo\n"    "fin"
                               r = "mun" + "do\n"
   3      "fin"  sin '\n'      ""           (0)     "fin"        ""
                               EOF: r = "fin"
   4      ""                   ""           (0)     NULL         free → NULL

                 ┌──────────────── static char *buf[MAX_FD] ───────────────┐
                 │ buf[0]  buf[1]  buf[2]  buf[3]          ...   buf[1023] │
                 │  NULL    NULL    NULL    │                        NULL  │
                 └──────────────────────────┼──────────────────────────────┘
                                            ▼  (heap, BUFFER_SIZE + 1)
                                          ┌───┬───┬───┬────┬─────────┐
                                          │ m │ u │ n │ \0 │ ...     │
                                          └───┴───┴───┴────┴─────────┘
Qué te obliga a aprender — A pensar en flujos en lugar de en ficheros completos: los datos llegan a trozos de tamaño arbitrario y la frontera lógica (el '\n') casi nunca coincide con la física (el final del read). La solución es siempre la misma tríada — un buffer de lectura, un acumulador y un resto — y la volverás a ver en cualquier código que lea de un socket, de una tubería o de un parser. También obliga a manejar aritmética de punteros con soltura: p - buf es una distancia en bytes, no una dirección.

EOFEl final del fichero y la última línea

Entrega: get_next_line.cValor devuelto: la línea leída, o NULL al terminar o si hay error

read devuelve 0 en fin de fichero y -1 en error. El bucle de lectura para con cualquiera de los dos (bytes_read > 0), pero los distingue después:

Que el buffer quede a NULL al terminar tiene una consecuencia práctica: si después se reutiliza ese número de fd para otro fichero, empieza limpio.

Qué te obliga a aprender — Que NULL y "" son cosas distintas (un puntero que no apunta a nada frente a una cadena válida de longitud cero) y que aquí la cadena vacía funciona como señal interna de «no queda nada». Y que una función que devuelve NULL «al terminar» tiene que dejar su estado recogido en ese momento: la última llamada es la que libera.

utilsLas funciones de cadena propias

Entrega: get_next_line_utils.cProhibido: libft

Como la libft está prohibida, el usuario reescribe en get_next_line_utils.c las cinco funciones de cadena que necesita, con prefijo gnl_: gnl_strlen, gnl_strchr, gnl_strdup, gnl_strncpy y gnl_strncat. No son clones de las de la libc: están adaptadas al proyecto. Por ejemplo, gnl_strlen acepta NULL y devuelve 0, y gnl_strdup recibe una longitud máxima y rellena con '\0' hasta el final. La más importante es gnl_strncat, porque no concatena en el sitio sino que reserva una cadena nueva:

char	*gnl_strncat(char *dst, char *src, size_t n)
{
	char	*r;
	size_t	l_d;
	size_t	l_s;
	size_t	i;

	l_d = gnl_strlen(dst);
	l_s = gnl_strlen(src);
	r = gnl_strdup(dst, n);
	free(dst);
	if (!r)
		return (NULL);
	i = 0;
	while (i < l_s && i + l_d < n && src[i])
	{
		r[l_d + i] = src[i];
		i++;
	}
	r[l_d + i] = '\0';
	return (r);
}

n es la longitud total del resultado: por eso las llamadas le pasan gnl_strlen(r) + bytes_read o gnl_strlen(r) + (p - buf + 1). La función copia dst en un bloque de n + 1 bytes, libera dst y añade src detrás.

Qué te obliga a aprender — A diseñar el contrato de propiedad de cada función: gnl_strncat «se come» su primer argumento, y quien la llama tiene que sustituir su puntero por el devuelto (r = gnl_strncat(r, ...)) y no volver a tocar el antiguo. Si la reserva falla, el original ya está liberado y se devuelve NULL, de modo que el error sube sin dejar nada colgando. Es la misma idea que realloc, escrita a mano.

valgrindMemoria y leaks

Requisito: toda la memoria del heap liberada, sin leaksComprobación: valgrind --leak-check=full

El reparto de responsabilidades es este:

Leyendo dos ficheros alternados hasta el final, con BUFFER_SIZE de 1, 3, 42 y 10000000, valgrind no informa de ningún leak.

Dos cosas que conviene saber explicar en la evaluación. Primera: si el programa deja de leer un fd antes de llegar a EOF, su buffer sigue reservado en el array static al terminar el programa. Valgrind lo muestra como still reachable (sigue habiendo un puntero a él), no como definitely lost; con la interfaz que fija el enunciado no hay forma de avisar a la función de que ya no vas a leer más. Segunda: ojo con el coste. Cada vuelta sin salto de línea hace un gnl_strncat que vuelve a copiar toda la línea acumulada, así que una línea de L bytes cuesta del orden de L² / BUFFER_SIZE copias. Con BUFFER_SIZE=1 y líneas muy largas se nota.

Qué te obliga a aprender — Que la memoria dinámica tiene dueño, y que cada puntero que sale de una función tiene que llevar escrito (aunque sea en tu cabeza) quién lo libera. Que un leak no se ve funcionando, solo con herramientas como valgrind. Y la diferencia entre «memoria perdida» y «memoria que sigue localizable», que es justo la situación en la que deja la static a un fd sin terminar.

bonusVarios descriptores a la vez

Entrega: get_next_line_bonus.c, get_next_line_bonus.h, get_next_line_utils_bonus.cRequisito: una sola variable static, varios fd alternados

El bonus pide dos cosas: usar una sola variable estática, y poder alternar llamadas sobre fd 3, 4 y 5 sin que se mezclen las líneas de uno con las de otro. Con un único buffer static compartido, leer del fd 4 machacaría el resto pendiente del fd 3.

	static char	*buf[MAX_FD];
	...
	p = gnl_strchr(buf[fd], CHAR_SEP);

La solución del usuario es indexar por fd: cada descriptor tiene su propio resto en buf[fd], y todos viven dentro de una variable static, el array. Lo curioso es que el usuario ya lo hizo así en la parte obligatoria, de modo que los ficheros _bonus son copias idénticas de los normales; la única diferencia es el #include "get_next_line_bonus.h". Leyendo dos ficheros alternados se obtiene:

[hola\n] [uno\n] [mundo\n] [dos\n] [\n] [NULL] ... [sin salto]

El precio del array es fijo: 1024 punteros (8 KB en 64 bits) en .bss, aunque solo se use uno. Los buffers en sí solo se reservan para los fd que se leen.

Qué te obliga a aprender — Que el estado de una función con memoria tiene que estar indexado por aquello que identifica a cada «cliente» — aquí, el número de fd. Es la misma idea que una tabla de sesiones en un servidor. Y que el número de descriptor no es más que un índice pequeño que el kernel asigna (empezando por el menor libre, normalmente el 3), lo que permite usarlo directamente como posición de un array.

?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: la static y el buffer, casos límite, memoria, y bonus y Norma. Antes de mirar la respuesta, intenta contestar tú.

La static y el buffer

¿Qué es una variable static y por qué la necesitas aquí?

Una variable que solo se ve dentro de la función pero existe todo el programa, así que conserva su valor entre llamadas. La necesitas porque un read casi nunca acaba justo en el '\n': lo que sobra detrás hay que guardarlo para la siguiente llamada, y una local normal desaparecería. No es una global porque nadie fuera de get_next_line puede nombrarla. → static

¿Funciona con BUFFER_SIZE=1? ¿Y con 10000000?

Sí con los dos; el tester lo prueba con 1, 42 y 10000000. Con 1 es correcto pero lento: un read y una copia de la línea por byte. Con 10000000 funciona porque el buffer se reserva con malloc en el heap; un array local de 10 MB no cabría en una pila de 8 MB. → -D

¿Y con BUFFER_SIZE=0 o sin -D?

Con 0 o negativo, get_next_line devuelve NULL antes de reservar nada (BUFFER_SIZE <= 0). Sin -D, el #ifndef del header pone 42. → -D

¿Lees lo menos posible, como pide el enunciado?

Sí. Si el resto guardado ya tiene un '\n', se corta sin llamar a read. Si no, se lee de BUFFER_SIZE en BUFFER_SIZE y se para en el primer bloque que trae un salto. Nunca se lee el fichero entero. → read

Casos límite

¿Qué devuelves si el fichero no acaba en '\n'? ¿Y un fichero vacío?

La última línea sin salto ("fin") y, en la llamada siguiente, NULL. Un fichero vacío da NULL a la primera. Una línea vacía en medio del fichero sale como "\n", no como NULL. → EOF

¿Qué pasa con un fd inválido, cerrado o con un directorio?

NULL en todos. El −1 se rechaza antes de nada; con uno cerrado o un directorio, read devuelve −1, se libera lo acumulado y el buffer del fd, y se devuelve NULL. El tester prueba los cuatro casos (−1, 4242 sin abrir, ya cerrado y un directorio). → EOF

¿Funciona leyendo de la entrada estándar?

Sí: get_next_line(0) es un fd más. Con la terminal, cada línea llega cuando se pulsa Intro, y Ctrl-D al principio de una línea da EOF. El tester lo prueba con stdin y con una tubería que escribe a trozos. → entrada estándar

¿Y si lees un fichero binario?

El enunciado lo declara indeterminado. Con esta implementación, un '\0' dentro de los datos corta la cadena, porque todo se mide con gnl_strlen, y el resultado depende de BUFFER_SIZE. No revienta, pero pierde datos. → texto y binario

Memoria

¿Hay leaks? ¿Quién libera cada cosa?

La línea devuelta la libera quien llama. El buffer de cada fd lo libera get_next_line al llegar a EOF o al fallar. Los bloques intermedios (q en gnl_split, las copias de gnl_strncat) se liberan en la misma función. Leyendo hasta NULL, valgrind termina con 0 bytes en uso. → valgrind

¿Y si el programa deja de leer antes del final?

El buffer de ese fd se queda reservado en la static. Valgrind lo marca como still reachable, no como definitely lost, porque la static sigue apuntando a él. Con la firma char *get_next_line(int fd) no hay forma de decirle a la función que ya no vas a leer más. → valgrind

¿Qué pasa si falla un malloc a mitad de línea?

La función que falla libera lo que tenía y devuelve NULL; el NULL sube hasta get_next_line, que libera el buffer del fd y devuelve NULL. gnl_strncat libera su entrada aunque la reserva falle, así que no queda nada colgando. El tester hace fallar, en pruebas separadas, distintos malloc de una lectura (el 1.º, el 2.º, el 4.º… de 21) y no encuentra leaks. → utils

Bonus y Norma

¿Cómo lees de varios fd a la vez con una sola static?

La static es un array, buf[MAX_FD]: una sola variable con un resto por fd. Cada llamada usa buf[fd] y no toca los demás. La parte obligatoria ya estaba hecha así, y los ficheros _bonus solo cambian el #include. → bonus

¿Qué pasa con un fd mayor que 1023?

Devuelve NULL aunque esté abierto, porque no cabe en el array. En el ordenador donde se probó, ulimit -n da 1048576, así que un proceso podría tener fd mucho más altos. Se puede cambiar compilando con -D MAX_FD=…, a costa de 8 bytes de .bss por cada fd de más. → -D

¿Por qué gnl_read_loop es una función aparte?

Lo más probable, por la Norma: 25 líneas por función como mucho, y el bucle de lectura junto al resto de gnl_read pasaría de ahí. Se parte en dos y el primer read se pasa como argumento. Las auxiliares no son static, y el evaluador puede preguntarlo: funcionan igual, pero son visibles desde otros ficheros. → static