inet(3) Library Functions Manual inet(3) NOM inet_aton, inet_addr, inet_network, inet_ntoa, inet_makeaddr, inet_lnaof, inet_netof - Routines de manipulation d'adresses Internet BIBLIOTHEQUE Bibliotheque C standard (libc, -lc) SYNOPSIS #include #include #include int inet_aton(const char *cp, struct in_addr *inp); in_addr_t inet_addr(const char *cp); in_addr_t inet_network(const char *cp); [[deprecated]] char *inet_ntoa(struct in_addr in); [[obsolete]] struct in_addr inet_makeaddr(in_addr_t net, in_addr_t host); [[obsolete]] in_addr_t inet_lnaof(struct in_addr in); [[obsolete]] in_addr_t inet_netof(struct in_addr in); Exigences de macros de test de fonctionnalites pour la glibc (consulter feature_test_macros(7)) : inet_aton(), inet_ntoa() : Depuis la glibc 2.19 : _DEFAULT_SOURCE Dans les glibc anterieures et egale a 2.19 : _BSD_SOURCE || _BSD_SOURCE DESCRIPTION inet_aton() convertit l'adresse Internet de l'hote cp depuis la notation IPv4 avec nombres et points vers une forme binaire (dans l'ordre d'octet du reseau), et la stocke dans la structure pointee par inp. inet_aton() renvoie une valeur non nulle si l'adresse est valable, et zero sinon. L'adresse fournie a cp peut avoir l'une des formes suivantes : a.b.c.d Chacune des quatre parties numeriques represente un octet de l'adresse ; ces octets sont assignes de gauche a droite pour produire l'adresse binaire. a.b.c Les parties a et b representent les deux premiers octets de l'adresse binaire. La partie c est interpretee comme une valeur 16 bits definissant les deux octets les plus a droite de l'adresse binaire. Cette notation est pertinente pour indiquer (demode) des adresses de reseaux de classe B. a.b La partie a represente le premier octet de l'adresse binaire. La partie b est interpretee comme une valeur 24 bits definissant les trois octets les plus a droite de l'adresse binaire. Cette notation est pertinente pour indiquer (demode) des adresses de reseaux de classe A. a La valeur a est interpretee comme une valeur 32 bits directement enregistree dans l'adresse binaire, sans aucun reajustement d'octet. Dans toutes les formes precedentes, les elements d'une adresse en notation pointee peuvent etre indiques sous forme decimale, octale (avec un 0 devant) ou hexadecimale (avec un 0X devant). La terminologie des adresses sous ces formes est appelee notation numerique pointee IPv4. La forme qui utilise exactement quatre nombres decimaux est appelee notation decimale pointee IPV4 (ou quelques fois : notation quadruplee pointee IPv4). inet_aton() renvoie 1 si la chaine fournie a ete interpretee correctement ou 0 si la chaine n'est pas valable (errno n'est pas defini en cas d'erreur). La fonction inet_addr() convertit l'adresse Internet de l'hote cp depuis la notation IPv4 avec nombres et points en une donnee binaire dans l'ordre des octets du reseau. Si l'adresse est incorrecte, INADDR_NONE (generalement -1) est renvoye. L'utilisation de cette fonction pose probleme car -1 est une adresse valable (255.255.255.255). Evitez-la au profit de inet_aton(), inet_pton(3) ou getaddrinfo(3), qui fournissent un renvoi d'erreur plus propre. La fonction inet_network() convertit cp, une chaine en notation numerique pointee IPv4, en un nombre dans l'ordre des octets de l'hote qui pourra etre utilise comme adresse de reseau Internet. Si elle reussit, cette fonction renvoie l'adresse convertie. Si l'adresse n'est pas valable, -1 est renvoye. La fonction inet_ntoa() convertit l'adresse Internet de l'hote in donnee dans l'ordre des octets du reseau en une chaine de caracteres dans la notation numerique pointee. La chaine est renvoyee dans un tampon alloue statiquement, qui est donc ecrase a chaque appel. La fonction inet_lnaof() renvoie la partie correspondant a l'adresse du reseau local d'une adresse Internet in. La valeur est renvoyee dans l'ordre des octets de l'hote. La fonction inet_netof() renvoie la partie adresse reseau extraite d'une adresse Internet in. La valeur est renvoyee dans l'ordre des octets de l'hote. La fonction inet_makeaddr() est la reciproque des fonctions inet_netof() et inet_lnaof(). Elle renvoie une adresse d'hote Internet dans l'ordre des octets du reseau, en combinant le numero du reseau net et l'adresse locale host, chacun d'eux etant donne dans l'ordre des octets de l'hote. La structure in_addr utilisee dans inet_ntoa(), inet_makeaddr(), inet_lnaof() et inet_netof() est definie ainsi dans : typedef uint32_t in_addr_t; struct in_addr { in_addr_t s_addr; }; ATTRIBUTS Pour une explication des termes utilises dans cette section, consulter attributes(7). +--------------------------+--------------------------+----------------+ |Interface | Attribut | Valeur | +--------------------------+--------------------------+----------------+ |inet_aton(), inet_addr(), | Securite des threads | MT-Safe locale | |inet_network(), | | | |inet_ntoa() | | | +--------------------------+--------------------------+----------------+ |inet_makeaddr(), | Securite des threads | MT-Safe | |inet_lnaof(), | | | |inet_netof() | | | +--------------------------+--------------------------+----------------+ STANDARDS inet_addr() inet_ntoa() POSIX.1-2008. inet_aton() Aucune. STANDARDS inet_addr() inet_ntoa() POSIX.1-2001, 4.3BSD. inet_lnaof(), inet_netof() et inet_makeaddr() sont des fonctions heritees qui supposent qu'elles traitent des adresses de classes canoniques. Les sous-reseaux de classes canoniques divisent la partie reseau et la partie hote des adresses IPv4 sur des limites d'octets comme suit : Classe A Ce type d'adresse est indique par la valeur 0 du bit de poids fort (dans l'ordre des octets du reseau) de l'adresse. L'adresse du reseau est contenue dans l'octet de poids fort et l'adresse de l'hote dans les trois octets restants. Classe B Ce type d'adresse est indique par la valeur binaire 10 dans les deux bits de poids fort de l'adresse. L'adresse du reseau est contenue dans les deux octets de poids fort et l'adresse de l'hote dans les deux octets restants. Classe C Ce type d'adresse est indique par la valeur binaire 110 dans les trois bits de poids fort de l'adresse. L'adresse du reseau est contenue dans les trois octets de poids fort et l'adresse de l'hote dans l'octet restant. La classification des adresses reseaux est aujourd'hui obsolete, supplantee par le << Classless Inter-Domain Routing (CIDR) >>, qui scinde les adresses en elements reseau et hote sur une frontiere arbitraire en bit (plutot qu'en octet). NOTES L'ordre des octets des machines i386 est << LSB >> (poids faible en premier, << little endian >>), alors que l'ordre des octets sur internet est << MSB >> (poids fort en premier ou << big endian >>). EXEMPLES Ci-dessous, un exemple de l'utilisation de inet_aton() et de inet_ntoa(). Voici des exemples d'execution : $ ./a.out 226.000.000.037 # Last byte is in octal 226.0.0.31 $ ./a.out 0x7f.1 # First byte is in hex 127.0.0.1 Source du programme #define _DEFAULT_SOURCE #include #include #include int main(int argc, char *argv[]) { struct in_addr addr; if (argc != 2) { fprintf(stderr, "%s \n", argv[0]); exit(EXIT_FAILURE); } if (inet_aton(argv[1], &addr) == 0) { fprintf(stderr, "Invalid address\n"); exit(EXIT_FAILURE); } printf("%s\n", inet_ntoa(addr)); exit(EXIT_SUCCESS); } VOIR AUSSI byteorder(3), getaddrinfo(3), gethostbyname(3), getnameinfo(3), getnetent(3), inet_net_pton(3), inet_ntop(3), inet_pton(3), hosts(5), networks(5) TRADUCTION La traduction francaise de cette page de manuel a ete creee par Christophe Blaess , Stephan Rafin , Thierry Vignaud , Francois Micaux, Alain Portal , Jean-Philippe Guerard , Jean-Luc Coulon (f5ibh) , Julien Cristau , Thomas Huriaux , Nicolas Francois , Florentin Duneau , Simon Paillard , Denis Barbier , David Prevot et Jean-Philippe MENGUAL Cette traduction est une documentation libre ; veuillez vous reporter a la GNU General Public License version 3 concernant les conditions de copie et de distribution. Il n'y a aucune RESPONSABILITE LEGALE. Si vous decouvrez un bogue dans la traduction de cette page de manuel, veuillez envoyer un message a . Pages du manuel de Linux 6.12 23 juillet 2024 inet(3)