Quando si dice che in Linux tutto è file, allora è davvero vero. La maggior parte delle operazioni che possiamo eseguire sui file possono essere eseguite su altre entità come socket, pipe, directory ecc.
Ci sono alcune situazioni in cui un'utilità software potrebbe dover viaggiare tra le directory del sistema Linux per trovare o abbinare qualcosa. Questo è il caso d'uso in cui il programmatore di quell'utilità deve occuparsi della programmazione di directory. Quindi, in questo articolo tratteremo le seguenti basi della programmazione di directory con un esempio.
- Creazione di directory.
- Lettura delle directory.
- Rimozione delle directory.
- Chiudere la directory.
- Ottenere la directory di lavoro corrente.
Esamineremo le funzioni utilizzate per ogni passaggio precedente e infine vedremo un esempio che riassumerà tutte le operazioni sulle directory.
1. Creazione di directory
Il sistema Linux fornisce la seguente chiamata di sistema per creare directory:
#include <sys/stat.h> #include <sys/types.h> int mkdir(const char *pathname, mode_t mode);
L'argomento 'percorso' viene utilizzato per il nome della directory.
Dalla pagina man :
La modalità argomento specifica le autorizzazioni da utilizzare. Viene modificato dalla umask del processo nel solito modo:i permessi della directory creata sono (mode &~umask &0777). Altri bit di modalità della directory creata dipendono dal sistema operativo. Per Linux, vedi sotto.
La directory appena creata sarà di proprietà dell'ID utente effettivo del processo. Se la directory contenente il file ha il bit set-group-ID impostato, o se il file system è montato con la semantica di gruppo BSD (mount -o bsdgroups o, sinonimo mount -o grpid), la nuova directory erediterà la proprietà del gruppo da il suo genitore; in caso contrario, sarà di proprietà dell'ID gruppo effettivo del processo. Se la directory principale ha il bit set-group-ID impostato, lo sarà anche la directory appena creata.
2. Directory di lettura
Una famiglia di funzioni viene utilizzata per leggere il contenuto della directory.
1. Innanzitutto è necessario aprire un flusso di directory. Questo viene fatto dalla seguente chiamata di sistema:
#include <sys/types.h> #include <dirent.h> DIR *opendir(const char *name);
Dalla pagina man :
La funzione opendir() apre un flusso di directory corrispondente al nome della directory e restituisce un puntatore al flusso di directory. Lo stream è posizionato alla prima voce della directory.
2. Successivamente, per leggere le voci nella directory, il flusso aperto sopra viene utilizzato dalla seguente chiamata di sistema:
#include struct dirent *readdir(DIR *dirp);
Dalla pagina man :
La funzione readdir() restituisce un puntatore a una struttura diretta che rappresenta la voce di directory successiva nel flusso di directory a cui punta dirp. Restituisce NULL al raggiungimento della fine del flusso di directory o se si è verificato un errore.
Su Linux, la struttura diretta è definita come segue:
struct dirent
{
ino_t d_ino; /* inode number */
off_t d_off; /* offset to the next dirent */
unsigned short d_reclen; /* length of this record */
unsigned char d_type; /* type of file; not supported
by all file system types */
char d_name[256]; /* filename */
}; 3. Rimozione delle directory
Il sistema Linux fornisce la seguente chiamata di sistema per rimuovere le directory:
#include <unistd.h> int rmdir(const char *pathname);
Dalla pagina man :
rmdir() rimuove la directory rappresentata da 'percorso' se è vuota. SE la directory non è vuota, questa funzione non avrà esito positivo.
4. Directory di chiusura
Il sistema Linux fornisce la seguente chiamata di sistema per chiudere le directory:
#include <sys/types.h> #include <dirent.h> int closedir(DIR *dirp);
Dalla pagina man :
La funzione closedir() chiude il flusso di directory associato a dirp. Una chiamata riuscita a closedir() chiude anche il descrittore di file sottostante associato a dirp. Il descrittore del flusso di directory dirp non è disponibile dopo questa chiamata.
5. Ottenere la directory di lavoro corrente
Il sistema Linux fornisce la seguente chiamata di sistema per ottenere il CWD :
#include <unistd.h> char *getcwd(char *buf, size_t size);
Dalla pagina man :
La funzione getcwd() copia un nome di percorso assoluto della directory di lavoro corrente nell'array puntato da buf, che è di lunghezza size. Questa funzione restituisce una stringa con terminazione null contenente un nome di percorso assoluto che è la directory di lavoro corrente del processo di chiamata. Il nome del percorso viene restituito come risultato della funzione e tramite l'argomento buf, se presente. Se la lunghezza del nome del percorso assoluto della directory di lavoro corrente, incluso il byte null terminante, supera la dimensione dei byte, viene restituito NULL e errno viene impostato su ERANGE; un'applicazione dovrebbe verificare questo errore e allocare un buffer più grande, se necessario.
6. Un esempio
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<dirent.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
int main (int argc, char *argv[])
{
if(2 != argc)
{
printf("\n Please pass in the directory name \n");
return 1;
}
DIR *dp = NULL;
struct dirent *dptr = NULL;
// Buffer for storing the directory path
char buff[128];
memset(buff,0,sizeof(buff));
//copy the path set by the user
strcpy(buff,argv[1]);
// Open the directory stream
if(NULL == (dp = opendir(argv[1])) )
{
printf("\n Cannot open Input directory [%s]\n",argv[1]);
exit(1);
}
else
{
// Check if user supplied '/' at the end of directory name.
// Based on it create a buffer containing path to new directory name 'newDir'
if(buff[strlen(buff)-1]=='/')
{
strncpy(buff+strlen(buff),"newDir/",7);
}
else
{
strncpy(buff+strlen(buff),"/newDir/",8);
}
printf("\n Creating a new directory [%s]\n",buff);
// create a new directory
mkdir(buff,S_IRWXU|S_IRWXG|S_IRWXO);
printf("\n The contents of directory [%s] are as follows \n",argv[1]);
// Read the directory contents
while(NULL != (dptr = readdir(dp)) )
{
printf(" [%s] ",dptr->d_name);
}
// Close the directory stream
closedir(dp);
// Remove the new directory created by us
rmdir(buff);
printf("\n");
}
return 0;
} L'esempio sopra dovrebbe ora essere autoesplicativo.
L'output dell'esempio precedente è :
# ./direntry /home/himanshu/practice/linux Creating a new directory [/home/himanshu/practice/linux/newDir/] The contents of directory [/home/himanshu/practice/linux] are as follows [redhat] [newDir] [linuxKernel] [..] [ubuntu] [.]