Provided by: manpages-fr-dev_3.27fr1.4-1_all bug

NOM

       htobe16, htole16, be16toh, le16toh, htobe32, htole32, be32toh, le32toh,
       htobe64, htole64,  be64toh,  le64toh  -  convertir  des  valeurs  entre
       l'ordre des octets de l'hote et l'ordre petit et gros boutiste

SYNOPSIS

       #define _BSD_SOURCE             /* Consultez feature_test_macros(7) */
       #include <endian.h>

       uint16_t htobe16(uint16_t host_16bits);
       uint16_t htole16(uint16_t host_16bits);
       uint16_t be16toh(uint16_t big_endian_16bits);
       uint16_t le16toh(uint16_t little_endian_16bits);

       uint32_t htobe32(uint32_t host_32bits);
       uint32_t htole32(uint32_t host_32bits);
       uint32_t be32toh(uint32_t big_endian_32bits);
       uint32_t le32toh(uint32_t little_endian_32bits);

       uint64_t htobe64(uint64_t host_64bits);
       uint64_t htole64(uint64_t host_64bits);
       uint64_t be64toh(uint64_t big_endian_64bits);
       uint64_t le64toh(uint64_t little_endian_64bits);

DESCRIPTION

       Ces  fonctions  convertissent l'encodage des octets de valeurs entieres
       depuis l'ordre de l'hote (l'ordre utilise par le CPU), vers  ou  depuis
       l'ordre petit et gros boutiste.

       Le  nombre,  nn,  dans  le nom de chaque fonction indique la taille des
       entiers geree par la fonction, soit 16, 32 ou 64 bits.

       Les fonctions dont le nom est de la forme  << htobenn >>  convertissent
       depuis l'ordre des octets de l'hote vers l'ordre gros boutiste.

       Les  fonctions  dont le nom est de la forme << htolenn >> convertissent
       depuis l'ordre des octets de l'hote vers l'ordre petit boutiste.

       Les fonctions dont le nom est de la forme  << benntoh >>  convertissent
       depuis l'ordre gros boutiste vers l'ordre des octets de l'hote.

       Les  fonctions  dont le nom est de la forme << lenntoh >> convertissent
       depuis l'ordre petit boutiste vers l'ordre des octets de l'hote.

VERSIONS

       Cette fonction a ete ajoutee dans la version 2.9 de la glibc.

CONFORMIT'E

       Ces fonctions ne sont  pas  standard.  Des  fonctions  similaires  sont
       presentes   sur   les  systemes  BSD,  ou  le  fichier  d'en-tetes  est
       <sys/endian.h> au lieu de <endian.h>. Cependant, NetBSD, FreeBSD et  la
       glibc n'ont pas suivi le nommage original d'OpenBSD ou la composante nn
       est placee a la fin du nom de la fonction (par  exemple,  sous  NetBSD,
       FreeBSD   et  la  glibc,  l'equivalent  OpenBSD  de  << betoh32 >>  est
       << be32toh >>).

NOTES

       Ces fonctions  sont  similaires  a  la  vieille  famille  de  fonctions
       byteorder(3). Par exemple, be32toh() est identique a ntohl().

       L'avantage  des fonctions de byteorder(3) est que ce sont des fonctions
       standard disponibles sur tous les systemes Unix.  D'autre  part,  elles
       ont  ete  creees  pour  etre  utilisees dans un contexte TCP/IP, ce qui
       signifie qu'elles ne gerent  pas  les  architectures  64  bits  et  les
       variantes petit boutistes vues dans cette page.

EXEMPLE

       Le  programme  ci-dessous  affiche  les  resultats des conversions d'un
       entier depuis l'ordre des octets de l'hote vers l'ordre petit  et  gros
       boutiste.  Puisque  l'ordre  de  l'hote est soit petit boutiste ou soit
       gros boutiste, seule une de ces conversions a un  effet.  Lorsque  vous
       executez  ce programme sur un systeme petit boutiste comme x86-32, vous
       avez :

           $ ./a.out
           x.u32 = 0x44332211
           htole32(x.u32) = 0x44332211
           htobe32(x.u32) = 0x11223344

   Source du programme

       #include <endian.h>
       #include <stdint.h>
       #include <stdio.h>
       #include <stdlib.h>

       int
       main(int argc, char *argv[])
       {
           union {
            uint32_t u32;
            uint8_t arr[4];
           } x;

           x.arr[0] = 0x11;     /* octet d'adresse basse */
           x.arr[1] = 0x22;
           x.arr[2] = 0x33;
           x.arr[3] = 0x44;     /* octet d'adresse haute */

           printf("x.u32 = 0x%x\n", x.u32);
           printf("htole32(x.u32) = 0x%x\n", htole32(x.u32));
           printf("htobe32(x.u32) = 0x%x\n", htobe32(x.u32));

           exit(EXIT_SUCCESS);
       }

VOIR AUSSI

       byteorder(3)

COLOPHON

       Cette page fait partie de  la  publication  3.27  du  projet  man-pages
       Linux.  Une description du projet et des instructions pour signaler des
       anomalies      peuvent      etre       trouvees       a       l'adresse
       <URL:http://www.kernel.org/doc/man-pages/>.

TRADUCTION

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

       Florentin   Duneau   et   l'equipe   francophone   de   traduction   de
       Debian (2006-2009).

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

       Vous  pouvez  toujours avoir acces a la version anglaise de ce document
       en utilisant la commande << man -L C <section> <page_de_man> >>.