TP1 TP2 Systeme L3 Explication

Explication TP système L3 ACAD C
MEDJADBA
TP1
gcc TP1.c -o tp1 //pour compiler un code .c
./tp1
argc: Argument Count : Le nombre de paramètres à passer
argv: Argument Vector: tableau de chaine de caractères, chaque case est une chaine de caracteres:
tableau argv
Argv[0] : Nom de l'exécutable ex ./TP1
Argv[1]:paramètre 1
Argv[argc-1]: le dernier paramètres

MEDJADBA
TP2
Exercice1
man access
access, faccessat - check user's permissions for a file
#include <unistd.h>
int access(const char *pathname, int mode);
MEDJADBA
Exercice02:
man 2 open
open, openat, creat - open and possibly create a file
SYNOPSIS
#include <fcntl.h>
int open(const char *pathname, int flags);
int open(const char *pathname, int flags, mode_t mode);
MEDJADBA
O_XCL
3-
Q5
MEDJADBA
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
int main(int argc, char **argv)

{
int i = 1; // initialisation du i
int file;
char buffer;
if (argc < 2)
{
printf("Erreur: usage: ./cat nomfichier\n"); // vérification du nombre d'arguments
return (-1);
}
while(i < argc){ // on met a boucle while pour parcourir tous les fichiers
file = open(argv[i], O_RDONLY); // ouvrir en lecture seul
if (file == -1) // traitment d'erreur
{
printf("Erreur: %s: fichier introuvable\n", argv[i]);
return (-1);
}
while ( read(file, &buffer, 1)) != 0) // cette boucle est pour lire un seul fichier et
afficher le contenu dans la sortie standard (1)
write(1, &buffer, 1);
close(file);
i++;
}
return (0);
}
MEDJADBA
Exercice3:
#include<stdio.h>
#include<stdlib.h>
#include <unistd.h>
#include <fcntl.h>
int main(int argc, char const *argv[])

{
char buf;
int fd;
int j;
if (argc == 1) //verifier que le nom des fichier sont passer comme parametre
printf("Manque d'arg !\n");
else
{
for (int i = 1; i < argc; i++)
{ //parcourir les fichiers
fd = open(argv[i],O_RDONLY); // ouvrir le fichier en mode lecture seul
if (fd==-1){
printf("Le fichier %s n'existe pas !\n",argv[1]); //afficher l'erreur en cas de erreur
MEDJADBA
exit(1);
}
else{
j=0;
while(read(fd, &buf, 1))j++ ;
printf("fichier %s numero %d \n",argv[i],i); //affiche le num de fichier
printf("Nombre de caracteres : %d\n",j);
close(fd);
}
}
return EXIT_SUCCESS;
}
}
MEDJADBA
MEDJADBA
TP2 partieII
Exercice 1
SYNOPSIS
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int open(const char *pathname, int flags);

int open(const char *pathname,int flags, mode_t mode);
Un appel à open() crée une nouvelle description de fichier ouvert, une entrée dans la table des fichiers ouverts du système. Cette
entrée enregistre la position dans le fichier et les attributs d'état du fichier (modifiable via l'opération F_SETFL de fcntl(2)). Un
descripteur de fichier est une référence à l'une de ces entrées ; cette référence n'est pas affectée si pathname est ultérieurement
supprimé ou modifié pour se référer à un fichier différent. La nouvelle description de fichier ouvert n'est initialement pas partagée avec
un autre processus, mais ce partage peut survenir après un fork(2).
Le paramètre flags doit inclure l'un des mode d'accès suivants : O_RDONLY, O_WRONLY ou O_RDWR. Ceux-ci réclament
respectivement l'ouverture du fichier en lecture seule, écriture seule, ou lecture-écriture. À cette valeur peut être ajouté zéro ou
plusieurs attributs de création de fichier et attributs d'état de fichier avec un OU binaire. Les attributs de création de
fichier sont O_CREAT, O_EXCL, O_NOCTTY et O_TRUNC. Les attributs d'état de fichier sont tous les autres attributs restant listés
plus loin. La différence entre ces deux groupes d'attributs est que l'on peut récupérer et (dans certains cas) modifier avec fcntl(2) les
attributs d'état de fichier. La liste complète des attributs de création de fichier et des attributs d'état de fichier est la suivante :
Nom Description
pathname Ce paramètre permet d'indiquer le nom du fichier.
oflag Ce paramètre permet d'indiquer le drapeau de mode d'ouverture (les constantes peuvent être combiné avec un
caractère «|» sauf pour O_RDONLY, O_WRONLY et O_RDWR) :
Constante Description
Cette constante permet d'indiquer qu'il faut ouvrir le fichier en mode lecture
O_RDONLY
seulement.
Cette constante permet d'indiquer qu'il faut ouvrir le fichier en mode écriture
O_WRONLY
seulement.
Cette constante permet d'indiquer qu'il faut ouvrir le fichier en mode lecture et
O_RDWR
écriture.
Cette constante permet d'indiquer que le déplacement du fichier doit être défini
O_APPEND
à la fin du fichier avant chaque écriture.
O_CREAT Cette constante permet de créer le fichier.
O_EXCL Cette constante permet d'indiquer que si le fichier existe, il ne peut pas être créé
MEDJADBA
et qu'il doit retourner un erreur dans errno.
Cette constante permet d'indiquer que le fichier doit avoir la taille de 0 octets et
O_TRUNC donc que les données sont effacé s'il existe et a été ouvert avec succès par
O_RDWR ou O_WRONLY.
mode mode indique les permissions à utiliser si un nouveau fichier est créé. Cet argument doit être fourni
lorsque O_CREAT est spécifié dans flags ; si O_CREAT n'est pas spécifié, mode est ignoré. Les
permissions effectives sont modifiées par l'umask du processus de manière classique : les
permissions du fichier créé sont (mode & ~umask). Veuillez noter que ce mode ne s'applique qu'aux
accès ultérieurs au fichier nouvellement créé. L'appel open() qui crée un fichier dont le mode est en
lecture seule fournira quand même un descripteur de fichier en lecture et écriture.
Constante Valeur Description
Cette valeur permet d'indiquer que l'utilisateur a la

S_IRWXU 00700
permission en lecture, écriture et d'exécution.

S_IRUSR 00400
permission en lecture.

S_IWUSR 00200
permission en écriture.

S_IXUSR 00100
permission en exécution.
Cette valeur permet d'indiquer que le groupe a la

S_IRWXG 00070
permission en lecture, écriture et exécution.

S_IRGRP 00040

S_IRGRP 00020

S_IXGRP 00010
Cette valeur permet d'indiquer que tous ont la

S_IRWXO 00007
permission en lecture, écriture et d'exécution.

S_IROTH 00004

S_IWOTH 00002

S_IXOTH 00001
Retour
Valeur Description
-1 Cette valeur permet d'indiquer qu'une erreur s'est produite et la variable «errno» contiendra l'erreur.
valeur entière != -1 Ces valeurs permettent d'indiquer qu'un descripteur pour le socket est accepté.
MEDJADBA
Retour
Valeur Description
-1 Cette valeur permet d'indiquer qu'une erreur s'est produite et la variable «errno» contiendra l'erreur.
valeur entière != -1 open() et creat() renvoient le nouveau descripteur de fichier s'ils réussissent, ou -1 s'ils échouent, auq
O_EXCL tjrs combiné avec O_CREAT
mode = S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IWGRP| S_IROTH | S_IWOTH;

rwx rw- rw-
3) la premiere fois ça marche
la deuxieme fois: une erreur est déclenchée avec perror qui appartient à la bibliotheque fcntl.h
5)
la valeur du masque dépondera de la machine
0002 ou 0022
6)
Nous avons spécifié dans la variable mode le mode: rwx rw- rw-
MEDJADBA
et apres creation on le mode : rwx rw- r--
Ceci es tà cause du masque qui est égale à 0002
rwx rw- rw- = 111 110 110 = 766
766-002= 764 = : rwx rw- r--
Exercice02
i-nœuds(index node)
Dans le système Unix/Linux toutes les informations des fichiers sont rassemblées dans une structure associée
au fichier, appelée nœud d’information, i-nœud ou i-node.
L’i-nœud contient les informations suivantes : le type du fichier (régulier, répertoire, caractère, bloc ou tube)
; le code de protection sur 9 bits ; l’identificateur et groupe du propriétaire ; les dates de création, du dernier
accès et de la dernière modification ;; la
La figure montre la structure typique d’un i-nœud.
NOM
stat, fstat, lstat - Obtenir l'état d'un fichier (file status)
SYNOPSIS
#include <unistd.h>
MEDJADBA
int stat(const char *path, struct stat *buf);
int fstat(int fd, struct stat *buf);
int lstat(const char *path, struct stat *buf);
Exigences de macros de test de fonctionnalités pour la glibc (voir feature_test_macros(7)) :
lstat() : _BSD_SOURCE || _XOPEN_SOURCE >= 500
DESCRIPTION
Ces fonctions renvoient des informations à propos d'un fichier. Aucune permission n'est
nécessaire sur le fichier lui-même, mais vous devez --- dans le cas de stat() et lstat() --- avoir
la permission d'exécution (parcours) pour tous les répertoires de path qui mènent au fichier.
stat() récupère l'état du fichier pointé par path et remplit le tampon buf.
lstat() est identique à stat(), sauf que si path est un lien symbolique, il donne l'état du lien
lui-même plutôt que celui du fichier visé.
fstat() est identique à stat(), sauf que le fichier ouvert est pointé par le descripteur fd, obtenu
avec open(2).
Les trois fonctions retournent une structure stat contenant les champs suivants :
struct stat {
dev_t st_dev; /* ID du périphérique contenant le fichier */
ino_t st_ino; /* Numéro inœud */
mode_t st_mode; /* Protection (droit d'accès)*/
nlink_t st_nlink; /* Nb liens matériels */
uid_t st_uid; /* UID propriétaire */
gid_t st_gid; /* GID propriétaire */
dev_t st_rdev; /* ID périphérique (si fichier spécial) */
off_t st_size; /* Taille totale en octets */
blksize_t st_blksize; /* Taille de bloc pour E/S */
blkcnt_t st_blocks; /* Nombre de blocs alloués */
time_t st_atime; /* Heure dernier accès */
time_t st_mtime; /* Heure dernière modification */
time_t st_ctime; /* Heure dernier changement état */
};
Le champ st_dev indique le périphérique sur lequel réside le fichier. Le champ st_rdev indique le
périphérique que ce fichier (inœud) représente. Le champ st_size indique la taille du fichier (s'il s'agit
d'un fichier régulier ou d'un lien symbolique) en octets. La taille d'un lien symbolique est la longueur de
la chaîne représentant le chemin d'accès qu'il vise, sans l'octet nul final.
Le champ st_blocks indique le nombre de blocs de 512 octets alloués au fichier (cette valeur peut être
inférieure à st_size/512 si le fichier contient des trous). Le champ st_blksize indique la taille de bloc
MEDJADBA
« préférée » pour les entrées-sorties du système de fichiers (l'écriture dans un fichier par petits
morceaux peut induire de nombreuses étapes lecture-modification-écriture peu efficaces).
Tous les systèmes de fichiers de Linux n'implémentent pas tous les champs liés à la date. Certains
systèmes de fichiers autorisent le montage de telle manière que les accès ne modifient pas le
champ st_atime (voir l'option « noatime » de mount(8)).
Le champ st_atime est modifié par les accès au fichier, c'est-à-dire

avec execve(2), mknod(2), pipe(2), utime(2) et read(2) (d'au moins un octet). D'autres routines,
comme mmap(2), peuvent ou non mettre à jour ce champ st_atime.
Le champ st_mtime est modifié par des changements sur le fichier lui-même, c'est-à-
dire mknod(2), truncate(2), utime(2) et write(2) (d'au moins un octet). D'autre part, le
champ st_mtime d'un répertoire est modifié lors de la création ou la suppression de fichiers en son sein.
Le champ st_mtime n'est pas mis à jour lors de modification de propriétaire, groupe, mode ou nombre
de liens physiques.
Le champ st_ctime est modifié lors d'une écriture ou une modification de données concernant l'inœud
(propriétaire, groupe, mode, etc.).
Les macros POSIX suivantes sont fournies pour vérifier le type de fichier en utilisant le champ stmode :
S_ISREG(m)
un fichier ordinaire ?
S_ISDIR(m)
un répertoire ?
S_ISCHR(m)
un périphérique en mode caractère ?
S_ISBLK(m)
un périphérique en mode bloc ?
S_ISFIFO(m)
une FIFO (tube nommé) ?
S_ISLNK(m)
un lien symbolique ? (Pas dans POSIX.1-1996).
S_ISSOCK(m)
une socket ? (Pas dans POSIX.1-1996).
VALEUR RENVOYÉE
Ces appels système retournent zéro s'ils réussissent. En cas d'échec, -1 est renvoyé,
et errno contient le code de l'erreur.
MEDJADBA
getpwuid
NOM
getpwnam, getpwnam_r, getpwuid, getpwuid_r - Lire un enregistrement du fichier des mots de passe
SYNOPSIS
#include <pwd.h>
struct passwd *getpwnam(const char *name);
struct passwd *getpwuid(uid_t uid);
int getpwnam_r(const char *name, struct passwd *pwbuf,

char *buf, size_t buflen, struct passwd **pwbufp);
int getpwuid_r(uid_t uid, struct passwd *pwbuf,

char *buf, size_t buflen, struct passwd **pwbufp);
getpwnam_r(), getpwuid_r() : _POSIX_C_SOURCE || _XOPEN_SOURCE || _BSD_SOURCE || _SVID_SOURCE
DESCRIPTION
La fonction getpwnam() renvoie un pointeur sur une structure contenant les divers champs de
l'enregistrement de la base de données des mots de passe (par exemple, la base de données
locale /etc/passwd, NIS ou LDAP) correspondant au nom d'utilisateur name.
La fonction getpwuid() renvoie un pointeur sur une structure contenant les divers champs de l'enregistrement de
la base de données des mots de passe correspondant à l'UID uid.
Les fonctions getpwnam_r() et getpwuid_r() obtiennent les mêmes informations mais enregistrent la
structure passwd trouvée dans l'espace pointé par pwbuf. Cette structure passwd contient des pointeurs vers des
chaînes, et ces chaînes sont enregistrées dans le tampon buf de taille buflen. Un pointeur vers le résultat (en cas
de succès) ou NULL (au cas où aucune entrée n'ait été trouvée ou qu'une erreur ne soit survenue) est enregistré
dans *pwbufp.
La structure passwd est définie dans <pwd.h> ainsi :

MEDJADBA
struct passwd {
char *pw_name; /* Nom d'utilisateur */
char *pw_passwd; /* Mot de passe de l'utilisateur */
uid_t pw_uid; /* Identifiant de l'utilisateur */
gid_t pw_gid; /* Identifiant du groupe de l'utilisateur */
char *pw_gecos; /* Nom réel */
char *pw_dir; /* Répertoire personnel */
char *pw_shell; /* Interpréteur de commande */
};
La taille maximum nécessaire pour buf peut être récupérée en utilisant sysconf(3) avec le
paramètre _SC_GETPW_R_SIZE_MAX.
VALEUR RENVOYÉE
Les fonctions getpwnam() et getpwuid() renvoient un pointeur sur une structure passwd, ou NULL si
une erreur se produit, ou si l'enregistrement correspondant n'est pas trouvé. En cas d'erreur, errno est
remplie en conséquence. Si on souhaite vérifier errno après l'appel, celle-ci devrait être remplie avec
zéro avant l'appel.
La valeur de retour peut pointer vers une zone statique et donc être écrasée par des appels successifs
à getpwent(3), getpwnam() ou getpwuid().
Les fonctions getpwnam_r() et getpwuid_r() renvoient zéro si elles réussissent. En cas d'erreur, une valeur
d'erreur est renvoyée.
ERREURS
0 ou ENOENT ou ESRCH ou EBADF ou EPERM ou ...
Le nom name ou l'identifiant uid n'ont pas été trouvés.
EINTR
Un signal a été intercepté.
EIO
Erreur d'entrée-sortie.
EMFILE
Le nombre maximal (OPEN_MAX) de fichiers ouverts par le processus est atteint.
ENFILE
Le nombre maximal de fichiers ouverts sur le système est atteint.
ENOMEM
Pas assez de mémoire pour allouer la structure passwd.
ERANGE
L'espace tampon fourni est insuffisant.
FICHIERS
/etc/passwd
Fichier local base de données des mots de passe.
MEDJADBA
CONFORMITÉ
SVr4, BSD 4.3, POSIX.1-2001.
NOTES
La section VALEUR RENVOYÉE ci-dessus vient de POSIX.1-2001. Elle ne considère pas le cas « non
trouvé » comme une erreur, et ne spécifie pas errno dans ce cas. Cela rend la détection d'erreur
impossible. On peut dire que, d'après POSIX, errno est inchangée dans le cas où aucune entrée n'est
trouvée. Des essais sur de nombreux systèmes Unix ont fait apparaître différentes valeurs dans ce
cas : 0, ENOENT, EBADF, ESRCH, EWOULDBLOCK, EPERM et probablement d'autres.
Le champ pw_dir contient le nom du répertoire de travail initial de l'utilisateur. Les programmes de connexion
utilisent la valeur de ce champ pour initialiser la variable d'environnement HOME de l'interpréteur de commandes
de connexion. Une application qui veut déterminer le répertoire personnel de l'utilisateur doit inspecter la valeur
de HOME (plutôt que la valeur getpwuid(getuid())->pw_dir) puisque cela permet à l'utilisateur de modifier la
notion de « répertoire personnel » lors d'une session de connexion. Pour déterminer le répertoire personnel
« initial » d'un autre utilisateur, il est nécessaire d'utiliser getpwnam(nom_utilisateur)->pw_dir ou un équivalent.
VOIR AUSSI
endpwent(3), fgetpwent(3), getgrnam(3), getpw(3), getpwent(3), putpwent(3), setpwent(3), passwd(5)
TRADUCTION
Ce document est une traduction réalisée par Christophe Blaess <http://www.blaess.fr/christophe/> le

3 novembre 1996 et révisée le 17 juillet 2008.
L'équipe de traduction a fait le maximum pour réaliser une adaptation française de qualité. La version anglaise la
plus à jour de ce document est toujours consultable via la commande : « LANG=C man 3 getpwnam ».
N'hésitez pas à signaler à l'auteur ou au traducteur, selon le cas, toute erreur dans cette page de manuel.
getgrgid
NOM
getgrnam, getgrgid - Obtenir l'enregistrement d'un goupe.
SYNOPSIS
#include<grp.h>
#include<sys/types.h>
structgroup*getgrnam(constchar*name);
structgroup*getgrgid(gid_tgid);
DESCRIPTION
La fonction getgrnam() renvoie un pointeur sur structure
contenant l'enregistrement issus de /etc/group pour le
groupe correspondant au nom name.
MEDJADBA
La fonction getgrgid() renvoie un pointeur sur structure

contenant l'enregistrement issus de /etc/group pour le
groupe correspondant a l'ID gid.
La structure group est définie dans <grp.h> ainsi :
struct group {
char *gr_name; /* Nom du groupe. */
char *gr_passwd; /* Mot de passe du groupe. */
gid_t gr_gid; /* ID du groupe. */
char **gr_mem; /* Membres du groupe. */
};
VALEURRENVOYÉE
Les fonctions getgrnam() et getgrgid() renvoient la struc
ture de groupe, ou NULL s'il n'y a pas de groupe corre
spondant aux données, ou si une erreur se produit.
ERREURS
ENOMEM Pas assez de mémoire pour allouer la structure.
FICHIERS
/etc/group
Base de données des groupes.
CONFORMITÉ
SVID 3, POSIX, BSD 4.3
VOIRAUSSI
fgetgrent(3), getgrent(3), setgrent(3), endgrent(3).
TRADUCTION
Christophe Blaess, 1997.
CTIME
http://manpagesfr.free.fr/man/man3/ctime.3.html
Section : Manuel du programmeur Linux (3)
Mise à jour de la version anglaise : 6 avril 2008
Index Menu principal
NOM
ctime, asctime, gmtime, localtime, mktime, asctime_r, ctime_r, gmtime_r, localtime_r - Conversions de dates et heures binaires en
ASCII
MEDJADBA
SYNOPSIS
#include <time.h>
char *asctime(const struct tm *tm);
char *asctime_r(const struct tm *tm, char *buf);
char *ctime(const time_t *timep);
char *ctime_r(const time_t *timep, char *buf);
struct tm *gmtime(const time_t *timep);
struct tm *gmtime_r(const time_t *timep, struct tm *result);
struct tm *localtime(const time_t *timep);
struct tm *localtime_r(const time_t *timep, struct tm *result);
time_t mktime(struct tm *tm);
asctime_r(), ctime_r(), gmtime_r(), localtime_r() :

_POSIX_C_SOURCE || _XOPEN_SOURCE || _BSD_SOURCE || _SVID_SOURCE
DESCRIPTION
Les fonctions ctime(), gmtime() et localtime() prennent toutes un argument de
type time_t qui représente une date. Si l'on interprète cet argument comme une valeur
absolue, il s'agit du nombre de secondes écoulées depuis le 1er Janvier 1970 à 00h 00m 00s
en Temps Universel (TU).
Les fonctions asctime() et mktime() utilisent toutes deux un argument de type struct tm, c'est-à-dire
une représentation binaire divisée en année, mois, jour, heure...
Cette structure tm est définie dans <time.h> comme suit :
struct tm {
int tm_sec; /* secondes */
int tm_min; /* minutes */
int tm_hour; /* heures */
int tm_mday; /* quantième du mois */
int tm_mon; /* mois (0 à 11 !) */
int tm_year; /* année */
int tm_wday; /* jour de la semaine */
int tm_yday; /* jour de l'année */
int tm_isdst; /* décalage horaire */
};
MEDJADBA
Les membres de la structure tm sont :
tm_sec
Le nombre de secondes écoulées depuis le dernier changement de minute. Normalement dans
l'intervalle 0 à 59, ce membre peut aller jusqu'à 60 durant les secondes de rattrapage
périodique.
tm_min
Le nombre de minutes écoulées depuis le dernier changement d'heure, dans l'intervalle 0 à 59.
tm_hour
Le nombre d'heures écoulées depuis minuit, dans l'intervalle 0 à 23.
tm_mday
Le quantième du mois, dans l'intervalle 1 à 31.
tm_mon
Le nombre de mois écoulés depuis le début de l'année, dans l'intervalle 0 à 11.
tm_year
Le nombre d'années écoulées depuis 1900.
tm_wday
Le nombre de jours écoulés depuis dimanche, dans l'intervalle 0 à 6.
tm_yday
Le nombre de jours écoulés depuis le 1er janvier, dans l'intervalle 0 à 365 (0 à 364 si l'année
n'est pas bissextile).
tm_isdst
Un drapeau indiquant si le décalage heure d'hiver, heure d'été est en cours au moment de
l'appel. La valeur retournée est positive si le décalage est en fonction, nulle s'il ne l'est pas, et
négative si l'information n'est pas disponible.
L'appel ctime(t) est équivalent à asctime(localtime(t)). Il convertit la date t en une chaîne de caractères de la
forme
"Wed Jun 30 21:49:08 1993\n"
Les abréviations des jours de la semaine sont « Sun », « Mon », « Tue », « Wed », « Thu », « Fri », et « Sat ».
Les abréviations des mois sont « Jan », « Feb », « Mar », « Apr », « May », « Jun », « Jul », « Aug », « Sep »,
« Oct », « Nov », et « Dec ». La valeur renvoyée pointe sur une chaîne statique qui sera écrasée à chaque appel
de l'une des fonctions ci-dessus. La fonction renseigne également la variable externe tzname avec les informations
concernant le fuseau horaire (voir tzset(3)).
La version réentrante ctime_r() effectue le même travail mais stocke la chaîne dans un tampon fourni par
l'appelant, d'une longueur minimale de 26 caractères. Elle ne renseigne pas nécessairement tzname.
La fonction gmtime() convertit la date timep en une représentation struct tm exprimée en Temps Universel. Elle
peut renvoyer NULL quand l'année ne tient pas dans un entier. La valeur renvoyée pointe vers une structure
MEDJADBA
allouée statiquement qui peut être écrasée par une invocation ultérieure d'une fonction de date ou d'heure. La
fonction réentrante gmtime_r() effectue le même travail mais stocke le résultat dans une structure fournie par
l'appelant.
La fonction localtime() convertit la date timep en une représentation struct tm exprimée en fonction du fuseau
horaire de l'utilisateur. Cette fonction se comporte comme si elle appelait tzset(3) et renseigne les variables
externes tzname avec les informations concernant le fuseau horaire, timezone avec la différence (en secondes)
entre Temps Universel et Temps Local, et daylight avec une valeur non nulle si le décalage horaire saisonnier
s'applique. La valeur renvoyée pointe vers une structure allouée statiquement qui peut être écrasée par une
invocation ultérieure d'une fonction de date ou d'heure. La fonction réentrante localtime_r() effectue le même
travail mais stocke le résultat dans une structure fournie par l'appelant.
La fonction asctime() convertit la date tm exprimée sous forme struct tm en une chaîne de caractères du même
format que ctime(). La valeur renvoyée pointe sur une chaîne statique qui sera écrasée à chaque appel de l'une
des fonctions ci-dessus. La version réentrante asctime_r() effectue le même travail mais stocke la chaîne dans un
tampon fourni par l'appelant, d'une longueur minimale de 26 caractères.
La fonction mktime() convertit la date timeptr exprimée sous forme struct tm en une date locale sous
forme time_t. La fonction ignore les valeurs transmises des membres tm_wday tm_yday de la structure, et les
recalcule en utilisant les autres membres. Si des membres de la structure débordent de l'intervalle autorisé, ils
seront corrigés (par exemple le 40 Octobre devient le 9 Novembre). L'appel de mktime() renseigne également la
variable externe tzname avec les informations concernant le fuseau horaire. Si la structure transmise ne peut pas
être convertie, mktime() renvoie la valeur (time_t) -1 et ne modifie pas les membres tm_wday et tm_yday.
VALEUR RENVOYÉE
Chacune de ces fonctions renvoie la valeur décrite plus haut, ou NULL (-1 dans le cas de mktime()) si une erreur est détectée.
CONFORMITÉ
POSIX.1-2001. C89 et C99 spécifient asctime(), ctime(), gmtime(), localtime() et mktime().
NOTES
Les quatre fonctions asctime(), ctime(), gmtime() et localtime() renvoient un pointeur vers des
données statiques et ne sont donc pas sûres dans un contexte multithreads. Les versions
réentrantes asctime_r(), ctime_r(), gmtime_r() et localtime_r() sont mentionnées dans SUSv2, et
disponibles depuis la libc 5.2.5.
POSIX.1-2001 indique : « Les fonctions asctime(), ctime(), gmtime() et localtime() retourneront les valeurs
dans l'un des deux objets statiques : une structure de temps détraquée et un tableau de type char. L'exécution de
n'importe laquelle de ces fonctions peut écraser l'information renvoyée dans l'un ou l'autre de ces objets par
n'importe quelle autre fonction. » cela peut arriver dans l'implémentation de la glibc.
MEDJADBA
Dans beaucoup d'implémentations, incluant la glibc, un 0 dans tm_mday est interprété comme étant le dernier
jour du mois précédent.
La version glibc de la struct tm a des champs supplémentaires :
long tm_gmtoff; /* Secondes vers l'Est du temps TU */

const char *tm_zone; /* Abréviation du nom de fuseau */
présents quand _BSD_SOURCE est définiE avant l'inclusion de <time.h>. Ceci est une extension BSD, présente
dans 4.3BSD-Reno.
Comformément à POSIX.1-2004, localtime() est doit se comporter comme si tzset() était appelée alors
que localtime_r() n'a pas ce pré-requis. Dans un code portable tzset() devrait être appelé
avant localtime_r().
VOIR AUSSI
date(1), clock(2), gettimeofday(2), time(2), utime(2), difftime(3), strftime(3), strptime(3), timegm(3), tzset(3), time(7)
TRADUCTION
Ce document est une traduction réalisée par Christophe Blaess <http://www.blaess.fr/christophe/> le

23 octobre 1996 et révisée le 17 juillet 2008.
L'équipe de traduction a fait le maximum pour réaliser une adaptation française de qualité. La version anglaise la
plus à jour de ce document est toujours consultable via la commande : « LANG=C man 3 ctime ». N'hésitez pas
à signaler à l'auteur ou au traducteur, selon le cas, toute erreur dans cette page de manuel.
Simlation de ls -l
#include <stdio.h>
#include <stdlib.h>
#include <pwd.h>
#include <grp.h>
#include <time.h>
int main(int argc, char *argv[]) {

struct stat StatusBuffer;
if (stat(argv[1], &StatusBuffer) == -1) {
perror(argv[1]);
exit(1);
}
if (S_ISREG(StatusBuffer.st_mode)) {
printf("-");
} else if (S_ISDIR(StatusBuffer.st_mode)) {
MEDJADBA
printf("d");
}
else if (S_ISCHR(StatusBuffer.st_mode)) {
printf("c"); }
else if (S_ISBLK(StatusBuffer.st_mode)) {
printf("b"); }
else if (S_ISSOCK(StatusBuffer.st_mode)) {
printf("s"); }
else if (S_ISLNK(StatusBuffer.st_mode)) {
printf("l"); }
else if (S_ISFIFO(StatusBuffer.st_mode)) {
printf("p"); }
printf ("%c", StatusBuffer.st_mode & S_IRUSR ? 'r' : '-');

printf ("%c", StatusBuffer.st_mode & S_IWUSR ? 'w' : '-');
printf ("%c", StatusBuffer.st_mode & S_IXUSR ? 'x' : '-');
printf ("%c", StatusBuffer.st_mode & S_IRGRP ? 'r' : '-');

printf ("%c", StatusBuffer.st_mode & S_IWGRP ? 'w' : '-');
printf ("%c", StatusBuffer.st_mode & S_IXGRP ? 'x' : '-');
printf ("%c", StatusBuffer.st_mode & S_IROTH ? 'r' : '-');

printf ("%c", StatusBuffer.st_mode & S_IWOTH ? 'w' : '-');
printf ("%c", StatusBuffer.st_mode & S_IXOTH ? 'x' : '-');
printf(" %d ", StatusBuffer.st_nlink);

printf("%s ",getpwuid(StatusBuffer.st_uid)->pw_name);
printf("%s ",getgrgid(StatusBuffer.st_uid)->gr_name);
printf("%ld ",StatusBuffer.st_size);
printf("%s ",ctime(&StatusBuffer.st_mtime));
printf(" %s\n",argv[1]);
return EXIT_SUCCESS;
}
Exo3 :
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
MEDJADBA
{
char buf;
int fd1,fd2;
struct stat StatusBuffer;
//Verifier nombre d'arguments

if (argc != 3){
printf("Manque d'arguments, il faut entrer les deux fichiers !\n");
return -1;
}
stat(argv[1], &StatusBuffer);
mode_t mode = StatusBuffer.st_mode; // on sauvegarde les mode de permision de l'executable
// pour utiliser dans la creation de fichier
//verifier si le fichier existe
fd1 = open(argv[1], O_RDONLY); //ouvrir le fichier en lecture seul
if (fd1 == -1){
printf("Le fichier %s n'existe pas ! \n",argv[1]);
return -1;
}
//ouvrir le fichier s'il existe en ecriture seul sinon elle va le cree
fd2 = open(argv[2], O_WRONLY | O_CREAT, mode );
if (fd2 == -1)
{
printf("Erreur d'ouverture ou de creation ! \n",argv[2]);
close(fd1);//fermer le fichier 1 (en cas d'erreur)
return -1;
}
//Copier le contenu du fichier 1 dans le fichier 2

while (read(fd1, &buf, 1) != 0)
write(fd2, &buf, 1);
printf("Copie terminée\n");
return 0;
}
MEDJADBA
OPENDIR
NOM
opendir, fdopendir - Ouvrir un répertoire
SYNOPSIS
#include <dirent.h>
DIR *opendir(const char *name);

DIR *fdopendir(int fd);
DESCRIPTION
La fonction opendir() ouvre un flux répertoire correspondant au répertoire name, et renvoie un pointeur sur ce flux. Le flux est positionné sur la
première entrée du répertoire.
VALEUR RENVOYÉE
Les fonctions opendir() et fdopendir() renvoient un pointeur sur le flux répertoire ou NULL si une erreur se produit, auquel
cas errno contient le code d'erreur.
ERREURS
EACCES
Accès interdit.
EBADF
fd n'est pas un descripteur de fichier ouvert en lecture valide.
EMFILE
Trop de descripteurs de fichier pour le processus appelant.
ENFILE
Trop de fichiers ouverts simultanément sur le système.
ENOENT
Le répertoire n'existe pas, ou name est une chaîne vide.
ENOMEM
Pas assez de mémoire pour terminer l'opération.
ENOTDIR
name n'est pas un répertoire
**************************************************************************************************************
READDIR
MEDJADBA
Mise à jour de la version anglaise : 4 juillet 2008
NOM
readdir, readdir_r - Consulter un répertoire
SYNOPSIS
#include <dirent.h>
struct dirent *readdir(DIR *dir);
int readdir(DIR *dir, struct dirent *entry, struct dirent **result);
DESCRIPTION
La fonction readdir() renvoie un pointeur sur une structure dirent représentant l'entrée suivante du flux répertoire
pointé par dir. Elle renvoie NULL à la fin du répertoire, ou en cas d'erreur.
Sous Linux, la structure dirent est définie de la façon suivante :
struct dirent {
ino_t d_ino; /* numéro d'inœud */
off_t d_off; /* décalage jusqu'à la dirent suivante */
unsigned short d_reclen; /* longueur de cet enregistrement */
unsigned char d_type; /* type du fichier */
char d_name[256]; /* nom du fichier */
};
D'après POSIX, la structure dirent contient un champ char d_name[] de taille non spécifiée, avec au
plus NAME_MAX caractères avant l'octet nul final. POSIX.1-2001 documente aussi le champ ino_t d_ino comme une
extension XSI. Les autres champs ne sont pas normalisés et ne sont pas présents sur tous les systèmes ; voir la section
NOTES plus loin pour plus de détails.
Les données renvoyées par readdir() sont écrasées lors de l'appel suivant à readdir() sur le même flux répertoire.
VALEUR RENVOYÉE
La fonction readdir() renvoie un pointeur sur une structure dirent, ou NULL lorsqu'une erreur se produit, ou lorsque la
fin du répertoire est atteinte. Si une erreur se produit, errno contient le code d'erreur.
ERREURS
EBADF
Le descripteur de flux répertoire dir n'est pas valide.
CONFORMITÉ
MEDJADBA
SVr4, BSD 4.3, POSIX.1-2001.
NOTES
Seuls les champs d_name et d_ino sont spécifiés par POSIX.1-2001. Les autres champs sont disponibles sur beaucoup
de systèmes, mais pas sur tous. Avec la glibc, les programmes peuvent vérifier la disponibilité des champs non définis
par POSIX.1 en testant si les
macros _DIRENT_HAVE_D_NAMLEN, _DIRENT_HAVE_D_RECLEN, _DIRENT_HAVE_D_OFF ou _DIRENT_HAVE
_D_TYPE sont définies.
Ailleurs que sous Linux, le champ d_type n'est principalement disponible que sur les systèmes BSD. Ce champ permet
d'éviter de devoir appeler stat(2) si d'autres actions dépendent du type de fichier. Si la macro de test de
fonctionnalités _BSD_SOURCE est définie, la glibc définit les constantes suivantes pour la valeur renvoyée
dans d_type :
DT_BLK
C'est un périphérique de blocs.
DT_CHR
C'est un périphérique de caractères.
DT_DIR
C'est un répertoire.
DT_FIFO
C'est un tube nommé (FIFO).
DT_LNK
C'est un lien symbolique.
DT_REG
C'est un fichier ordinaire.
DT_SOCK
C'est une socket de domaine Unix.
DT_UNKNOWN
Le type de fichier est inconnu.
Si le type de fichier ne peut pas être déterminé, la valeur DT_UNKNOWN est renvoyée dans d_type.
Puisque POSIX.1 ne spécifie pas la taille du champ d_name, et que d'autres champs non standard peuvent précéder ce
champ dans la structure dirent, les applications portables utilisant readdir_r() devraient allouer le tampon dont
l'adresse est passée dans entry de la façon suivante :
Question2
GETOPT
NOM
getopt, getopt_long, getopt_long_only, optarg, optind, opterr, optopt - Analyser les options de la ligne de commande
SYNOPSIS
MEDJADBA
#include <unistd.h>
int getopt(int argc, char * const argv[],

const char *optstring);
extern char *optarg;

extern int optind, opterr, optopt;
#define _GNU_SOURCE
#include <getopt.h>
int getopt_long (int argc, char * const argv[],

const char *optstring,
const struct option *longopts, int *longindex);
int getopt_long_only (int argc, char * const argv[],

const char *optstring,
const struct option *longopts, int *longindex);
DESCRIPTION
La fonction getopt() analyse les arguments de la ligne de commande. Ses éléments argc et argv correspondent aux nombres
et à la table d'arguments qui sont transmis à la fonction main() lors du lancement du programme. Un élément de argv qui
commence par « - » (et qui ne soit pas uniquement « -- » ou « - ») est considéré comme une option. Les caractères à la suite
du « - » initial sont les caractères de l'option. Si getopt() est appelée à plusieurs reprises, elle renverra successivement
chaque caractère de chaque option.
Si getopt() trouve un autre caractère d'option, elle le renvoie, mettant à jour la variable externe optind et la variable
statique nextchar, ainsi, getopt() peut continuer l'analyse avec le caractère suivant ou l'élément argv.
S'il n'y a plus de caractères d'option, getopt() renvoie -1. Alors, optind devient l'index du premier élément de argv qui ne soit
pas une option.
optstring est une chaîne contenant l'ensemble des caractères d'option autorisés. Si un de ces caractères est suivi par un deux-
point (« : »), l'option nécessite un argument supplémentaire, et getopt() placera un pointeur sur le texte suivant dans le
même argv, ou sur le texte de l'élément argv suivant dans optarg. Un double deux-points (« :: ») signifie qu'une option prend
un argument optionnel. S'il existe un texte dans le même élément de argv, (c'est-à-dire dans le même mot que le nom de
l'option elle-même, par exemple « -oarg »), il est renvoyé dans optarg, sinon optarg est défini à zéro. Il s'agit d'une extension
GNU. Si optstring contient W suivi d'un point-virgule, alors -W foo est traité comme l'option longue --foo. (L'option -W est
réservée par POSIX.2 pour des extensions spécifiques à l'implémentation). Ce comportement, spécifique à la version GNU,
n'est pas disponible avant la bibliothèque glibc 2.
Par défaut, getopt() permute les éléments de argv au fur et à mesure de son analyse, ainsi tous les arguments éventuels ne
constituant pas des options se trouvent à la fin. Deux autres modes sont également implémentés : Si le premier caractère
de optstring vaut « + », ou si la variable d'environnement POSIXLY_CORRECT est valide, alors l'analyse s'arrête aussitôt
qu'un argument ne constituant pas une option est rencontré. Si le premier caractère de optstring vaut « - », alors les
arguments ne correspondant pas à une option sont manipulés comme s'ils étaient des arguments d'une option dont le
caractère serait le caractère de code 1. Ceci est utilisé par les programmes qui sont conçus pour recevoir des options et
d'autres éléments de argv dans n'importe quel ordre mais qui prennent en compte l'ordre de ces de types.
L'argument spécial « -- » arrête l'analyse des options, quelque soit le mode en cours.
Si getopt() ne reconnaît pas un caractère d'option, il affiche un message d'erreur sur la sortie standard stderr, stocke le
caractère dans optopt, et renvoie « ? ». Le programme appelant peut empêcher l'affichage du message d'erreur en
positionnant opterr à 0.
Si getopt() trouve dans argv un caractère d'option non inclus dans optstring, ou s'il manque un argument d'option, l'appel
renvoie « ? » et remplit la variable externe optopt avec le vrai caractère trouvé. Si le premier caractère de optstring (suivi par
« + » ou « - ») est un deux-points (« : »), alors getopt() renvoie « : » plutôt que « ? » pour indiquer un argument d'option
MEDJADBA
manquant. Si une erreur est détectée, si le premier caractère de optstring n'est pas un deux-points, et si la variable
externe opterr est non nulle, (non nulle par défaut), alors getopt() affiche un message d'erreur.
getopt_long() et getopt_long_only()
La fonction getopt_long() fonctionne comme getopt() sauf qu'elle accepte également des noms longs d'option,
commençant par deux tirets. (Si le programme n'accepte que les options longues, optstring devrait être spécifié
comme une chaîne vide « "" »), pas NULL.) Les noms longs d'option peuvent être abrégés, si l'abréviation est
unique, ou si elle correspond exactement à une option définie. Une option longue peut prendre un argument, de la
forme --arg=param ou --arg param.
longopts est un pointeur sur le premier élément d'un tableau de structures struct option déclarées dans <getopt.h> ainsi :
struct option {
const char *name;
int has_arg;
int *flag;
int val;
};
La signification des différents champs est la suivante :
name
est le nom de l'option longue.
has_arg
vaut : no_argument (ou 0), si l'option ne prend pas d'argument, required_argument (ou 1) si l'option
prend un argument, ou optional_argument (ou 2) si l'option prend un argument optionnel.
flag
spécifie la manière de renvoyer les résultats pour une option longue. Si flag vaut NULL,
alors getopt_long() renvoie val. (Par exemple, le programme appelant peut remplir val avec le caractère
de l'option courte correspondante). Sinon, getopt_long() renvoie 0, et flag pointe sur une variable
correspondant à val si l'option est trouvée, mais reste inchangé si l'option est absente.
val
est la valeur à renvoyer, ou à charger dans la variable pointée par flag.
Le dernier élément de la table doit être rempli avec des zéros.
Si longindex n'est pas NULL, il pointe vers une variable qui est définie avec l'index de l'option longue correspondant à longopts.
getopt_long_only() fonctionne comme getopt_long(), mais « - » tout comme « -- » indiquent une option longue. Si une
option commençant par « - » (et non « -- ») ne correspond pas à une option longue, mais correspond à une option courte, elle
est analysée en tant qu'option courte.
VALEUR RENVOYÉE
Si une option est trouvée, getopt() renvoie le caractère de l'option. Si toutes les options de la ligne de commande
ont été analysées, getopt() renvoie -1. Si getopt() rencontre un caractère d'option qui ne se trouve pas
dans optstring, « ? » est retourné. Si getopt() rencontre une option à laquelle il manque un argument, la valeur de
retour dépend du premier caractère de optstring : si c'est « : », « : » est retourné ; autrement « ? » est retourné.
MEDJADBA
getopt_long() et getopt_long_only() renvoient également le caractère d'option courte s'ils en trouvent une. Pour les options
longues, ils renvoient val si flag vaut NULL, et 0 sinon. Les erreurs et la fin des options sont gérées comme avec getopt(), en
renvoyant de surcroît « ? » pour une correspondance ambiguë, ou un paramètre en trop.
#include <stdio.h>
#include <dirent.h> //utilisation opendir(),DIR,closedir...

{
struct dirent *de; // pointeur pour l'entree du repertoire
DIR *dr;
if (argc==2) //nom de dossier entré en parametre

dr = opendir(argv[1]);
else// opendir() retourne un pointeur de type DIR
dr = opendir(".");
if (dr == NULL) //Cas d'erreur

{
perror(argv[1]);
return -1;
}
//chercher et afficher les noms des dossiers
while ((de = readdir(dr)) != NULL) //la fonction readdir renvoie un pointeur sur une structure dirent
printf("%s\n", de->d_name);
closedir(dr); //fermer le répertoire

return 0;
}
MEDJADBA
//question2 exo4
#include <unistd.h>
#include <stdio.h>
#include <dirent.h> //utilisation opendir(),DIR,closedir...

{
struct dirent *de; // pointeur pour l'entréee du répertoire

DIR *dr;
int opt;
if(argc!=2 && argc!=3) {printf("manque d'argument\n"); return -1;}
if (argc==3){ //nom de dossier entré en parametre
dr = opendir(argv[1]);
if (dr == NULL) //Cas d'erreur

{
perror(argv[1]);
return -1;
}
}
else if (argc==2)// opendir() retourne un pointeur de type DIR
dr = opendir(".");
opt=getopt(argc, argv, "fr"); // getopt est un fonction qui analyse les options de ligne de commande (ici -r et -f)
switch(opt)
{
case 'r':
while ((de = readdir(dr)) != NULL){ //la fonction readdir renvoie un pointeur sur une structure dirent
if (de->d_type == DT_DIR) //l'option -r affiche seulment les repertoires
printf("%s\n", de->d_name);}
break;
case 'f':
while ((de = readdir(dr)) != NULL){
if (de->d_type == DT_REG) //l'option -f affiche seulment les fichiers reguliers
printf("%s\n", de->d_name);}
break;
MEDJADBA
case '?': // cas ou on a une option diffrent de r ou f

printf("Option inconnu: %c\n", optopt);
break;
}

return 0;
}

TP1 TP2 Systeme L3 Explication

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

TP1 TP2 Systeme L3 Explication

Transféré par

Droits d'auteur :

Formats disponibles

Explication TP système L3 ACAD C

Argv[argc-1]: le dernier paramètres

int main(int argc, char **argv)

int main(int argc, char const *argv[])

int open(const char *pathname, int flags);

pathname Ce paramètre permet d'indiquer le nom du fichier.

O_CREAT Cette constante permet de créer le fichier.

Constante Valeur Description

Cette valeur permet d'indiquer que l'utilisateur a la

Cette valeur permet d'indiquer que l'utilisateur a la

Cette valeur permet d'indiquer que l'utilisateur a la

Cette valeur permet d'indiquer que l'utilisateur a la

Cette valeur permet d'indiquer que le groupe a la

Cette valeur permet d'indiquer que le groupe a la

Cette valeur permet d'indiquer que le groupe a la

Cette valeur permet d'indiquer que le groupe a la

Cette valeur permet d'indiquer que tous ont la

Cette valeur permet d'indiquer que tous ont la

Cette valeur permet d'indiquer que tous ont la

Cette valeur permet d'indiquer que tous ont la

O_EXCL tjrs combiné avec O_CREAT

mode = S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IWGRP| S_IROTH | S_IWOTH;

Exigences de macros de test de fonctionnalités pour la glibc (voir feature_test_macros(7)) :

lstat() : _BSD_SOURCE || _XOPEN_SOURCE >= 500

Le champ st_atime est modifié par les accès au fichier, c'est-à-dire

struct passwd *getpwnam(const char *name);

struct passwd *getpwuid(uid_t uid);

int getpwnam_r(const char *name, struct passwd *pwbuf,

int getpwuid_r(uid_t uid, struct passwd *pwbuf,

Exigences de macros de test de fonctionnalités pour la glibc (voir feature_test_macros(7)) :

getpwnam_r(), getpwuid_r() : _POSIX_C_SOURCE || _XOPEN_SOURCE || _BSD_SOURCE || _SVID_SOURCE

La structure passwd est définie dans <pwd.h> ainsi :

Ce document est une traduction réalisée par Christophe Blaess <http://www.blaess.fr/christophe/> le

La fonction getgrgid() renvoie un pointeur sur structure

La structure group est définie dans <grp.h> ainsi :

char *asctime(const struct tm *tm);

char *asctime_r(const struct tm *tm, char *buf);

char *ctime(const time_t *timep);

char *ctime_r(const time_t *timep, char *buf);

struct tm *gmtime(const time_t *timep);

struct tm *gmtime_r(const time_t *timep, struct tm *result);

struct tm *localtime(const time_t *timep);

struct tm *localtime_r(const time_t *timep, struct tm *result);

time_t mktime(struct tm *tm);

Exigences de macros de test de fonctionnalités pour la glibc (voir feature_test_macros(7)) :

asctime_r(), ctime_r(), gmtime_r(), localtime_r() :

Cette structure tm est définie dans <time.h> comme suit :

"Wed Jun 30 21:49:08 1993\n"

La version glibc de la struct tm a des champs supplémentaires :

long tm_gmtoff; /* Secondes vers l'Est du temps TU */

Ce document est une traduction réalisée par Christophe Blaess <http://www.blaess.fr/christophe/> le

int main(int argc, char *argv[]) {

printf ("%c", StatusBuffer.st_mode & S_IRUSR ? 'r' : '-');

printf ("%c", StatusBuffer.st_mode & S_IRGRP ? 'r' : '-');

printf ("%c", StatusBuffer.st_mode & S_IROTH ? 'r' : '-');

printf(" %d ", StatusBuffer.st_nlink);

//Verifier nombre d'arguments

//Copier le contenu du fichier 1 dans le fichier 2

DIR *opendir(const char *name);

struct dirent *readdir(DIR *dir);

int readdir(DIR *dir, struct dirent *entry, struct dirent **result);

Sous Linux, la structure dirent est définie de la façon suivante :

int getopt(int argc, char * const argv[],

extern char *optarg;

struct passwd getpwnam(const char name);

int getpwnam_r(const char name, struct passwd pwbuf,

char asctime(const struct tm tm);

char asctime_r(const struct tm tm, char *buf);

char ctime(const time_t timep);

char ctime_r(const time_t timep, char *buf);

struct tm gmtime(const time_t timep);

struct tm gmtime_r(const time_t timep, struct tm *result);

struct tm localtime(const time_t timep);

struct tm localtime_r(const time_t timep, struct tm *result);

DIR opendir(const char name);

struct dirent readdir(DIR dir);

int readdir(DIR dir, struct dirent entry, struct dirent **result);