Provided by: manpages-fr-dev_4.18.1-1_all bug

NOM

       getspnam,  getspnam_r,  getspent,  getspent_r, setspent, endspent, fgetspent, fgetspent_r,
       sgetspent, sgetspent_r, putspent, lckpwdf, ulckpwdf - Obtenir une entrée  du  fichier  des
       mots de passe cachés

BIBLIOTHÈQUE

       Bibliothèque C standard (libc, -lc)

SYNOPSIS

       /* API globale du fichier des mots de passe cachés */
       #include <shadow.h>

       struct spwd *getspnam(const char *nom);
       struct spwd *getspent(void);

       void setspent(void);
       void endspent(void);

       struct spwd *fgetspent(FILE *flux);
       struct spwd *sgetspent(const char *s);

       int putspent(const struct spwd *p, FILE *flux);

       int lckpwdf(void);
       int ulckpwdf(void);

       /* Extension GNU */
       #include <shadow.h>

       int getspent_r(struct spwd *spbuf,
                      char tampon[.taille_tampon], size_t taille_tampon, struct spwd **spbufp);
       int getspnam_r(const char *nom, struct spwd *spbuf,
                      char tampon[.taille_tampon], size_t taille_tampon, struct spwd **spbufp);

       int fgetspent_r(FILE *flux, struct spwd *spbuf,
                      char tampon[.taille_tampon], size_t taille_tampon, struct spwd **spbufp);
       int sgetspent_r(const char *s, struct spwd *spbuf,
                      char tampon[.taille_tampon], size_t taille_tampon, struct spwd **spbufp);

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

       getspent_r(), getspnam_r(), fgetspent_r(), sgetspent_r():
           Depuis la glibc 2.19 :
               _DEFAULT_SOURCE
           Pour la glibc 2.19 et précédentes :
               _BSD_SOURCE || _SVID_SOURCE

DESCRIPTION

       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
       /etc/shadow, NIS ou LDAP), lisible seulement par le superutilisateur.

       Les fonctions décrites ci-dessous ressemblent aux fonctions traditionnelles de la base  de
       données des mots de passe (par exemple, consultez getpwnam(3) et getpwent(3)).

       La  fonction  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  au  nom
       de l'utilisateur.

       La  fonction  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 setspent().  Lorsque  la
       lecture est finie, le programme devrait appeler endspent() pour désallouer les ressources.

       La  fonction  fgetspent() est similaire à getspent(), mais utilise le flux spécifié plutôt
       que celui implicitement ouvert par setspent().

       La fonction sgetspent() analyse la chaîne s fournie dans la structure spwd.

       La fonction putspent() écrit le contenu de la structure spwd *p fournie sous  forme  d'une
       ligne  de  texte  au  format du fichier des mots de passe cachés dans le flux. Les entrées
       chaînes de valeur NULL et les entrées numériques de  valeur  -1  sont  écrites  comme  des
       chaînes vides.

       La  fonction  lckpwdf() a pour but de protéger la base de données des mots de passe cachés
       contre des 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
       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 lckpwdf()
       remarqueront le verrou.

       C'étaient les routines qui composaient l'API originale « shadow ».  Elles  sont  largement
       disponibles.

   Versions réentrantes
       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 getspnam_r() est équivalente à la fonction getspnam(), mais enregistre
       la structure des mots de passe cachés  trouvée  dans  l'espace  pointé  par  spbuf.  Cette
       structure  des  mots  de  passe  cachés  contient  des pointeurs vers des chaînes qui sont
       stockées dans le tampon de taille taille_tampon. Un pointeur vers le résultat (en  cas  de
       réussite)  ou  NULL  (si  aucune entrée n'a été trouvée ou si une erreur est survenue) est
       stocké dans *spbufp.

       Les  fonctions  getspent_r(),  fgetspent_r()  et  sgetspent_r()  sont  analogues  à  leurs
       homologues non réentrantes.

       Certains systèmes non glibc ont également des fonctions portant ces noms, souvent avec des
       prototypes différents.

   Structure
       La structure des mots de passe cachés est définie dans <shadow.h> de la manière suivante :

           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é */
           };

VALEUR RENVOYÉE

       Les 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 int comme
       valeur de retour renvoient 0 en cas de réussite. En cas d'erreur, -1 est renvoyé et  errno
       est définie pour préciser l'erreur.

       Pour les fonctions non réentrantes, la valeur de retour peut pointer sur une zone statique
       et peut être écrasée par des appels ultérieurs de ces fonctions.

       Les fonctions réentrantes renvoient zéro si elles  réussissent.  Si  elles  échouent,  une
       valeur d'erreur est renvoyée.

ERREURS

       EACCES L'appelant n'a pas le droit d'accéder au fichier de mots de passe cachés.

       ERANGE Le tampon fourni est trop petit.

FICHIERS

       /etc/shadow
              fichier base de données des mots de passe cachés

       /etc/.pwd.lock
              fichier verrou

       Le  fichier  d'inclusion <paths.h> définit la constante _PATH_SHADOW comme étant le chemin
       du fichier des mots de passe cachés.

ATTRIBUTS

       Pour une explication des termes utilisés dans cette section, consulter attributes(7).

       ┌────────────────────────┬──────────────────────┬─────────────────────────────────────────┐
       │InterfaceAttributValeur                                  │
       ├────────────────────────┼──────────────────────┼─────────────────────────────────────────┤
       │getspnam()              │ Sécurité des threads │ MT-Unsafe race:getspnam locale          │
       ├────────────────────────┼──────────────────────┼─────────────────────────────────────────┤
       │getspent()              │ Sécurité des threads │ MT-Unsafe race:getspent race:spentbuf   │
       │                        │                      │ locale                                  │
       ├────────────────────────┼──────────────────────┼─────────────────────────────────────────┤
       │setspent(), endspent(), │ Sécurité des threads │ MT-Unsafe race:getspent locale          │
       │getspent_r()            │                      │                                         │
       ├────────────────────────┼──────────────────────┼─────────────────────────────────────────┤
       │fgetspent()             │ Sécurité des threads │ MT-Unsafe race:fgetspent                │
       ├────────────────────────┼──────────────────────┼─────────────────────────────────────────┤
       │sgetspent()             │ Sécurité des threads │ MT-Unsafe race:sgetspent                │
       ├────────────────────────┼──────────────────────┼─────────────────────────────────────────┤
       │putspent(),             │ Sécurité des threads │ MT-Safe locale                          │
       │getspnam_r(),           │                      │                                         │
       │sgetspent_r()           │                      │                                         │
       ├────────────────────────┼──────────────────────┼─────────────────────────────────────────┤
       │lckpwdf(), ulckpwdf(),  │ Sécurité des threads │ MT-Safe                                 │
       │fgetspent_r()           │                      │                                         │
       └────────────────────────┴──────────────────────┴─────────────────────────────────────────┘
       Dans le tableau ci-dessus, getspent dans race:getspent signifie que si des fonctions parmi
       setspent(), getspent(), getspent_r()  ou  endspent()  sont  utilisées  en  parallèle  dans
       différents  threads d'un programme, des situations de compétition entre données pourraient
       apparaître.

STANDARDS

       La base de données de mots de passe masqués  et  son  API  ne  sont  pas  spécifiées  dans
       POSIX.1. Cependant, beaucoup de systèmes fournissent une API similaire.

VOIR AUSSI

       getgrnam(3), getpwnam(3), getpwnam_r(3), shadow(5)

TRADUCTION

       La  traduction  française  de  cette  page  de  manuel  a  été créée par Christophe Blaess
       <https://www.blaess.fr/christophe/>, Stéphan  Rafin  <stephan.rafin@laposte.net>,  Thierry
       Vignaud  <tvignaud@mandriva.com>,  François Micaux, Alain Portal <aportal@univ-montp2.fr>,
       Jean-Philippe   Guérard   <fevrier@tigreraye.org>,   Jean-Luc   Coulon   (f5ibh)    <jean-
       luc.coulon@wanadoo.fr>,    Julien    Cristau    <jcristau@debian.org>,    Thomas   Huriaux
       <thomas.huriaux@gmail.com>, Nicolas François <nicolas.francois@centraliens.net>, Florentin
       Duneau  <fduneau@gmail.com>, Simon Paillard <simon.paillard@resel.enst-bretagne.fr>, Denis
       Barbier  <barbier@debian.org>,  David  Prévot   <david@tilapin.org>   et   Lucien   Gentis
       <lucien.gentis@waika9.com>

       Cette  traduction  est  une  documentation libre ; veuillez vous reporter à la GNU General
       Public  License  version 3  ⟨https://www.gnu.org/licenses/gpl-3.0.html⟩   concernant   les
       conditions de copie et de distribution. Il n'y a aucune RESPONSABILITÉ LÉGALE.

       Si vous découvrez un bogue dans la traduction de cette page de manuel, veuillez envoyer un
       message à ⟨debian-l10n-french@lists.debian.org⟩.