网络字节序与主机字节序的转换

Posted 2022-11-24 wonxxx

前言

端口号和IP地址都是以网络字节序存储的，不是主机字节序。网络字节序都是大端模式，而我们常用的机器都是小端模式。要把主机字节序和网络字节序相互对应起来，需要对这两个字节存储优先顺序进行相互转化。其实这个转换实质是：字节“搬家”。

先分析一下我们平时使用ntohl、ntohs、htonl、htons函数是怎么实现的，然后在本文最后写一个判断机器是大/小端的函数。

函数追踪

函数定义的地方：
/usr/include/netinet/in.h

# if __BYTE_ORDER == __BIG_ENDIAN
/* The host byte order is the same as network byte order,
   so these functions are all just identity.  */
# define ntohl(x)   (x)
# define ntohs(x)   (x)
# define htonl(x)   (x)
# define htons(x)   (x)
# else
#  if __BYTE_ORDER == __LITTLE_ENDIAN
#   define ntohl(x) __bswap_32 (x)
#   define ntohs(x) __bswap_16 (x)
#   define htonl(x) __bswap_32 (x)
#   define htons(x) __bswap_16 (x)                                                                                                  
#  endif
# endif
#endif

可以看到ntohl和htonl使用的是同一个函数__bswap_32，ntohs和htons使用的是同一个函数__bswap_16，在这里只对__bswap_32函数的实现进行追踪：
/usr/include/i386-linux-gnu/bits/byteswap.h

/* Swap bytes in 32 bit value.  */
#define __bswap_constant_32(x) \\
     ((((x) & 0xff000000) >> 24) | (((x) & 0x00ff0000) >>  8) |           \\
      (((x) & 0x0000ff00) <<  8) | (((x) & 0x000000ff) << 24))

#ifdef __GNUC__
# if __GNUC__ >= 2
/* To swap the bytes in a word the i486 processors and up provide the
   `bswap' opcode.  On i386 we have to use three instructions.  */
#  if !defined __i486__ && !defined __pentium__ && !defined __pentiumpro__ \\
      && !defined __pentium4__ && !defined __k8__ && !defined __athlon__ \\
      && !defined __k6__ && !defined __nocona__ && !defined __core2__ \\
      && !defined __geode__ && !defined __amdfam10__
#   define __bswap_32(x)                              \\
     (__extension__                               \\
      ( register unsigned int __v, __x = (x);                    \\
     if (__builtin_constant_p (__x))                      \\
       __v = __bswap_constant_32 (__x);                   \\
     else                                     \\
       __asm__ ("rorw $8, %w0;"                       \\
            "rorl $16, %0;"                       \\
            "rorw $8, %w0"                        \\
            : "=r" (__v)                          \\
            : "0" (__x)                           \\
            : "cc");                              \\
     __v; ))
#  else
#   define __bswap_32(x) \\
     (__extension__                               \\
      ( register unsigned int __v, __x = (x);                    \\
     if (__builtin_constant_p (__x))                      \\
       __v = __bswap_constant_32 (__x);                   \\
     else                                     \\
       __asm__ ("bswap %0" : "=r" (__v) : "0" (__x));             \\
     __v; ))
#  endif
# else
#  define __bswap_32(x) \\
     (__extension__                               \\
      ( register unsigned int __x = (x); __bswap_constant_32 (__x); ))
# endif
#else
static __inline unsigned int
__bswap_32 (unsigned int __bsx)
                                        
  return __bswap_constant_32 (__bsx);

#endif

这里有对不同的处理器有不同的处理情况，还有汇编指令，这里先不对这部分做深究，所以最终的实现为：

/* Swap bytes in 32 bit value.  */
#define __bswap_constant_32(x) \\
     ((((x) & 0xff000000) >> 24) | (((x) & 0x00ff0000) >>  8) |           \\
      (((x) & 0x0000ff00) <<  8) | (((x) & 0x000000ff) << 24))

虽然没有对应的64bit的转换函数接口，但在文件bits/byteswap.h中还是有实现：

#if defined __GNUC__ && __GNUC__ >= 2
/* Swap bytes in 64 bit value.  */
# define __bswap_constant_64(x) \\
     (__extension__ ((((x) & 0xff00000000000000ull) >> 56)            \\
             | (((x) & 0x00ff000000000000ull) >> 40)              \\
             | (((x) & 0x0000ff0000000000ull) >> 24)              \\
             | (((x) & 0x000000ff00000000ull) >> 8)           \\
             | (((x) & 0x00000000ff000000ull) << 8)           \\
             | (((x) & 0x0000000000ff0000ull) << 24)              \\
             | (((x) & 0x000000000000ff00ull) << 40)              \\
             | (((x) & 0x00000000000000ffull) << 56)))

# define __bswap_64(x) \\
     (__extension__                               \\
      ( union  __extension__ unsigned long long int __ll;           \\
         unsigned long int __l[2];  __w, __r;                \\
     if (__builtin_constant_p (x))                        \\
       __r.__ll = __bswap_constant_64 (x);                    \\
     else                                     \\
                                             \\
         __w.__ll = (x);                              \\
         __r.__l[0] = __bswap_32 (__w.__l[1]);                \\
         __r.__l[1] = __bswap_32 (__w.__l[0]);                \\
                                             \\
     __r.__ll; ))
#endif

对于__BYTE_ORDER：

/* i386 is little-endian.  */                                                                                                       

#ifndef _ENDIAN_H
# error "Never use <bits/endian.h> directly; include <endian.h> instead."
#endif

#define __BYTE_ORDER __LITTLE_ENDIAN

这里大小端模式竟然是直接定义好的，还以为会用使用数据存储来判断一下呢。。。那我们自己动手来写一下大小端的判断函数：

#include <stdio.h>

#define BIG_ENDIAN 1  
#define LITTLE_ENDIAN 0  

#define BOOL unsigned int

/*
 * 定义一个2个字节长度的数据，并赋值为1,则其16进制表示为0x0001 
 * 如果系统以“大端”存放数据,那么低字节存放的必定是0x00，高字节存放的必定是0x01 
 * 如果系统以“小端”存放数据,那么低字节存放的必定是0x01，高字节存放的必定是0x00 
 */  
static BOOL is_bigendian()
  
    const short n = 1;  
    if (*(char *)&n)  
       
        return LITTLE_ENDIAN;  
       
    return BIG_ENDIAN;  
 

int main()

    if (BIG_ENDIAN == is_bigendian())
       
        printf("Big Endian\\n");
       
    else
       
        printf("Little Endian\\n");
       

    return 0;
 

结语

知其然，也要知其所以然。