网络字节序与主机字节序

来源：互联网发布：京东左侧悬浮楼层js 编辑：程序博客网时间：2024/05/10 21:53

最近在项目开发过程中，需要在采用JAVA作为语言的服务器与采用C++作为语言的服务器间进行通信，这就涉及到这两种语言间数据类型的转换以及网络字节序与主机字节序的区别。该文主要说说网络字节序和主机字节序的区别以及Little endian与Big endian的概念。其实编程的事就比较简单了
我也懒得写了，直接引用了我觉得写的挺好的两篇文章：

什么是Big Endian和Little Endian？

来源：http://blog.ednchina.com/qinyonglyz/194674/message.aspx

1．故事的起源

“endian”这个词出自《格列佛游记》。小人国的内战就源于吃鸡蛋时是究竟从大头(Big-Endian)敲开还是从小头(Little-Endian)敲开，由此曾发生过六次叛乱，其中一个皇帝送了命，另一个丢了王位。

我们一般将endian翻译成“字节序”，将big endian和little endian称作“大尾”和“小尾”。

2．什么是Big Endian和Little Endian？

在设计计算机系统的时候，有两种处理内存中数据的方法。一种叫为little-endian，存放在内存中最低位的数值是来自数据的最右边部分（也就是数据的最低位部分）。比如一个16进制数字0x12345678，在内存存放的方式如下：

值

0111，1000

0101，0110

0011，0100

0001，0010

地址

100

101

102

103

另一种称为big-endian，正好相反，存放在内存中最低位的数值是来自数据的最左边边部分（也就是数据的最高为部分）。比如一个16进制数字0x12345678，在内存存放的方式如下：

值

0001，0010

0011，0100

0101，0110

0111，1000

地址

100

101

102

103

比如某些文件需要在不同平台处理，或者通过Socket通信。这方面我们可以借助ntohl(), ntohs(), htonl(), and htons()函数进行格式转换。

3．如何判断系统是Big Endian还是Little Endian？

在/usr/include/中（包括子目录）查找字符串BYTE_ORDER(或_BYTE_ORDER, __BYTE_ORDER)，确定其值。这个值一般在endian.h或machine/endian.h文件中可以找到,有时在feature.h中，不同的操作系统可能有所不同。一般来说，Little Endian系统BYTE_ORDER(或_BYTE_ORDER,__BYTE_ORDER)为1234，Big Endian系统为4321。大部分用户的操作系统（如windows, FreeBsd,Linux）是Little Endian的。少部分，如MAC OS ,是Big Endian 的。本质上说，Little Endian还是Big Endian与操作系统和芯片类型都有关系。

======================================================================

ext3 文件系统在硬盘分区上的数据是按照 Intel 的 Little-endian 格式存放的，如果是在 PC 以外的平台上开发 ext3 相关的程序，要特别注意这一点。

谈到字节序的问题，必然牵涉到两大 CPU派系。那就是Motorola的PowerPC系列CPU和Intel的x86系列CPU。PowerPC系列采用big endian方式存储数据，而x86系列则采用little endian方式存储数据。那么究竟什么是big endian，什么又是little endian呢？

其实big endian是指低地址存放最高有效字节（MSB），而little endian则是低地址存放最低有效字节（LSB）。

     用文字说明可能比较抽象，下面用图像加以说明。比如数字0x12345678在两种不同字节序CPU中的存储顺序如下所示：

Big Endian

   低地址                                            高地址
   ----------------------------------------->
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   |     12     |      34    |     56      |     78    |
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

Little Endian

   低地址                                            高地址
   ----------------------------------------->
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   |     78     |      56    |     34      |     12    |
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

     从上面两图可以看出，采用big endian方式存储数据是符合我们人类的思维习惯的。而little endian，!@#$%^&*，见鬼去吧 -_-|||

     为什么要注意字节序的问题呢？你可能这么问。当然，如果你写的程序只在单机环境下面运行，并且不和别人的程序打交道，那么你完全可以忽略字节序的存在。但是，如果你的程序要跟别人的程序产生交互呢？在这里我想说说两种语言。C/C++语言编写的程序里数据存储顺序是跟编译平台所在的CPU相关的，而 JAVA编写的程序则唯一采用big endian方式来存储数据。试想，如果你用C/C++语言在x86平台下编写的程序跟别人的JAVA程序互通时会产生什么结果？就拿上面的 0x12345678来说，你的程序传递给别人的一个数据，将指向0x12345678的指针传给了JAVA程序，由于JAVA采取big endian方式存储数据，很自然的它会将你的数据翻译为0x78563412。什么？竟然变成另外一个数字了？是的，就是这种后果。因此，在你的C程序传给JAVA程序之前有必要进行字节序的转换工作。

     无独有偶，所有网络协议也都是采用big endian的方式来传输数据的。所以有时我们也会把big endian方式称之为网络字节序。当两台采用不同字节序的主机通信时，在发送数据之前都必须经过字节序的转换成为网络字节序后再进行传输。

网络字节序与主机字节序

来源：http://www.cnblogs.com/jacktu/archive/2008/11/24/1339789.html
不同的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

///////////////////////////////////////////////////////////////////////////////////////////

在C/C++写网络程序的时候，往往会遇到字节的网络顺序和主机顺序的问题。

其实数据的顺序是由cpu决定的,与操作系统无关。

如 Intel x86结构下,short型数0x1234表示为34 12,int型数0x12345678表示为78 56 34 12

如IBM power PC结构下,short型数0x1234表示为12 34,int型数0x12345678表示为12 34 56 78

由于这个原因不同的机器之间无法通信,所以要转换成一种约定的数序,也就是网络字节顺序,其实就是如同power pc那样的顺序。

在PC开发中有ntohl和htonl函数可以用来进行网络字节和主机字节的转换，但是Symbian开发中没有这两个函数，那就要自己写接口来进行转换了。

下面是两个进行转换的接口：

//主机顺序转换成网络顺序或网络顺序转换成主机顺序

inline unsigned long HTONL(unsigned long h)
  {
return (h>>24)+((h>>16)<<8)+((h>>8)<<16)+(h<<24);
  }

//主机顺序转换成网络顺序或网络顺序转换成主机顺序
  inline unsigned short HTONS(unsigned short h)
  {
return (h>>8)+(h<<8);
  }

这些问题在Java做为Server端，Symbian做为Client端时表现的更为明显，因为Java中的通讯传输的都是网络字节。到了Symbian端要转换成主机字节。

比如你要发送一个结构
struct test{
short   a;
    int      b;
    long   c;
    float   d;
    double f;
};
test st;
char *p = (char*)&st;//看看p中的字节顺序（就是发送的字节顺序）

java端你相应写些函数进行转换就行了。
  举一个例子：
//与c对应的ntohl函数
public static long ntohl(long in){
long out = 0;
out = (in&0xff)<<24;
out |= (in&0xff00)<<8;
out |= (in&0xff0000)>>8;
out |= (in&0xff000000)>>24;
return out;
}

下面再转几篇不错的文章:

原文地址:http://blog.csdn.net/kingfish/archive/2005/03/29/333635.aspx

近几天看到csdn上问c/c++和java通信的问题比较多，特别是c特有的数据结构（如struct）。

特地根据网友的一个问题举个例子，希望对初学者有所帮助。

原问题见：http://community.csdn.net/Expert/topic/3886/3886989.xml?temp=.3527033

这类问题通常是为了利用原有Server或者Server不能做修改（通常是c/c++）造成。

比如Server端只接收一个结构Employee，定义如下：

struct UserInfo {
               char UserName[20];
               int UserId;
        };
       struct Employee {
               UserInfo user;
               float salary;
      };
当然也可以定义为

struct Employee {
              char name[20];
              int    id;
            float salary;
};

java client 测试源码(为说明问题，假设struct字节对齐，sizeof(Employee)=28)

import java.net.*;

/*
          * 与C语言通信(java做Client，c/c++做Server，传送一个结构)
          * @author kingfish
          * @version 1.0
       */
class Employee {
private byte[] buf = new byte[28]; //为说明问题，定死大小，事件中可以灵活处理

/*
           * 将int转为低字节在前，高字节在后的byte数组
         */
private static byte[] toLH(int n) {
    byte[] b = new byte[4];
    b[0] = (byte) (n & 0xff);
    b[1] = (byte) (n >> 8 & 0xff);
    b[2] = (byte) (n >> 16 & 0xff);
    b[3] = (byte) (n >> 24 & 0xff);
    return b;
}

/*
           * 将float转为低字节在前，高字节在后的byte数组
         */
private static byte[] toLH(float f) {
    return toLH(Float.floatToRawIntBits(f));
}

/*
           * 构造并转换
         */
public Employee(String name, int id, float salary) {
    byte[] temp = name.getBytes();
    System.arraycopy(temp, 0, buf, 0, temp.length);

temp = toLH(id);
System.arraycopy(temp, 0, buf, 20, temp.length);

temp = toLH(salary);
System.arraycopy(temp, 0, buf, 24, temp.length);
}

/**
   * 返回要发送的数组
   */
public byte[] getBuf() {
    return buf;
}

/**
   * 发送测试
   */
public static void main(String[] args) {
    try {
      Socket sock = new Socket("127.0.0.1", 8888);
      sock.getOutputStream().write(new Employee("kingfish", 123456789, 8888.99f).
                                   getBuf());
      sock.close();
    }
    catch (Exception e) {
      e.printStackTrace();
    }

} //end

当然，也可以利用writeInt,writeFloat方法发送，但字节顺序需要改为低在前。
这个问题稍后在讨论。

第一部分请见http://blog.csdn.net/kingfish/archive/2005/03/29/333635.aspx

本部分提出另外一种做法, 供参考。

import java.net.*;
import java.io.*;

/**
* 与C语言通信(java做Client，c/c++做Server，传送一个结构)
* @author kingfish
* @version 1.0
*/
public class Employee2 {
private String name;
private int id;
private float salary;

/**
   * 将int转为低字节在前，高字节在后的int
   */
private static int toLH(int in) {
    int out = 0;
    out = (in & 0xff) << 24;
    out |= (in & 0xff00) << 8;
    out |= (in & 0xff0000) >> 8;
    out |= (in & 0xff000000) >> 24;
    return out;
}

/**
   * 将float转为低字节在前，高字节在后的int
   */
private static int toLH(float f) {
    return toLH(Float.floatToRawIntBits(f));
}

/**
   * 构造并转换
   */
public Employee2(String name, int id, float salary) {
    this.name = name;
    this.id = id;
    this.salary = salary;
}

/**
   * 取得名字，定长byte数组
   */
public byte[] getName() {
    byte[] b = new byte[20];
    System.arraycopy(name.getBytes(), 0, b, 0, name.getBytes().length);
    return b;
}

/**
   * 取得编号(低字节在前)
   */
public int getId() {
    return toLH(id);
}

/**
   * 取得工资(低字节在前)
   */
public int getSalary() {
    return toLH(salary);
}

/**
   * 发送测试
   */
public static void main(String[] args) {
    try {
      Employee2 p = new Employee2("kingfish", 123456789, 8888.99f);

      Socket sock = new Socket("127.0.0.1", 8888);
      DataOutputStream dos = new DataOutputStream(sock.getOutputStream());
      dos.write(p.getName());
      dos.writeInt(p.getId());
      dos.writeInt(p.getSalary());
      sock.close();
    }
    catch (Exception e) {
      e.printStackTrace();
    }
}
} //end