标签：sockaddr addr int 编程 socket 客户端 Linux include Socket

预备知识

 

1. 网络字节序

我们已经知道，内存中的多字节数据相对于内存地址有大端和小端之分。

 

磁盘文件中的多字节数据相对于文件中的偏移地址也有大端小端之分。网络数据流同样有大端小端之分，那么如何定义网络数据流的地址呢？发送主机通常将发送缓冲区中的数据按内存地址从低到高的顺序发出，接收主机把从网络上接到的字节依次保存在接收缓冲区中，也是按内存地址从低到高的顺序保存，因此，网络数据流的地址应这样规定：先发出的数据是低地址，后发出的数据是高地址。

 

TCP/IP协议规定，网络数据流应采用大端字节序，即低地址高字节。例如：发送主机中地址0-1存储16位的源端口号，这个端口号是1000（0x3e8），则地址0是0x03，地址1是0xe8，也就是先发0x03，再发0xe8，这16位在发送主机的缓冲区中也应该是低地址存0x03，高地址存0xe8。但是，如果发送主机是小端字节序的，则地址0存储0xe8，地址1存储0x03，接收方接收到的端口号就成了59395（0xe803）而不是1000。因此，发送主机把1000填到发送缓冲区之前需要做字节序的转换。同样地，接收主机如果是小端字节序的，接到16位的源端口号也要做字节序的转换。如果主机是大端字节序的，发送和接收都不需要做转换。同理，32位的IP地址也要考虑网络字节序和主机字节序的问题。

 

为使网络程序具有可移植性，使同样的C代码在大端和小端计算机上编译后都能正常运行，可以调用以下库函数做网络字节序和主机字节序的转换。

#include <arpa/inet.h>
uint32_t htonl(uint32_t hostlong);  // 32位，host转为net，用于主机向网络发送IP时的转换
uint16_t htons(uint16_t hostshort); // 16位，host转为net，用于主机向网络发送IP时的转换
uint32_t ntohl(uint32_t netlong);   // 32位，net转为host，用于主机向网络发送端口号时的转换
uint16_t ntohs(uint16_t netshort);  // 16位，net转为host，用于主机向网络发送端口号时的转换

h表示host，n表示network，l表示32位长整数（IP地址为32位），s表示16位短整数（端口号位16位）。

如果主机是小端字节序，这些函数将参数做相应的大小端转换然后返回，如果主机是大端字节序，这些函数不做转换，将参数原封不动地返回。 

 

2. IP地址转换函数

通常，人们习惯用可读性好的字符串来表示 IP 地址，比如用点分十进制字符串表示 IPv4 地址，以及用十六进制字符串表示 IPv6 地址。但编程中我们需要先把它们转化为整数（二进制数）方能使用。而记录日志时则相反，我们要把整数表示的 IP 地址转化为可读的字符串。

#include <arpa/inet.h>
// p:点分十进制的IP字符串，n:表示network，网络字节序的整数
int inet_pton(int af, const char *src, void *dst);

af:地址族： AF_INET（表示ipv4） AF_INET6（表示ipv6）
src:需要转换的点分十进制的IP字符串
dst:转换后的结果保存在这个里面

 

#include <arpa/inet.h>
// 将网络字节序的整数，转换成点分十进制的IP地址字符串
const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);

af:地址族： AF_INET（表示ipv4） AF_INET6（表示ipv6）
src: 要转换的ip的整数的地址
dst: 转换成IP地址字符串保存的地方
size：第三个参数的大小（数组的大小）
返回值：返回转换后的数据的地址（字符串），和 dst 是一样的

 

 

3. socket 地址

socket 网路编程接口中表示 socket 地址的是结构体 sockaddr，其定义如下：

#include <bits/socket.h>
struct sockaddr {
sa_family_t sa_family;
char sa_data[14];
};
typedef unsigned short int sa_family_t;

很多网络编程函数诞生早于 IPv4 协议，那时候都使用的是 struct sockaddr 结构体，为了向前兼容，现在sockaddr 退化成了类似（void *）的作用，传递一个地址给函数，至于这个函数是 sockaddr_in 还是sockaddr_in6，由地址族确定，然后函数内部再强制类型转化为所需的地址类型

TCP/IP 协议族有 sockaddr_in 和 sockaddr_in6 两个专用的 socket 地址结构体，它们分别用于 IPv4 和IPv6：

#include <netinet/in.h>
struct sockaddr_in
{
sa_family_t sin_family; /* __SOCKADDR_COMMON(sin_) */
in_port_t sin_port; /* Port number. */
struct in_addr sin_addr; /* Internet address. */
/* Pad to size of `struct sockaddr'. */
unsigned char sin_zero[sizeof (struct sockaddr) - __SOCKADDR_COMMON_SIZE -
sizeof (in_port_t) - sizeof (struct in_addr)];
};
struct in_addr
{
in_addr_t s_addr;
};
struct sockaddr_in6
{
sa_family_t sin6_family;
in_port_t sin6_port; /* Transport layer port # */
uint32_t sin6_flowinfo; /* IPv6 flow information */
struct in6_addr sin6_addr; /* IPv6 address */
uint32_t sin6_scope_id; /* IPv6 scope-id */
};
typedef unsigned short uint16_t;
typedef unsigned int uint32_t;
typedef uint16_t in_port_t;
typedef uint32_t in_addr_t;
#define __SOCKADDR_COMMON_SIZE (sizeof (unsigned short int))

sin_family：指定你所使用哪种协议，ipv4或者ipv6.
AF_INET : ipv4
AF_INET6 : ipv6
AF_UNIX, AF_LOCAL : 本地套接字通信（进程间通信）

sin_port： 端口号

 

 所有专用 socket 地址（以及 sockaddr_storage）类型的变量在实际使用时都需要转化为通用 socket 地址类型 sockaddr（强制转化即可），因为所有 socket 编程接口使用的地址参数类型都是 sockaddr。

 

 

 

 

socket API

 

 

1. 什么是socket

 

所谓 socket（套接字），就是对网络中不同主机上的应用进程之间进行双向通信的端点的抽象。一个套接字就是网络上进程通信的一端，提供了应用层进程利用网络协议交换数据的机制。从所处的地位来讲，套接字上联应用进程，下联网络协议栈，是应用程序通过网络协议进行通信的接口，是应用程序与网络协议根进行交互的接口。

socket 可以看成是两个网络应用程序进行通信时，各自通信连接中的端点，这是一个逻辑上的概念。它是网络环境中进程间通信的 API，也是可以被命名和寻址的通信端点，使用中的每一个套接字都有其类型和一个与之相连进程。通信时其中一个网络应用程序将要传输的一段信息写入它所在主机的 socket 中，该 socket 通过与网络接口卡（NIC）相连的传输介质将这段信息送到另外一台主机的 socket 中，使对方能够接收到这段信息。socket 是由 IP 地址和端口结合的，提供向应用层进程传送数据包的机制。

socket 本身有“插座”的意思，在 Linux 环境下，用于表示进程间网络通信的特殊文件类型。本质为内核借助缓冲区形成的伪文件。既然是文件，那么理所当然的，我们可以使用文件描述符引用套接
字。与管道类似的，Linux 系统将其封装成文件的目的是为了统一接口，使得读写套接字和读写文件的操作一致。区别是管道主要应用于本地进程间通信，而套接字多应用于网络进程间数据的传递。

 在TCP/IP协议中，“IP地址+TCP或UDP端口号”唯一标识网络通讯中的一个进程。“IP地址+端口号”就对应一个socket。欲建立连接的两个进程各自有一个socket来标识，那么这两个socket组成的socket pair就唯一标识一个连接。因此可以用Socket来描述网络连接的一对一关系。
套接字通信原理如下图所示：

 

 

 在网络通信中，套接字一定是成对出现的。一端的发送缓冲区对应对端的接收缓冲区。我们使用同一个文件描述符索发送缓冲区和接收缓冲区。

 

2. socket相关函数

2.1 socket( )函数

#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h> // 包含了这个头文件，上面两个就可以省略
int socket(int domain, int type, int protocol);
功能：创建一个套接字

参数：

domain: 协议族：
AF_INET : ipv4
AF_INET6 : ipv6
AF_UNIX, AF_LOCAL : 本地套接字通信（进程间通信）

type: 通信过程中使用的协议类型：
SOCK_STREAM : 流式协议
SOCK_DGRAM : 报式协议

protocol : 具体的一个协议。一般写0：
SOCK_STREAM : 流式协议默认使用 TCP
SOCK_DGRAM : 报式协议默认使用 UDP

返回值： 成功：返回文件描述符，操作的就是内核缓冲区。失败：-1

 

socket( )打开一个网络通讯端口，如果成功的话，就像open()一样返回一个文件描述符，应用程序可以像读写文件一样用read/write在网络上收发数据，如果socket()调用出错则返回 -1。对于IPv4，domain参数指定为AF_INET。对于TCP协议，type参数指定为SOCK_STREAM，表示面向流的传输协议。如果是UDP协议，则type参数指定为SOCK_DGRAM，表示面向数据报的传输协议。protocol参数的介绍从略，指定为0即可。

 

2.2 bind( )函数

 

#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h> // 包含了这个头文件，上面两个就可以省略
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen); // socket命名
功能：绑定，将文件描述符fd和本地的<IP , 端口>进行绑定

参数：

sockfd : 通过socket()函数得到的文件描述符
addr : 需要绑定的socket地址，这个地址封装了ip和端口号的信息
addrlen : 第二个参数结构体占的内存大小
返回值：成功返回0，失败返回-1, 设置errno

 

服务器程序所监听的网络地址和端口号通常是固定不变的，客户端程序得知服务器程序的地址和端口号后就可以向服务器发起连接，因此服务器需要调用bind绑定一个固定的网络地址和端口号。

bind()的作用是将参数sockfd和addr绑定在一起，使sockfd这个用于网络通讯的文件描述符监听addr所描述的地址和端口号。上一篇讲过，struct sockaddr *是一个通用指针类型，addr参数实际上可以接受多种协议的sockaddr结构体，而它们的长度各不相同，所以需要第三个参数addrlen指定结构体的长度。

 

2.3 listen( )函数

#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h> // 包含了这个头文件，上面两个就可以省略
int listen(int sockfd, int backlog);
功能：监听这个socket上的连接

参数：

sockfd : 通过socket()函数得到的文件描述符
backlog : 未连接的和已经连接的和的最大值（排队建立3次握手队列和刚刚建立3次握手队列的链接数和的最大值）

 

典型的服务器程序可以同时服务于多个客户端，当有客户端发起连接时，服务器调用的accept()返回并接受这个连接，如果有大量的客户端发起连接而服务器来不及处理，尚未accept的客户端就处于连接等待状态，listen()声明sockfd处于监听状态，并且最多允许有backlog个客户端处于连接待状态，如果接收到更多的连接请求就忽略。listen()成功返回0，失败返回-1。

 

2.4 accept( )函数

#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h> // 包含了这个头文件，上面两个就可以省略
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
功能：接收客户端连接，默认是一个阻塞的函数，阻塞等待客户端连接

参数：

sockfd : 用于监听的文件描述符
addr : 传出参数，记录了连接成功后客户端的地址信息（ip，port）
addrlen : 传入传出参数（值-结果）， 指定第二个参数的对应的内存大小，传出第二个参数传出时的内存大小
返回值：
成功：返回一个新的socket文件描述符，用于和客户端通信，失败返回-1，设置errno

 

三次握手完成后，服务器调用accept()接受连接，如果服务器调用accept()时还没有客户端的连接请求，就阻塞等待直到有客户端连接上来。addr是一个传出参数，accept()返回时传出客户端的地址和端口号。addrlen参数是一个传入传出参数（value-result argument），传入的是调用者提供的缓冲区addr的长度以避免缓冲区溢出问题，传出的是客户端地址结构体的实际长度（有可能没有占满调用者提供的缓冲区）。如果给addr参数传NULL，表示不关心客户端的地址。

一般来说，我们的服务器程序结构是这样的：

while (1) {
	cliaddr_len = sizeof(cliaddr);
	connfd = accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddr_len);
	n = read(connfd, buf, MAXLINE);
	......
	close(connfd);
}

整个是一个while死循环，每次循环处理一个客户端连接。由于cliaddr_len是传入传出参数，每次调用accept()之前应该重新赋初值。accept()的参数listenfd是先前的监听文件描述符，而accept()的返回值是另外一个文件描述符connfd，之后与客户端之间就通过这个connfd通讯，最后关闭connfd断开连接，而不关闭listenfd，再次回到循环开头listenfd仍然用作accept的参数。accept()成功返回一个文件描述符，出错返回-1。

一定要区分开connfd和listenfd的作用，listenfd仅用于监听，监听到了以后并不用它来进行信息传输。

2.5 connect( )函数

#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h> // 包含了这个头文件，上面两个就可以省略
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
功能： 客户端连接服务器
参数：

sockfd : 用于通信的文件描述符
addr : 客户端要连接的服务器的地址信息
addrlen : 第二个参数的内存大小
返回值：成功 0， 失败 -1

 

 客户端需要调用connect()连接服务器，connect和bind的参数形式一致，区别在于bind的参数是自己的地址，而connect的参数是对方的地址。

 

3. 实现一个简单的服务端-客户端通信

接下来使用以上函数实现一个简单的服务端客户端通信，实现将客户端的小写字母转换为大写字母。

3.1 通信流程

 

上图给了一个C/S模型网络编程的socket模板。

 

服务端：

1. 调用 socket() 建立套接字
2. 创建 struct sockaddr_in ，并初始化服务端的ip和端口号
3. 调用 bind() 将第一步建立的套接字与第二步的sockaddr_in（ip和端口号）绑定
4. 调用 listen() 设置最大同时发起连接数量
5. 调用 accept() 阻塞等待客户端发起连接
6. 调用 read() 读取客户端发出的数据
7. 处理请求
8. 调用 write() 发送数据给客户端
9. 调用 close() 关闭socket伪文件

客户端：

1. 调用 socket() 建立套接字
2. 调用 connect() 向客户端发起连接
3. 调用 write() 发送数据给服务端
4. 调用 read() 读取服务端返回的数据
5. 调用 close() 关闭socket伪文件

其中还有很多细节，需要写代码的时候才能体会。

 

3.2 服务端

/*实现一个简单的服务器-客户端通信*/

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

// 设定一个服务器端口号
#define SERV_IP "127.0.0.1"
#define SERV_PORT 6666

int main()
{
    int lfd; // 用于监听的socket的文件描述符，真正用于通信的套接字是接下来accept函数返回的cfd套接字
    struct sockaddr_in serv_addr;

    lfd = socket(AF_INET, SOCK_STREAM, 0);
    
    serv_addr.sin_family = AF_INET;

    // 注意这里，要把小端存储的端口号改为大端存储
    serv_addr.sin_port = htons(SERV_PORT); 
    inet_pton(AF_INET, SERV_IP, &serv_addr.sin_addr.s_addr); // 调用ip转换函数，把字符串ip转化为网络字节序

    bind(lfd, (struct sockaddr * )&serv_addr, sizeof(serv_addr));

    listen(lfd, 128); // 最大连接与待连接数设为128

    int cfd; // 已连接的客户端的socket的文件描述符, 以便一会儿read用
    struct sockaddr_in clie_addr;                // 作为accept的第二个参数，为传出参数，传出的是客户端的sockadd_in
    socklen_t clie_addr_len = sizeof(clie_addr); // 作为accept的第三个参数，为传入传出参数，之所以要单独定义出来是因为要传出
    cfd = accept(lfd, (struct sockaddr *)&clie_addr, &clie_addr_len);
	
	while(1) {
	
    	// 此处输出连接的客户端的ip和端口
    	char clie_IP[BUFSIZ];
    	printf("Client IP: %s, client port: %d\n", 
            inet_ntop(AF_INET, &clie_addr.sin_addr.s_addr, clie_IP, sizeof(clie_IP)),
            ntohs(clie_addr.sin_port));

    	char buf[BUFSIZ]; // 给read使用，存储读出的数据，BUFSIZ宏是系统用来专门给buf赋长度的宏，为8k（Default buffer size）

    	int len; // read的返回值，是读入字符的长度
    	len = read(cfd, buf, sizeof(buf));
	
    	// 把小写字母转化为大写字母
    	int i;
    	for(i = 0; i < len; ++i) {
    	    if(buf[i] <= 'z' && buf[i] >= 'a') {
    	        buf[i] -= 32;
    	    }
    	}
    	write(cfd, buf, len);
    
	}

    close(lfd);
    close(cfd);

    return 0;
}

 

以上代码为突出主体，没有写错误判断与错误提示。带错误提示代码如下：

/*实现一个简单的服务器-客户端通信*/

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

// 设定一个服务器端口号
#define SERV_IP "127.0.0.1"
#define SERV_PORT 6666

int main()
{
    int lfd; // 用于监听的socket的文件描述符
    struct sockaddr_in serv_addr;
    int ret; // 用于错误检测

    lfd = socket(AF_INET, SOCK_STREAM, 0);
    if(lfd == -1) {
        perror("socket error");
        exit(1);
    }
    
    serv_addr.sin_family = AF_INET;

    // 注意这里，要把小端存储的端口号改为大端存储
    serv_addr.sin_port = htons(SERV_PORT); 
    inet_pton(AF_INET, SERV_IP, &serv_addr.sin_addr.s_addr); // 调用ip转换函数，把字符串ip转化为网络字节序

    ret = bind(lfd, (struct sockaddr * )&serv_addr, sizeof(serv_addr));
    if(ret == -1) {
        perror("bind error");
        exit(1);
    }

    ret = listen(lfd, 128); // 最大连接与待连接数设为128
    if(ret == -1) {
        perror("listen error");
        exit(1);
    }
    
    int cfd; // 已连接的客户端的socket的文件描述符, 以便一会儿read用
    struct sockaddr_in clie_addr;                // 作为accept的第二个参数，为传出参数，传出的是客户端的sockadd_in
    socklen_t clie_addr_len = sizeof(clie_addr); // 作为accept的第三个参数，为传入传出参数，之所以要单独定义出来是因为要传出
    cfd = accept(lfd, (struct sockaddr *)&clie_addr, &clie_addr_len);
    if(cfd == -1) {
        perror("accept error");
        exit(1);
    }

    // 此处输出连接的客户端的ip和端口
    char clie_IP[BUFSIZ];
    printf("Client IP: %s, client port: %d\n", 
            inet_ntop(AF_INET, &clie_addr.sin_addr.s_addr, clie_IP, sizeof(clie_IP)),
            ntohs(clie_addr.sin_port));


    while(1) {
        char buf[BUFSIZ]; // 给read使用，存储读出的数据，BUFSIZ宏是系统用来专门给buf赋长度的宏，为8k（Default buffer size）

        int len; // read的返回值，是读入字符的长度
        len = read(cfd, buf, sizeof(buf));
        if(len == -1) {
            perror("read error");
            exit(1);
        }

        // 把小写字母转化为大写字母
        int i;
        for(i = 0; i < len; ++i) {
            if(buf[i] <= 'z' && buf[i] >= 'a') {
                buf[i] -= 32;
            }
        }
        ret = write(cfd, buf, len);
        if(ret == -1) {
            perror("write error");
            exit(1);
        }
        
    }
    
    close(cfd);
    close(lfd);

    return 0;
}

 

3.3 客户端

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

// 服务器的ip和端口
#define SERV_IP "127.0.0.1"
#define SERV_PORT 6666

int main()
{
    int cfd; // 用于写入数据传输给服务端的socket的文件描述符

    cfd = socket(AF_INET, SOCK_STREAM, 0);

    // bind()  可以不调用bind()， linux会隐式地绑定

    struct sockaddr_in serv_addr; // 因为要连接服务端，这里的sockadd_in是用于指定服务端的ip和端口

    bzero(&serv_addr, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(SERV_PORT);
    inet_pton(AF_INET, SERV_IP, &serv_addr.sin_addr.s_addr); // 调用ip转换函数，把字符串ip转化为网络字节序
    connect(cfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr));
	
	while(1) {
    	// 从终端读取内容
    	char buf[BUFSIZ];
    	fgets(buf, sizeof(buf), stdin);  // 读一行

    	// 写入到cfd中，传输给服务端
    	write(cfd, buf, strlen(buf)); // 注意不要写成sizeof(buf)，sizeof是在内存中所占的大小，strlen是到第一个'\0'位止。

    	// read在读socket时默认时阻塞的，阻塞等待服务端传输数据
    	int len;
    	len = read(cfd, buf, sizeof(buf));

    	printf("%s", buf);
    }

    close(cfd);
    
    return 0;
}

以上代码为突出主体，没有写错误判断与错误提示。带错误提示代码如下：

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

// 服务器的ip和端口
#define SERV_IP "127.0.0.1"
#define SERV_PORT 6666

int main()
{
    int ret; // 用于错误检测
    int cfd; // 用于写入数据传输给服务端的socket的文件描述符

    cfd = socket(AF_INET, SOCK_STREAM, 0);
    if(cfd == -1) {
        perror("socket error");
        exit(1);
    }

    // bind()  可以不调用bind()， linux会隐式地绑定

    struct sockaddr_in serv_addr; // 因为要连接服务端，这里的sockadd_in是用于指定服务端的ip和端口

    bzero(&serv_addr, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(SERV_PORT);
    inet_pton(AF_INET, SERV_IP, &serv_addr.sin_addr.s_addr); // 调用ip转换函数，把字符串ip转化为网络字节序

    ret = connect(cfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr));
    if(ret == -1) {
        perror("connect error");
        exit(1);
    }
    // 从终端读取内容

    while(1) {
        char buf[BUFSIZ];
        fgets(buf, sizeof(buf), stdin);  // 读一行

        // 写入到cfd中，传输给服务端
        ret = write(cfd, buf, strlen(buf)); // 注意不要写成sizeof(buf)，sizeof是在内存中所占的大小，strlen是到第一个'\0'位止。
        if(ret == -1) {
            perror("write error");
            exit(1);
        }

        // read在读socket时默认时阻塞的，阻塞等待服务端传输数据
        int len;
        len = read(cfd, buf, sizeof(buf));
        if(len == -1) {
            perror("read error");
            exit(1);
        }

        printf("%s", buf);
    }

    

    close(cfd);
    
    return 0;
}

 

标签：sockaddr,addr,int,编程,socket,客户端,Linux,include,Socket
From： https://www.cnblogs.com/wxk1213/p/16898109.html