inet_addr和inet_aton

inet_addr的功能是将一个ip地址字符串转换成一个整数值。一般的IP地址串格式为：'a.b.c.d'分成四段。
但是也会有分为1、2或3段的格式。下面我们来看看WIN2K下inet_addr函数的源码：

 unsigned long PASCAL
 inet_addr(
     IN const char *cp
     )
 {
         register unsigned long val, base, n;
         register char c;
         unsigned long parts[4], *pp = parts;

         WS_ENTER( "inet_addr", (PVOID)cp, NULL, NULL, NULL );
 again:
         /*
          * Collect number up to ``.''.
          * Values are specified as for C:
          * 0x=hex, 0=octal, other=decimal.
          */
         val = 0; base = 10;  //每段中根据中根据前缀知道其使用的进制。
         if (*cp == '0') {    //0X前缀为十六进制；0前缀为八进制；缺省为十进制
                 base = 8, cp++;
                 if (*cp == 'x' || *cp == 'X')
                         base = 16, cp++;
     }

         //下面这段代码是用来取得IP地址的一段将其转换值整数
         while (c = *cp) {
                 if (isdigit(c)) {                         //若为数字，则将其转换至数字进行计算
                         val = (val * base) + (c - '0');   //注意，在W2K下这儿有一个BUG，因为当为8进制时没有
                         cp++;                             //检查是否为8、9数字；这个问题在XP下修正了。
                         continue;
                 }
                 if (base == 16 && isxdigit(c)) {  //当为16进制时，检查是否为‘a’~ 'f'字母
                         val = (val << 4) + (c + 10 - (islower(c) ? 'a' : 'A'));
                         cp++;
                         continue;
                 }
                 break;
         }
        //当为‘.’时，此时表示地址段结束了。
         if (*cp == '.') {
                 /*
                  * Internet format:
                  *      a.b.c.d
                  *      a.b.c   (with c treated as 16-bits)
                  *      a.b     (with b treated as 24 bits)
                  */
                 /* GSS - next line was corrected on 8/5/89, was 'parts + 4' */
                 if (pp >= parts + 3) {                   //若为‘.’间隔，检查是否已经超过3个了。
                         WS_EXIT( "inet_addr", -1, TRUE );//因为最多为3个‘.’
                         return ((unsigned long) -1);     //在W2K下可以看出允许直接以‘.’开头的IP地址
                 }                                        //而在XP下是不允许的。
                 *pp++ = val, cp++;
                 goto again;
         }

         /*
          * Check for trailing characters.//到此处时，要么结束，要么为出错字符
          */                              //只有为0或者空格是结束，否则出错。
         if (*cp && !isspace(*cp)) {
                 WS_EXIT( "inet_addr", -1, TRUE );
                 return (INADDR_NONE);
         }
         *pp++ = val;
         /*
          * Concoct the address according to
          * the number of parts specified.
          */
         n = (unsigned long)(pp - parts);
         switch ((int) n) {

         case 1:                         /* a -- 32 bits */  //当为一个段a时，直接就是这个值。
                 val = parts[0];
                 break;

         case 2:                         /* a.b -- 8.24 bits */    //当为两个段a.b时，整数值构成XX  XX XX XX
                 if ((parts[0] > 0xff) || (parts[1] > 0xffffff)) { //                           --  --------
                     WS_EXIT( "inet_addr", -1, TRUE );             //                           a       b
                     return(INADDR_NONE);
                 }
                 val = (parts[0] << 24) | (parts[1] & 0xffffff);
                 break;

         case 3:                         /* a.b.c -- 8.8.16 bits *///当为3个段a.b.c时，整数值构成XX  XX   XX XX
                 if ((parts[0] > 0xff) || (parts[1] > 0xff) ||     //                            --  --   -----
                     (parts[2] > 0xffff)) {                        //                            a    b     c
                     WS_EXIT( "inet_addr", -1, TRUE );
                     return(INADDR_NONE);
                 }
                 val = (parts[0] << 24) | ((parts[1] & 0xff) << 16) |
                         (parts[2] & 0xffff);
                 break;

         case 4:          /* a.b.c.d -- 8.8.8.8 bits *///当为4个段a.b.c.d时，整数值构成XX  XX   XX   XX
                 if ((parts[0] > 0xff) || (parts[1] > 0xff) ||        //               --  --   --   --
                     (parts[2] > 0xff) || (parts[3] > 0xff)) {        //               a    b    c    d
                     WS_EXIT( "inet_addr", -1, TRUE );
                     return(INADDR_NONE);
                 }
                 val = (parts[0] << 24) | ((parts[1] & 0xff) << 16) |
                       ((parts[2] & 0xff) << 8) | (parts[3] & 0xff);
                 break;

         default:
                 WS_EXIT( "inet_addr", -1, TRUE );
                 return (INADDR_NONE);
         }
         val = htonl(val);
         WS_EXIT( "inet_addr", val, FALSE );
         return (val);
 }

原文地址： http://blog.csdn.net/misterliwei/article/details/2318725

inet_addr 将"数字+句点"的格式的IP地址转换到unsigned long中,返回值已经是按照网络字节顺序的
相反inet_ntoa把类型为struct in_addr的数据转化为"数字+句点"的形式的字符串
typedef u_int32_t in_addr_t;
struct in_addr
{
       in_addr_t s_addr;
};

本机字节顺序与网络字节顺序的转换
#include
htons  ------"host to network short"
htonl   -------"host to network long"
ntohs  -------"network to host short"
ntohl   -------"network to host long"
*注意:在你的数据放到网络上的时候，确信它是网络字节顺序
网络字节顺序(大端字节)和x86机器字节顺序(小端字节)
eg:0X3132  在x86上显示21  在网络传输中为12

inet_addr返回的整数形式是网络字节序，而inet_network返回的整数形式是主机字节序。他俩都有一个小缺陷，
那就是当IP是255.255.255.255时，这两个函数会认为这是个无效的IP地址，这是历史遗留问题，其实在目前大部
分的路由器上，这个255.255.255.255的IP都是有效的。
inet_aton函数和上面这俩个函数的区别就是在于他认为255.255.255.255是有效的，他不会冤枉这个看似特殊的IP地址。对了，inet_aton函数返回的是网络字节序的IP地址。

综上所述，应该使用inet_aton和inet_ntoa这一对函数。


资料：

#include 
#include in.h>
#include 

typedef uint32_t in_addr_t;

int inet_aton( const  char *cp,  struct in_addr *inp);
in_addr_t inet_addr( const  char *cp);
in_addr_t inet_network( const  char *cp);
char *inet_ntoa( struct in_addr  in);
struct in_addr inet_makeaddr( int net,  int host);
in_addr_t inet_lnaof( struct in_addr  in);
in_addr_t inet_netof( struct in_addr  in);

 

//  Internet address.
struct in_addr {
        union {
                 struct { u_char s_b1,s_b2,s_b3,s_b4; } S_un_b;
                 struct { u_short s_w1,s_w2; } S_un_w;
                u_long S_addr;  /*  port in network byte order  */
        } S_un;
#define s_addr  S_un.S_addr
};
//  Socket address, internet style.
struct sockaddr_in {         //  struct sockaddr的一种特殊形式
         short            sin_family;     /*  address family: AF_INET  */
        u_short        sin_port;         /*  port in network byte order  */
         struct in_addr sin_addr;         /*  port in network byte order  */
         char            sin_zero[8];     /*  8 byte pad  */
};
//  Structure used by kernel to store most addresses.
struct sockaddr {
        u_short sa_family;  /*  address family  */
         char    sa_data[14];  /*  up to 14 bytes of direct address  */
};

struct in_addr {
    unsigned  long  int s_addr;
}

原文地址： http://www.cppblog.com/toMyself/archive/2010/08/13/123353.aspx