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

Socket 描述符

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

[cpp] view
plaincopy

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 是地址的通用结构体：

[cpp] view
plaincopy

struct sockaddr {

sa_family_t sa_family;/* address family */

char sa_data[];/* variable-length address */

.

.

.

};

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

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

[cpp] view
plaincopy

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 结构体呈现：

[cpp] view
plaincopy

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 */

};

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

[cpp] view
plaincopy

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 描述符后，对于服务器，首先就是和一个具体的网络地址绑定，函数声明如下：

[cpp] view
plaincopy

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

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

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

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

[cpp] view
plaincopy

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

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

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

[cpp] view
plaincopy

int listen(int sockfd, int backlog);

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

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

[cpp] view
plaincopy

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 函数：

[cpp] view
plaincopy

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 协议，其规定的是大端模式，因此这就涉及到大小端的转换问题，以下函数用于解决这个问题：

[cpp] view
plaincopy

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 网络字节序。

服务端程序：

[cpp] view
plaincopy

/*

*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;

}

客户端程序：

[cpp] view
plaincopy

/*

*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 函数：

[cpp] view
plaincopy

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 函数：

[cpp] view
plaincopy

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 结构体的成员：

[cpp] view
plaincopy

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 的例子程序

服务端程序：

[cpp] view
plaincopy

/*

*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;

}

客户端程序：

[cpp] view
plaincopy

/*

*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 函数：

[html] view
plaincopy

int shutdown (int sockfd, int how);

how的意义：

SHUT_RD 关闭读。

SHUT_WR 关闭写。

SHUT_RDWR 关闭读写。

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

[html] view
plaincopy

int getsockname(int sockfd, struct sockaddr *restrict addr,

socklen_t *restrict alenp);

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

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

[html] view
plaincopy

int getpeername(int sockfd, struct sockaddr *restrict addr,

socklen_t *restrict alenp);

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

[html] view
plaincopy

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 描述符的属组或是属主：

[html] view
plaincopy

fcntl(sockfd, F_SETOWN, pid);

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

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

[html] view
plaincopy

owner = fcntl(sockfd, F_GETOWN, 0);

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