Provided by: manpages-fr-dev_4.19.0-7_all bug

NOM

       inet_net_pton, inet_net_ntop - Conversion d'adresse réseau Internet

BIBLIOTHÈQUE

       Bibliothèque resolver (libresolv, -lresolv)

SYNOPSIS

       #include <arpa/inet.h>

       int inet_net_pton(int af, const char *pres,
                         void netp[.nsize], size_t nsize);
       char *inet_net_ntop(int af,
                         const void netp[(.bits - CHAR_BIT + 1) / CHAR_BIT],
                         int bits,
                         char pres[.psize], size_t psize);

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

       inet_net_pton(), inet_net_ntop() :
           Depuis la glibc 2.20 :
               _DEFAULT_SOURCE
           Avant la glibc 2.20 :
               _BSD_SOURCE || _SVID_SOURCE

DESCRIPTION

       Ces fonctions convertissent les adresses de réseau entre  leur  format  de  représentation
       (c-à-d. textuelle) et leur format binaire pour le réseau.

       Dans  le  cas  des  deux  fonctions, af indique la famille d'adresse à utiliser lors de la
       conversion. Seule la valeur AF_INET est prise en charge.

   inet_net_pton()
       La fonction inet_net_pton() convertit pres, une chaîne terminée par un  caractère  nul  et
       contenant  la représentation d'une adresse réseau vers le format réseau. Le résultat de la
       conversion, dans l'ordre du réseau,  est  placé  dans  le  tampon  pointé  par  netp.  (Le
       paramètre  netp pointe typiquement vers une structure in_addr.) Le paramètre nsize indique
       le nombre d'octets disponibles dans netp.

       En cas de réussite, inet_net_pton() renvoie le nombre de bits dans le champ de  numéro  de
       réseau  du  résultat placé dans netp. Pour une discussion sur le format de présentation de
       l’entrée et la valeur de retour, consultez NOTES.

       Remarque :  le  tampon  pointé  par  netp  devrait  être  mis  à  zéro   avant   d’appeler
       inet_net_pton()  puisque  l’appel n’écrit que le nombre d’octets nécessaire pour le numéro
       de réseau (ou qu’explicitement indiqué par pres), ce qui pourrait être moins que le nombre
       d’octets dans une adresse de réseau complète.

   inet_net_ntop()
       La  fonction  inet_net_ntop() convertit le numéro de réseau dans le tampon pointé par netp
       au format de présentation ; *netp est interprété comme une valeur dans l’ordre d’octets du
       réseau. L’argument bits indique le nombre de bits dans le numéro de réseau *netp.

       La chaîne au format de présentation terminée par NULL est placée dans le tampon pointé par
       pres. L’argument psize indique le nombre d’octets disponibles  dans  pres.  La  chaîne  de
       présentation est au format CIDR : notation décimale pointée représentant l’adresse réseau,
       suivie par une barre oblique et la taille du numéro de réseau en bit.

VALEUR RENVOYÉE

       Si elle réussit, inet_net_pton() renvoie le nombre de bits de  l'adresse  réseau.  En  cas
       d'erreur, -1 est renvoyé et errno est défini pour indiquer l'erreur.

       Si elle réussit, inet_net_ntop() renvoie pres. En cas d'erreur, elle renvoie NULL et errno
       est défini pour indiquer l'erreur.

ERREURS

       EAFNOSUPPORT
              af indique une valeur différente de AF_INET.

       EMSGSIZE
              La taille du tampon de sortie est insuffisante.

       ENOENT (inet_net_pton()) pres n’était pas dans un format de présentation correct.

STANDARDS

       Les fonctions inet_net_pton() et inet_net_ntop() ne sont pas standard, mais sont largement
       répandues.

NOTES

   Format de présentation en entrée pour inet_net_pton()
       L'adresse  réseau  peut  être  indiquée  sous  forme de valeur hexadécimale ou de notation
       décimale pointée.

       Les valeurs hexadécimales sont indiquées en préfixant  par  "0x"  ou  "0X".  Les  symboles
       hexadécimaux  remplissent  les nibbles (semioctets) de l'adresse réseau de gauche à droite
       dans l'ordre du réseau.

       Dans la notation décimale pointée, jusqu'à quatre octets sont indiqués sous  la  forme  de
       nombres  décimaux  séparées par des points. Ainsi, n'importe laquelle des formes suivantes
       est acceptée :

           a.b.c.d
           a.b.c
           a.b
           a

       Chaque partie est un nombre dans l'intervalle 0 à 255 remplissant un  octet  de  l'adresse
       réseau,  de  gauche  à  droite,  dans l'ordre des octets du réseau (gros-boutisme). Si une
       partie est omise, l'octet correspondant dans l'adresse réseau vaut zéro.

       Pour la notation hexadécimale comme la notation décimale pointée,  l'adresse  réseau  peut
       être  suivie  d'une  barre  oblique  et  d'un nombre compris entre 0 et 32, définissant la
       taille de l'adresse réseau en bits.

   Valeur de retour de inet_net_pton()
       La valeur de retour de inet_net_pton() est le nombre de bits dans le champ  de  numéro  de
       réseau.  Si  la  chaîne  de présentation se termine par une barre oblique et une valeur de
       taille explicite, alors cette taille devient  la  valeur  de  retour  de  inet_net_pton().
       Sinon, la valeur de retour, bits, est supposée comme suit.

       •  Si  l'octet  de  poids fort de l'adresse réseau est supérieur ou égal à 240, alors bits
          vaut 32.

       •  Sinon, si l'octet de poids fort de l'adresse réseau est supérieur ou égal à 224,  alors
          bits vaut 4.

       •  Sinon,  si l'octet de poids fort de l'adresse réseau est supérieur ou égal à 192, alors
          bits vaut 24.

       •  Sinon, si l'octet de poids fort de l'adresse réseau est supérieur ou égal à 128,  alors
          bits vaut 16.

       •  Sinon bits vaut 8.

       Si  la valeur de bits résultant des étapes précédentes est au moins égale à 8, mais que le
       nombre d’octets indiqué dans le numéro de réseau dépasse bits/8, alors bits est  défini  à
       huit fois le nombre d’octets vraiment indiqué.

EXEMPLES

       Le  programme  suivant  montre  l’utilisation  de  inet_net_pton()  et inet_net_ntop(). Il
       utilise inet_net_pton() pour convertir une adresse réseau au format de présentation fourni
       en  premier  argument  de  ligne  de  commande  vers sa forme binaire et affiche la valeur
       renvoyée par inet_net_pton(). Il utilise ensuite inet_net_ntop() pour reconvertir la forme
       binaire au format de présentation, et affiche la chaîne résultante.

       De  façon  à  démontrer  que inet_net_pton() peut ne pas écrire sur tous les octets de son
       argument netp, le programme permet un deuxième argument de ligne de commande :  un  nombre
       utilisé  pour  initialiser  le  tampon  avant d’appeler inet_net_pton(). Comme en dernière
       ligne de  sa  sortie,  le  programme  affiche  tous  les  octets  du  tampon  renvoyé  par
       inet_net_pton(), cela permet à l’utilisateur de voir les octets qui n’ont pas été modifiés
       par inet_net_pton().

       Un exemple où inet_net_pton() déduit le nombre de bits de l'adresse réseau :

           $ ./a.out 193.168
           inet_net_pton() a renvoyé : 24
           inet_net_ntop() a produit : 193.168.0/24
           Adresse brute :             c1a80000

       Démontrer que inet_net_pton() ne met pas  à  zéro  les  octets  inutilisés  du  tampon  de
       résultat :

           $ ./a.out 193.168 0xffffffff
           inet_net_pton() a renvoyé : 24
           inet_net_ntop() a produit : 193.168.0/24
           Adresse brute :             c1a800ff

       Démontrer que inet_net_pton() élargira la taille supposée du numéro de réseau si le nombre
       d’octets fournis dans la chaîne de présentation dépasse la valeur supposée :

           $ ./a.out 193.168.1.128
           inet_net_pton() a renvoyé : 32
           inet_net_ntop() a produit : 193.168.1.128/32
           Adresse brute :             c1a80180

       Définir explicitement la taille de l'adresse réseau outrepasse toute déduction au sujet de
       sa taille (mais tous les octets en trop explicitement définis seront tout de même utilisés
       par inet_net_pton() pour remplir le tampon de résultat).

           $ ./a.out 193.168.1.128/24
           inet_net_pton() a renvoyé : 24
           inet_net_ntop() a produit : 193.168.1/24
           Adresse brute :             c1a80180

   Source du programme
       /* Effectuer l'édition des liens avec "-lresolv" */

       #include <arpa/inet.h>
       #include <stdio.h>
       #include <stdlib.h>

       #define errExit(msg)    do { perror(msg); exit(EXIT_FAILURE); \
                               } while (0)

       int
       main(int argc, char *argv[])
       {
           char buf[100];
           struct in_addr addr;
           int bits;

           if (argc < 2) {
               fprintf(stderr,
                       "Utilisation : %s forme-présentation [val-adr-init]\n",
                       argv[0]);
               exit(EXIT_FAILURE);
           }

           /* Si argv[2] est fourni (une valeur numérique), l'utiliser pour
              initialiser le tampon de sortie fourni à inet_net_pton(), afin
              de montrer que inet_net_pton() n'initialise que les octets
              nécessaires pour stocker l'adresse réseau.
              Si argv[2] n'est pas fourni, alors initialiser le tampon à zéro
              (ce qui est une bonne pratique). */

           addr.s_addr = (argc > 2) ? strtod(argv[2], NULL) : 0;

           /* Convertir le numéro de réseau sous forme de présentation
              argv[1] sous forme binaire. */

           bits = inet_net_pton(AF_INET, argv[1], &addr, sizeof(addr));
           if (bits == -1)
               errExit("inet_net_ntop");

           printf("inet_net_pton() a renvoyé : %d\n", bits);

           /* Reconvertir de la forme binaire au format de présentation, en
              utilisant « bits » renvoyé par inet_net_pton(). */

           if (inet_net_ntop(AF_INET, &addr, bits, buf, sizeof(buf)) == NULL)
               errExit("inet_net_ntop");

           printf("inet_net_ntop() a produit : %s\n", buf);

           /* Afficher « aqaddr » sous forme brute (en ordre d’octets du
              réseau), pour permettre de voir les octets non affichés par
              inet_net_ntop() ; certains de ces octets pourraient ne pas
              avoir été modifiés par inet_net_ntop(), et avoir toujours la
              valeur initiale qui était indiquée argv[2]. */

           printf("Adresse brute :           %x\n", htonl(addr.s_addr));

           exit(EXIT_SUCCESS);
       }

VOIR AUSSI

       inet(3), networks(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> et David Prévot <david@tilapin.org>

       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⟩.