1. ¿Qué es un Descriptor de Archivo?

En el sistema operativo Linux, cada proceso mantiene un conjunto de archivos abiertos. Para gestionar estos archivos de manera eficiente, el kernel asocia una estructura interna, llamada struct file, a cada archivo que se abre. Para que un proceso pueda interactuar con estos archivos, Linux utiliza una capa adicional de abstracción: los descriptores de archivo.

Cuando un proceso se crea, el kernel le asigna una estructura task_struct para su gestión. Dentro de esta estructura, hay un puntero a una estructura struct files_struct. Esta última contiene un array, a menudo llamado fd_array (abreviatura de file descriptor array), que almacena punteros a las estructuras struct file de todos los archivos abiertos por ese proceso. Un descriptor de archivo es, esencialmente, el índice de este array.

Por lo tanto, al obtener el task_struct de un proceso, el sistema puede acceder al array de descriptores de archivo, y a través de un descriptor específico, localizar la struct file correspondiente para realizar operaciones sobre el archivo. Esta es la razón por la que las llamadas al sistema para operaciones de archivo suelen requerir un parámetro de descriptor de archivo (fd).

2. Reglas de Asignación de Descriptores de Archivo

Regla 1: Descriptores Estándar

Linux asigna por defecto tres descriptores de archivo a cada proceso al inicio de su ejecución:

• 0 (STDIN_FILENO): Descriptor de entrada estándar, generalmente asociado al teclado.
• 1 (STDOUT_FILENO): Descriptor de salida estándar, generalmente asociado a la pantalla (terminal).
• 2 (STDERR_FILENO): Descriptor de error estándar, también asociado a la pantalla (terminal).

En el lenguaje C, las estructuras FILE* stdin, FILE* stdout y FILE* stderr son abstracciones de estos descriptores 0, 1 y 2, respectivamente. En esencia, todas las operaciones de archivo se canalizan a través de estos descriptores.

Para ilustrar esta regla, si abrimos un nuevo archivo, su descriptor debería ser el 3, ya que 0, 1 y 2 ya están ocupados. El siguiente código lo demuestra:

#include <stdio.h>
#include <fcntl.h>    // Para open
#include <unistd.h>   // Para close
#include <sys/stat.h> // Para S_IRUSR, S_IWUSR, etc.

int main() {
    // Intentar abrir un nuevo archivo o crearlo si no existe
    // Con permisos de lectura y escritura para el propietario
    int descriptor_arch = open("log_aplicacion.txt", O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);

    if (descriptor_arch == -1) {
        perror("Error al abrir/crear el archivo");
        return 1;
    }

    printf("Descriptor de archivo asignado para 'log_aplicacion.txt': %d\n", descriptor_arch);

    // Escribir algo al archivo para demostrar su uso
    dprintf(descriptor_arch, "Este es un mensaje inicial.\n");

    // Cerrar el descriptor de archivo
    close(descriptor_arch);

    return 0;
}

Al ejecutar este programa, se observará que el descriptor asignado al archivo log_aplicacion.txt es, de hecho, 3.

Regla 2: El Menor Índice Disponible

Cuando se solicita abrir un nuevo archivo, el sistema operativo busca en el array fd_array el índice más bajo y no utilizado. Este índice se asigna como el descriptor del nuevo archivo. Esto significa que si liberamos un descriptor de archivo, el siguiente archivo abierto podría reutilizar ese índice.

Consideremos el caso de liberar el descriptor 0 (entrada estándar) y luego abrir un archivo. El nuevo archivo debería recibir el descriptor 0:

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h> // Para STDIN_FILENO, close
#include <sys/stat.h>

int main() {
    printf("Preparando para liberar STDIN_FILENO (0).\n");
    // Cerrar el descriptor de archivo estándar de entrada (0)
    if (close(STDIN_FILENO) == -1) { // Usamos STDIN_FILENO para mayor claridad
        perror("Error al cerrar STDIN_FILENO");
        return 1;
    }
    printf("STDIN_FILENO (0) cerrado exitosamente.\n");

    // Abrir un nuevo archivo. Debería obtener el FD más bajo disponible, que es 0.
    int nuevo_fd = open("salida_redirigida.txt", O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);

    if (nuevo_fd == -1) {
        perror("Error al abrir/crear el archivo de salida");
        return 1;
    }

    printf("Descriptor de archivo asignado para 'salida_redirigida.txt': %d\n", nuevo_fd);
    // Verificar si realmente es 0
    if (nuevo_fd == STDIN_FILENO) {
        printf("Como se esperaba, el descriptor 0 fue reasignado.\n");
    }

    // Escribir al archivo usando el nuevo FD
    dprintf(nuevo_fd, "Este texto ha sido escrito a traves del FD %d (antes stdin).\n", nuevo_fd);
    
    close(nuevo_fd);
    return 0;
}

La ejecución de este código confirmará que el archivo salida_redirigida.txt recibe el descriptor 0.

3. Implementando Redirección con Descriptores de Archivo

Redirección de Salida desde la Línea de Comandos

En la terminal, la redirección de salida es una operación común. Por ejemplo, el comando echo Hola Mundo > archivo.txt enviará la cadena "Hola Mundo" al archivo archivo.txt en lugar de a la pantalla. Esto es posible porque el operador > manipula el descriptor de salida estándar.

Redirección de Salida Programática

Podemos replicar el comportamiento de la redirección en nuestros programas de C utilizando las reglas de asignación de descriptores. Si cerramos el descriptor de salida estándar (1) y luego abrimos un nuevo archivo, ese archivo ocupará el descriptor 1. Cualquier función que escriba a la salida estándar (como printf) ahora escribirá en nuestro nuevo archivo.

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h> // Para STDOUT_FILENO, close
#include <sys/stat.h>

int main() {
    printf("Intentando redirigir la salida estándar a un archivo...\n");
    // Cerrar el descriptor de archivo estándar de salida (1)
    if (close(STDOUT_FILENO) == -1) {
        perror("Error al cerrar STDOUT_FILENO");
        return 1;
    }

    // Abrir un archivo. El siguiente FD disponible debería ser 1.
    int archivo_salida_fd = open("registro_proceso.log", O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);

    if (archivo_salida_fd == -1) {
        perror("Error al abrir el archivo de registro");
        return 1;
    }

    // Este printf ahora escribirá en 'registro_proceso.log'
    printf("Este mensaje originalmente iría a la consola.\n");
    printf("El descriptor asignado al archivo de registro es: %d\n", archivo_salida_fd);

    // Asegurarse de que el archivo_salida_fd es 1 para que printf funcione como esperado
    if (archivo_salida_fd != STDOUT_FILENO) {
        fprintf(stderr, "Advertencia: archivo_salida_fd no es %d. La redirección podría no funcionar como se espera.\n", STDOUT_FILENO);
    }
    
    // Podemos escribir directamente al archivo usando el descriptor
    dprintf(archivo_salida_fd, "Mensaje adicional escrito directamente al FD %d.\n", archivo_salida_fd);

    close(archivo_salida_fd);
    return 0;
}

Al ejecutar este código, el mensaje de printf no aparecerá en la terminal, sino en el archivo registro_proceso.log. Esto ocurre porque printf, a nivel de librería C, asume que está escribiendo al descriptor de archivo 1. Cuando hemos modificado lo que el descriptor 1 apunta, printf lo sigue ciegamente.

La Esencia de la Redirección

La redirección, en su núcleo, implica la manipulación de las entradas en el array fd_array de un proceso. Específicamente, se trata de cambiar a qué struct file apunta el índice 0 (para entrada) o el índice 1 (para salida).

• Cambiar el contenido del elemento en el índice 0 (STDIN_FILENO) se conoce como redirección de entrada.
• Cambiar el contenido del elemento en el índice 1 (STDOUT_FILENO) se conoce como redirección de salida.

La Llamada al Sistema dup2 para Redirección

Linux ofrece una llamada al sistema más robusta y específica para la redirección: dup2.

Descripción de la función dup2

• Prototipo: int dup2(int oldfd, int newfd);
• Cabecera: #include <unistd.h>
• Parámetros:
  • oldfd: El descriptor de archivo existente que queremos duplicar.
  • newfd: El descriptor de archivo al que queremos que oldfd apunte también.
• Valor de retorno:
  • Éxito: Retorna newfd.
  • Fallo: Retorna -1 y establece errno para indicar la causa del error.
• Funcionalidad: Establece newfd para que apunte a la misma estructura de archivo (y por ende, al mismo archivo) que oldfd.

Flujo de Ejecución de dup2

Cuando se invoca dup2:

1. El kernel verifica si newfd ya está en uso por el proceso.
2. Si newfd está en uso, el kernel primero lo cierra (liberando cualquier recurso asociado).
3. Luego, el kernel hace que la entrada del array fd_array correspondiente a newfd apunte a la misma struct file que la entrada de oldfd.

Esto significa que, tras una llamada exitosa a dup2, tanto oldfd como newfd se refieren al mismo archivo abierto. Cualquier operación realizada a través de oldfd o newfd afectará al mismo archivo.

Ejemplo de Uso de dup2

Usemos dup2 para redirigir la salida estándar (descriptor 1) a un archivo:

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h> // Para dup2, STDOUT_FILENO, close
#include <sys/stat.h>

int main() {
    const char *nombre_archivo_destino = "salida_del_programa.txt";
    int fd_fuente; // Descriptor para el archivo original

    // Abrir el archivo que será el nuevo destino de la salida estándar
    fd_fuente = open(nombre_archivo_destino, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
    if (fd_fuente == -1) {
        perror("Error al abrir/crear el archivo de destino");
        return 1;
    }

    printf("Descriptor original del archivo '%s': %d\n", nombre_archivo_destino, fd_fuente);
    printf("Realizando redirección de la salida estándar (FD 1) usando dup2...\n");

    // Redirigir STDOUT_FILENO (descriptor 1) para que apunte al mismo archivo que fd_fuente
    int fd_destino_redirect = dup2(fd_fuente, STDOUT_FILENO);
    if (fd_destino_redirect == -1) {
        perror("Error al realizar dup2 para la redirección");
        close(fd_fuente); // Asegurarse de cerrar el archivo si dup2 falla
        return 1;
    }

    // Una vez que dup2 ha sido llamado, fd_fuente y STDOUT_FILENO (1) apuntan al mismo archivo.
    // Ya no necesitamos fd_fuente. Cerrarlo no afectará a STDOUT_FILENO.
    close(fd_fuente);

    printf("dup2 completado. Nuevo descriptor (que es 1): %d\n", fd_destino_redirect);

    // Ahora, cualquier printf() irá al archivo 'salida_del_programa.txt'
    printf("Este texto debería aparecer en '%s', no en la consola.\n", nombre_archivo_destino);
    fprintf(stderr, "Este mensaje de error sí aparecerá en la consola (FD 2).\n"); // stderr sigue sin redirigir

    return 0;
}