# endian

## NAME



           htobe16, htole16, be16toh, le16toh, htobe32, htole32, be32toh,
           le32toh, htobe64, htole64, be64toh, le64toh - convert values
           between host and big-/little-endian byte order
    


## LIBRARY



           Standard C library (_libc_ , _-lc_)
    


## SYNOPSIS



           **#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_**);**
    
       Feature Test Macro Requirements for glibc (see
       feature_test_macros(7)):
    
           **htobe16**(), **htole16**(), **be16toh**(), **le16toh**(), **htobe32**(), **htole32**(),
           **be32toh**(), **le32toh**(), **htobe64**(), **htole64**(), **be64toh**(), **le64toh**():
               Since glibc 2.19:
                   _DEFAULT_SOURCE
               In glibc up to and including 2.19:
                   _BSD_SOURCE
    


## DESCRIPTION



           These  functions  convert the byte encoding of integer values from
           the byte order that the current CPU (the "host") uses, to and from
           little-endian and big-endian byte order.
    
           The number, _nn_ , in the name of each function indicates the size of
           integer handled by the function, either 16, 32, or 64 bits.
    
           The functions with names of the form "htobe _nn_ " convert  from  host
           byte order to big-endian order.
    
           The  functions  with names of the form "htole _nn_ " convert from host
           byte order to little-endian order.
    
           The functions with names of the form "be _nn_ toh" convert  from  big-
           endian order to host byte order.
    
           The  functions  with  names  of  the  form  "le _nn_ toh" convert from
           little-endian order to host byte order.
    


## VERSIONS



           Similar functions are present on  the  BSDs,  where  the  required
           header    file    is   _< sys/endian.h>_   instead   of   _< endian.h>_.
           Unfortunately, NetBSD, FreeBSD, and  glibc  haven't  followed  the
           original  OpenBSD  naming  convention for these functions, whereby
           the _nn_ component always appears at the end of  the  function  name
           (thus,  for example, in NetBSD, FreeBSD, and glibc, the equivalent
           of OpenBSDs "betoh32" is "be32toh").
    


## STANDARDS



           None.
    


## EXAMPLES



           The  program  below  display  the results of converting an integer
           from host byte order to both  little-endian  and  big-endian  byte
           order.   Since  host  byte  order  is either little-endian or big-
           endian, only one of these conversions will have an  effect.   When
           we  run  this program on a little-endian system such as x86-32, we
           see the following:
    
               $ **./a.out** ;
               x.u32 = 0x44332211
               htole32(x.u32) = 0x44332211
               htobe32(x.u32) = 0x11223344
    
       **Program source**
    
           #include <endian.h>
           #include <stdint.h>
           #include <stdio.h>
           #include <stdlib.h>
    
           int
           main(void)
           {
               union {
                   uint32_t u32;
                   uint8_t arr[4];
               } x;
    
               x.arr[0] = 0x11;    /* Lowest-address byte */
               x.arr[1] = 0x22;
               x.arr[2] = 0x33;
               x.arr[3] = 0x44;    /* Highest-address byte */
    
               printf("x.u32 = %#x\n", x.u32);
               printf("htole32(x.u32) = %#x\n", htole32(x.u32));
               printf("htobe32(x.u32) = %#x\n", htobe32(x.u32));
    
               exit(EXIT_SUCCESS);
           }
    


* * *