UNIX环境高级编程-网络socket编程

---

大家可以提前看一下OSI七层模型的文章：OSI（open system internet）七层模型介绍以及NAT（Network Address Translation）技术详解

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

1- socket通信流程图

socket通信基本原理：“open—write/read—close“模式。

下面是网络socket通信的基本流程：

---

2- socket操作API函数介绍

（1）socket()函数

socket函数对应于普通文件的打开操作。普通文件的打开操作返回一个文件描述字，而socket()用于创建一个socket描述符（socket descriptor），它唯一标识一个socket。这个socket描述字跟文件描述字一样，后续的操作都有用到它，把它作为参数，通过它来进行一些读写操作。创建socket的时候，也可以指定不同的参数创建不同的socket描述符

#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>

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

• domain：
  即协议域，又称为协议族（family）。常用的协议族有，AF_INET、AF_INET6、AF_LOCAL（或称AF_UNIX，Unix域socket）、AF_ROUTE等等。协议族决定了socket的地址类型，在通信中必须采用对应的地址，如AF_INET决定了要用ipv4地址（32位的）与端口号（16位的）的组合、AF_UNIX决定了要用一个绝对路径名作为地址。
• type：
  指定socket类型。常用的socket类型有，SOCK_STREAM（流格式套接字）、SOCK_DGRAM（数据报格式套接字）、SOCK_RAW、SOCK_PACKET、SOCK_SEQPACKET等等（socket的类型有哪些？）。
• protocol：
  指定协议。常用的协议有，IPPROTO_TCP、IPPTOTO_UDP、IPPROTO_SCTP、IPPROTO_TIPC等，它们分别对应TCP传输协议、UDP传输协议、STCP传输协议、TIPC传输协议，type和protocol并不是可以随意组合的，如SOCK_STREAM不可以跟IPPROTO_UDP组合。当protocol为0时，会自动选择type类型对应的默认协议。

简单介绍一下用的比较多两种socket类型：

• 流格式套接字（SOCK_STREAM）

流格式套接字（Stream Sockets）也叫“面向连接的套接字”，在代码中使用 SOCK_STREAM 表示。SOCK_STREAM 是一种可靠的、双向的通信数据流，数据可以准确无误地到达另一台计算机，如果损坏或丢失，可以重新发送。使用了TCP协议，所以流格式套接字可以达到高质量的数据传输。

• 数据报格式套接字（SOCK_DGRAM）

数据报格式套接字（Datagram Sockets）也叫“无连接的套接字”，在代码中使用 SOCK_DGRAM 表示。数据报套接字是一种不可靠的、不按顺序传递的、以追求速度为目的的套接字。使用了UDP协议，所以传输速率很快。

（2）bind函数

当我们调用socket创建一个socket时，返回的socket描述字它存在于协议族（address family，AF_XXX）空间中，但没有一个具体的地址。如果想要给它赋值一个地址，就必须调用bind()函数。通常服务器在启动的时候都会绑定一个众所周知的地址（如ip地址+端口号），用于提供服务，客户就可以通过它来接连服务器；而客户端就不用指定，由系统自动分配一个端口号和自身的ip地址组合。这就是为什么通常服务器端在listen之前会调用bind()，而客户端就不会调用，而是在connect()时由系统随机生成一个。当然客户端也可以在调用connect()之前bind一个地址和端口，这样就能使用特定的IP和端口来连服务器了。

#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>

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

• sockfd：
  即socket描述字，它是通过socket()函数创建了，唯一标识一个socket。bind()函数就是将给这个描述字绑定一个名字。
• addrlen：
  对应的是地址的长度。
• addr：
  一个const struct sockaddr *指针，指向要绑定给sockfd的协议地址。这个地址结构根据地址创建socket时的地址协议族的不同而不同，但最终都会强制转换后赋值给sockaddr这种类型的指针传给内核。

下面简单来看一下通用套接字socketaddr类型定义：

typedef unsigned short int sa_family_t;

struct sockaddr { 
	sa_family_t sa_family; /* 2 bytes address family, AF_xxx */
 	char sa_data[14]; /* 14 bytes of protocol address */
}

ipv4对应的是sockaddr_in类型定义：

typedef unsigned short sa_family_t;
typedef uint16_t in_port_t;

struct in_addr {
 	uint32_t s_addr; 
};

struct sockaddr_in {
 	sa_family_t sin_family; /* 2 bytes address family, AF_xxx such as AF_INET */
 	in_port_t sin_port; /* 2 bytes port*/
	 struct in_addr sin_addr; /* 4 bytes IPv4 address*/
	 /* Pad to size of `struct sockaddr'. */
	 unsigned char sin_zero[8]; /* 8 bytes unused padding data, always set be zero */
};

ipv6对应的sockaddr_in6类型定义：

typedef unsigned short sa_family_t;
typedef uint16_t in_port_t;

struct in6_addr{
 union{
 	 uint8_t __u6_addr8[16];
	 uint16_t __u6_addr16[8];
	 uint32_t __u6_addr32[4];
 } __in6_u;
}
 
struct sockaddr_in6 {
	 sa_family_t sin6_family; /*2B*/
	 in_port_t sin6_port; /*2B*/
	 uint32_t sin6_flowinfo; /*4B*/
	 struct in6_addr sin6_addr; /*16B*/
	 uint32_t sin6_scope_id; /*4B*/
};

（3）listen()函数

socket()函数创建的socket默认是一个主动类型的，如果作为一个服务器，在调用socket()、bind()之后就会调用listen()来监听这个socket，该函数将socket变为被动类型的，等待客户的连接请求。

#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>

int listen(int sockfd, int backlog);

• sockefd：
  socket()系统调用创建的要监听的socket描述字。
• backlog：
  相应socket可以在内核里排队的最大连接个数。

（4）accept()函数

accept函数的返回值是由内核自动生成的一个全新的描述字(fd)，代表与返回客户的TCP连接。如果想发送数据给该客户端，则我们可以调用write()等函数往该fd里写内容即可；而如果想从该客户端读内容则调用read()等函数从该fd里读数据即可。一个服务器通常通常仅仅只创建一个监听socket描述字，它在该服务器的生命周期内一直存在。内核为每个由服务器进程接受的客户连接创建了一个新的socket描述字，当服务器完成了对某个客户的服务，就应当把该客户端相应的的socket描述字关闭。

#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

• sockfd：
  服务器开始调用socket()函数生成的，称为监听socket描述字；
• *addr：
  用于返回客户端的协议地址，这个地址里包含有客户端的IP和端口信息等；
• addrlen：
  返回客户端协议地址的长度

（5）connect()函数

TCP客户端程序调用socket()创建socket fd之后，就可以调用connect()函数来连接服务器。如果客户端这时调用connect()发出连接请求，服务器端就会接收到这个请求并使accept()返回，accept()返回的新的文件描述符就是对应到该客户的TCP连接，通过这两个文件描述符(客户端connect的fd和服务器端accept返回的fd)就可以实现客户端和服务器端的相互通信。

#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>

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

• sockfd： 客户端的socket()创建的描述字
• addr： 要连接的服务器的socket地址信息，这里面包含有服务器的IP地址和端口等信息
• addrlen： socket地址的长度

（6）close()函数

close一个TCP socket的缺省行为时把该socket标记为以关闭，然后立即返回到调用进程。

#include <unistd.h>

int close(int fd);

---

3- 客户端-服务器代码编写

客户端和服务器端代码都是在虚拟机测试，所以测试的时候没有加IP地址，默认是主机ip地址，大家想要分开测试的话可以使用tcp_test_tools工具单独测试，那个时候就需要指定IP地址了。

代码中命令行参数解析函数不了解的可以参考一下这篇文章：浅谈linux的命令行解析参数之getopt_long函数、

如果是不同的电脑一定需要在一个网段内才可以连接的。

服务器：

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

#define     MSG_STR    "My name is server! Nice to meet you!\n"
#define     BACKLOG    13
int main(int argc, char *argv[])
{
	int                   sockfd = -1;
	int                   client_fd = -1;
	int                   rv = -1;
	int                   port;
	char                  *IP;
	int                   new_fd = -1;
	char                  buf[1024];
	struct sockaddr_in    server_addr;
	struct sockaddr_in    client_addr;
	int                   ch = -1;
	socklen_t             addr_len;
	pid_t                   pid = -1;
	static struct option long_options[] = {
		{"ipaddr", required_argument, 0, 'i'},
		{"port", required_argument, 0, 'p'},
		{"help", no_argument, 0, 'h'},
		{0, 0, 0, 0}
	};
	void usage( char *program_name)
	{
		printf("%s usage: \n", program_name);

		printf("-i(--ipaddr): server IP address \n");
		printf("-p(--port):server Port \n");
		printf("-h(--help): For help \n");
		return ;
	}
	while((ch = getopt_long(argc, argv, "i:p:h", long_options, NULL)) != -1)
	{
		switch(ch)
		{
			case 'i':
				{
					IP = optarg;
					break;
				}
			case 'p':
				{
					port = atoi(optarg);	
					break;
				}
			case 'h':
				{
					usage(argv[0]);
					return 0;
				}
		}
	}

	sockfd = socket(AF_INET, SOCK_STREAM, 0);
	if(sockfd < 0)
	{
		printf("Creat socket failure: %s\n", strerror(errno));
		return -1;
	}
	printf("Creat sockfd[%d] successfully!\n", sockfd);

	memset(&server_addr, 0, sizeof(server_addr));
	server_addr.sin_family = AF_INET;
	server_addr.sin_port = htons(port);
	//	inet_aton(IP, &server_addr.sin_addr);
	/*
	   这里通过调用两个函数 htons() 和 htolnl() 分别用来将 端口和IP地址转换成网络字节序，这两个函数名中的 h表示host, n表
	   示network, s表示short(2字节/16位), l表示long(4字节/32位)。因为端口号是16位的，所以我们用htons()把端口号从主机字节
	   序转换成网络字节序， 而IP地址是32位的，所以我们用htonl()函数把IP地址从主机字节序转换成网络字节序。INADDR_ANY
	   就是指定地址为0.0.0.0的地址，这个地址事实上表示不确定地址，或“所有地址”、“任意地址”。 一般来说，在各个系统中均
	   定义成为0值。这里也就意味着监听所有的IP地址。
	   */
	server_addr.sin_addr.s_addr = htonl(INADDR_ANY);

	int opt = 1;
	setsockopt(sockfd,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));

	rv = bind(sockfd, (struct sockaddr*)&server_addr, sizeof(server_addr));
	if(rv < 0)
	{
		printf("Bind socket failure: %s\n", strerror(errno));
		return -2;
	}
	printf("Bind socket[%d] successfully!\n", port);

	listen(sockfd, BACKLOG);
	printf("Start to listen client[%d] \n", port);
	printf("Waiting to client come to connect...\n");
	new_fd = accept(sockfd, (struct sockaddr*)&client_addr, &addr_len);
	if(new_fd < 0)
	{
		printf("Accept client failure: %s\n", strerror(errno));
		return -3;
	}
	printf("Accept client[%s:%d] successfully!\n", inet_ntoa(client_addr.sin_addr),ntohs(client_addr.sin_port));

	while(1)
	{
		memset(buf, 0, sizeof(buf));
		rv = read(new_fd, buf, sizeof(buf));
		if (rv < 0)
		{
			printf("read client[%s:%d] failure: %s\n", inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port), strerror(errno));
			close(new_fd);
			continue;
		}
		if(rv == 0)
		{
			printf("Read client disconnected!: %s\n", strerror(errno));
			close(new_fd);
			continue;
		}
		printf("Read %d bytes from client[%s:%d]: %s\n", rv, inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port),  buf);

		rv = write(new_fd, MSG_STR, strlen(MSG_STR));
		if(rv < 0)
		{
			printf("Write MSG_STR failure to client: %s\n", strerror(errno));
			continue;
		}
		printf("Write MSG_STR to client[%s:%d] successfully!\n",inet_ntoa(client_addr.sin_addr),ntohs(client_addr.sin_port));
		sleep(3);
	}
	close(new_fd);
	return 0;
}

客户端：

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

#define     MSG_STR    "My name is client! Nice to meet you!\n"

int main(int argc, char *argv[])
{
	int                   sockfd = -1;
	int                   client_fd = -1;
	int                   rv = -1;
	int                   port;
	char                  *IP;
	char                  buf[1024];
	struct sockaddr_in    server_addr;
	int                   ch = -1;
	static struct option long_options[] = {
		{"ipaddr", required_argument, 0, 'i'},
		{"port", required_argument, 0, 'p'},
		{"help", no_argument, 0, 'h'},
		{0, 0, 0, 0}
	};
	void usage( char *program_name)
	{
		printf("%s usage: \n", program_name);
		printf("-i(--ipaddr): server IP address \n");
		printf("-p(--port):server Port \n");
		printf("-h(--help): For help \n");
		return ;
	}
	while((ch = getopt_long(argc, argv, "i:p:h", long_options, NULL)) != -1)
	{
		switch(ch)
		{
			case 'i':
			{
				IP = optarg;
				break;
			}
			case 'p':
			{
			        port = atoi(optarg);	
				break;
			}
			case 'h':
			{
				usage(argv[0]);
				return 0;
			}
		}
	}

	sockfd = socket(AF_INET, SOCK_STREAM, 0);//创建一个socket描述符
	if(sockfd < 0)
	{
		printf("Creat socket failure: %s\n", strerror(errno));
		return -1;
	}
	printf("Creat sockfd[%d] successfully!\n", sockfd);
	
	memset(&server_addr, 0, sizeof(server_addr));
	server_addr.sin_family = AF_INET;//AF_INET决定了要用ipv4地址（32位的）与端口号（16位的）的组合
	server_addr.sin_port = htons(port);//将主机字节序转换为网络子节序，h（host），s（short），n（network）
	inet_aton(IP, &server_addr.sin_addr);//调用 inet_aton() 函数将点分十进制字符串转换成 32位整形类型

	client_fd = connect(sockfd, (struct sockaddr*)&server_addr, sizeof(server_addr));
	if(client_fd < 0)
	{
		printf("Connect socket failure: %s\n", strerror(errno));
		return -2;
	}
	printf("Connect server[%s:%d] successfully!\n", IP, sockfd);
	
	while(1)
	{
		rv = write(sockfd, MSG_STR, strlen(MSG_STR));
		if(rv < 0)
		{
			printf("Write MSG_STR failure to server[%s:%d]\n", IP, sockfd);
			break;
		}
		printf("Write MSG_STR to server[%s:%d] successfully!\n",IP, sockfd);
		
		memset(buf, 0, sizeof(buf));
		rv = read(sockfd, buf, sizeof(buf));
		if (rv < 0)
		{
			printf("read sever[%s:%d] failure: %s\n", IP, sockfd, strerror(errno));
			return -4; 
		}
		if(rv == 0)
		{
			printf("Read server disconnected!: %s\n", strerror(errno));
			return -5;
		}
		printf("Read %d bytes from sever[%s:%d]: %s\n", rv, IP, sockfd, buf);
		sleep(3);
	}
	close(sockfd);
}

结果：

---