Linux中的Socket网络通信

目录

1.Socket基础

1.1基本概念

1.2域

1.3主要类型

1.4地址结构

2.设计流程

2.1Socket()创建网络插口函数

2.2Bind()绑定一个地址端口对

2.3Connect()连接目标网络服务器

2.4Listen()监听本地端口

2.5Accept()接受一个网络请求

2.6Write()写入数据函数

2.7Read()读取数据函数

2.8Close()关闭套接字函数

3.Demo

3.1TCP

3.2UDP

---

1.Socket基础

1.1基本概念

socket 的原意是“插座”，在计算机通信领域，socket 被翻译为“套接字”，它是计算机之间进行通信的一种约定或一种方式。通过 socket 这种约定，一台计算机可以接收其他计算机的数据，也可以向其他计算机发送数据。

socket 的典型应用就是 Web 服务器和浏览器：浏览器获取用户输入的 URL，向服务器发起请求，服务器分析接收到的 URL，将对应的网页内容返回给浏览器，浏览器再经过解析和渲染，就将文字、图片、视频等元素呈现给用户。

套接字上联应用进程，下联网络协议栈，是应用程序通过网络协议进行通信的接口，是应用程序与网络协议根进行交互的接口 。

1.2域

域指定套接字通信中使用的网络介质。最常见的套接字域是 AF_INET（IPv4）或者AF_INET6(IPV6)，它是指 Internet 网络，许多 Linux 局域网使用的都是该网络，当然，因特网自身用的也是它。

1.3主要类型

        1.流套接字(SOCK_STREAM)

流套接字用于提供面向连接、可靠的数据传输服务。该服务将保证数据能够实现无差错、无重复送，并按顺序接收。流套接字之所以能够实现可靠的数据服务，原因在于其使用了传输控制协议，即TCP(The Transmission Control Protocol)协议 。

        2.数据报套接字(SOCK_DGRAM)

数据报套接字提供一种无连接的服务。该服务并不能保证数据传输的可靠性,数据有可能在传输过程中丢失或出现数据重复，且无法保证顺序地接收到数据。数据报套接字使用UDP( User DatagramProtocol)协议进行数据的传输。由于数据报套接字不能保证数据传输的可靠性，对于有可能出现的数据丢失情况，需要在程序中做相应的处理 。

        3.原始套接字(SOCK_RAW)

原始套接字与标准套接字(标准套接字指的是前面介绍的流套接字和数据报套接字)的区别在于：原始套接字可以读写内核没有处理的IP数据包，而流套接字只能读取TCP协议的数据，数据报套接字只能读取UDP协议的数据。因此，如果要访问其他协议发送的数据必须使用原始套接 。

1.4地址结构

通用套接字地址结构：

实际使用的套接字地址结构：

结构struct sockaddr_in 的成员变量in_addr 表示IP地址，这个结构的定义如下:

结构 struct sockaddr 和结构 struct sockaddr_in是一个同样大小的结构，所以进行地址结构设置时,通常的方法是利用结构struct sockaddr_in进行设置，然后强制转换为结构struct sockaddr类型。因为这两个结构大小是完全一致的，所以进行这样的转换不会有什么副作用。(地址转换这一部分的具体原因参看本文2.2部分）

1.5设计模式

TCP 网络编程有两种模式，一种是服务器模式，另一种是客户端模式。服务器模式创建一个服务程序，等待客户端用户的连接，接收到用户的连接请求后，根据用户的请求进行处理:客户端模式则根据目的服务器的地址和端口进行连接，向服务器发送请求并对服务器的响应进行数据处理。

TCP链接的设计流程如下所示：

UDP链接的设计流程如下所示：

2.设计流程

2.1Socket()创建网络插口函数

在 Linux 下使用 <sys/socket.h> 头文件中 socket() 函数来创建套接字，原型为：

int socket(int af, int type, int protocol);

        1) af 为地址族（Address Family），也就是 IP 地址类型，常用的有 AF_INET 和 AF_INET6。AF 是“Address Family”的简写，INET是“Inetnet”的简写。AF_INET 表示 IPv4 地址，例如 127.0.0.1；AF_INET6 表示 IPv6 地址，例如 1030::C9B4:FF12:48AA:1A2B。

你也可以使用 PF 前缀，PF 是“Protocol Family”的简写，它和 AF 是一样的。例如，PF_INET 等价于 AF_INET，PF_INET6 等价于 AF_INET6。

        2)type 为数据传输方式/套接字类型，常用的有 SOCK_STREAM（流格式套接字/面向连接的套接字）和 SOCK_DGRAM（数据报套接字/无连接的套接字）。
        3) protocol 表示传输协议，常用的有 IPPROTO_TCP 和 IPPTOTO_UDP，分别表示 TCP 传输协议和 UDP 传输协议。
        有了地址类型和数据传输方式，还不足以决定采用哪种协议吗？为什么还需要第三个参数呢？一般情况下有了 af 和 type 两个参数就可以创建套接字了，操作系统会自动推演出协议类型，除非遇到这样的情况：有两种不同的协议支持同一种地址类型和数据传输类型。如果我们不指明使用哪种协议，操作系统是没办法自动推演的。
        本例使用 IPv4 地址，参数 af 的值为 PF_INET。如果使用 SOCK_STREAM 传输数据，那么满足这两个条件的协议只有 TCP，因此可以这样来调用 socket() 函数：

int tcp_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);  //IPPROTO_TCP表示TCP协议

        这种套接字称为 TCP 套接字。
        如果使用 SOCK_DGRAM 传输方式，那么满足这两个条件的协议只有 UDP，因此可以这样来调用 socket() 函数：

int udp_socket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);  //IPPROTO_UDP表示UDP协议

        这种套接字称为 UDP 套接字。
        上面两种情况都只有一种协议满足条件，可以将 protocol 的值设为 0，系统会自动推演出应该使用什么协议，如下所示：

int tcp_socket = socket(AF_INET, SOCK_STREAM, 0);  //创建TCP套接字

int udp_socket = socket(AF_INET, SOCK_DGRAM, 0);  //创建UDP套接字

2.2Bind()绑定一个地址端口对

服务器端要用 bind() 函数将套接字与特定的 IP 地址和端口绑定起来，只有这样，流经该 IP 地址和端口的数据才能交给套接字处理。

bind() 函数的原型为：

int bind(int sock, struct sockaddr *addr, socklen_t addrlen);  //Linux

int bind(SOCKET sock, const struct sockaddr *addr, int addrlen);  //Windows

sock 为 socket 文件描述符，addr 为 sockaddr 结构体变量的指针，addrlen 为 addr 变量的大小，可由 sizeof() 计算得出。
下面的代码，将创建的套接字与IP地址 127.0.0.1、端口 1234 绑定：

//创建套接字
int serv_sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

//创建sockaddr_in结构体变量
struct sockaddr_in serv_addr;
memset(&serv_addr, 0, sizeof(serv_addr));  //每个字节都用0填充
serv_addr.sin_family = AF_INET;  //使用IPv4地址
serv_addr.sin_addr.s_addr = inet_addr("127.0.0.1");  //具体的IP地址
serv_addr.sin_port = htons(1234);  //端口

//将套接字和IP、端口绑定
bind(serv_sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr));

这里我们使用 sockaddr_in 结构体，然后再强制转换为 sockaddr 类型，具体原因如下：

sockaddr_in 结构体的成员变量如下：

struct sockaddr_in{
    sa_family_t     sin_family;   //地址族（Address Family），也就是地址类型
    uint16_t        sin_port;     //16位的端口号
    struct in_addr  sin_addr;     //32位IP地址
    char            sin_zero[8];  //不使用，一般用0填充
};

        1) sin_family 和 socket() 的第一个参数的含义相同，取值也要保持一致。
        2) sin_prot 为端口号。uint16_t 的长度为两个字节，理论上端口号的取值范围为 0~65536，但 0~1023 的端口一般由系统分配给特定的服务程序，例如 Web 服务的端口号为 80，FTP 服务的端口号为 21，所以我们的程序要尽量在 1024~65536 之间分配端口号。
        3) sin_addr 是 struct in_addr 结构体类型的变量，下面会详细讲解。
        4) sin_zero[8] 是多余的8个字节，没有用，一般使用 memset() 函数填充为 0。上面的代码中，先用 memset() 将结构体的全部字节填充为 0，再给前3个成员赋值，剩下的 sin_zero 自然就是 0 了。

sockaddr_in 的第3个成员是 in_addr 类型的结构体，该结构体只包含一个成员，如下所示：

struct in_addr{
    in_addr_t  s_addr;  //32位的IP地址
};

        in_addr_t 在头文件 <netinet/in.h> 中定义，等价于 unsigned long，长度为4个字节。也就是说，s_addr 是一个整数，而IP地址是一个字符串，所以需要 inet_addr() 函数进行转换。

        为什么要搞这么复杂，结构体中嵌套结构体，而不用 sockaddr_in 的一个成员变量来指明IP地址呢？socket() 函数的第一个参数已经指明了地址类型，为什么在 sockaddr_in 结构体中还要再说明一次呢，这不是啰嗦吗？这是由于历史的代码原因，后面的接口兼容前面的代码导致的。

        bind() 第二个参数的类型为 sockaddr，而代码中却使用 sockaddr_in，然后再强制转换为 sockaddr，这是为什么呢？
        sockaddr 结构体的定义如下：

struct sockaddr{
    sa_family_t  sin_family;   //地址族（Address Family），也就是地址类型
    char         sa_data[14];  //IP地址和端口号
};

下图是 sockaddr 与 sockaddr_in 的对比（括号中的数字表示所占用的字节数）：

        sockaddr 和 sockaddr_in 的长度相同，都是16字节，只是将IP地址和端口号合并到一起，用一个成员 sa_data 表示。要想给 sa_data 赋值，必须同时指明IP地址和端口号，例如”127.0.0.1:80“，遗憾的是，没有相关函数将这个字符串转换成需要的形式，也就很难给 sockaddr 类型的变量赋值，所以使用 sockaddr_in 来代替。这两个结构体的长度相同，强制转换类型时不会丢失字节，也没有多余的字节。
        可以认为，sockaddr 是一种通用的结构体，可以用来保存多种类型的IP地址和端口号，而 sockaddr_in 是专门用来保存 IPv4 地址的结构体。另外还有 sockaddr_in6，用来保存 IPv6 地址，它的定义如下：

struct sockaddr_in6 { 
    sa_family_t sin6_family;  //(2)地址类型，取值为AF_INET6
    in_port_t sin6_port;  //(2)16位端口号
    uint32_t sin6_flowinfo;  //(4)IPv6流信息
    struct in6_addr sin6_addr;  //(4)具体的IPv6地址
    uint32_t sin6_scope_id;  //(4)接口范围ID
};

正是由于通用结构体 sockaddr 使用不便，才针对不同的地址类型定义了不同的结构体

2.3Connect()连接目标网络服务器

客户端在建立套接字之后，不需要进行地址绑定，就可以直接连接服务器。连接服务器的函数为 connect()，此函数连接指定参数的服务器，例如IP地址端口等。

Connect()函数的原型如下:

int connect(int sock, struct sockaddr *serv_addr, socklen_t addrlen);  //Linux

int connect(SOCKET sock, const struct sockaddr *serv_addr, int addrlen);  //Windows

各个参数的说明和 bind() 类似。 sock 是建立套接字时返回的套接字文件描述符，它是由系统调用 socket()返回的。参数 serv_addr，是一个指向数据结构 sockaddr 的指针，其中包括客户端需要连接的服务器的目的端口和 IP 地址以及协议类型。参数addrlen表示第二个参数内容的大小，可以使用 sizeof(struct sockaddr)而获得，与bind()不同，这个参数是一个整型的变量而不是指针。

2.4Listen()监听本地端口

通过 listen() 函数可以让套接字进入被动监听状态，它的原型为：

int listen(int sock, int backlog);  //Linux
int listen(SOCKET sock, int backlog);  //Windows

        sock 为需要进入监听状态的套接字，backlog 为请求队列的最大长度。
        所谓被动监听，是指当没有客户端请求时，套接字处于“睡眠”状态，只有当接收到客户端请求时，套接字才会被“唤醒”来响应请求。

        当套接字正在处理客户端请求时，如果有新的请求进来，套接字是没法处理的，只能把它放进缓冲区，待当前请求处理完毕后，再从缓冲区中读取出来处理。如果不断有新的请求进来，它们就按照先后顺序在缓冲区中排队，直到缓冲区满。这个缓冲区，就称为请求队列（Request Queue）。
        缓冲区的长度（能存放多少个客户端请求）可以通过 listen() 函数的 backlog 参数指定，但究竟为多少并没有什么标准，可以根据你的需求来定，并发量小的话可以是10或者20。如果将 backlog 的值设置为 SOMAXCONN，就由系统来决定请求队列长度，这个值一般比较大，可能是几百，或者更多。
        当请求队列满时，就不再接收新的请求，对于 Linux，客户端会收到 ECONNREFUSED 错误，对于 Windows，客户端会收到 WSAECONNREFUSED 错误。
注意：listen() 只是让套接字处于监听状态，并没有接收请求。接收请求需要使用 accept() 函数。

2.5Accept()接受一个网络请求

当套接字处于监听状态时，可以通过 accept() 函数来接收客户端请求。它的原型为：

int accept(int sock, struct sockaddr *addr, socklen_t *addrlen);  //Linux
SOCKET accept(SOCKET sock, struct sockaddr *addr, int *addrlen);  //Windows

        它的参数与 listen() 和 connect() 是相同的：sock 为服务器端套接字，addr 为 sockaddr_in 结构体变量，addrlen 为参数 addr 的长度，可由 sizeof() 求得。
        accept() 返回一个新的套接字来和客户端通信，addr 保存了客户端的IP地址和端口号，而 sock 是服务器端的套接字，注意区分。后面和客户端通信时，要使用这个新生成的套接字，而不是原来服务器端的套接字。
        最后需要说明的是：listen() 只是让套接字进入监听状态，并没有真正接收客户端请求，listen() 后面的代码会继续执行，直到遇到 accept()。accept() 会阻塞程序执行（后面代码不能被执行），直到有新的请求到来。

2.6Write()写入数据函数

        Linux 不区分套接字文件和普通文件，使用 write() 可以向套接字中写入数据，使用 read() 可以从套接字中读取数据。前面说过，两台计算机之间的通信相当于两个套接字之间的通信，在服务器端用 write() 向套接字写入数据，客户端就能收到，然后再使用 read() 从套接字中读取出来，就完成了一次通信。
        write() 的原型为：

ssize_t write(int fd, const void *buf, size_t nbytes);

fd 为要写入的文件的描述符，buf 为要写入的数据的缓冲区地址，nbytes 为要写入的数据的字节数。

size_t 是通过 typedef 声明的 unsigned int 类型；ssize_t 在 "size_t" 前面加了一个"s"，代表 signed，即 ssize_t 是通过 typedef 声明的 signed int 类型。

write() 函数会将缓冲区 buf 中的 nbytes 个字节写入文件 fd，成功则返回写入的字节数，失败则返回 -1。

2.7Read()读取数据函数

read() 的原型为：

ssize_t read(int fd, void *buf, size_t nbytes);

        fd 为要读取的文件的描述符，buf 为要接收数据的缓冲区地址，nbytes 为要读取的数据的字节数。
        read() 函数会从 fd 文件中读取 nbytes 个字节并保存到缓冲区 buf，成功则返回读取到的字节数（但遇到文件结尾则返回0），失败则返回 -1。

2.8Close()关闭套接字函数

        关闭 socket连接可以使用close()函数实现，函数的作用是关闭已经打开的 socket 连接内核会释放相关的资源，关闭套接字之后就不能再使用这个套接字文件描述符进行读写操作了。

3.Demo

在linux上进行TCP/UDP的SocketAPI通信应用编写：

3.1TCP

Client：

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

int main(){
    //创建套接字
    int sock = socket(AF_INET, SOCK_STREAM, 0);

    //向服务器（特定的IP和端口）发起请求
    struct sockaddr_in serv_addr;
    memset(&serv_addr, 0, sizeof(serv_addr));  //每个字节都用0填充
    serv_addr.sin_family = AF_INET;  //使用IPv4地址
    serv_addr.sin_addr.s_addr = inet_addr("127.0.0.1");  //具体的IP地址
    serv_addr.sin_port = htons(1234);  //端口
    connect(sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr));
   
    //读取服务器传回的数据
    char buffer[80];
    read(sock, buffer, sizeof(buffer)-1);
   
    printf("Message form server: %s\n", buffer);
 
    //关闭套接字
    close(sock);

    return 0;
}

 Server:

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

int main(){
    //创建套接字
    int serv_sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

    //将套接字和IP、端口绑定
    struct sockaddr_in serv_addr;
    memset(&serv_addr, 0, sizeof(serv_addr));  //每个字节都用0填充
    serv_addr.sin_family = AF_INET;  //使用IPv4地址
    serv_addr.sin_addr.s_addr = inet_addr("127.0.0.1");  //具体的IP地址
    serv_addr.sin_port = htons(1234);  //端口
    bind(serv_sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr));

    //进入监听状态，等待用户发起请求
    listen(serv_sock, 20);

    //接收客户端请求
    struct sockaddr_in clnt_addr;
    socklen_t clnt_addr_size = sizeof(clnt_addr);
    int clnt_sock = accept(serv_sock, (struct sockaddr*)&clnt_addr, &clnt_addr_size);

    //向客户端发送数据
    char str[] = "This Message is yugui from server to cilent";
    write(clnt_sock, str, sizeof(str));
   
    //关闭套接字
    close(clnt_sock);
    close(serv_sock);

    return 0;
}

运行结果如下所示： 

3.2UDP

 Client：

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

typedef struct sockaddr* SP;

int main(int argc,const char* argv[])
{
	//	创建socket
	int sockfd = socket(AF_INET,SOCK_DGRAM,0);
	if(0 > sockfd)
	{
		perror("socket");
		return EXIT_FAILURE;
	}
	
	//	准备服务器通信地址
	struct sockaddr_in srv_addr = {};
	srv_addr.sin_family = AF_INET;
	srv_addr.sin_port = htons(7788);
	srv_addr.sin_addr.s_addr = inet_addr("127.0.0.1");//这里写需要通信的ip地址
	socklen_t addrlen = sizeof(srv_addr);

	char buf[4096] = {};
	size_t buf_size = sizeof(buf);

	for(;;)
	{
		printf(">>>");
		scanf("%s",buf);
		if(0 == strcmp(buf,"quit"))
		{
			printf("error!\n");
			close(sockfd);
			return EXIT_SUCCESS;
		}
		int ret = sendto(sockfd,buf,strlen(buf)+1,0,(SP)&srv_addr,addrlen);
		if(0 >= ret)
		{
			printf("sendto error!\n");
			close(sockfd);
			return EXIT_FAILURE;
		}
		//	接收数据和对方的地址
		ret = recvfrom(sockfd,buf,buf_size,0,(SP)&srv_addr,&addrlen);
		if(0 >= ret)
		{
			printf("recvfrom error");
			close(sockfd);
			return EXIT_FAILURE;
		}
		printf("from %s recv:[%s] bits:%d\n",
			inet_ntoa(srv_addr.sin_addr),buf,ret);

	}
}	

 Server:

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

typedef struct sockaddr* SP;

int main(int argc,const char* argv[])
{
	//	创建socket
	int sockfd = socket(AF_INET,SOCK_DGRAM,0);
	if(0 > sockfd)
	{
		perror("socket");
		return EXIT_FAILURE;
	}
	
	//	准备本机通信地址
	struct sockaddr_in srv_addr = {},cli_addr = {};
	srv_addr.sin_family = AF_INET;
	srv_addr.sin_port = htons(7788);
	srv_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
	socklen_t addrlen = sizeof(srv_addr);

	//	绑定
	if(bind(sockfd,(SP)&srv_addr,addrlen))
	{
		perror("bind");
		return EXIT_FAILURE;
	}

	char buf[4096] = {};
	size_t buf_size = sizeof(buf);

	for(;;)
	{
		//	接收数据和对方的地址
		int ret = recvfrom(sockfd,buf,buf_size,0,(SP)&cli_addr,&addrlen);
		if(0 >= ret)
		{
			printf("recvfrom error!");
			close(sockfd);
			return EXIT_FAILURE;
		}
		printf("from %s recv:[%s] bits:%d\n",
			inet_ntoa(cli_addr.sin_addr),buf,ret);

		//	返回响应
		strcat(buf,"from udpS");
		ret = sendto(sockfd,buf,strlen(buf)+1,0,(SP)&cli_addr,addrlen);
		if(0 >= ret)
		{
			printf("sendto error!\n");	
		}
	}
}	

运行结果如下所示：