Unix环境高级编程学习笔记（十一） 网络IPC：套接字

Socket 描述符

socket 主要用于运行在不同服务器上的进程之间通信(服务器通过网络相连)，也可以用于在同一服务器上的进程之间通信。而 Socket 描述符则是 Socket 的唯一标识，其本质是一种特殊的文件描述符。创建 Socket 描述符 的函数声明如下：

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

domain 参数决定了通信的性质，这些性质包括地址格式等。domain 的取值如下：

AF_INET IPv4 因特网域。

AF_INET6 IPv6 因特网域。

AF_UNIX UNIX 域。

AF_UNSPEC 未指定，这是一个可以表达任何域的通配符。

type 参数的类型：

SOCK_DGRAM 固定长度，无连接，不可靠的消息。

SOCK_RAW IP 协议的数据报接口。（在 POSIX.1 中是可选的）

SOCK_SEQPACKET 固定长度，顺序式，面向连接的，可靠的消息。

SOCK_STREAM 顺序式，面向连接的，双向的，可靠的字节流。

protocol 参数代表协议号，如果给0，则使用对于给定 domain 和 type 下的默认协议。在 AF_INET 通信域下，SOCK_STREAM 类型的默认协议是 TCP (Transmission Control Protocol)，而对于 SOCK_DGRAM 类型的默认协议则是 UDP (User Datagram Protocol)。

网络地址

不同的网络域具有不同的地址格式，sockaddr 是地址的通用结构体：

struct sockaddr {
		sa_family_t		sa_family;/* address family */
		char			sa_data[];/* variable-length address */
		.
		.
		.
	};

其中，sa_family 实际上就是前面提到过的网络域。

对于 AF_INET，其地址格式由 sockaddr_in 结构体呈现：

	struct sockaddr_in {
		sa_family_t		sin_family;/* address family */
		in_port_t		sin_port;/* port number */
		struct in_addr 	sin_addr;/* IPv4 address */
	};

	struct in_addr {
		in_addr_t	s_addr;/* IPv4 address */
	};

而对于 AF_INET6，其地址格式由 sockaddr_in6 结构体呈现：

struct sockaddr_in6 {
	sa_family_t		sin6_family;/*address family */
	in_port_t		sin6_port;/*port number */
	uint32_t		sin6_flowinfo;/*traffic class and flow info */
	struct in6_addr 	sin6_addr;/*IPv6 address */
	uint32_t		sin6_scope_id;/*IPv6 address */
};

struct in6_addr {
	uint8_t	s6_addr[16];/* IPv6 address */
};

许多时候，我们需要在二进制地址和人类可识别的字符串之间进程转换，可以使用以下函数：

const char *inet_ntop(int domain, const void *restrict addr,
	char *restrict str, socklen_t size);
int inet_pton(int domain, const char *restrict str, void *restrict addr);

前者将二进制地址转换为人类可识别的字符串，后者则相反。

对于 domain 参数，只有 AF_INET 和 AF_INET6 是支持的。

在 inet_ntop 中，str 是 O 参数，size 是该缓存区的大小，缓存区必需足够大，以存放转换后的字符串。这里有两个比较方便的宏：INET_ADDRSTRLEN 和 INET6_ADDRSTRLEN，它们分别足够大对于存放 IPV4 以及 IPV6 的地址。

建立连接

当获得 Socket 描述符后，对于服务器，首先就是和一个具体的网络地址绑定，函数声明如下：

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

前面介绍了， sockaddr 是一个通用的地址结构，因此，任意的网络地址结构都可以作为参数在这里传递，len 是传递的结构体的长度。

对于 Internet 域，如果将 IP 地址指定为 INADDR_ANY，则该 Socket 描述符将绑定到该系统上的所有网络接口上。这意味着，我们可以从安装在该系统上的任何网卡上接收数据包。

如果我们要处理的是面向连接的服务(SOCK_STREAM or SOCK_SEQPACKET)，那么，在我们可以交换数据之前，客户端必须首先和服务端建立连接。

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

该函数将使 sockfd 与 addr 所代表的网络地址建立连接。如果当建立连接时，客户端的 sockfd 还没有和地址绑定（实际上一般说来也不需要），则它将首先为 sockfd 绑定一个默认的地址。该函数也可以用在无连接的网络服务上（SOCK_DGRAM），如果我们使用 SOCK_DGRAM 类型的 socket 凋用该函数，则之后我们通过该 socket 发送的所有数据的目的地址都将被设置成 addr。对于通过该 socket 接收的所有数据的源地址也将被设置成 addr。

当客户端建立连接时，如果服务器没有对该地址进行监听，则连接将失败，服务端的监听函数如下：

int listen(int sockfd, int backlog);

backlog 参数表示能够排队最大连接请求数量，它只是为系统提供了一个建议值。

使用 accept 函数用于接受一个请求，我们知道，建立 TCP 连接是需要进行三次握手的，当客户端调用 connect 函数后实际上只是发了一个 SYN，只有当服务端 accept 了这个请求之后，才真正完成了这三次握手。

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

该函数将返回另一个 socket 描述符，该描述符与客户端的 socket 描述符建立了一个 TCP 连接，而原先的描述符则仍然可用于接收连接请求。

如果在调用该函数时，还没有等待响应的连接请求，则进程将默认阻塞，直到有请求到达。而如果，sockfd 是非阻塞模式（关于该模式后面会讲到），accept 将返回 -1，并设置 errno 为 EAGAIN 或是EWOULDBLOCK。

参数 addr 在这里是一个 O 参数，用于获取客户端的地址，如果对此并不关心，可以置 addr 为 NULL。

数据传输

前面说了，socket 描述符实际上就是文件描述符，因此，许多针对文件描述符的操作也可以直接使用到 socket 描述符上，例如 read 和 write 函数，可以使用它们来收发数据，当然，也有专门针对 socket 描述符的数据传输操作。最基本的就是 send 和 recv 函数：

ssize_t send(int sockfd, const void *buf, size_t nbytes, int flags);
ssize_t recv(int sockfd, void *buf, size_t nbytes, int flags);

send 支持四种 flag 参数：

MSG_DONTROUTE  数据不能被路由出本地网络。

MSG_DONTWAIT 非阻塞操作（等价于 O_NONBLOCK 模式）.。

MSG_EOR 如果协议支持，此为记录结束（end of record）。

MSG_OOB 如果协议支持，发送带外数据（out-of-band data），

对于一个支持消息边界的协议，如果我们试图发送的单个消息的长度大于该协议所支持的最大长度，send 将会失败，并设置 errno 为 EMSGSIZE。

对于字节流协议，默认情况下（非阻塞模式），send 将阻塞直到所有数据都发送完毕。

recv 也支持甲种 flag 参数：

MSG_OOB 如果协议支持，获取带外数据（out-of-band data）。

MSG_PEEK 返回包内容，但不取走。

MSG_TRUNC 即使包被截断，函数也将返回完整包的长度。

MSG_WAITALL 等到所有数据都有效（只有 SOCK_STREAM 支持）。.

这两个函数是最基本的数据传输函数，更多的函数之后再讲。

基于 TCP 的例子程序

前面说了那么多，还是来看一个例子比较有深刻的印象。不过在学习例子之前，我们需要先理解大小端的概念。

所谓的大端模式，是指数据的高位，保存在内存的低地址中，而数据的低位，保存在内存的高地址中，而小端模式则正好相反。以下是四种常用系统的大小端模式：

FreeBSD 5.2.1	Intel Pentium	little-endian
Linux 2.4.22	Intel Pentium	little-endian
Mac OS X 10.3	PowerPC	big-endian
Solaris 9	Sun SPARC	big-endian

对于 TCP 协议，其规定的是大端模式，因此这就涉及到大小端的转换问题，以下函数用于解决这个问题：

	uint32_t htonl(uint32_t hostint32);
	uint16_t htons(uint16_t hostint16);
	uint32_t ntohl(uint32_t netint32);
	uint16_t ntohs(uint16_t netint16);

前两个函数用于将主机模式的数据转化为 TCP 模式的数据，后两者则相反。l 代表32位数据的，s 代表16位。

对于 sockaddr_in 数据结构，其中 端口号与 IP 地址都是 TCP 网络字节序。

服务端程序：

/*
 *author: justaipanda
 *create time:2012/09/03 09:38:51
 */

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

#define BUF_SIZE	1024
#define MY_PORT 	6788

int main() {

	//set server socket address
	struct sockaddr_in server_addr;
	server_addr.sin_family = AF_INET;
	server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
	server_addr.sin_port = htons(MY_PORT);

	int sd;
	if((sd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
		printf("socket error!\n");
		exit(0);
	}

	if (bind(sd, (struct sockaddr*)&server_addr, 
								sizeof(server_addr)) < 0) {
		printf("bind error!\n");
		exit(0);
	}

	if (listen(sd, 128) < 0) {
		printf("listen error!\n");
		exit(0);
	}

	while(1) {

		int sclient = accept(sd, NULL, NULL);
		if (sclient < 0) {
			printf("accept error!\n");
			exit(0);
		}

		char buffer[BUF_SIZE];
		ssize_t len = recv(sclient, buffer, BUF_SIZE, 0);
		if (len < 0) {
			printf("recieve error!\n");
			close(sclient);
			continue;
		}

		buffer[len] = '\0';
		printf("receive[%d]:%s\n", (int)len, buffer);
		if (len > 0) {
			if('q' == buffer[0]) {
				printf("server over!\n");
				exit(0);
			}
				
			char* buffer2 = "I'm a server!";
			len = send(sclient, buffer2, strlen(buffer2), 0);
			if (len < 0)
				printf("send error!\n");
		}
		close(sclient);
	}

	return 0;
}

客户端程序：

/*
 *author: justaipanda
 *create time:2012/09/03 10:47:35
 */

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

#define SERVER_PORT 6788
#define SERVER_IP "127.0.0.1"
#define BUF_SIZE	1024

int main() {

	int ip;
	inet_pton(AF_INET, SERVER_IP, &ip);

	//set server socket address
	struct sockaddr_in server_addr;
	server_addr.sin_family = AF_INET;
	server_addr.sin_addr.s_addr = ip;
	server_addr.sin_port = htons(SERVER_PORT);

	int sd;
	if ((sd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
		printf("socket error!\n");
		exit(0);
	}

	if (connect(sd, (struct sockaddr*)&server_addr,
		sizeof(server_addr)) < 0) {
		printf("connect error!\n");
		exit(0);
	}

	char buffer[BUF_SIZE];
	printf("input:");
	scanf("%s", buffer);
	int len = send(sd, buffer, strlen(buffer), 0);
	if (len < 0) {
		printf("send error!\n");
		exit(0);
	}

	len = recv(sd, buffer, BUF_SIZE, 0);
	if (len < 0) {
		printf("recieve error!\n");
		exit(0);
	}

	buffer[len] = '\0';
	printf("receive[%d]:%s\n", (int)len, buffer);

	return 0;
}

其它数据传输函数

sendto 与 recvfrom 函数：

ssize_t sendto(int sockfd, const void *buf, size_t nbytes, int flags,
		const struct sockaddr *destaddr, socklen_t destlen);
ssize_t recvfrom(int sockfd, void *restrict buf, size_t len, int flags,
		struct sockaddr *restrict addr, socklen_t *restrict addrlen);

这两个函数都是用在无连接的 socket 数据传输中的，sendto 函数和 send 基本一致，它只是多了两个参数，可以用来指定发送的目的地址，而 recvfrom 多的那两个参数则是用来在接收数据时获取发送方的地址的。

sendmsg 与 recvmsg 函数：

ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags);
ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags);

这两个函数的作用有点儿类似于我以前介绍过的 writev 和 readv 函数（关于这两个函数请参见Unix环境高级编程学习笔记（九） 高级IO）。sendmsg 从 多个缓存区收集数据并发送到多个目的地址，而 readv 则可从多个源地址中接收数据。看一下 msghdr 结构体的成员：

	struct msghdr {
		void			*msg_name;/*optional address */
		socklen_t		msg_namelen;/*address size in bytes */
		struct iovec 	*msg_iov;/*array of I/O buffers */
		int				msg_iovlen;/*number of elements in array */
		void			*msg_control;/*ancillary data */
		socklen_t		msg_controllen;/*number of ancillary bytes */
		int				msg_flags;/*flags for received message */
		.
		.
		.
	};

基于 UDP 的例子程序

服务端程序：

/*
 *author: justaipanda
 *create time:2012/09/03 09:38:51
 */

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

#define BUF_SIZE	1024
#define MY_PORT 	6788

int main() {

	//set server socket address
	struct sockaddr_in server_addr;
	server_addr.sin_family = AF_INET;
	server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
	server_addr.sin_port = htons(MY_PORT);

	int sd;
	if((sd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
		printf("socket error!\n");
		exit(0);
	}

	if (bind(sd, (struct sockaddr*)&server_addr, 
								sizeof(server_addr)) < 0) {
		printf("bind error!\n");
		exit(0);
	}

	while(1) {

		char buffer[BUF_SIZE];
		struct sockaddr_in client_addr;
		int sock_len = sizeof(client_addr);
		ssize_t len = recvfrom(sd, buffer, BUF_SIZE, 0,
				(struct sockaddr*)&client_addr, &sock_len);
		if (len < 0) {
			printf("recieve error!\n");
			continue;
		}

		buffer[len] = '\0';
		printf("receive[%d]:%s\n", (int)len, buffer);
		if (len > 0) {
			if('q' == buffer[0]) {
				printf("server over!\n");
				exit(0);
			}
				
			char* buffer2 = "I'm a server!";
			len = sendto(sd, buffer2, strlen(buffer2), 0,
					(struct sockaddr*)&client_addr, sock_len);
			if (len < 0)
				printf("send error!\n");
		}
	}

	return 0;
}

客户端程序：

/*
 *author: justaipanda
 *create time:2012/09/03 10:47:35
 */

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <signal.h>

#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/socket.h>

#define SERVER_PORT 6788
#define SERVER_IP "127.0.0.1"
#define BUF_SIZE	1024

void sig_alarm(int signo) {
	printf("receive timeout!\n");
	exit(0);
}

int main() {

	int ip;
	inet_pton(AF_INET, SERVER_IP, &ip);

	//set server socket address
	struct sockaddr_in server_addr;
	server_addr.sin_family = AF_INET;
	server_addr.sin_addr.s_addr = ip;
	server_addr.sin_port = htons(SERVER_PORT);

	int sd;
	if ((sd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
		printf("socket error!\n");
		exit(0);
	}

	if (connect(sd, (struct sockaddr*)&server_addr,
		sizeof(server_addr)) < 0) {
		printf("connect error!\n");
		exit(0);
	}

	char buffer[BUF_SIZE];
	printf("input:");
	scanf("%s", buffer);
	int len = send(sd, buffer, strlen(buffer), 0);
	if (len < 0) {
		printf("send error!\n");
		exit(0);
	}

	struct sigaction sa;
	sa.sa_handler = sig_alarm;
	sa.sa_flags = 0;
	sigemptyset(&sa.sa_mask);
	sigaction(SIGALRM, &sa, NULL);
	alarm(3);//set timeout

	len = recv(sd, buffer, BUF_SIZE, 0);
	if (len < 0) {
		printf("recieve error!\n");
		exit(0);
	}

	buffer[len] = '\0';
	printf("receive[%d]:%s\n", (int)len, buffer);

	return 0;
}

关于客户端这里的程序我需要说一下的是，由于 UDP 是不可靠的传输协议，因此，客户端调用 recv 就可能会因为丢包而永远阻塞。所以，这里，我添加了时钟信号用于唤醒（关于信号机制的问题可以参看Unix环境高级编程学习笔记（六） 信号机制 ）。

连接关闭及其他

前面我们使用的连接关闭方式是 close，这是从文件描述符继承下来的关闭方式，对于这种方式存在的问题是，只有当最后一个该描述符的活动引用（使用 dup 函数可增加引用）被关闭后，才会真正关闭连接。因此我们可以考虑使用 shutdown 函数：

int shutdown (int sockfd, int how);

how的意义：

SHUT_RD 关闭读。

SHUT_WR 关闭写。

SHUT_RDWR 关闭读写。

使用 getsockname 函数可以获得与该 socket 描述符绑定的地址：

int getsockname(int sockfd, struct sockaddr *restrict addr,
		socklen_t *restrict alenp);

函数返回时，alenp 会被设置成获取的地址长度，如果缓存区的大小不足以存放，则地址结构体会被截断，并且没有任何错误提示。

如果该 socket 已经建立了 TCP 连接，则可以使用 getpeername 函数可以获得对方的地址：

int getpeername(int sockfd, struct sockaddr *restrict addr,
	socklen_t *restrict alenp);

我们可以通过利用设置 socket 选项来设置一些高级属性，例如带外数据的发送与接收等等。

int setsockopt(int sockfd, int level, int option, const void *val, 
		socklen_t len);
int getsockopt(int sockfd, int level, int option, void *restrict val,
		socklen_t *restrict lenp);

对于带外数据，最常见的例如紧急字节，当接收到该紧急字节时，socket 会向自己的属主或是属组发送 SIGURG 信号，可以使用 F_SETOWN 命令调用 fcntl 函数去设置一个 socket 描述符的属组或是属主：

fcntl(sockfd, F_SETOWN, pid);

如果 pid 大于0，则它指定的是属主，小与-1，则指定的是属组。

使用 GETOWN 可以获得一个 socket 描述符的属组或是属主：

owner = fcntl(sockfd, F_GETOWN, 0);

如果 owner 大于0，则它得到的是属主，小与-1，则得到的是属组。