Acceso a directorios

ACCESO A DIRECTORIOS
Varias son las llamadas al sistema que se requieren para acceder al
contenido de los directorios.
Para abrir un directorio necesitamos usar la llamada al sistema
opendir().
opendir() presenta el siguiente prototipo:
#include <sys/types.h>
#include <dirent.h>
DIR *opendir(const char *pathname);
La llamada a opendir() abre el directorio especificado y retorna un
puntero a dicho directorio en caso de éxito o retorna NULL en caso
de error. Este puntero al directorio es utilizado por las llamadas al
sistema readdir(), en el caso que deseemos leer el directorio, y
closedir(), en el caso que deseemos cerrar el directorio.
La llamada al sistema closedir() cierra un directorio previamente
abierto con opendir() y presenta el siguiente prototipo:
#include <sys/types.h>
#include <dirent.h>
int closedir(DIR *dirptr);
La llamada al sistema closedir() devuelve 0 si tiene éxito o -1 si falla.
La llamada al sistema readdir() tiene el prototipo:
#include <dirent.h>
struct dirent *readdir(DIR *dirptr);
Esta llamada retorna un puntero a una estructura dirent que
representa la siguiente entrada de directorios en el flujo de
directorio al que apunte dirptr. Devuelve NULL cuando alcanza el
fin_de_archivo o si hay un error. Llamando repetidamente a
readdir() resultará en una lectura secuencial del contenido del
directorio especificado.
La estructura dirent se define como sigue:
struct dirent{
long d_ino; /* número de i-nodo */
off_t d_off; /* desplazamiento al siguiente
dirent */
unsigned short d_reclen; /* longitud de
este registro */
unsigned char d_type; /* tipo de archivo
*/
char d_name[256]; /* nombre del
directorio */
};
El siguiente ejemplo lista todos los archivos del directorio
/home/jaime:
#include <stdio.h>
#include <sys/types.h>
#include <dirent.h>
main(){
DIR *dirptr;
struct dirent *buf;
//Abrir el directorio /home/jaime
dirptr=opendir(“/home/jaime”);
//Leer secuencialmente el directorio
/home/jaime
while((buf=readdir(dirptr))!=0){
printf(“%s\n”,buf->d_name);
}
//Cerrar el directorio /home/jaime
closedir(dirptr);
}
I-NODOS
Un directorio está compuesto de una serie de estructuras; cada
estructura contiene el nombre de un archivo y un puntero al archivo
mismo. Este puntero es un entero llamado i-number (index number)
del archivo. Cuando el archivo es accesado, su i-number es usado
como un índice en la tabla del sistema i-list, en donde, la entrada
para el archivo, i-node, es almacenada.
Un archivo en los Sistemas UNIX/LINUX se describe mediante un
objeto denominado "i-nodo". Por cada archivo existe un i-nodo único
que lo describe y que contiene punteros a los bloques que
comprende dicho archivo.
El i-nodo contiene información sobre los derechos de acceso
(permisos) al archivo, el número de enlaces, fecha de creación, fecha
de modificación, identificación del dueño, un indicador del tipo de
archivo y alguna otra información. Sin lugar a duda que la
información más importante de un i-nodo se refiere a los números de
bloque referidos a los bloques físicos (o de disco) que contienen los
datos del archivo.
El sistema mantiene una i-list separada para cada árbol de directorio
montado; así, es posible para varios archivos en el sistema de
archivos tener el mismo i-number.
Toda la información del i-nodo de un archivo es copiada en una
estructura denominada stat, que se encuentra definida en
<sys/stat.h>:
struct stat{
dev_t st_dev; /* dispositivo */
ino_t st_ino; /* i-nodo */
mode_t st_mode /* protección */
...
};
La información de esta estructura puede ser recuperada usando la
llamada al sistema stat(). La llamada al sistema stat() presenta el
siguiente prototipo:
#include <sys/stat.h>
#include <unistd.h>
int stat(const char *pathname, struct stat
*buf);
Para stat(), el primer parámetro es el pathname al archivo y buf es
un puntero a la estructura stat la cual será llenada con la
información de estado apropiada; stat() examina el archivo al que
apunta patíname y entonces llena buf.
La llamada al sistema stat() retorna 0 en caso de completarse
satisfactoriamente la estructura, -1 en caso de error.
El siguiente ejemplo permite obtener la información del archivo
/home/jaime/prueba:
#include <stdio.h>
#include <sys/stat.h>
#include <unistd.h>
main(){
struct stat buf;
//Obtener información del archivo prueba
stat(“/home/jaime/prueba”,&buf);
printf(“%s\t%d\t%d\n”,”home/jaime/prueba”,buf.st_ino,buf.st_
size);
}
Bibliografia
Linux A-Z, Phil Cornes, Prentice-Hall, 1997.