perkamon - en to fr translation catalogue (243 entries)

note: type: TH
en: 2013-04-19
fr: 19 avril 2013

note: type: TH
en: Linux Programmer's Manual
fr: Manuel du programmeur Linux

note: type: SH
en: NAME
fr: NOM

note: type: Plain text
en: fgetgrent - get group file entry
fr: fgetgrent - Lire un fichier de groupe

note: type: Plain text
en: Feature Test Macro Requirements for glibc (see B<feature_test_macros>(7)):
fr: Exigences de macros de test de fonctionnalités pour la glibc (consultez B<feature_test_macros>(7)) :

note: type: Plain text
en: B<fgetgrent>(): _SVID_SOURCE
fr: B<fgetgrent>()\ : _SVID_SOURCE

note: type: Plain text
en: The B<fgetgrent>()  function returns a pointer to a structure containing the group information from the file referred to by I<stream>.  The first time it is called it returns the first entry; thereafter, it returns successive entries.  The file referred to by I<stream> must have the same format as I</etc/group> (see B<group>(5)).
fr: La fonction B<fgetgrent>() renvoie un pointeur vers une structure contenant les informations sur un groupe, lues depuis le fichier indiqué par I<stream>. La première fois qu'elle est appelée, elle retourne la première entrée du fichier, puis les appels successifs renverront les entrées suivantes. Le fichier indiqué par I<stream> doit avoir le même format que I</etc/group> (consultez B<group>(5)).

note: type: Plain text
en: The I<group> structure is defined in I<E<lt>grp.hE<gt>> as follows:
fr: La structure I<group> est définie dans I<E<lt>grp.hE<gt>> comme ceci\ :

note: type: Plain text
en: struct group {
        char   *gr_name;        /* group name */
        char   *gr_passwd;      /* group password */
        gid_t   gr_gid;         /* group ID */
        char  **gr_mem;         /* group members */
    };
fr: 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 */
    };

note: type: SH
en: RETURN VALUE
fr: VALEUR RENVOYÉE

note: type: Plain text
en: The B<fgetgrent>()  function returns a pointer to a I<group> structure, or NULL if there are no more entries or an error occurs.  In the event of an error, I<errno> is set to indicate the cause.
fr: La fonction B<fgetgrent>() renvoie un pointeur vers une structure I<group>, ou NULL s'il n'y a plus d'entrée, ou si une erreur a eu lieu.En cas d'erreur, I<errno> contient le code d'erreur.

note: type: SH
en: ERRORS
fr: ERREURS

note: not in POSIX to allocate the group structure, or to allocate buffers type: Plain text
en: Insufficient memory to allocate I<group> structure.
fr: Pas assez de mémoire pour allouer la structure I<group>.

note: type: SH
en: CONFORMING TO
fr: CONFORMITÉ

note: type: SH
en: SEE ALSO
fr: VOIR AUSSI

note: type: Plain text
en: This page is part of release 3.65 of the Linux I<man-pages> project.  A description of the project, and information about reporting bugs, can be found at \%http://www.kernel.org/doc/man-pages/.
fr: Cette page fait partie de la publication 3.65 du projet I<man-pages> Linux. Une description du projet et des instructions pour signaler des anomalies peuvent être trouvées à l'adresse \%http://www.kernel.org/doc/man-pages/.

note: type: Plain text
en: fgetpwent - get password file entry
fr: fgetpwent - Lire des entrées d'un fichier de mots de passe

note: type: Plain text
en: B<fgetpwent>(): _SVID_SOURCE
fr: B<fgetpwent>()\ : _SVID_SOURCE

note: type: Plain text
en: The B<fgetpwent>()  function returns a pointer to a structure containing the broken out fields of a line in the file I<stream>.  The first time it is called it returns the first entry; thereafter, it returns successive entries.  The file referred to by I<stream> must have the same format as I</etc/passwd> (see B<passwd>(5)).
fr: La fonction B<fgetpwent>() renvoie un pointeur vers une structure contenant les différents champs d'une ligne du fichier I<stream>. Lors de la première invocation, elle renvoie le premier enregistrement, ensuite elle retourne successivement les enregistrements suivants du fichier. Le fichier indiqué par I<stream> doit avoir le même format que I</etc/passwd> (consultez B<passwd>(5)).

note: type: Plain text
en: The I<passwd> structure is defined in I<E<lt>pwd.hE<gt>> as follows:
fr: La structure I<passwd> est définie dans I<E<lt>pwd.hE<gt>> comme ceci\ :

note: type: Plain text
en: struct passwd {
        char   *pw_name;       /* username */
        char   *pw_passwd;     /* user password */
        uid_t   pw_uid;        /* user ID */
        gid_t   pw_gid;        /* group ID */
        char   *pw_gecos;      /* real name */
        char   *pw_dir;        /* home directory */
        char   *pw_shell;      /* shell program */
    };
fr: struct passwd {
        char   *pw_name;       /* Nom d'utilisateur */
        char   *pw_passwd;     /* Mot de passe de l'utilisateur */
        uid_t   pw_uid;        /* ID de l'utilisateur */
        gid_t   pw_gid;        /* ID du groupe */
        char   *pw_gecos;      /* Nom réel */
        char   *pw_dir;        /* Répertoire personnel */
        char   *pw_shell;      /* Interpréteur de commande */
    };

note: type: Plain text
en: The B<fgetpwent>()  function returns a pointer to a I<passwd> structure, or NULL if there are no more entries or an error occurs.  In the event of an error, I<errno> is set to indicate the cause.
fr: La fonction B<fgetpwent>() renvoie un pointeur vers une structure I<passwd>, ou NULL si il n'y a plus d'enregistrement, ou si une erreur s'est produite.En cas d'erreur, I<errno> contient le code d'erreur.

note: not in POSIX This structure is static, allocated 0 or 1 times. No memory leak. (libc45) type: Plain text
en: Insufficient memory to allocate I<passwd> structure.
fr: Pas assez de mémoire pour allouer la structure I<passwd>.

note: type: SH
en: FILES
fr: FICHIERS

note: type: Plain text
en: password database file
fr: Fichier de base de données des mots de passe

note: type: TH
en: 2000-08-27
fr: 27 août 2000

note: type: Plain text
en: ftpusers - list of users that may not log in via the FTP daemon
fr: ftpusers - Liste des utilisateurs interdits de connexion par FTP

note: type: Plain text
en: The text file B<ftpusers> contains a list of users that may not log in using the File Transfer Protocol (FTP) server daemon.  This file is used not merely for system administration purposes but for improving security within a TCP/IP networked environment.  It will typically contain a list of the users that either have no business using ftp or have too many privileges to be allowed to log in through the FTP server daemon.  Such users usually include root, daemon, bin, uucp, and news.  If your FTP server daemon doesn't use B<ftpusers>, then it is suggested that you read its documentation to find out how to block access for certain users.  Washington University FTP server Daemon (wuftpd) and Professional FTP Daemon (proftpd) are known to make use of B<ftpusers>.
fr: Le fichier de texte I<ftpusers> contient une liste des utilisateurs qui ne doivent pas se connecter via le démon serveur FTP (File Transfer Protocol). Ce fichier est utilisé non seulement pour l'administration système mais également pour augmenter la sécurité du réseau. Il contient typiquement la liste des utilisateurs qui soit n'ont rien à faire avec le transfert ftp, soit ont trop de privilèges pour être autorisés à se connecter par ce démon serveur. De tels utilisateurs sont en général root, daemon, bin, uucp et news. Si votre serveur FTP n'utilise pas I<ftpusers>, il est alors conseillé de lire sa documentation pour savoir comment bloquer l'accès à certains utilisateurs. Le démon serveur FTP Washington University (wuftpd) et le démon Professional FTP (proftpd) utilisent notoirement I<ftpusers>.

note: type: Plain text
en: The format of B<ftpusers> is very simple.  There is one account name (or username) per line.  Lines starting with a # are ignored.
fr: Le format du fichier I<ftpusers> est très simple. Il y a un nom de compte (nom d'utilisateur) par ligne. Les lignes commençant par un «\ #\ » sont ignorées.

note: type: TH
en: 2013-06-21
fr: 21 juin 2013

note: type: Plain text
en: getgrent, setgrent, endgrent - get group file entry
fr: getgrent, setgrent, endgrent - Lire les enregistrements du fichier de groupes

note: type: Plain text
en: B<setgrent>():
fr: B<setgrent>() :

note: type: Plain text
en: /* Since glibc 2.12: */ _POSIX_C_SOURCE\ E<gt>=\ 200809L
fr: /* Depuis la glibc 2.12 : */ _POSIX_C_SOURCE\ E<gt>=\ 200809L

note: type: Plain text
en: B<getgrent>(), B<endgrent>():
fr: B<getgrent>(), B<endgrent>()\ :

note: type: Plain text
en: The B<getgrent>()  function returns a pointer to a structure containing the broken-out fields of a record in the group database (e.g., the local group file I</etc/group>, NIS, and LDAP).  The first time B<getgrent>()  is called, it returns the first entry; thereafter, it returns successive entries.
fr: La fonction B<getgrent>() renvoie un pointeur sur une structure contenant les champs d'un enregistrement de la base de données de groupe (par exemple, le fichier de groupe local I</etc/group>, NIS ou LDAP). Au premier appel, B<getgrent>() renvoie le premier enregistrement, puis les autres enregistrements lors des appels successifs.

note: type: Plain text
en: The B<setgrent>()  function rewinds to the beginning of the group database, to allow repeated scans.
fr: La fonction B<setgrent>() ramène le pointeur au début de la base de données de groupe pour permettre des balayages répétitifs.

note: type: Plain text
en: The B<endgrent>()  function is used to close the group database after all processing has been performed.
fr: La fonction B<endgrent>() est utilisée pour fermer la base de données de groupe après que toutes les actions ont été réalisées.

note: type: Plain text
en: struct group {
        char   *gr_name;       /* group name */
        char   *gr_passwd;     /* group password */
        gid_t   gr_gid;        /* group ID */
        char  **gr_mem;        /* group members */
    };
fr: 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 */
    };

note: type: Plain text
en: For more information about the fields of this structure, see B<group>(5).
fr: Pour plus d'informations à propos des champs de cette structure, consultez B<group>(5).

note: type: Plain text
en: The B<getgrent>()  function returns a pointer to a I<group> structure, or NULL if there are no more entries or an error occurs.
fr: La fonction B<getgrent>() renvoie un pointeur vers une structure I<group> ou un pointeur NULL s'il n'y a plus d'enregistrement, ou si une erreur se produit.

note: type: Plain text
en: Upon error, I<errno> may be set.  If one wants to check I<errno> after the call, it should be set to zero before the call.
fr: En cas d'erreur, I<errno> peut être positionnée. Si vous souhaitez vérifier sa valeur, il est nécessaire de la positionner à zéro avant l'appel.

note: type: Plain text
en: The return value may point to a static area, and may be overwritten by subsequent calls to B<getgrent>(), B<getgrgid>(3), or B<getgrnam>(3).  (Do not pass the returned pointer to B<free>(3).)
fr: La valeur de retour peut pointer sur une zone de mémoire statique et peut être écrasée par des appels successifs à B<getgrent>(), B<getgrgid>(3) ou B<getgrnam>(3). (Ne pas passer le pointeur renvoyé à B<free>(3).)

note: type: Plain text
en: A signal was caught.
fr: Un signal a été intercepté.

note: type: Plain text
en: I/O error.
fr: Erreur d'entrée-sortie.

note: type: Plain text
en: The calling process already has too many open files.
fr: Le nombre maximal de fichiers ouverts pour le processus est atteint.

note: type: Plain text
en: Too many open files in the system.
fr: Le nombre maximal de fichiers ouverts sur le système est atteint.

note: type: Plain text
en: Insufficient buffer space supplied.
fr: L'espace tampon fourni est insuffisant.

note: type: Plain text
en: local group database file
fr: Base de données des groupes locaux

note: type: SH
en: ATTRIBUTES
fr: ATTRIBUTS

note: type: SS
en: Multithreading (see pthreads(7))
fr: Multithreading (voir pthreads(7))

note: type: Plain text
en: The B<getgrent>()  function is not thread-safe.
fr: La fonction B<getgrent>() n'est pas sûre dans un contexte multithread.

note: type: Plain text
en: The B<setgrent>()  and B<endgrent>()  functions are thread-safe.
fr: Les fonctions B<setgrent>() et B<endgrent>() sont sûres dans un contexte multithread.

note: type: Plain text
en: SVr4, 4.3BSD, POSIX.1-2001.
fr: SVr4, BSD\ 4.3, POSIX.1-2001.

note: type: TH
en: 2010-10-21
fr: 21 octobre 2010

note: type: Plain text
en: getgrent_r, fgetgrent_r - get group file entry reentrantly
fr: getgrent_r, fgetgrent_r - Obtenir un enregistrement du fichier group de manière réentrante

note: FIXME . The FTM requirements seem inconsistent here.  File a glibc bug? type: Plain text
en: B<getgrent_r>(): _GNU_SOURCE
fr: B<getgrent_r>()\ : _GNU_SOURCE

note: type: Plain text
en: B<fgetgrent_r>(): _SVID_SOURCE
fr: B<fgetgrent_r>()\ : _SVID_SOURCE

note: type: Plain text
en: The functions B<getgrent_r>()  and B<fgetgrent_r>()  are the reentrant versions of B<getgrent>(3)  and B<fgetgrent>(3).  The former reads the next group entry from the stream initialized by B<setgrent>(3).  The latter reads the next group entry from the stream I<fp>.
fr: Les fonctions B<getgrent_r>() et B<fgetgrent_r>() sont les versions réentrantes des fonctions B<getgrent>(3) et B<fgetgrent>(3). La première lit l'enregistrement group suivant à partir du flux initialisé par B<setgrent>(3). La seconde lit l'enregistrement group suivant à partir du flux I<fp>.

note: type: Plain text
en: struct group {
        char    *gr_name;     /* group name */
        char    *gr_passwd;   /* group password */
        gid_t    gr_gid;      /* group ID */
        char   **gr_mem;      /* group members */
    };
fr: 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*/
    };

note: type: Plain text
en: The nonreentrant functions return a pointer to static storage, where this static storage contains further pointers to group name, password and members.  The reentrant functions described here return all of that in caller-provided buffers.  First of all there is the buffer I<gbuf> that can hold a I<struct group>.  And next the buffer I<buf> of size I<buflen> that can hold additional strings.  The result of these functions, the I<struct group> read from the stream, is stored in the provided buffer I<*gbuf>, and a pointer to this I<struct group> is returned in I<*gbufp>.
fr: Les fonctions non réentrantes renvoient un pointeur sur une zone statique, zone qui contient d'autres pointeurs vers le nom, le mot de passe et les membres du groupe. Les fonctions réentrantes décrites ici renvoient tout ceci dans des tampons fournis par l'appelant. Il y a tout d'abord le tampon I<gbuf> qui contient une structure I<group>. Puis le tampon I<buf> de taille I<buflen> qui contient les chaînes supplémentaires. Le résultat de ces fonctions, la structure I<group> lue dans le flux, est enregistré dans le tampon I<*gbuf> fourni, et un pointeur vers cette structure I<group> est renvoyé dans I<*gbufp>.

note: type: Plain text
en: On success, these functions return 0 and I<*gbufp> is a pointer to the I<struct group>.  On error, these functions return an error value and I<*gbufp> is NULL.
fr: Si elles réussissent, ces fonctions renvoient 0 et I<*gbufp> est un pointeur vers la structure I<group>. Si elles échouent, ces fonctions renvoient une valeur d'erreur et I<*gbufp> est NULL.

note: type: Plain text
en: No more entries.
fr: Plus d'entrées.

note: type: Plain text
en: Insufficient buffer space supplied.  Try again with larger buffer.
fr: L'espace tampon fourni est insuffisant. Veuillez essayer à nouveau avec un tampon plus grand.

note: type: Plain text
en: These functions are GNU extensions, done in a style resembling the POSIX version of functions like B<getpwnam_r>(3).  Other systems use prototype
fr: Ces fonctions sont des extensions GNU, effectuées dans un style ressemblant à la version POSIX de fonctions comme B<getpwnam_r>(3). D'autres systèmes utilisent le prototype

note: type: Plain text
en: or, better,
fr: ou mieux,

note: type: Plain text
en: The function B<getgrent_r>()  is not really reentrant since it shares the reading position in the stream with all other threads.
fr: La fonction B<getgrent_r>() n'est pas vraiment réentrante puisqu'elle partage la position de lecture dans le flux avec tous les autres fils (threads).

note: type: SH
en: EXAMPLE
fr: EXEMPLE

note: type: TH
en: 2013-07-22
fr: 22 juillet 2013

note: type: Plain text
en: getgrnam, getgrnam_r, getgrgid, getgrgid_r - get group file entry
fr: getgrnam, getgrnam_r, getgrgid, getgrgid_r - Obtenir l'enregistrement d'un groupe

note: type: Plain text
en: B<getgrnam_r>(), B<getgrgid_r>():
fr: B<getgrnam_r>(), B<getgrgid_r>() :

note: type: Plain text
en: The B<getgrnam>()  function returns a pointer to a structure containing the broken-out fields of the record in the group database (e.g., the local group file I</etc/group>, NIS, and LDAP)  that matches the group name I<name>.
fr: La fonction B<getgrnam>() renvoie un pointeur vers une structure contenant les champs de l'enregistrement de la base de données de groupe (par exemple, le fichier de groupes local I</etc/group>, NIS, et LDAP) correspondant au nom I<name>.

note: type: Plain text
en: The B<getgrgid>()  function returns a pointer to a structure containing the broken-out fields of the record in the group database that matches the group ID I<gid>.
fr: La fonction B<getgrgid>() renvoie un pointeur vers une structure contenant les champs de l'enregistrement de la base de données de groupe correspondant au GID I<gid>.

note: type: Plain text
en: The B<getgrnam_r>()  and B<getgrgid_r>()  functions obtain the same information as B<getgrnam>()  and B<getgrgid>(), but store the retrieved I<group> structure in the space pointed to by I<grp>.  The string fields pointed to by the members of the I<group> structure are stored in the buffer I<buf> of size I<buflen>.  A pointer to the result (in case of success) or NULL (in case no entry was found or an error occurred) is stored in I<*result>.
fr: Les fonctions B<getgrnam_r>() et B<getgrgid_r>() fournissent la même information que B<getgrnam>() et B<getgrgid>() mais enregistrent la structure I<group> trouvée dans l'espace pointé par I<grp>. Cette structure I<group> contient des pointeurs vers des chaînes de caractères qui sont enregistrées dans le tampon I<buf> de taille I<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 soit survenue) est enregistré dans I<*result>.

note: type: Plain text
en: The call
fr: L'appel

note: type: Plain text
en: returns either -1, without changing I<errno>, or an initial suggested size for I<buf>.  (If this size is too small, the call fails with B<ERANGE>, in which case the caller can retry with a larger buffer.)
fr: renvoie soit -1 sans modifier I<errno>, soit une suggestion de taille initiale pour I<buf> (si cette taille est trop petite, l'appel échoue avec B<ERANGE>, auquel cas l'appelant peut réessayer avec un tampon plus grand).

note: type: Plain text
en: The B<getgrnam>()  and B<getgrgid>()  functions return a pointer to a I<group> structure, or NULL if the matching entry is not found or an error occurs.  If an error occurs, I<errno> is set appropriately.  If one wants to check I<errno> after the call, it should be set to zero before the call.
fr: Les fonctions B<getgrnam>() et B<getgrgid>() renvoient un pointeur vers une structure I<group>, ou NULL s'il n'y a pas de correspondance, ou si une erreur se produit. Dans ce cas, I<errno> est défini en conséquence. Si on souhaite vérifier I<errno> après l'appel, il devrait être positionné à zéro avant l'appel.

note: type: Plain text
en: The return value may point to a static area, and may be overwritten by subsequent calls to B<getgrent>(3), B<getgrgid>(), or B<getgrnam>().  (Do not pass the returned pointer to B<free>(3).)
fr: La valeur de retour peut pointer sur une zone de mémoire statique et peut être écrasée par des appels successifs à B<getgrent>(3), B<getgrgid>() ou B<getgrnam>(). (Ne pas passer le pointeur renvoyé à B<free>(3).)

note: type: Plain text
en: On success, B<getgrnam_r>()  and B<getgrgid_r>()  return zero, and set I<*result> to I<grp>.  If no matching group record was found, these functions return 0 and store NULL in I<*result>.  In case of error, an error number is returned, and NULL is stored in I<*result>.
fr: En cas de succès, B<getgrnam_r>() et B<getgrgid_r>() renvoient 0, et définissent I<*result> à I<grp>. Si aucun enregistrement de groupe de correspondance est trouvé, ces fonctions renvoient 0 et définissent I<*result> à NULL. En cas d'erreur, un numéro d'erreur est renvoyé et I<*result> est défini à NULL.

note: type: TP
en: B<0> or B<ENOENT> or B<ESRCH> or B<EBADF> or B<EPERM> or ...
fr: B<0> ou B<ENOENT> ou B<ESRCH> ou B<EBADF> ou B<EPERM> ou ...

note: type: Plain text
en: The given I<name> or I<gid> was not found.
fr: Le nom I<name> ou l'identifiant I<gid> n'ont pas été trouvés.

note: type: Plain text
en: The maximum number (B<OPEN_MAX>)  of files was open already in the calling process.
fr: Le nombre maximal (B<OPEN_MAX>) de fichiers ouverts par le processus est atteint.

note: type: Plain text
en: The maximum number of files was open already in the system.
fr: Le nombre maximal de fichiers ouverts sur le système est atteint.

note: type: Plain text
en: The B<getgrnam>()  and B<getgrgid>()  functions are not thread-safe.
fr: Les fonctions B<getgrnam>() et B<getgrgid>() ne sont pas sûres dans un contexte multithread.

note: type: Plain text
en: The B<getgrnam_r>()  and B<getgrgid_r>()  functions are thread-safe.
fr: Les fonctions B<getgrnam_r>() et B<getgrgid_r>() sont sûres dans un contexte multithread.

note: more precisely: AIX 5.1 - gives ESRCH OSF1 4.0g - gives EWOULDBLOCK libc, glibc up to version 2.6, Irix 6.5 - give ENOENT glibc since version 2.7 - give 0 FreeBSD 4.8, OpenBSD 3.2, NetBSD 1.6 - give EPERM SunOS 5.8 - gives EBADF Tru64 5.1b, HP-UX-11i, SunOS 5.7 - give 0 type: Plain text
en: The formulation given above under "RETURN VALUE" is from POSIX.1-2001.  It does not call "not found" an error, hence does not specify what value I<errno> might have in this situation.  But that makes it impossible to recognize errors.  One might argue that according to POSIX I<errno> should be left unchanged if an entry is not found.  Experiments on various UNIX-like systems shows that lots of different values occur in this situation: 0, ENOENT, EBADF, ESRCH, EWOULDBLOCK, EPERM, and probably others.
fr: La description «\ VALEUR RENVOYÉE\ » ci-dessus provient de POSIX.1-2001. Elle ne considère pas le cas «\ non trouvé\ » comme une erreur et ne spécifie pas I<errno> dans ce cas. Cela rend la détection d'erreur impossible. On peut dire que, d'après POSIX, I<errno> est inchangé 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.

note: type: TH
en: 2008-07-03
fr: 3 juillet 2008

note: type: Plain text
en: getgrouplist - get list of groups to which a user belongs
fr: getgrouplist - Obtenir la liste des groupes auxquels appartient un utilisateur

note: type: Plain text
en: B<getgrouplist>(): _BSD_SOURCE
fr: B<getgrouplist>()\ : _BSD_SOURCE

note: type: Plain text
en: The B<getgrouplist>()  function scans the group database (see B<group>(5))  to obtain the list of groups that I<user> belongs to.  Up to I<*ngroups> of these groups are returned in the array I<groups>.
fr: La fonction B<getgrouplist>() balaie la base de données des groupes (voir B<group>(5)) pour obtenir la liste des groupes auxquels appartient l'utilisateur I<user>. Jusqu'à I<*ngroups> de ces groupes sont retournés dans le tableau I<groups>.

note: type: Plain text
en: If it was not among the groups defined for I<user> in the group database, then I<group> is included in the list of groups returned by B<getgrouplist>(); typically this argument is specified as the group ID from the password record for I<user>.
fr: S'il n'était pas parmi les groupes définis pour l'utilisateur I<user> dans la base de données des groupes, I<group> est inclus dans la liste des groupes retournée par B<getgrouplist> ; typiquement, cet argument est spécifié comme étant l'identifiant du groupe de l'utilisateur I<user> pris dans l'enregistrement correspondant dans le fichier des mots de passe.

note: type: Plain text
en: The I<ngroups> argument is a value-result argument: on return it always contains the number of groups found for I<user>, including I<group>; this value may be greater than the number of groups stored in I<groups>.
fr: L'argument I<ngroups> est un argument «\ valeur résultat\ »\ : au retour, il contient toujours le nombre de groupes trouvés pour l'utilisateur I<user>, incluant I<group> ; cette valeur peut être supérieure au nombre de groupes enregistrés dans I<groups>.

note: type: Plain text
en: If the number of groups of which I<user> is a member is less than or equal to I<*ngroups>, then the value I<*ngroups> is returned.
fr: Si le nombre de groupes auquel l'utilisateur I<user> appartient est inférieur ou égal à I<*ngroups>, la valeur I<*ngroups> est renvoyée.

note: type: Plain text
en: If the user is a member of more than I<*ngroups> groups, then B<getgrouplist>()  returns -1.  In this case, the value returned in I<*ngroups> can be used to resize the buffer passed to a further call B<getgrouplist>().
fr: Si l'utilisateur appartient à plus de I<*ngroups> groupes, B<getgrouplist>() renvoie -1. Dans ce cas, la valeur renvoyée dans I<*ngroups> peut être utilisée pour redimensionner le tampon passé à un appel B<getgrouplist>() ultérieur.

note: type: Plain text
en: This function is present since glibc 2.2.4.
fr: Cette fonction est présente depuis glibc 2.2.4.

note: type: Plain text
en: This function is nonstandard; it appears on most BSDs.
fr: Cette fonction n'est pas standard, elle est apparue sur la plupart des BSD.

note: type: SH
en: BUGS
fr: BOGUES

note: type: Plain text
en: In glibc versions before 2.3.3, the implementation of this function contains a buffer-overrun bug: it returns the complete list of groups for I<user> in the array I<groups>, even when the number of groups exceeds I<*ngroups>.
fr: Dans les versions de la glibc antérieures à la 2.3.3, l'implémentation de cette fonction comportait un bogue de débordement de tampon : elle renvoyait la liste complète des groupes de l'utilisateur I<user> dans le tableau I<groups>, même si le nombre de groupes était supérieur à I<*ngroups>.

note: type: Plain text
en: The program below displays the group list for the user named in its first command-line argument.  The second command-line argument specifies the I<ngroups> value to be supplied to B<getgrouplist>().  The following shell session shows examples of the use of this program:
fr: Le programme ci-dessous affiche la liste des groupes auxquels appartient l'utilisateur indiqué comme premier argument de la ligne de commande. Le second argument indique la valeur I<ngroups> à passer à B<getgrouplist>(). La session shell suivante montre des exemples d'utilisation de ce programme :

note: type: SS
en: Program source
fr: Source du programme

note: type: Plain text
en: getpw - reconstruct password line entry
fr: getpw - Reconstruire un enregistrement de mot de passe

note: type: Plain text
en: B<#define _GNU_SOURCE>             /* See feature_test_macros(7) */
    B<#include E<lt>sys/types.hE<gt>>
    B<#include E<lt>pwd.hE<gt>>
fr: B<#define _GNU_SOURCE>             /* Consultez feature_test_macros(7) */
    B<#include E<lt>sys/types.hE<gt>>
    B<#include E<lt>pwd.hE<gt>>

note: type: Plain text
en: The B<getpw>()  function reconstructs the password line entry for the given user ID I<uid> in the buffer I<buf>.  The returned buffer contains a line of format
fr: La fonction B<getpw>() reconstruit l'enregistrement de la ligne de mot de passe de l'utilisateur I<uid> et le place dans le tampon I<buf>. Ce tampon contient en retour une ligne au format suivant\ :

note: type: Plain text
en: struct passwd {
        char   *pw_name;       /* username */
        char   *pw_passwd;     /* user password */
        uid_t   pw_uid;        /* user ID */
        gid_t   pw_gid;        /* group ID */
        char   *pw_gecos;      /* user information */
        char   *pw_dir;        /* home directory */
        char   *pw_shell;      /* shell program */
    };
fr: struct passwd {
        char   *pw_name;       /* Nom d'utilisateur */
        char   *pw_passwd;     /* Mot de passe de l'utilisateur */
        uid_t   pw_uid;        /* ID de l'utilisateur */
        gid_t   pw_gid;        /* ID du groupe */
        char   *pw_gecos;      /* Information utilisateur */
        char   *pw_dir;        /* Répertoire personnel */
        char   *pw_shell;      /* Interpréteur de commande */
    };

note: type: Plain text
en: For more information about the fields of this structure, see B<passwd>(5).
fr: Pour plus d'informations à propos des champs de cette structure, consultez B<passwd>(5).

note: type: Plain text
en: The B<getpw>()  function returns 0 on success; on error, it returns -1, and I<errno> is set to indicate the error.
fr: Si elle réussit, la fonction B<getpw>() renvoie 0. En cas d'erreur, elle renvoie -1 et définit I<errno> en conséquence.

note: type: Plain text
en: I<buf> is NULL.
fr: I<buf> est NULL.

note: type: Plain text
en: No user corresponding to I<uid>.
fr: Pas d'utilisateur correspondant ç I<uid>.

note: type: Plain text
en: The B<getpw>()  function is dangerous as it may overflow the provided buffer I<buf>.  It is obsoleted by B<getpwuid>(3).
fr: La fonction B<getpw>() est dangereuse car elle peut provoquer un débordement du tampon I<buf>. Elle est rendue obsolète par B<getpwuid>(3).

note: type: Plain text
en: getpwent, setpwent, endpwent - get password file entry
fr: getpwent, setpwent, endpwent - Lire un enregistrement du fichier des mots de passe

note: type: Plain text
en: B<getpwent>(), B<setpwent>(), B<endpwent>():
fr: B<getpwent>(), B<setpwent>(), B<endpwent>() :

note: type: Plain text
en: The B<getpwent>()  function returns a pointer to a structure containing the broken-out fields of a record from the password database (e.g., the local password file I</etc/passwd>, NIS, and LDAP).  The first time B<getpwent>()  is called, it returns the first entry; thereafter, it returns successive entries.
fr: La fonction B<getpwent>() renvoie un pointeur sur une structure contenant les divers champs d'un enregistrement de la base de données des mots de passe (par exemple, le fichier de mots de passe local I</etc/passwd>, NIS ou LDAP). Au premier appel, B<getpwent>() renvoie le premier enregistrement, puis les enregistrements suivants lors des appels suivants.

note: type: Plain text
en: The B<setpwent>()  function rewinds to the beginning of the password database.
fr: La fonction B<setpwent>() ramène le pointeur de fichier au début de base de données des mots de passe.

note: type: Plain text
en: The B<endpwent>()  function is used to close the password database after all processing has been performed.
fr: La fonction B<endpwent>() est utilisée pour fermer la base de données des mots de passe après que toutes les actions ont été réalisées.

note: type: Plain text
en: The B<getpwent>()  function returns a pointer to a I<passwd> structure, or NULL if there are no more entries or an error occurs.  If an error occurs, I<errno> is set appropriately.  If one wants to check I<errno> after the call, it should be set to zero before the call.
fr: La fonction B<getpwent>() renvoie un pointeur sur une structure I<passwd>, ou NULL si une erreur s'est produite ou s'il n'y a plus d'enregistrement. En cas d'erreur, I<errno> est positionnée en conséquence. Si vous souhaitez vérifier I<errno> après l'appel, celle-ci doit être positionnée à zéro avant l'appel.

note: type: Plain text
en: The return value may point to a static area, and may be overwritten by subsequent calls to B<getpwent>(), B<getpwnam>(3), or B<getpwuid>(3).  (Do not pass the returned pointer to B<free>(3).)
fr: La valeur de retour peut pointer vers une zone statique et donc être écrasée par des appels successifs à B<getpwent>(), B<getpwnam>(3) ou B<getpwuid>(3). (Ne pas passer le pointeur renvoyé à B<free>(3).)

note: type: Plain text
en: local password database file
fr: Base de données des mots de passe locaux

note: type: Plain text
en: The B<getpwent>()  function is not thread-safe.
fr: La fonction B<getpwent>() n'est pas sûre dans un contexte multithread.

note: type: Plain text
en: The B<setpwent>()  and B<endpwent>()  functions are thread-safe.
fr: Les fonctions B<setpwent>() et B<endpwent>() sont sûres dans un contexte multithread.

note: type: Plain text
en: SVr4, 4.3BSD, POSIX.1-2001.  The I<pw_gecos> field is not specified in POSIX, but is present on most implementations.
fr: SVr4, 4.3BSD, POSIX.1-2001. Le champ I<pw_gecos> n'est pas spécifié dans POSIX, mais il est présent sur la plupart des implémentations.

note: type: Plain text
en: getpwent_r, fgetpwent_r - get passwd file entry reentrantly
fr: getpwent_r, fgetpwent_r - Obtenir un enregistrement du fichier passwd de manière réentrante

note: type: Plain text
en: B<getpwent_r>(), _BSD_SOURCE || _SVID_SOURCE
fr: B<getpwent_r>()\ : _BSD_SOURCE || _SVID_SOURCE

note: type: Plain text
en: B<fgetpwent_r>(): _SVID_SOURCE
fr: B<fgetpwent_r>()\ : _SVID_SOURCE

note: type: Plain text
en: The functions B<getpwent_r>()  and B<fgetpwent_r>()  are the reentrant versions of B<getpwent>(3)  and B<fgetpwent>(3).  The former reads the next passwd entry from the stream initialized by B<setpwent>(3).  The latter reads the next passwd entry from the stream I<fp>.
fr: Les fonctions B<getpwent_r>() et B<fgetpwent_r>() sont les versions réentrantes des fonctions B<getpwent>(3) et B<fgetpwent>(3). La première lit l'enregistrement passwd suivant à partir du flux initialisé par B<setpwent>(3). La seconde lit l'enregistrement passwd suivant à partir du flux I<fp>.

note: type: Plain text
en: struct passwd {
        char    *pw_name;      /* username */
        char    *pw_passwd;    /* user password */
        uid_t    pw_uid;       /* user ID */
        gid_t    pw_gid;       /* group ID */
        char    *pw_gecos;     /* user information */
        char    *pw_dir;       /* home directory */
        char    *pw_shell;     /* shell program */
    };
fr: struct passwd {
        char    *pw_name;      /* Nom d'utilisateur */
        char    *pw_passwd;    /* Mot de passe de l'utilisateur */
        uid_t    pw_uid;       /* ID de l'utilisateur */
        gid_t    pw_gid;       /* ID du groupe */
        char    *pw_gecos;     /* Information utilisateur */
        char    *pw_dir;       /* Répertoire personnel */
        char    *pw_shell;     /* Interpréteur de commande */
    };

note: type: Plain text
en: The nonreentrant functions return a pointer to static storage, where this static storage contains further pointers to user name, password, gecos field, home directory and shell.  The reentrant functions described here return all of that in caller-provided buffers.  First of all there is the buffer I<pwbuf> that can hold a I<struct passwd>.  And next the buffer I<buf> of size I<buflen> that can hold additional strings.  The result of these functions, the I<struct passwd> read from the stream, is stored in the provided buffer I<*pwbuf>, and a pointer to this I<struct passwd> is returned in I<*pwbufp>.
fr: Les fonctions non réentrantes renvoient un pointeur sur une zone statique, zone qui contient d'autres pointeurs vers le nom, le mot de passe, le champ gecos, le répertoire personnel et le shell de l'utilisateur. Les fonctions réentrantes décrites ici renvoient tout ceci dans des tampons fournis par l'appelant. Il y a tout d'abord le tampon I<pwbuf> qui contient une structure I<passwd>. Puis le tampon I<buf> de taille I<buflen> qui contient les chaînes supplémentaires. Le résultat de ces fonctions, la structure I<passwd> lue dans le flux, est enregistré dans le tampon I<*pwbuf> fourni, et un pointeur vers cette structure I<passwd> est renvoyé dans I<*pwbufp>.

note: type: Plain text
en: On success, these functions return 0 and I<*pwbufp> is a pointer to the I<struct passwd>.  On error, these functions return an error value and I<*pwbufp> is NULL.
fr: Si elles réussissent, ces fonctions renvoient 0 et I<*pwbufp> est un pointeur vers la structure I<passwd>. Si elles échouent, ces fonctions renvoient une valeur d'erreur et I<*pwbufp> est NULL.

note: type: Plain text
en: The function B<getpwent_r>()  is not really reentrant since it shares the reading position in the stream with all other threads.
fr: La fonction B<getpwent_r>() n'est pas vraiment réentrante puisqu'elle partage la position de lecture dans le flux avec tous les autres threads.

note: type: Plain text
en: getpwnam, getpwnam_r, getpwuid, getpwuid_r - get password file entry
fr: getpwnam, getpwnam_r, getpwuid, getpwuid_r - Lire un enregistrement du fichier des mots de passe

note: type: Plain text
en: B<getpwnam_r>(), B<getpwuid_r>():
fr: B<getpwnam_r>(), B<getpwuid_r>() :

note: type: Plain text
en: The B<getpwnam>()  function returns a pointer to a structure containing the broken-out fields of the record in the password database (e.g., the local password file I</etc/passwd>, NIS, and LDAP)  that matches the username I<name>.
fr: La fonction B<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 I</etc/passwd>, NIS ou LDAP) correspondant au nom d'utilisateur I<name>.

note: type: Plain text
en: The B<getpwuid>()  function returns a pointer to a structure containing the broken-out fields of the record in the password database that matches the user ID I<uid>.
fr: La fonction B<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'ID utilisateur I<uid>.

note: type: Plain text
en: See B<passwd>(5)  for more information about these fields.
fr: Consultez B<passwd>(5) pour plus d'informations sur ces champs.

note: type: Plain text
en: The B<getpwnam_r>()  and B<getpwuid_r>()  functions obtain the same information as B<getpwnam>()  and B<getpwuid>(), but store the retrieved I<passwd> structure in the space pointed to by I<pwd>.  The string fields pointed to by the members of the I<passwd> structure are stored in the buffer I<buf> of size I<buflen>.  A pointer to the result (in case of success) or NULL (in case no entry was found or an error occurred) is stored in I<*result>.
fr: Les fonctions B<getpwnam_r>() et B<getpwuid_r>() fournissent les mêmes informations que B<getpwnam>() et B<getpwuid>() mais enregistrent la structure I<passwd> trouvée dans l'espace pointé par I<pwd>. Cette structure I<passwd> contient des pointeurs vers des chaînes qui sont enregistrées dans le tampon I<buf> de taille I<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 soit survenue) est enregistré dans I<*result>.

note: type: Plain text
en: The B<getpwnam>()  and B<getpwuid>()  functions return a pointer to a I<passwd> structure, or NULL if the matching entry is not found or an error occurs.  If an error occurs, I<errno> is set appropriately.  If one wants to check I<errno> after the call, it should be set to zero before the call.
fr: Les fonctions B<getpwnam>() et B<getpwuid>() renvoient un pointeur sur une structure I<passwd>, ou NULL si une erreur se produit, ou si l'enregistrement correspondant n'est pas trouvé. En cas d'erreur, I<errno> est positionnée en conséquence. Si on souhaite vérifier I<errno> après l'appel, celle-ci devrait être positionnée à zéro avant l'appel.

note: type: Plain text
en: The return value may point to a static area, and may be overwritten by subsequent calls to B<getpwent>(3), B<getpwnam>(), or B<getpwuid>().  (Do not pass the returned pointer to B<free>(3).)
fr: La valeur de retour peut pointer vers une zone statique et donc être écrasée par des appels successifs à B<getpwent>(3), B<getpwnam>() ou B<getpwuid>(). (Ne pas passer le pointeur renvoyé à B<free>(3).)

note: type: Plain text
en: On success, B<getpwnam_r>()  and B<getpwuid_r>()  return zero, and set I<*result> to I<pwd>.  If no matching password record was found, these functions return 0 and store NULL in I<*result>.  In case of error, an error number is returned, and NULL is stored in I<*result>.
fr: En cas de succès, B<getpwnam_r>() et B<getpwuid_r>() renvoient zéro et définissent I<*result> à I<pwd>. Si aucun mot de passe ne correspond, ces fonctions renvoient 0 et définissent I<*result> à NULL. En cas d'erreur, un code d'erreur est renvoyé et I<*result> et définit à NULL.

note: type: Plain text
en: The given I<name> or I<uid> was not found.
fr: Le nom I<name> ou l'identifiant I<uid> n'ont pas été trouvés.

note: type: Plain text
en: The B<getpwnam>()  and B<getpwuid>()  functions are not thread-safe.
fr: Les fonctions B<getpwnam>() et B<getpwuid>() ne sont pas sûres dans un contexte multithread.

note: type: Plain text
en: The B<getpwnam_r>()  and B<getpwuid_r>()  functions are thread-safe.
fr: Les fonctions B<getpwnam_r>() et B<getpwuid_r>() sont sûres dans un contexte multithread.

note: more precisely: AIX 5.1 - gives ESRCH OSF1 4.0g - gives EWOULDBLOCK libc, glibc up to version 2.6, Irix 6.5 - give ENOENT glibc since version 2.7 - give 0 FreeBSD 4.8, OpenBSD 3.2, NetBSD 1.6 - give EPERM SunOS 5.8 - gives EBADF Tru64 5.1b, HP-UX-11i, SunOS 5.7 - give 0 type: Plain text
en: The formulation given above under "RETURN VALUE" is from POSIX.1-2001.  It does not call "not found" an error, and hence does not specify what value I<errno> might have in this situation.  But that makes it impossible to recognize errors.  One might argue that according to POSIX I<errno> should be left unchanged if an entry is not found.  Experiments on various UNIX-like systems show that lots of different values occur in this situation: 0, ENOENT, EBADF, ESRCH, EWOULDBLOCK, EPERM, and probably others.
fr: La description "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 I<errno> dans ce cas. Cela rend la détection d'erreur impossible. On peut dire que, d'après POSIX, I<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.

note: type: Plain text
en: The I<pw_dir> field contains the name of the initial working directory of the user.  Login programs use the value of this field to initialize the B<HOME> environment variable for the login shell.  An application that wants to determine its user's home directory should inspect the value of B<HOME> (rather than the value I<getpwuid(getuid())-E<gt>pw_dir>)  since this allows the user to modify their notion of "the home directory" during a login session.  To determine the (initial) home directory of another user, it is necessary to use I<getpwnam("username")-E<gt>pw_dir> or similar.
fr: Le champ I<pw_dir> contient le nom du répertoire de travail initial de l'utilisateur. Les programmes de connexion («\ login\ ») utilisent ce champ pour initialiser la variable d'environnement B<HOME> pour les interpréteurs de commandes initiaux. Une application qui souhaite déterminer le répertoire personnel des utilisateurs devrait lire la valeur de B<HOME> (au lieu de la valeur de I<getpwuid(getuid())-E<gt>pw_dir>) puisque que ceci permet à l'utilisateur de modifier «\ son répertoire personnel\ » lorsqu'il est connecté. Pour déterminer le répertoire personnel «\ initial\ » d'un autre utilisateur, il est nécessaire d'utiliser I<getpwnam("utilisateur")-E<gt>pw_dir> ou un équivalent.

note: type: Plain text
en: The program below demonstrates the use of B<getpwnam_r>()  to find the full username and user ID for the username supplied as a command-line argument.
fr: Le programme suivant est un exemple d'utilisation de B<getpwnam_r>() pour trouver le nom complet et l'identifiant du nom d'utilisateur fourni en paramètre.

note: type: Plain text
en: getspnam, getspnam_r, getspent, getspent_r, setspent, endspent, fgetspent, fgetspent_r, sgetspent, sgetspent_r, putspent, lckpwdf, ulckpwdf - get shadow password file entry
fr: getspnam, getspnam_r, getspent, getspent_r, setspent, endspent, fgetspent, fgetspent_r, sgetspent, sgetspent_r, putspent, lckpwdf, ulckpwdf - Obtenir un enregistrement du fichier des mots de passe cachés

note: type: Plain text
en: /* General shadow password file API */
fr: /* API du fichier des mots de passe cachés */

note: type: Plain text
en: /* GNU extension */
fr: /* Extension GNU */

note: type: Plain text
en: B<getspent_r>(), B<getspnam_r>(), B<fgetspent_r>(), B<sgetspent_r>():
fr: B<getspent_r>(), B<getspnam_r>(), B<fgetspent_r>(), B<sgetspent_r>() :

note: type: Plain text
en: Long ago it was considered safe to have encrypted passwords openly visible in the password file.  When computers got faster and people got more security-conscious, this was no longer acceptable.  Julianne Frances Haugh implemented the shadow password suite that keeps the encrypted passwords in the shadow password database (e.g., the local shadow password file I</etc/shadow>, NIS, and LDAP), readable only by root.
fr: Il a longtemps été considéré comme sûr d'avoir des mots de passe chiffrés ouvertement visibles dans le fichier des mots de passe. Lorsque les ordinateurs sont devenus plus rapides et que les gens sont devenus plus conscients des problèmes de sécurité, cela n'était plus acceptable. Julianne Frances Haugh a implémenté la suite d'utilitaires «\ shadow\ » qui conserve les mots de passe chiffrés dans la base de données des mots de passe cachés «\ shadow\ » (par exemple, le fichier local des mots de passe cachés I</etc/shadow>, NIS ou LDAP), lisible seulement par le superutilisateur.

note: FIXME I've commented out the following for the moment.  The relationship between PAM and nsswitch.conf needs to be clearly documented in one place, which is pointed to by the pages for the user, group, and shadow password functions. (Jul 2005, mtk) This shadow password setup has been superseded by P
en: The functions described below resemble those for the traditional password database (e.g., see B<getpwnam>(3)  and B<getpwent>(3)).
fr: Les fonctions décrites ci-dessous ressemblent aux fonctions traditionnelles de la base de données des mots de passe (par exemple, consultez B<getpwnam>(3) et B<getpwent>(3)).

note: type: Plain text
en: The B<getspnam>()  function returns a pointer to a structure containing the broken-out fields of the record in the shadow password database that matches the username I<name>.
fr: La fonction B<getspnam>() renvoie un pointeur vers une structure contenant les champs d'un enregistrement extrait de la base de données «\ shadow\ » de l'entrée correspondant à l'utilisateur de nom I<name>.

note: some systems require a call of setspent() before the first getspent() glibc does not type: Plain text
en: The B<getspent>()  function returns a pointer to the next entry in the shadow password database.  The position in the input stream is initialized by B<setspent>().  When done reading, the program may call B<endspent>()  so that resources can be deallocated.
fr: La fonction B<getspent>() renvoie un pointeur sur l'entrée suivante de la base de données «\ shadow\ ». La position dans le flux d'entrée est initialisée par B<setspent>(). Lorsque la lecture est finie, le programme devrait appeler B<endspent>() pour désallouer les ressources.

note: type: Plain text
en: The B<fgetspent>()  function is similar to B<getspent>()  but uses the supplied stream instead of the one implicitly opened by B<setspent>().
fr: La fonction B<fgetspent>() est similaire à B<getspent>() mais utilise le flux fourni plutôt que celui implicitement ouvert par B<setspent>().

note: type: Plain text
en: The B<sgetspent>()  function parses the supplied string I<s> into a struct I<spwd>.
fr: La fonction B<sgetspent>() analyse la chaîne I<s> fournie dans la structure I<spwd>.

note: type: Plain text
en: The B<putspent>()  function writes the contents of the supplied struct I<spwd> I<*p> as a text line in the shadow password file format to the stream I<fp>.  String entries with value NULL and numerical entries with value -1 are written as an empty string.
fr: La fonction B<putspent>() écrit le contenu de la structure I<spwd> I<*p> fournie sous forme d'une ligne de texte au format du fichier des mots de passe cachés dans le flux I<fp>. Les entrées chaînes de valeur NULL et les entrées numériques de valeur -1 sont écrites comme des chaînes vides.

note: type: Plain text
en: The B<lckpwdf>()  function is intended to protect against multiple simultaneous accesses of the shadow password database.  It tries to acquire a lock, and returns 0 on success, or -1 on failure (lock not obtained within 15 seconds).  The B<ulckpwdf>()  function releases the lock again.  Note that there is no protection against direct access of the shadow password file.  Only programs that use B<lckpwdf>()  will notice the lock.
fr: La fonction B<lckpwdf>() a pour but de protéger la base de données des mots de passe cachés contre les accès simultanés. Elle tente d'obtenir un verrou, renvoie 0 si elle y arrive ou -1 si elle échoue (le verrou n'a pas pu être obtenu dans les 15 secondes). La fonction B<ulckpwdf>() libère le verrou. Veuillez noter qu'il n'y a pas de protection contre l'accès direct au fichier des mots de passe cachés. Seuls les programmes qui utilisent B<lckpwdf>() remarqueront le verrou.

note: Also in libc5 SUN doesn't have sgetspent() type: Plain text
en: These were the functions that formed the original shadow API.  They are widely available.
fr: C'étaient les routines qui composaient l'API originale shadow. Elles sont largement disponibles.

note: type: SS
en: Reentrant versions
fr: Versions réentrantes

note: type: Plain text
en: Analogous to the reentrant functions for the password database, glibc also has reentrant functions for the shadow password database.  The B<getspnam_r>()  function is like B<getspnam>()  but stores the retrieved shadow password structure in the space pointed to by I<spbuf>.  This shadow password structure contains pointers to strings, and these strings are stored in the buffer I<buf> of size I<buflen>.  A pointer to the result (in case of success) or NULL (in case no entry was found or an error occurred) is stored in I<*spbufp>.
fr: De manière analogue aux routines réentrantes pour la base de données des mots de passe, la glibc possède aussi des versions réentrantes pour la base de données des mots de passe cachés. La fonction B<getspnam_r>() est équivalente à la fonction B<getspnam>() mais enregistre la structure des mots de passe cachés trouvée dans l'espace pointé par I<spbuf>. Cette structure des mots de passe cachés contient des pointeurs vers des chaînes qui sont stockées dans le tampon I<buf> de taille I<buflen>. Un pointeur vers le résultat (en cas de réussite) ou NULL (au cas où aucune entrée n'ait été trouvée ou qu'une erreur soit survenue) est stocké dans I<*spbufp>.

note: type: Plain text
en: The functions B<getspent_r>(), B<fgetspent_r>(), and B<sgetspent_r>()  are similarly analogous to their nonreentrant counterparts.
fr: Les fonctions B<getspent_r>(), B<fgetspent_r>() et B<sgetspent_r>() sont analogues à leurs homologues non réentrantes.

note: SUN doesn't have sgetspent_r() type: Plain text
en: Some non-glibc systems also have functions with these names, often with different prototypes.
fr: Certains systèmes non glibc ont également des fonctions portant ces noms, souvent avec des prototypes différents.

note: type: Plain text
en: The shadow password structure is defined in I<E<lt>shadow.hE<gt>> as follows:
fr: La structure des mots de passe cachés est définie dans I<E<lt>shadow.hE<gt>> de la manière suivante\ :

note: type: Plain text
en: struct spwd {
        char *sp_namp;     /* Login name */
        char *sp_pwdp;     /* Encrypted password */
        long  sp_lstchg;   /* Date of last change
                              (measured in days since
                              1970-01-01 00:00:00 +0000 (UTC)) */
        long  sp_min;      /* Min # of days between changes */
        long  sp_max;      /* Max # of days between changes */
        long  sp_warn;     /* # of days before password expires
                              to warn user to change it */
        long  sp_inact;    /* # of days after password expires
                              until account is disabled */
        long  sp_expire;   /* Date when account expires
                              (measured in days since
                              1970-01-01 00:00:00 +0000 (UTC)) */
        unsigned long sp_flag;  /* Reserved */
    };
fr: struct spwd {
        char *sp_namp;     /* Identifiant de connexion */
        char *sp_pwdp;     /* Mot de passe chiffré */
        long sp_lstchg;    /* Date de dernière modification
                              (mesurée en jours depuis l'époque,
                              1er janvier 1970 à 00:00:00 (UTC)) */
        long sp_min;       /* Nombre de jours minimum entre
                              deux modifications */
        long sp_max;       /* Nombre de jours maximum entre
                              deux modifications */
        long sp_warn;      /* Nombre de jours avant l'expiration
                              du mot de passe pour avertir
                              l'utilisateur de le modifier */
        long sp_inact;     /* Nombre de jours après l'expiration
                              du mot de passe pour la désactivation
                              du compte */
        long sp_expire;    /* Date à laquelle le compte expirera,
                              (mesurée en jours depuis l'époque,
                              1er janvier 1970 à 00:00:00 (UTC)) */
        unsigned long sp_flag; /* Réservé */
    };

note: type: Plain text
en: The functions that return a pointer return NULL if no more entries are available or if an error occurs during processing.  The functions which have I<int> as the return value return 0 for success and -1 for failure, with I<errno> set to indicate the cause of the error.
fr: Ces routines qui renvoient un pointeur renvoient NULL s'il n'y a plus d'entrée disponible ou si une erreur est survenue pendant le traitement. Les routines qui ont un I<int> comme valeur de retour renvoient 0 en cas de réussite. En cas d'erreur, -1 est renvoyé et I<errno> contient le code d'erreur.

note: type: Plain text
en: For the nonreentrant functions, the return value may point to static area, and may be overwritten by subsequent calls to these functions.
fr: Pour les fonctions non réentrantes, la valeur de retour peut pointer sur une zone statique et peut être écrasée par des appels consécutifs de ces fonctions.

note: type: Plain text
en: The reentrant functions return zero on success.  In case of error, an error number is returned.
fr: Les fonctions réentrantes renvoient zéro si elles réussissent. Si elles échouent, une valeur d'erreur est renvoyée.

note: type: Plain text
en: The caller does not have permission to access the shadow password file.
fr: L'appelant n'a pas le droit d'accéder au fichier de mots de passe cachés.

note: type: Plain text
en: Supplied buffer is too small.
fr: Le tampon fourni est trop petit.

note: type: Plain text
en: local shadow password database file
fr: fichier base de données des mots de passe cachés

note: type: Plain text
en: lock file
fr: fichier verrou

note: type: Plain text
en: The include file I<E<lt>paths.hE<gt>> defines the constant B<_PATH_SHADOW> to the pathname of the shadow password file.
fr: Le fichier d'inclusion I<E<lt>paths.hE<gt>> définit la constante B<_PATH_SHADOW> comme étant le chemin du fichier des mots de passe cachés.

note: type: Plain text
en: The shadow password database and its associated API are not specified in POSIX.1-2001.  However, many other systems provide a similar API.
fr: La base de données shadow et son API ne sont pas spécifiées dans POSIX.1-2001. Cependant, beaucoup de systèmes fournissent une API similaire.

note: type: Plain text
en: group - user group file
fr: group - Fichier des groupes d'utilisateurs

note: type: Plain text
en: The I</etc/group> file is a text file that defines the groups on the system.  There is one entry per line, with the following format:
fr: Le fichier I</etc/group> est un fichier texte qui définit les groupes du système. Il y a une entrée par ligne, au format suivant :

note: type: Plain text
en: group_name:password:GID:user_list
fr: nom_du_groupe:mot_de_passe:GID:liste_utilisateurs

note: type: Plain text
en: The fields are as follows:
fr: Les champs sont les suivants :

note: type: TP
en: I<group_name>
fr: I<nom_du_groupe>

note: type: Plain text
en: the name of the group.
fr: nom du groupe.

note: type: TP
en: I<password>
fr: I<mot_de_passe>

note: type: Plain text
en: the (encrypted) group password.  If this field is empty, no password is needed.
fr: mot de passe chiffré du groupe. Si ce champ est vide, aucun mot de passe n'est nécessaire.

note: type: Plain text
en: the numeric group ID.
fr: identifiant numérique du groupe.

note: type: TP
en: I<user_list>
fr: I<liste_utilisateurs>

note: type: Plain text
en: a list of the usernames that are members of this group, separated by commas.
fr: une liste de nom d'utilisateurs membres du groupe, séparés par des virgules.

note: type: Plain text
en: As the 4.2BSD B<initgroups>(3)  man page says: No-one seems to keep I</etc/group> up-to-date.
fr: Comme l'indique la page de manuel BSD\ 4.2 B<initgroups>(3), personne ne semble tenir à jour I</etc/group>.

note: type: TH
en: 2007-07-26
fr: 26 juillet 2007

note: type: Plain text
en: initgroups - initialize the supplementary group access list
fr: initgroups - Initialiser la liste de groupes supplémentaires

note: type: Plain text
en: B<initgroups>(): _BSD_SOURCE
fr: B<initgroups>()\ : _BSD_SOURCE

note: type: Plain text
en: The B<initgroups>()  function initializes the group access list by reading the group database I</etc/group> and using all groups of which I<user> is a member.  The additional group I<group> is also added to the list.
fr: La fonction B<initgroups>() initialise la liste des groupes supplémentaires en recherchant dans la base de données I</etc/group> tous les groupes dont I<user> est membre. Le groupe supplémentaire I<group> est également ajouté à la liste.

note: type: Plain text
en: The I<user> argument must be non-NULL.
fr: L'argument I<user> ne doit pas être nul.

note: type: Plain text
en: The B<initgroups>()  function returns 0 on success.  On error, -1 is returned, and I<errno> is set appropriately.
fr: Si elle réussit, la fonction B<initgroups>() renvoie 0. En cas d'erreur, elle renvoie -1 et définit I<errno> en conséquence.

note: type: Plain text
en: Insufficient memory to allocate group information structure.
fr: Pas assez de mémoire pour allouer la structure d'information de groupe.

note: type: Plain text
en: The calling process has insufficient privilege.  See the underlying system call B<setgroups>(2).
fr: Le processus appelant n'a pas les privilèges adéquats. Consultez l'appel système sous-jacent B<setgroups>(2).

note: type: Plain text
en: I</etc/group>		group database file
fr: I</etc/group>  Base de données des groupes.

note: type: Plain text
en: SVr4, 4.3BSD.
fr: SVr4, BSD\ 4.3.

note: type: TH
en: 2014-02-11
fr: 11 février 2014

note: type: Plain text
en: passwd - password file
fr: passwd - Fichier des mots de passe

note: type: Plain text
en: The I</etc/passwd> file is a text file that describes user login accounts for the system.  It should have read permission allowed for all users (many utilities, like B<ls>(1)  use it to map user IDs to usernames), but write access only for the superuser.
fr: Le fichier I</etc/passwd> est un fichier de texte qui décrit les comptes des utilisateurs sur le système. Le fichier des mots de passe doit permettre la lecture par tout le monde (de nombreux utilitaires comme B<ls>(1)  l'utilisent pour convertir les UID en noms d'utilisateur). Par contre, seul le superutilisateur doit disposer de droits d'écriture sur le fichier.

note: type: Plain text
en: In the good old days there was no great problem with this general read permission.  Everybody could read the encrypted passwords, but the hardware was too slow to crack a well-chosen password, and moreover the basic assumption used to be that of a friendly user-community.  These days many people run some version of the shadow password suite, where I</etc/passwd> has an \(aqx\(aq character in the password field, and the encrypted passwords are in I</etc/shadow>, which is readable by the superuser only.
fr: Au bon vieux temps, aucun problème de sécurité ne se posait avec ce droit de lecture général. Chacun pouvait consulter les mots de passe cryptés, mais le matériel était trop lent pour pouvoir décrypter un mot de passe bien choisi. De plus, le principe de base d'UNIX reposait sur une communauté soudée d'utilisateurs sans intentions néfastes. Actuellement, il est de plus en plus recommandé d'utiliser des systèmes de masquage des mots de passe, comme B<shadow> avec lequel le fichier I</etc/passwd> contient un caractère «\ x\ » à la place des mots de passe, et où ces derniers sont stockés sous forme cryptée dans I</etc/shadow>, qui n'est lisible que par le superutilisateur.

note: type: Plain text
en: If the encrypted password, whether in I</etc/passwd> or in I</etc/shadow>, is an empty string, login is allowed without even asking for a password.  Note that this functionality may be intentionally disabled in applications, or configurable (for example using the "nullok" or "nonull" arguments to pam_unix.so).
fr: Si le mot de passe chiffré est une chaîne vide, que ce soit dans I</etc/passwd> ou dans I</etc/shadow>, la connexion est autorisée sans même demander de mot de passe. Notez que cette fonctionnalité peut être intentionnellement désactivée (ou configurée autrement) par les applications, par exemple en utilisant les arguments « nullok » ou « nonull » de pam_unix.so.

note: type: Plain text
en: If the encrypted password in I</etc/passwd> is "I<*NP*>" (without the quotes), the shadow record should be obtained from an NIS+ server.
fr: Si le mot de passe chiffré dans I</etc/passwd> est « I<*NP*> » (sans les guillemets), le mot de passe masqué devrait être obtenu à partir d'un serveur NIS+.

note: type: Plain text
en: Regardless of whether shadow passwords are used, many system administrators use an asterisk (*) in the encrypted password field to make sure that this user can not authenticate him- or herself using a password.  (But see NOTES below.)
fr: Que le masquage des mots de passe soit utilisé ou non, de nombreux administrateurs systèmes utilisent un astérisque («\ *\ ») dans le champ «\ mot de passe\ » pour s'assurer que l'utilisateur en question ne puisse pas se connecter (consultez la section NOTES plus bas).

note: type: Plain text
en: If you create a new login, first put an asterisk (*) in the password field, then use B<passwd>(1)  to set it.
fr: Si vous devez créer un nouvel utilisateur, placez un astérisque («\ *\ ») dans le champ «\ mot de passe\ », puis utilisez la commande B<passwd>(1)  pour le mettre à jour.

note: type: Plain text
en: Each line of the file describes a single user, and contains seven colon-separated fields:
fr: Chaque ligne du fichier décrit un utilisateur unique, et contient sept champs séparés par le caractère « : » :

note: type: Plain text
en: name:password:UID:GID:GECOS:directory:shell
fr: nom:mot_de_passe:UID:GID:GECOS:répertoire:shell

note: type: Plain text
en: The field are as follows:
fr: Les champs sont les suivants :

note: type: TP
en: I<name>
fr: I<nom>

note: type: Plain text
en: This is the user's login name.  It should not contain capital letters.
fr: Le nom que l'utilisateur utilisera pour se connecter, il ne devrait normalement pas contenir de majuscules

note: type: Plain text
en: This is either the encrypted user password, an asterisk (*), or the letter \(aqx\(aq.  (See B<pwconv>(8)  for an explanation of \(aqx\(aq.)
fr: Contient la représentation encryptée du mot de passe, une astérique ou la lettre «\ x\ ». (Consultez B<pwconv>(8)  pour une explication sur «\ x\ ».)

note: type: Plain text
en: The privileged I<root> login account (superuser) has the user ID 0.
fr: Le compte superutilisateur (I<root>) a 0 comme identifiant d'utilisateur.

note: type: Plain text
en: This is the numeric primary group ID for this user.  (Additional groups for the user are defined in the system group file; see B<group>(5)).
fr: Il s'agit de l'ID numérique du groupe principal de l'utilisateur (les groupes supplémentaires de l'utilisateur sont définis dans le fichier de groupes, consultez B<group>(5)).

note: type: Plain text
en: This field (sometimes called the "comment field")  is optional and used only for informational purposes.  Usually, it contains the full username.  Some programs (for example, B<finger>(1))  display information from this field.
fr: Ce champ (parfois aussi appelé le « champ commentaire ») est optionnel et n'a qu'un rôle informatif. Il contient généralement le nom complet de l'utilisateur. Certains programmes (comme par exemple B<finger>(1)) l'utilisent pour afficher leurs informations.

note: type: Plain text
en: GECOS stands for "General Electric Comprehensive Operating System", which was renamed to GCOS when GE's large systems division was sold to Honeywell.  Dennis Ritchie has reported: "Sometimes we sent printer output or batch jobs to the GCOS machine.  The gcos field in the password file was a place to stash the information for the $IDENTcard.  Not elegant."
fr: GECOS signifie «\ General Electric Comprehensive Operating System\ », qui fut renommé GCOS quand la division «\ gros systèmes\ » de General Electric a été vendue à Honeywell. Dennis Ritchie raconte\ : «\ Il arrivait que l'on envoie des sorties d'impression ou des résultats de traitements différés vers une machine GCOS. Le champ GCOS du fichier password était un endroit classique pour glisser des informations dans la carte $IDENT. Pas très élégant...\ »

note: type: TP
en: I<directory>
fr: I<répertoire>

note: type: Plain text
en: This is the user's home directory: the initial directory where the user is placed after logging in.  The value in this field is used to set the B<HOME> environment variable.
fr: Il s'agit du répertoire de l'utilisateur, celui dans lequel l'utilisateur se trouve après s'être connecté. La valeur de ce champ est utilisée pour définir la variable d'environnement B<$HOME>.

note: type: Plain text
en: This is the program to run at login (if empty, use I</bin/sh>).  If set to a nonexistent executable, the user will be unable to login through B<login>(1).  The value in this field is used to set the B<SHELL> environment variable.
fr: Il s'agit du programme à exécuter après la phase de connexion (par défaut I</bin/sh>). Si ce fichier n'existe pas, l'utilisateur ne pourra pas se connecter avec B<login>(1). La valeur de ce champ est utilisée pour définir la variable d'environnement B<SHELL>.

note: type: Plain text
en: If you want to create user groups, there must be an entry in I</etc/group>, or no group will exist.
fr: Si vous désirez créer des groupes d'utilisateurs, il doit y avoir une entrée correspondante dans le fichier I</etc/group>.

note: type: Plain text
en: If the encrypted password is set to an asterisk (*), the user will be unable to login using B<login>(1), but may still login using B<rlogin>(1), run existing processes and initiate new ones through B<rsh>(1), B<cron>(8), B<at>(1), or mail filters, etc.  Trying to lock an account by simply changing the shell field yields the same result and additionally allows the use of B<su>(1).
fr: Si le mot de passe crypté est rempli avec un astérisque («\ *\ »), l'utilisateur ne pourra pas se connecter avec B<login>(1), mais pourra toujours le faire avec B<rlogin>(1), lancer des processus en utilisant B<rsh>(1), B<cron>(8), B<at>(1), ou des filtres de courrier, etc. La modification du champ «\ shell\ » a généralement les mêmes effets, et autorise toujours l'utilisation de B<su>(1).

note: type: TH
en: 2003-09-09
fr: 9 septembre 2003

note: type: Plain text
en: putgrent - write a group database entry to a file
fr: putgrent - Écrire un enregistrement base de données group dans un fichier

note: type: Plain text
en: B<#define _GNU_SOURCE> /* See feature_test_macros(7) */
fr: B<#define _GNU_SOURCE> /* Consultez feature_test_macros(7) */

note: type: Plain text
en: The B<putgrent>()  function is the counterpart for B<fgetgrent>(3).  The function writes the content of the provided I<struct group> into the file pointed to by I<fp>.  The list of group members must be NULL-terminated or NULL-initialized.
fr: La fonction B<putgrent>() est la fonction complémentaire de B<fgetgrent>(3). La fonction écrit le contenu de la structure I<struct group> fournie dans le fichier pointé par I<fp>. La liste des membres doit se terminer par le caractère NUL ou bien être initialisée à NULL.

note: type: Plain text
en: The I<struct group> is defined as follows:
fr: La structure I<struct group> est définie comme suit\ :

note: type: Plain text
en: struct group {
        char   *gr_name;      /* group name */
        char   *gr_passwd;    /* group password */
        gid_t   gr_gid;       /* group ID */
        char  **gr_mem;       /* group members */
    };
fr: 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 */
    };

note: type: Plain text
en: The function returns zero on success, and a nonzero value on error.
fr: La fonction renvoie zéro si elle réussit et une valeur non nulle s'il y a une erreur.

note: type: Plain text
en: This function is a GNU extension.
fr: Cette fonction est une extension GNU.

note: type: Plain text
en: putpwent - write a password file entry
fr: putpwent - Écrire un enregistrement dans un fichier de mots de passe

note: type: Plain text
en: B<putpwent>(): _SVID_SOURCE
fr: B<putpwent>() : _SVID_SOURCE

note: type: Plain text
en: The B<putpwent>()  function writes a password entry from the structure I<p> in the file associated with I<stream>.
fr: La fonction B<putpwent>() écrit un enregistrement fourni par la structure I<p> dans le fichier associé au flux I<stream>.

note: type: Plain text
en: struct passwd {
        char    *pw_name;        /* username */
        char    *pw_passwd;      /* user password */
        uid_t    pw_uid;         /* user ID */
        gid_t    pw_gid;         /* group ID */
        char    *pw_gecos;       /* real name */
        char    *pw_dir;         /* home directory */
        char    *pw_shell;       /* shell program */
    };
fr: struct passwd {
        char    *pw_name;        /* Nom d'utilisateur */
        char    *pw_passwd;      /* Mot de passe */
        uid_t    pw_uid;         /* ID de l'utilisateur */
        gid_t    pw_gid;         /* ID du groupe de l'utilisateur */
        char    *pw_gecos;       /* Nom réel de l'utilisateur */
        char    *pw_dir;         /* Répertoire de connexion */
        char    *pw_shell;       /* Programme Shell de connexion */
    };

note: type: Plain text
en: The B<putpwent>()  function returns 0 on success, or -1 if an error occurs.  In the event of an error, I<errno> is set to indicate the cause.
fr: Si elle réussit, la fonction B<getpw>() renvoie 0. En cas d'erreur, -1 est renvoyé et I<errno> contient le code d'erreur.

note: type: Plain text
en: Invalid (NULL) argument given.
fr: Argument invalide (NULL).

note: type: Plain text
en: setaliasent, endaliasent, getaliasent, getaliasent_r, getaliasbyname, getaliasbyname_r - read an alias entry
fr: setaliasent, endaliasent, getaliasent, getaliasent_r, getaliasbyname, getaliasbyname_r - Lire une entrée alias

note: type: Plain text
en: One of the databases available with the Name Service Switch (NSS)  is the aliases database, that contains mail aliases.  (To find out which databases are supported, try I<getent --help>.)  Six functions are provided to access the aliases database.
fr: Une des bases de données disponibles avec le «\ Name Service Switch\ » (NSS) est la base de données des alias qui contient les alias de mail (pour savoir quelles bases de données sont supportées, taper la commande «\ I<getent --help>\ »). Six fonctions sont fournies pour accéder à la base de données des alias.

note: type: Plain text
en: The B<getaliasent>()  function returns a pointer to a structure containing the group information from the aliases database.  The first time it is called it returns the first entry; thereafter, it returns successive entries.
fr: La fonction B<getaliasent>() renvoie un pointeur sur une structure contenant l'information de groupe dans la base de données des alias. Le premier appel de cette fonction permet de retourner la première entrée\ ; les appels suivants retourneront les entrées successives.

note: type: Plain text
en: The B<setaliasent>()  function rewinds the file pointer to the beginning of the aliases database.
fr: La fonction B<setaliasent>() positionne le pointeur de fichier au début de la base de données des alias.

note: type: Plain text
en: The B<endaliasent>()  function closes the aliases database.
fr: La fonction B<endaliasent>() ferme la base de données des alias.

note: type: Plain text
en: B<getaliasent_r>()  is the reentrant version of the previous function.  The requested structure is stored via the first argument but the programmer needs to fill the other arguments also.  Not providing enough space causes the function to fail.
fr: B<getaliasent_r>() est la version réentrante de la fonction B<getaliasent>(). La structure recherchée est enregistrée via le premier argument mais le programmeur doit également renseigner les autres arguments. Ne pas fournir suffisamment d'espace provoquera l'échec de la fonction.

note: type: Plain text
en: The function B<getaliasbyname>()  takes the name argument and searches the aliases database.  The entry is returned as a pointer to a I<struct aliasent>.
fr: La fonction B<getaliasbyname>() prend en argument «\ name\ » et cherche dans la base de données des alias. L'entrée est retournée sous forme de pointeur vers une structure I<aliasent>.

note: type: Plain text
en: B<getaliasbyname_r>()  is the reentrant version of the previous function.  The requested structure is stored via the second argument but the programmer needs to fill the other arguments also.  Not providing enough space causes the function to fail.
fr: La fonction B<getaliasbyname_r>() est la version réentrante de la fonction précédente. La structure recherchée est enregistrée via le deuxième argument mais le programmeur doit également renseigner les autres arguments. Ne pas fournir suffisamment d'espace provoquera l'échec de la fonction.

note: type: Plain text
en: The I<struct aliasent> is defined in I<E<lt>aliases.hE<gt>>:
fr: La structure I<aliasent> est définie dans I<E<lt>aliases.hE<gt>> :

note: type: Plain text
en: struct aliasent {
        char    *alias_name;             /* alias name */
        size_t   alias_members_len;
        char   **alias_members;          /* alias name list */
        int      alias_local;
    };
fr: struct aliasent {
        char    *alias_name;              /* nom de alias */
        size_t   alias_members_len;
        char   **alias_members;           /* liste de noms d'alias */
        int      alias_local;
    };

note: type: Plain text
en: The functions B<getaliasent_r>()  and B<getaliasbyname_r>()  return a nonzero value on error.
fr: Les fonctions B<getaliasent_r>() et B<getaliasbyname_r>() renvoient une valeur non nulle en cas d'erreur.

note: type: Plain text
en: The default alias database is the file I</etc/aliases>.  This can be changed in the I</etc/nsswitch.conf> file.
fr: La base de données des alias par défaut est le fichier I</etc/aliases>. Elle peut être modifiée dans le fichier I</etc/nsswitch.conf>.

note: type: Plain text
en: These routines are glibc-specific.  The NeXT system has similar routines:
fr: Ces routines sont spécifiques à la glibc. Le système NeXT a des routines similaires :

note: type: Plain text
en: The following example compiles with I<gcc example.c -o example>.  It will dump all names in the alias database.
fr: L'exemple suivant se compile avec la commande I<gcc example.c -o example>. Il affichera tous les noms trouvés dans la base de données des alias.
