网络地址相关函数一网打尽

warmingsummer

已于 2024-01-31 16:51:58 修改

阅读量1k

点赞数 26

分类专栏：就业班视频学习文章标签：网络 linux c语言

于 2024-01-30 19:07:11 首次发布

本文链接：https://blog.csdn.net/warmingsummer/article/details/135928645

版权

就业班视频学习专栏收录该内容

26 篇文章 1 订阅

订阅专栏

这块的函数又多又乱，今天写篇日志，以后慢慢补充

1. 网络地址介绍

1.1 ipv4

1.1.1 点、分十进制的ipv4

你对这个地址熟悉吗？ 192.168.10.100，这可以当做一个字符串。被十进制数字、 “ . ”分开。IP地址的知识就不再多讲了，旧的分类方法把IP地址分为A类B类C类，这部分知识本文最末会提及。但是你见过300.401.299.299这样的网络地址吗？为什么这4个数字每个最大只有255呢？

1.1.2 32位无符号、整数型的ipv4

在电脑中，所有的数据都是二进制存储的，ipv4的地址，由4个数字组成，每个数字都占有二进制的8位，那么最大就是11111111（二进制），转化成十进制就是255 。所以ipv4 每个数字最大只能是255.

192.168. 10.100转化为二进制（用你win10电脑上自带的计算器，左上角选择（程序员））就得到结果“

1100 0000 。1010 1000 。 00001010 。 0110 0100 把我用来分割的句号去掉就是32位短整数；

还有64位长整数，后面用到再说

1.1.3 字节序

这个词应该是前辈们直接翻译的man手册。

本机字节序：host byte order数据在你的电脑上的存放方式。

网络字节序: network byte order 。要跟别人的终端打交道，所有数据都得放到网上传输。网上的传输格式。

字节序有两种，大端字节序，小端字节序。不管哪种、都是二进制！！

先来弄明白内存中，有一块叫做 “栈 ”，栈的增长方向是从下到上，就跟你摞砖头一样，

比方说，

你先定义了一个变量int a =10 ,

你又定义了int b =20,

b 和a的值就存放在栈上。你先定义了a ，a 就放0x0001这块内存，b 就在0x0002这块内存

（仅仅是举例而已，！这个例子别当真其实一个int就要占4个字节的，，相当于8位十六进制）

（ 0x表示16进制，16进制的一位相当于二进制4位。）

假设现在有一个十六进制的数字 0x1234 (转化为十进制是 4660）它需要上图中4个空抽屉才能存下他，如果4放在最低的抽屉，1放在最上面的抽屉，那就是 “小端”字节序。如果相反，那么就是大端字节序。

大端 : 高位数据，放在低位内存。

小端：高位数据，放在高位内存。低位数据，放在低位内存。

你的主机，是怎么存放很长的一个数据的呢？（x86一般都是小端字节序）参考另一个博主的文章

验证你的本机字节序，是大端还是小端

网络字节序可不能随心所欲，因为所有上网的人都用这一种格式。网络字节序采用 大端字节序格式。想象一下，别人给你发“我们去春游”，你的电脑肯定先收到 “我” ，最后一个收到“游” ，（网络传输是字节流）“我”先存起来肯定在低位内存，而这个短语当成一个整数 2603来看的话，最高位的 2 相当于最开头的 “ 我”，是高位数据，放低位内存（这个比喻恰当不？）

1.2 ipv6

IPv6的地址长度为128位，是IPv4地址长度的4倍。ipv6的地址不是被冒号切成4段，而是切成8段，每两个冒号之间相当于16位二进制。

于是IPv4点分十进制格式不再适用，采用十六进制表示。两个冒号之间16位二进制正好用4位十六进制表示。

IPv6有3种表示方法。（摘自百度百科）

1.2.1 冒分十六进制表示法

格式为 X: X: X: X:X:X:X:X，其中每个X表示地址中的16b，以十六进制表示，例如：

ABCD:EF01:2345:6789:ABCD:EF01:2345:6789

这种表示法中，每个X的前导0是可以省略的，例如：

2001:0DB8:0000:0023:0008:0800:200C:417A→ 2001:DB8:0:23:8:800:200C:417A

另外两种表示方法自学一下不重要，因为你用不规范的输入当做inet_pton inet_ntop的参数的时候可能出错。

2. IP地址结构体分析

当我们说网络地址时，必须包括ip地址和一个16位的端口号，我们平时在浏览器输入网址，从来没输入过端口号，www.baidu.com : 80 没打过吧。是因为服务器上什么协议（服务）对应什么端口都是默认的。

2.1 sockaddr_in结构体

包含3个成员：

struct sockaddr_in {
sa_family_t sin_family; /* address family: AF_INET */
in_port_t sin_port; /* port in network byte order */
struct in_addr sin_addr; /* internet address */
};

注意：port端口是 IP协议的上层---TCP /UDP协议里的内容，IP协议就只管IP地址。 sin_family一般就是AF_INET（个别函数里特殊的话一会儿再说），也不用转换成网络字节序，因为它不在网络上传播，只是本地电脑关心这个值。

sin_port和sin_addr必须转换成网络字节序，才能在网络上传播。注意IP地址结构体 in_addr 的成员：s_addr就是Ip 地址的网络字节序。

/* Internet address. */
struct in_addr {
uint32_t s_addr; /* address in network byte order */
};

uint32_t 不就是无符号32位整数吗！所以应该是ipv4 。然后在inet_aton的帮助手册中，你发现它还有另外一个名字in_addr_t

in <netinet/in.h> as:

typedef uint32_t in_addr_t;

struct in_addr {
in_addr_t s_addr;
};

2.2 sockaddr的结构体

现在一般不用它了，因为它的长度是固定的，但是填充什么需要你决定，你要是填不满它规定的字节，你还得设计一些字符 “填充”进去 (padding) 太麻烦了所以废弃了。但是它也有写进代码的机会！！

函数bind 的第二个参数必须是它的指针，所以要用强制类型转换。

int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen)

我前一篇讲udp的代码里有句代码是：

int ret = bind(sfd, (struct sockaddr*)&servad, sizeof( servad));

2.3 总结一下！！！

网络地址结构体到底是什么！是in_addr结构体！！注意！！不是 in_addr_t

in_addr_t 是网络地址的网络字节序！！

3.相关函数

三大类，就是网络字节序，本机字节序，字符串这3种格式来回转换。然后这3类函数，每类再细分2小种，你要的结果在返回值里，还是你要的结果在传出参数里。

3.1 字符串格式 “127.0.0.1 ”-- -- > 网络字节序格式

3.1.1 结果在返回值里

3.1.1.1 inet_addr

#include <arpa/inet.h>

in_addr_t inet_addr(const char * string);

将一个点、数字格式的ipv4地址，转为二进制的网络字节序格式

返回值：

成功：32位大端序整数型值，注意unsigned int ，不是long unsigned int

失败：函数可以检测你的输入格式是否正确，你输入的不正确的话，函数返回值是 INADDR_NONE (usually -1)

man手册上说的： Use of this function is problematic because -1 is a valid address (255.255.255.255). 别用这个函数。尽量去用 inet_aton(), inet_pton(3), or getaddrinfo(3), which provide a cleaner way to indicate error return.

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>

int main() {   
    //定义一个地址mytest
    struct sockaddr_in mytest;
    bzero(&mytest, sizeof(mytest));
    mytest.sin_family =AF_INET;
    //mytest.sin_port =htons(8888);
    const char* str = "127.0.0.1";
    in_addr_t result111 = inet_addr(str);
    mytest.sin_addr.s_addr = result111;
   printf("网络地址是%u\n", result111);
 
return 0;
}

结果

网络地址是16777343

用你的计算器二进制是 0001。 0000 0000。 0000 0000 。0111 1111

哦？ 1.0.0.127 ？？对了，网络字节序是大端的，所以127放在最低位了

3.1.1.2 inet_network

in_addr_t inet_network(const char *cp);

将一个点、数字形式的ipv4的字符串，转化为本机字节序格式，但是仍可以作为网络地址，进行网络传输（？？？）我测试过了，用不了网络传输。。

struct sockaddr_in mytest;
mytest.sin_addr.s_addr = inet_network （“127.0.0.1”）;//无法建立网络连接的

返回值：成功：转换成的网络地址。

失败： -1

#include <unistd.h>
#include <stdio.h>
int main(char agrc,char *argv[]){
    int i,x;
    printf("%s\n",argv[1]);
    unsigned int ip = inet_network(argv[1]);
    printf("%8x  \n",ip);
    printf("%x\n",ip);
return 0;
}

编译后，输入./a.out 192.168.0.1

结果

192.168.0.1
c0a80001
c0a80001

3.1.2 结果在参数里

3.1.2.1 inet_aton

#include <arpa/inet.h>

int inet_aton (const char *cp, struct in_addr *inp);

将一个本机（host ，本地的）的点、数字格式的ipv4地址，转为二进制的网络字节序格式

参数1 ：有const ，是传入参数。需转换的IP地址信息的字符串，例如“127.0.0.1””

参数2：传出参数， in_addr结构体的指针里，现在存着你想要的in_addr的信息了。（看清楚是谁的指针！！！）

返回值：成功 1 失败 0

//inet_aton    
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>

int main() {
    //定义一个地址mytest
    struct sockaddr_in mytest;
    bzero(&mytest, sizeof(mytest));
    mytest.sin_family =AF_INET;
    //mytest.sin_port =htons(8888);
    const char* str = "127.0.0.1";
    inet_aton( str, &(mytest.sin_addr));
    printf("网络地址是%u\n", mytest.sin_addr.s_addr); 
return 0;
}

结果跟上面那个一样网络地址是16777343

3.1.2.2 inet_pton

#include <arpa/inet.h>

int inet_pton (int af, const char *src, void *dst);

将字符串转为网络地址结构体，ipv4 ipv6都实用结果复制到dst指针指向的内容里。

参数1 ： af 填写AF_INET时，参数2 应该是点分十进制的ipv4格式

af填写 AF_INET6 时，参数2应该是冒号切好的，8个十六进制的ipv6 (这种写法最稳妥）。后面太复杂了不讨论ipv6 情况。。。

参数2 ：格式对应好。

参数3：你可以传任何指针进去，反正void* 是万用指针。。看一下最后面那个man手册子带例子，作者就是传了unsigned char buf[ sizeof( struct in6_addr) ] 字符数组指针buf进去。

返回值：

成功：返回1

失败：你写的参数2格式不对，返回0

你写的af参数不对，返回-1

例子：看我最后面复制的man 手册的例子。作者把地址复制到一个unsigned char 无符号字符数组里了。。里面每个元素都是1字节（二进制8位）的，正好（如果是ipv4）就是地址中的一个十进制数字。

在之前写的一篇代码中，老师也用到了这个函数，但是我现在学习了说明手册，我觉得可以将结果复制到网络地址结构体，而不是网络地址的字节序

这篇中的客户端，

在客户端要去连接服务器的时候，需要将字符串转换为网络字节序。

老师原代码 int s = inet_pton( AF_INET,"127.0.0.1",&seradd.sin_addr.s_addr);

我自己改了一个小地方，一样可以成功
int s = inet_pton( AF_INET,"127.0.0.1",&seradd.sin_addr);

看来这个函数第三个参数很灵活

3.2 网络字节序格式 -- -- 》字符串格式

3.2.1 结果在返回值里

3.2.1.1 inet_ntoa 函数

#include <sys/socket.h>

#include <netinet/in.h>

#include <arpa/inet.h>

char * inet_ntoa (struct in_addr in);

将一个网络字节序格式的网络主机地址 in，转化为数字+点的字符串格式的ipv4地址。这里是服务器端代码，客户端不需要代码，直接开启一个新终端，nc 127.0.0.1 8888命令，然后服务器那边就

请求连接的客户网络地址是127.0.0.1

//inet_ntoa   
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
int main() {
    int sfd = socket (AF_INET, SOCK_STREAM, 0);
    if (sfd <0){
        printf("socket fun error/n");
        return -1;
    }
    struct sockaddr_in myad;
    bzero(&myad, sizeof(myad));
    myad.sin_family =AF_INET;
    myad.sin_port =htons(8888);
    myad.sin_addr.s_addr = htonl (INADDR_ANY);
 
    int ret = bind(sfd, (struct sockaddr *)&myad, sizeof(myad));
    if (ret<0) {
        printf("bind error/n");
        return -1;
    }
    listen( sfd,128);  

    //把连接的客户端的地址打出来
    struct sockaddr_in clientad;
    bzero(&clientad, sizeof(clientad));
    clientad.sin_family =AF_INET;
    clientad.sin_port =htons(8888);
    socklen_t clilen = sizeof(clientad);
    //有客户连接啦
    int newfd= accept(sfd,(struct sockaddr*)&clientad,&clilen);
    char* str = {0};
    str = inet_ntoa(clientad.sin_addr);
   printf("请求连接的客户网络地址是%s\n",str);
 
return 0;
}

3.2.1.2 inet_ntop 函数

#include <arpa/inet.h>

const char * inet_ntop (int af, const void *src, char *dst, socklen_t size);

将网络地址结构体src ，转化为字符串，复制到字符串的指针 dst 中。dst必须不是NULL

看一下这篇文章最后的代码

用到了inet_ntop函数

char addstring[128];
    memset(addstring, 0x00,128);
     printf("服务器端，get connect,客户端地址是:\n");
    printf("IP:%s,PORT: %d\n", inet_ntop(AF_INET, &dst.sin_addr.s_addr,addstring,sizeof(addstring)), ntohs(dst.sin_port));

函数说明里说，第二个参数只要是一个容器就行，老师这里的代码是不是多写了一点呢，我试着传递到sin_addr里面!! 结果一样！成功了。（端口就不打印了）

//服务器端，部分代码！完整代码去看我那篇文章
//socket编程基础
    struct sockaddr_in dst;
    bzero(&dst, sizeof(dst));
    dst.sin_family =AF_INET;
    dst.sin_port =htons(8888);
    socklen_t dstleng = sizeof(dst);
   
    int newfd = accept (sfd, (struct sockaddr* )&dst, &dstleng);
    if (newfd <0) {
        printf("服务端，accept error、\n");
        return -1;
    }
    char addstring[128];
    memset(addstring, 0x00,128);
     printf("服务器端,现在打印客户端地址:\n");
    //  const char *inet_ntop(int af, const void *src,
                          //   char *dst, socklen_t size);
    printf("IP:%s\n", inet_ntop(AF_INET, &dst.sin_addr,addstring,sizeof(addstring)));

运行结果，连接后，服务器端这边

服务器端,现在打印客户端地址:
IP:127.0.0.1

3.2.2 结果在传出参数里

还没找到

3.3 字节序相互转化

3.3.1 本机字节序 -》》网络字节序

uint32_t htonl (uint32_t hostlong); // 32位 IP 地址
uint16_t htons (uint16_t hostshort); // 16位短整数，端口

3.3.2 网络字节序 --》》本机字节序

uint32_t ntohl (uint32_t netlong);
uint16_t ntohs (uint16_t netshort);

注意，自己写的代码里端口不要设置1024以前的。。。那是保留端口，给系统用的。

3.4 废弃的3个函数

网络地址结构体，这个结构体里唯一成员（32位无符号整型网络地址）来回转换的3个函数

in_addr_t inet_lnaof (struct in_addr in);

将in 结构体里的一部分 ---本地网络地址返回，格式是本机字节序。

in_addr_t inet_netof (struct in_addr in);

将in 结构体里的一部分 ---网络号码返回，格式是本机字节序。

？？？难道这个in里面不就一个成员吗

struct in_addr inet_makeaddr (in_addr_t net, in_addr_t host);

为啥废弃了呢：在传统x86架构的电脑里（大家用的都是吧），主机字节序是小端Least Significant Byte first (little endian) ，最没地位的字节站最前面

网络字节序是大端(big endian) Most Significant Byte first 最重要的字节最前面

这三个函数是跟过去的A B C 三类IP地址相关的。

A类IP 地址：一个重要的字节当网络地址，剩下三个字节当本地的机器们的地址。最重要的1个二进制，值是 0

B类IP 地址： 2个重要的字节当网络地址，剩下2个字节当本地的机器们的地址。最重要的2个二进制的1 0

C类IP 地址： 3个字节当网络地址，1个字节当本地的机器们的地址。最重要的3个二进制位，值是 11 0

传统的这个模式太死板了，现在已经是CIDR （无类别间域路由））

4.man手册自带例子解析

const char * inet_ntop (int af, const void *src, char *dst, socklen_t size);

int inet_pton (int af, const char *src, void *dst);

在代码中，作者的 af参数并没有写固定死，而是传参数进去。

是将你的执行命令的第二个参数 argv[1] (第一个参数是argv[0] 命令名称）转化为一个整数。

函数 int atoi (const char * str); 将一个字符串转化为整数。

当然，在inet_pton 和inet_ntop ()两个函数中，对于af参数的格式来说，本来就是 AF_INET 和AF_INET6两种。

result = A? B: C 如果A为真，那么result 等于B 否则等于C 但是加长的三目运算符见过吗

代码中有一句特别长的三目运算符，我看着比较晕

domain = (strcmp(argv[1], "i4") == 0) ? AF_INET :
(strcmp(argv[1], "i6") == 0) ? AF_INET6 : atoi(argv[1]);

查了一下，这是多条件的三目运算符

条件1 ？结果1

：条件2？结果2

：条件3 ？结果3

：""

条件1为真，取结果1 ；条件2为真，取结果2

如果第二个参数是 i4 那么domain = AF_INET 如果第二个参数你写i6 那么domain = AF_INET6 ,本示范代码最后原作者都写了i6 。

代码中首先使用inet_pton 函数，将你写的地址字符串转化为网络字节序，并且存储在unsigned char buf[sizeof(struct in6_addr)] 这个数组的首地址（buf）中，注意这个buf的长度必须是 sizeof( struct in6_addr ) 是结构体的字节数！！

文中有一个宏 INET6_ADDRSTRLEN 表示46（字节），参考看这篇

INET_ADDRSTRLEN

#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char *argv[]){  
    unsigned char buf[sizeof(struct in6_addr)];
    int domain, s;
    char str[INET6_ADDRSTRLEN];
    if (argc != 3) {
        fprintf(stderr, "Usage: %s {i4|i6|<num>} string\n", argv[0]);
        exit(EXIT_FAILURE);
    }
    domain = (strcmp(argv[1], "i4") == 0) ? AF_INET :
            (strcmp(argv[1], "i6") == 0) ? AF_INET6 : atoi(argv[1]);

    s = inet_pton(domain, argv[2], buf);
    if (s <= 0) {
        if (s == 0){
            fprintf(stderr, "Not in presentation format");
        }
        else {
                   perror("inet_pton");
        }
        exit(EXIT_FAILURE);
    }

   if (inet_ntop(domain, buf, str, INET6_ADDRSTRLEN) == NULL) {
       perror("inet_ntop");
       exit(EXIT_FAILURE);
   }

   printf("%s\n", str);
   exit(EXIT_SUCCESS);
       }