Provided by: manpages-fr-dev_3.32d0.2p4-1_all bug

NOM

       errno - Code de la dernière erreur

SYNOPSIS

       #include <errno.h>

DESCRIPTION

       Le  fichier  d'en-tête <errno.h> définit la variable entière errno, qui est renseignée par
       les appels système et quelques fonctions  de  bibliothèque  pour  décrire  les  conditions
       d'erreurs.  Sa  valeur n'est significative que lorsque la valeur de retour l'appel système
       indique une erreur (c'est-à-dire -1 pour la plupart des appels système ; -1 ou  NULL  pour
       la  plupart  des  fonctions  de  bibliothèque) ;  en  cas  de  réussite  une  fonction  de
       bibliothèque peut modifier errno.

       Les numéros d'erreur correctes son tous non nuls ; errno n'est mis à zéro par aucun  appel
       système ou fonction de bibliothèque.

       Pour certains appels système et fonctions de bibliothèque (par exemple getpriority(2)), -1
       est une valeur de retour correcte en cas de réussite. Dans de  tels  cas,  une  valeur  de
       retour  en cas de réussite peut être distinguée d'un cas d'erreur est positionnant errno à
       zéro avant l'appel, puis, quand l'appel fourni une valeur qui indique qu'une erreur  a  pu
       se produire, en vérifiant si errno a une valeur non nulle.

       errno  est  définie  par le standard ISO C comme une « lvalue » modifiable de type int, et
       n'a pas besoin d'être définie explicitement ; errno peut être une macro. errno est  locale
       à  un  thread ;  lui  affecter une valeur dans un thread ne modifie pas sa valeur dans les
       autres threads.

       Toutes les erreurs détaillées  dans  POSIX.1  doivent  avoir  des  valeurs  différentes  à
       l'exception de EAGAIN et EWOULDBLOCK qui peuvent avoir la même valeur.

       Ci-dessous,  un liste des noms d'erreurs symboliques qui sont définis sous Linux. Certains
       sont marqués avec POSIX.1, cela signifie que POSIX.1-2001 les définit, ceux  marqués  avec
       C99, sont définis par C99.

       E2BIG           Liste d'arguments trop longue (POSIX.1)

       EACCES          Permission refusée (POSIX.1)

       EADDRINUSE      Adresse déjà en cours d'utilisation (POSIX.1)

       EADDRNOTAVAIL   Adresse non disponible (POSIX.1)

       EAFNOSUPPORT    Famille d'adresses non supportée (POSIX.1)

       EAGAIN          Ressource  temporairement  indisponible  (peut  être  la  même  valeur que
                       EWOULDBLOCK) (POSIX.1)

       EALREADY        Connexion déjà en cours (POSIX.1)

       EBADE           Échange invalide

       EBADF           Mauvais descripteur de fichier (POSIX.1)

       EBADFD          Descripteur de fichier dans un mauvais état

       EBADMSG         Mauvais message (POSIX.1)

       EBADR           Descripteur de requête non valable

       EBADRQC         Code de requête non valable

       EBADSLT         Emplacement (« Slot ») non valable

       EBUSY           Périphérique ou ressource indisponible (POSIX.1)

       ECANCELED       Opération annulée (POSIX.1)

       ECHILD          Pas de processus fils (POSIX.1)

       ECHRNG          Numéro de voie hors du domaine de définition

       ECOMM           Échec de la communication lors de l'envoi

       ECONNABORTED    Connexion abandonnée (POSIX.1)

       ECONNREFUSED    Connexion refusée (POSIX.1)

       ECONNRESET      Connexion réinitialisée (POSIX.1)

       EDEADLK         Blocage d'une ressource évité (POSIX.1)

       EDEADLOCK       Synonyme de EDEADLK

       EDESTADDRREQ    Adresse de destination nécessaire (POSIX.1)

       EDOM            Argument mathématique  hors  du  domaine  de  définition  de  la  fonction
                       (POSIX.1, C99)

       EDQUOT          Quota du disque dépassé (POSIX.1)

       EEXIST          Fichier existant (POSIX.1)

       EFAULT          Mauvaise adresse (POSIX.1)

       EFBIG           Fichier trop grand (POSIX.1)

       EHOSTDOWN       Hôte éteint

       EHOSTUNREACH    Hôte non accessible (POSIX.1)

       EIDRM           Identificateur supprimé (POSIX.1)

       EILSEQ          Séquence d'octets illégale (POSIX.1, C99)

       EINPROGRESS     Opération en cours (POSIX.1)

       EINTR           Appel système interrompu (POSIX.1) ; consultez signal(7).

       EINVAL          Argument invalide (POSIX.1)

       EIO             Erreur d'entrée/sortie (POSIX.1)

       EISCONN         La socket est connectée (POSIX.1)

       EISDIR          Est un répertoire (POSIX.1)

       EISNAM          Est un fichier nommé

       EKEYEXPIRED     Clé expirée

       EKEYREJECTED    La clé a été rejeté par le service

       EKEYREVOKED     La clé a été révoquée

       EL2HLT          Niveau 2 arrêté

       EL2NSYNC        Niveau 2 non synchronisé

       EL3HLT          Niveau 3 arrêté

       EL3RST          Niveau 3 arrêté

       ELIBACC         Impossible d'accéder à la bibliothèque partagée nécessaire

       ELIBBAD         Accès à une bibliothèque partagée corrompue

       ELIBMAX         Tentative de liaison avec trop de bibliothèques partagées

       ELIBSCN         Section lib dans a.out corrompue

       ELIBEXEC        Impossible d'exécuter directement une bibliothèque partagée

       ELOOP           Trop de niveau de liens symboliques rencontrés (POSIX.1)

       EMEDIUMTYPE     Mauvais type de médium

       EMFILE          Trop de fichiers ouverts (POSIX.1)

       EMLINK          Trop de liens symboliques (POSIX.1)

       EMSGSIZE        Message trop long (POSIX.1)

       EMULTIHOP       Tentative de saut multiple « Multihop » (POSIX.1)

       ENAMETOOLONG    Nom de fichier trop long (POSIX.1)

       ENETDOWN        Le réseau est désactivé (POSIX.1)

       ENETRESET       Connexion annulée par le réseau (POSIX.1)

       ENETUNREACH     Réseau inaccessible (POSIX.1)

       ENFILE          Trop de fichiers ouverts sur le système (POSIX.1)

       ENOBUFS         Plus de tampons disponibles (POSIX.1 (option des FLUX XSI))

       ENODATA         Pas de message disponible en tête de la queue de lecture du FLUX (POSIX.1)

       ENODEV          Périphérique inexistant (POSIX.1)

       ENOENT          Fichier ou répertoire inexistant (POSIX.1)

       ENOEXEC         Erreur de format d'exécution (POSIX.1)

       ENOKEY          Clé nécessaire non disponible

       ENOLCK          Pas de verrou disponible (POSIX.1)

       ENOLINK         Un lien a été disjoint (POSIX.1)

       ENOMEDIUM       Aucun média trouvé

       ENOMEM          Pas assez de mémoire (POSIX.1)

       ENOMSG          Pas de message du type attendu (POSIX.1)

       ENONET          La machine n'est pas sur le réseau

       ENOPKG          Paquet non installé

       ENOPROTOOPT     Protocole indisponible (POSIX.1)

       ENOSPC          Plus de place sur le périphérique (POSIX.1)

       ENOSR           Pas de ressources FLUX (POSIX.1 (option des FLUX XSI))

       ENOSTR          Pas un FLUX (POSIX.1 (option des FLUX XSI))

       ENOSYS          Fonction non implémentée (POSIX.1)

       ENOTBLK         Périphérique de bloc nécessaire

       ENOTCONN        La socket n'est pas connectée (POSIX.1)

       ENOTDIR         Pas un répertoire (POSIX.1)

       ENOTEMPTY       Répertoire non vide (POSIX.1)

       ENOTSOCK        Pas une socket (POSIX.1)

       ENOTSUP         Opération non supportée (POSIX.1)

       ENOTTY          Opération de contrôle d'entrée/sortie invalide (POSIX.1)

       ENOTUNIQ        Le nom sur le réseau n'est pas unique

       ENXIO           Périphérique ou adresse inexistant (POSIX.1)

       EOPNOTSUPP      Opération non supportée par la socket (POSIX.1)

                       (ENOTSUP  et EOPNOTSUPP ont la même valeur sous Linux, mais selon POSIX.1,
                       ces codes d'erreurs doivent être différents).

       EOVERFLOW       Valeur trop grande pour être sauvé dans ce type de donnée (POSIX.1)

       EPERM           Opération interdite (POSIX.1)

       EPFNOSUPPORT    Famille de protocole non supportée

       EPIPE           Tube cassé (POSIX.1)

       EPROTO          Erreur de protocole (POSIX.1)

       EPROTONOSUPPORT Protocole non supporté (POSIX.1)

       EPROTOTYPE      Mauvais type de protocole pour la socket (POSIX.1)

       ERANGE          Résultat trop grand (POSIX.1, C99)

       EREMCHG         Adresse distante changée

       EREMOTE         L'objet est distant

       EREMOTEIO       Erreur d'entrées-sorties distante

       ERESTART        L'appel système interrompu devrait être relancé

       EROFS           Système de fichiers en lecture seule (POSIX.1)

       ESHUTDOWN       Impossible d'effectuer l'envoi après l'arrêt du point final du transport

       ESPIPE          Recherche invalide (POSIX.1)

       ESOCKTNOSUPPORT Type de socket non supporté

       ESRCH           Processus inexistant (POSIX.1)

       ESTALE          Vieux descripteur de fichier (POSIX.1)

                       Cette erreur peut se produire avec le système de fichiers NFS et d'autres

       ESTRPIPE        Tube de flux cassé

       ETIME           Compteur de temps écoulé (POSIX.1 (option des FLUX XSI))

                       (POSIX.1 dit « délai du FLUX ioctl(2) dépassé)

       ETIMEDOUT       Délai maximal de connexion écoulé (POSIX.1)

       ETXTBSY         Fichier texte occupé (POSIX.1)

       EUCLEAN         La structure nécessite un nettoyage

       EUNATCH         Protocole indisponible

       EUSERS          Trop d'utilisateurs

       EWOULDBLOCK     L'opération serait  bloquante  (peut  être  la  même  valeur  que  EAGAIN)
                       (POSIX.1)

       EXDEV           Lien inapproprié (POSIX.1)

       EXFULL          Échange plein

NOTES

       Une erreur fréquente est de faire

           if (somecall() == -1) {
               printf("somecall() failed\n");
               if (errno == ...) { ... }
           }

       où  errno  n'a  plus besoin de la valeur qu'elle avait juste après le retour de somecall()
       (par exemple, elle peut être changée par printf(3)). Si  la  valeur  de  errno  doit  être
       préservée à travers un appel bibliothèque, elle doit être sauvegardée :

           if (somecall() == -1) {
               int errsv = errno;
               printf("somecall() failed\n");
               if (errsv == ...) { ... }
           }

       C'est  commun  en  C  traditionnel de déclarer errno manuellement (par exemple, extern int
       errno) au lieu d'inclure <errno.h>. Ne faites pas ceci. Cela ne fonctionnera pas avec  les
       versions  modernes  des  bibliothèque  C. Toutefois, sur de (très) vieux systèmes UNIX, il
       peut ne pas y avoir de <errno.h> et dans ce cas la déclaration est nécessaire.

VOIR AUSSI

       err(3), error(3), perror(3), strerror(3)

COLOPHON

       Cette page fait partie de la publication 3.32 du projet man-pages Linux.  Une  description
       du  projet  et  des  instructions  pour  signaler  des  anomalies  peuvent être trouvées à
       l'adresse <URL:http://www.kernel.org/doc/man-pages/>.

TRADUCTION

       Depuis   2010,   cette   traduction   est   maintenue   à   l'aide   de    l'outil    po4a
       <URL:http://po4a.alioth.debian.org/>  par  l'équipe  de  traduction francophone au sein du
       projet perkamon <URL:http://perkamon.alioth.debian.org/>.

       Christophe  Blaess  <URL:http://www.blaess.fr/christophe/>   (1996-2003),   Alain   Portal
       <URL:http://manpagesfr.free.fr/>  (2003-2006). Florentin Duneau et l'équipe francophone de
       traduction de Debian (2006-2009).

       Veuillez     signaler     toute     erreur     de     traduction     en     écrivant     à
       <debian-l10n-french@lists.debian.org>   ou   par   un  rapport  de  bogue  sur  le  paquet
       manpages-fr.

       Vous pouvez toujours avoir accès à la version anglaise de  ce  document  en  utilisant  la
       commande « man -L C <section> <page_de_man> ».

                                          9 juillet 2008                                 ERRNO(3)