#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
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.
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.
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.
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.
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.
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é.
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
#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));
Cette traduction est une documentation libre ; veuillez vous reporter à la GNU General Public License version 3 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 à