一、字节序的概念

字节序是指多字节数据的存储顺序,在设计计算机系统的时候,有两种处理内存中数据的方法:大端格式、小端格式。

 

小端格式(Little-Endian):将低位字节数据存储在低地址。

大端格式(Big-Endian):将高位字节数据存储在低地址。

举个简单的例子,对于整形 0x12345678,它在大端格式和小端格式的系统中,分别如下图所示的方式存放:

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdio.h> 
 
int main(int argc, charchar *argv[]) 
    unsigned int a = 0x12345678
    unsigned char *p = (unsigned charchar *)&a; //只取一个字节 
    if(0x12 == *p){ 
        printf("Big-Endian\n"); 
    }else if(0x78 == *p){ 
        printf("Little-Endian\n"); 
    
 
    return 0
}
网络上的数据流是字节流,对于一个多字节数值,在进行网络传输的时候,先传递哪个字节?也就是说,当接收端收到第一个字节的时候,它是将这个字节作为高位还是低位来处理呢?

 

网络字节序定义:收到的第一个字节被当作高位看待,这就要求发送端发送的第一个字节应当是高位。而在发送端发送数据时,发送的第一个字节是该数字在内存中起始地址对应的字节。可见多字节数值在发送前,在内存中数值应该以大端法存放。  

 

所以,网络协议指定了通讯字节序:大端。只有在多字节数据处理时才需要考虑字节序,运行在同一台计算机上的进程相互通信时,一般不用考虑字节序,异构计算机之间通讯,需要转换自己的字节序为网络字节

 

二、字节序转换函数介绍

以下接口所需头文件:#include <arpa/inet.h>

 

uint32_t htonl(uint32_t hostint32);

功能:

将 32 位主机字节序数据转换成网络字节序数据

参数:

hostint32:需要转换的 32 位主机字节序数据,uint32_t 为 32 为无符号整型

返回值:

成功:返回网络字节序的值

 

uint16_t htons(uint16_t hostint16);

功能:

将 16 位主机字节序数据转换成网络字节序数据

参数:

hostint16:需要转换的 16 位主机字节序数据,uint16_t,unsigned short int

返回值:

成功:返回网络字节序的值

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h> 
#include <arpa/inet.h> 
 
int main(int argc, charchar *argv[]) 
    int a = 0x01020304
    short int b = 0x0102
 
    printf("htonl(0x%08x) = 0x%08x\n", a, htonl(a)); 
    printf("htons(0x%04x) = 0x%04x\n", b, htons(b)); 
 
    return 0
}

uint32_t ntohl(uint32_t netint32);

功能:

将 32 位网络字节序数据转换成主机字节序数据

参数:

netint32:待转换的 32 位网络字节序数据,uint32_t,unsigned int

返回值:

成功:返回主机字节序的值

 

uint16_t ntohs(uint16_t netint16);

功能:

将 16 位网络字节序数据转换成主机字节序数据

参数:

netint16:待转换的 16 位网络字节序数据,uint16_t,unsigned short int

返回值:

成功:返回主机字节序的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <stdio.h> 
#include <arpa/inet.h> 
int main() 
    char ip_str[]="172.20.223.75"
    unsigned int ip_uint = 0
    unsigned charchar *ip_p = NULL; 
 
    inet_pton(AF_INET,ip_str,&ip_uint); 
    printf("in_uint = %d\n",ip_uint); 
 
    ip_p = (charchar *)&ip_uint; 
    printf("in_uint = %d,%d,%d,%d\n",*ip_p,*(ip_p+1),*(ip_p+2),*(ip_p+3)); 
 
    return 0
}

const char *inet_ntop( int family, 

const void *addrptr,   

char *strptr, 

size_t len );

功能:

将 32 位无符号整数转换成点分十进制数串

参数:

family:协议族( AF_INET、AF_INET6、PF_PACKET 等 ),常用 AF_INET

addrptr:32 位无符号整数

strptr:点分十进制数串

len:strptr 缓存区长度

 len 的宏定义
 #define INET_ADDRSTRLEN   16  // for ipv4

#define INET6_ADDRSTRLEN  46  // for ipv6

返回值:

成功:则返回字符串的首地址

失败:返回 NULL

1
2
3
4
5
6
7
8
9
10
11
12
#include <stdio.h> 
#include <arpa/inet.h> 
int main() 
    unsigned char ip[] = {172,20,223,75}; 
    char ip_str[16] = "NULL"
 
    inet_ntop(AF_INET,(unsigned intint *)ip,ip_str,16); 
    printf("ip_str = %s\n",ip_str); 
 
    return 0
}

主机字节序与网络字节序的转换函数:htonl、ntohl、htons、ntohs

Part 1: htons函数具体解释
     在Linux和Windows网络编程时需要用到htons和htonl函数,用来将主机字节顺序转换为网络字节顺序。

     在Intel机器下,执行以下程序

int main()
...{
   printf("%d /n",htons(16));
      return 0;
}
得到的结果是4096,初一看感觉很怪。

    解释如下,数字16的16进制表示为0x0010,数字4096的16进制表示为0x1000。 由于Intel机器是小尾端,存储数字16时实际顺序为1000,存储4096时实际顺序为0010。因此在发送网络包时为了报文中数据为0010,需要经过htons进行字节转换。如果用IBM等大尾端机器,则没有这种字节顺序转换,但为了程序的可移植性,也最好用这个函数。

   另外用注意,数字所占位数小于或等于一个字节(8 bits)时,不要用htons转换。这是因为对于主机来说,大小尾端的最小单位为字节(byte)。

 

Part 2: 大小端模式


不同的CPU有不同的字节序类型 这些字节序是指整数在内存中保存的顺序 这个叫做主机序 
最常见的有两种
1. Little endian:将低序字节存储在起始地址
2. Big endian:将高序字节存储在起始地址

LE little-endian 
最符合人的思维的字节序 
地址低位存储值的低位 
地址高位存储值的高位 
怎么讲是最符合人的思维的字节序,是因为从人的第一观感来说 
低位值小,就应该放在内存地址小的地方,也即内存地址低位 
反之,高位值就应该放在内存地址大的地方,也即内存地址高位

BE big-endian 
最直观的字节序 
地址低位存储值的高位 
地址高位存储值的低位 
为什么说直观,不要考虑对应关系 
只需要把内存地址从左到右按照由低到高的顺序写出 
把值按照通常的高位到低位的顺序写出 
两者对照,一个字节一个字节的填充进去

例子:在内存中双字0x01020304(DWORD)的存储方式

内存地址 
4000 4001 4002 4003 
LE 04 03 02 01 
BE 01 02 03 04

例子:如果我们将0x1234abcd写入到以0x0000开始的内存中,则结果为
      big-endian  little-endian
0x0000  0x12      0xcd
0x0001  0x23      0xab
0x0002  0xab      0x34
0x0003  0xcd      0x12
x86系列CPU都是little-endian的字节序.

网络字节顺序是TCP/IP中规定好的一种数据表示格式,它与具体的CPU类型、操作系统等无关,从而可以保证数据在不同主机之间传输时能够被正确解释。网络字节顺序采用big endian排序方式。

为了进行转换 bsd socket提供了转换的函数 有下面四个
htons 把unsigned short类型从主机序转换到网络序
htonl 把unsigned long类型从主机序转换到网络序
ntohs 把unsigned short类型从网络序转换到主机序
ntohl 把unsigned long类型从网络序转换到主机序

在使用little endian的系统中 这些函数会把字节序进行转换 
在使用big endian类型的系统中 这些函数会定义成空宏

同样 在网络程序开发时 或是跨平台开发时 也应该注意保证只用一种字节序 不然两方的解释不一样就会产生bug.

注:
1、网络与主机字节转换函数:htons ntohs htonl ntohl (s 就是short l是long h是host n是network)
2、不同的CPU上运行不同的操作系统,字节序也是不同的,参见下表。
处理器    操作系统    字节排序
Alpha    全部    Little endian
HP-PA    NT    Little endian
HP-PA    UNIX    Big endian
Intelx86    全部    Little endian <-----x86系统是小端字节序系统
Motorola680x()    全部    Big endian
MIPS    NT    Little endian
MIPS    UNIX    Big endian
PowerPC    NT    Little endian
PowerPC    非NT    Big endian  <-----PPC系统是大端字节序系统
RS/6000    UNIX    Big endian
SPARC    UNIX    Big endian
IXP1200 ARM核心    全部    Little endian

本文来自CSDN博客,转载请标明出处:http://blog.csdn.NET/zouxinfox/archive/2007/10/07/1814088.aspx

 

 

Part 3: 模拟htonl、ntohl、htons、ntohs函数实现

 


--------------------------------------------------------------------------------
今天在如鹏网里讨论htonl、ntohl在不同机器的区别,特意模拟了htonl、ntohl、htons、ntohs函数实现。
实现如下:


typedef unsigned short int uint16;

typedef unsigned long int uint32;

 

// 短整型大小端互换

#define BigLittleSwap16(A)  ((((uint16)(A) & 0xff00) >> 8) | /

                                                 (((uint16)(A) & 0x00ff) << 8))

 

// 长整型大小端互换

#define BigLittleSwap32(A)  ((((uint32)(A) & 0xff000000) >> 24) | /

                                                 (((uint32)(A) & 0x00ff0000) >> 8) | /

                                                 (((uint32)(A) & 0x0000ff00) << 8) | /

                                                 (((uint32)(A) & 0x000000ff) << 24))

 

// 本机大端返回1,小端返回0

int checkCPUendian()

{

       union{

              unsigned long int i;

              unsigned char s[4];

       }c;

 

       c.i = 0x12345678;

       return (0x12 == c.s[0]);

}

 

// 模拟htonl函数,本机字节序转网络字节序

unsigned long int HtoNl(unsigned long int h)

{

       // 若本机为大端,与网络字节序同,直接返回

       // 若本机为小端,转换成大端再返回

       return checkCPUendian() ? h : BigLittleSwap32(h);

}

 

// 模拟ntohl函数,网络字节序转本机字节序

unsigned long int NtoHl(unsigned long int n)

{

       // 若本机为大端,与网络字节序同,直接返回

       // 若本机为小端,网络数据转换成小端再返回

       return checkCPUendian() ? n : BigLittleSwap32(n);

}

 

// 模拟htons函数,本机字节序转网络字节序

unsigned short int HtoNs(unsigned short int h)

{

       // 若本机为大端,与网络字节序同,直接返回

       // 若本机为小端,转换成大端再返回

       return checkCPUendian() ? h : BigLittleSwap16(h);

}

 

// 模拟ntohs函数,网络字节序转本机字节序

unsigned short int NtoHs(unsigned short int n)

{

       // 若本机为大端,与网络字节序同,直接返回

       // 若本机为小端,网络数据转换成小端再返回

       return checkCPUendian() ? n : BigLittleSwap16(n);

}

大端小端 && 网络字节序

(0)背景:
网络上的数据流是字节流,对于一个多字节数值,在进行网络传输的时候,先传递哪个字节?也就是说,当接收端收到第一个字节的时候,它是将这个字节作为高位还是低位来处理呢? 


(1)网络字节序定义:
收到的第一个字节被当作高位看待,这就要求发送端发送的第一个字节应当是高位。


(2)网络字节序为大端序列:
在发送端发送数据时,发送的第一个字节是该数字在内存中起始地址对应的字节。可见多字节数值在发送前,在内存中数值应该以大端法存放。 


htons():将16位无符号整数从本地字节序转换成网络字节序;
htonl():将32位无符号整数从本地字节序转换成网络字节序;
ntohs():将16位无符号整数从网络字节序转换成本地字节序;
ntohl():将32位无符号整数从网络字节序转换成本地字节序;


(3)举例:
比如我们经过网络发送0x12345678这个整形,在80X86平台中,它是以小端法存放的,在发送前需要使用系统提供的htonl将其转换成大端法存放,如图2所示。




(4)大端序列与小端序列:
1.小端法(Little-Endian)就是低位字节排放在内存的低地址端即该值的起始地址,高位字节排放在内存的高地址端。 
2.大端法(Big-Endian)就是高位字节排放在内存的低地址端即该值的起始地址,低位字节排放在内存的高地址端。


举个简单的例子,对于整形0x12345678。它在大端法和小端法的系统内中,分别如图1所示的方式存放。
如下图:




(5)字节序测试函数:


不同cpu平台上字节序通常也不一样,下面写个简单的C程序,它可以测试不同平台上的字节序。
  #include <stdio.h>
  #include <netinet/in.h>
  int main()
  {
     int i_num = 0x12345678;
     printf("[0]:0x%x\n", *((char *)&i_num + 0));
     printf("[1]:0x%x\n", *((char *)&i_num + 1));
     printf("[2]:0x%x\n", *((char *)&i_num + 2));
     printf("[3]:0x%x\n", *((char *)&i_num + 3));
   
     i_num = htonl(i_num);
     printf("[0]:0x%x\n", *((char *)&i_num + 0));
     printf("[1]:0x%x\n", *((char *)&i_num + 1));
     printf("[2]:0x%x\n", *((char *)&i_num + 2));
     printf("[3]:0x%x\n", *((char *)&i_num + 3));
   
     return 0;
  }