from:http://www.yeolar.com/note/2012/05/18/linux-socket/
套接字接口
套接字接口是一组用来结合UNIX I/O函数进行进程间通信的函数,大多数系统上都实现了它,包括各种UNIX变种、Windows和Mac系统。
![/media/note/2012/05/18/linux-socket/fig1.png](http://www.yeolar.com/media/note/2012/05/18/linux-socket/fig1.png)
套接字接口
套接字描述符
套接字是通信端点的抽象,使用套接字描述符访问套接字,Linux用文件描述符实现套接字描述符,很多处理文件描述符的函数也可以用于套接字描述符。
使用 socket 函数创建套接字。
#include <sys/socket.h>
/* 创建套接字
* @return 成功返回文件描述符,出错返回-1 */
int socket(int domain, int type, int protocol);
参数说明:
-
domain
-
确定通信的特性,包括地址格式,每个域都有自己的地址格式。POSIX.1指定的域包括:
- AF_INET :IPv4地址域。
- AF_INET6 :IPv6地址域。
- AF_UNIX :UNIX域。
- AF_UNSPEC :未指定,可以代表任何域。
type
-
确定套接字的类型。POSIX.1定义的套接字类型有:
- SOCK_SEQPACKET :长度固定、有序、可靠的面向连接报文传递。
- SOCK_STREAM :有序、可靠、双向的面向连接字节流。
- SOCK_DGRAM :长度固定、不可靠的无连接报文传递。
- SOCK_RAW :IP协议的数据报接口。
protocol
- 通常为0,表示按给定的域和套接字类型选择默认协议。在 domain 和 type 给定的情况下如果有多个协议,可以用 protocol 指定协议。
在 AF_INET 通信域, SOCK_SEQPACKET 套接字类型的默认协议是SCTP, SOCK_STREAM 套接字类型的默认协议是TCP, SOCK_DGRAM 套接字类型的默认协议是UDP。
面向连接的协议通信可比作打电话。在交换数据前,要求在本地套接字和远程套接字之间建立一个逻辑连接,即连接是端到端的通信信道。会话中不包含地址信息,它隐含在连接中。
SOCK_STREAM 套接字提供字节流服务,从套接字读取数据时可能需要多次函数调用。 SOCK_SEQPACKET 套接字提供报文服务,从套接字接收的数据量和对方发送的一致。
数据报提供了无连接服务,它是一种自含报文,发送数据报可比作寄邮件。可以发送很多数据报,但不保证它们的顺序,而且可能会丢失,数据报包含接收地址。
SOCK_RAW 套接字提供了一个数据报接口用于直接访问网络层(IP层),使用它时需要自己构造协议首部。创建 SOCK_RAW 套接字需要超级用户特权。
尽管套接字描述符是文件描述符,担不是所有使用文件描述符的函数都能处理套接字描述符,下面是有关函数的支持情况:
close | 释放套接字 |
dup dup2 | 正常复制 |
fcntl | 支持一些命令,如 F_DUPFD 、 F_GETFD 、 F_GETFL 、 F_GETOWN 、 F_SETFD 、 F_SETFL 、 F_SETOWN |
fstat | 支持一些 stat 结构成员,由实现定义 |
ioctl | 支持部分命令,依赖于底层设备驱动 |
poll | 正常使用 |
read readv | 等价于无标志位的 recv |
select | 正常使用 |
write writev | 等价于无标志位的 send |
close 直到套接字的最后一个描述符关闭时才释放网络端点。
可以用 shutdown 函数来禁止套接字上的输入/输出。
#include <sys/socket.h>
/* 关闭套接字上的输入/输出
* @return 成功返回0,出错返回-1 */
int shutdown(int sockfd, int how);
how 可以取:
- SHUT_RD ,关闭读端,即无法从套接字读取数据。
- SHUT_WR ,关闭写端,即无法用套接字发送数据。
- SHUT_RDWR ,关闭读写,同时无法读取和发送数据。
寻址
进程标识确定目标通信进程,它有两部分:计算机的网络地址确定计算机,服务确定计算机上的特定进程。
字节序
CPU有大端字节序和小端字节序两种字节表示顺序。为使不同的计算机可以正常交换信息,网络协议指定了字节序。
TCP/IP协议栈采用大端字节序。可以用下面的函数处理主机字节序和网络字节序之间的转换。
#include <arpa/inet.h>
/* 将主机字节序的32位整型数转换为网络字节序 */
uint32_t htonl(uint32_t hostlong); /* 将主机字节序的16位整型数转换为网络字节序 */ uint16_t htons(uint16_t hostshort); /* 将网络字节序的32位整型数转换为主机字节序 */ uint32_t ntohl(uint32_t netlong); /* 将网络字节序的16位整型数转换为主机字节序 */ uint16_t ntohs(uint16_t netshort);
地址格式
地址标识特定通信域中的套接字端点,地址格式和特定通信域相关。为兼容不同格式的地址,地址被强制转换为通用的地址结构 sockaddr ,Linux系统中该结构定义如下:
struct sockaddr {
sa_family_t sa_family; /* 地址类型 */ char sa_data[14]; /* 变长地址 */ };
因特网地址定义在 <netinet/in.h> 中。
AF_INET 域中,套接字地址结构如下:
struct in_addr {
in_addr_t s_addr; /* IPv4地址 */ }; struct sockaddr_in { sa_family_t sin_family; /* 地址类型 */ in_port_t sin_port; /* 端口号 */ struct in_addr sin_addr; /* IPv4地址 */ unsigned char sin_zero[8]; /* 0填充 */ };
AF_INET6 域中,套接字地址结构如下:
struct in6_addr {
uint8_t s6_addr[16]; /* IPv6地址 */ }; struct sockaddr_in6 { sa_family_t sin6_family; /* 地址类型 */ in_port_t sin6_port; /* 端口号 */ uint32_t sin6_flowinfo; /* 传输类和流信息 */ struct in6_addr sin6_addr; /* IPv6地址 */ uint32_t sin6_scope_id; /* 作用域的接口集 */ };
in_port_t 定义为 uint16_t , in_addr_t 定义为 uint32_t 。
可以用 inet_ntop 和 inet_pton 函数对IPv4和IPv6地址作二进制和点分十进制字符串之间的转换。类似的还有 inet_addr 和 inet_ntoa 等函数,但它们只能用于IPv4地址。
#include <arpa/inet.h>
/* 将网络字节序的二进制地址转换为字符串格式
* @return 成功返回地址字符串指针,出错返回NULL */
const char *inet_ntop(int af, const void *src, char *dst, socklen_t size); /* 将字符串格式转换为网络字节序的二进制地址 * @return 成功返回1,格式无效返回0,出错返回-1 */ int inet_pton(int af, const char *src, void *dst);
af 只支持 AF_INET 和 AF_INET6 。
size 指定字符串缓冲区 dst 的大小,可用 INET_ADDRSTRLEN 和 INET6_ADDRSTRLEN 来为IPv4和IPv6地址的字符串设置足够大的空间。
地址查询
使用 gethostent 函数可以找到给定计算机的主机信息。
#include <netdb.h>
/* 获取文件的下一个hostent结构
* @return 成功返回指向hostent结构的指针,出错返回NULL */
struct hostent *gethostent(void); /* gethostent的可重入版本,自设缓冲 */ int gethostent_r(struct hostent *ret, char *buf, size_t buflen, struct hostent **result, int *h_errnop); /* 回到文件开头 */ void sethostent(int stayopen); /* 关闭文件 */ void endhostent(void); /* 通过主机名或地址查询hostent结构 * @return 成功返回指向hostent结构的指针,出错返回NULL */ struct hostent *gethostbyname(const char *name); #include <sys/socket.h> /* for AF_INET */ struct hostent *gethostbyaddr(const void *addr, socklen_t len, int type);
结构 hostent 的定义如下:
struct hostent {
char *h_name; /* 主机名 */ char **h_aliases; /* 主机别名列表 */ int h_addrtype; /* 主机地址类型 */ int h_length; /* 地址长度 */ char **h_addr_list; /* 地址列表 */ };
其中的地址采用网络字节序。
gethostbyname 和 gethostbyaddr 函数已经过时。
使用 getnetent 函数可以获取网络名和网络号。
#include <netdb.h>
struct netent *getnetent(void); void setnetent(int stayopen); void endnetent(void); struct netent *getnetbyname(const char *name); struct netent *getnetbyaddr(uint32_t net, int type);
结构 netent 的定义如下:
struct netent {
char *n_name; /* 网络名 */ char **n_aliases; /* 网络别名列表 */ int n_addrtype; /* 网络地址类型 */ uint32_t n_net; /* 网络号 */ };
网络号按网络字节序返回。地址类型为 AF_XX 的地址族常量。
使用 getprotoent 可以获取协议名字和对应协议号。
#include <netdb.h>
struct protoent *getprotoent(void); void setprotoent(int stayopen); void endprotoent(void); struct protoent *getprotobyname(const char *name); struct protoent *getprotobynumber(int proto);
结构 protoent 的定义如下:
struct protoent {
char *p_name; /* 协议名 */ char **p_aliases; /* 协议别名列表 */ int p_proto; /* 协议号 */ };
服务由地址的端口号部分表示,每种服务由一个唯一和熟知的端口号提供。使用 getservent 可以获取服务名字和对应端口号。
#include <netdb.h>
struct servent *getservent(void); void setservent(int stayopen); void endservent(void); struct servent *getservbyname(const char *name, const char *proto); struct servent *getservbyport(int port, const char *proto);
结构 servent 的定义如下:
struct servent {
char *s_name; /* 服务名 */ char **s_aliases; /* 服务别名列表 */ int s_port; /* 端口号 */ char *s_proto; /* 使用的协议 */ };
getaddrinfo 函数可以将一个主机名字和服务名字映射到一个地址, getnameinfo 的作用相反,用它们替换旧函数 gethostbyname 和 gethostbyaddr 。 freeaddrinfo 用来释放 addrinfo 结构链表。
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
/* 获取地址信息
* @return 成功返回0,出错返回非0错误码 */ int getaddrinfo(const char *node, const char *service, const struct addrinfo *hints, struct addrinfo **res); /* 释放一个或多个addrinfo结构的链表 */ void freeaddrinfo(struct addrinfo *res); /* 将错误码转换为错误信息 */ const char *gai_strerror(int errcode); /* 获取主机名或/和服务名 * @return 成功返回0,出错返回非0值 */ int getnameinfo(const struct sockaddr *sa, socklen_t salen, char *host, size_t hostlen, char *serv, size_t servlen, int flags);
需要提供主机名或/和服务名,主机名可以是节点名或点分十进制字符串表示的主机地址。
结构 addrinfo 的定义如下:
struct addrinfo {
int ai_flags; /* 自定义行为 */ int ai_family; /* 地址类型 */ int ai_socktype; /* 套接字类型 */ int ai_protocol; /* 协议 */ size_t ai_addrlen; /* 地址长度 */ struct sockaddr *ai_addr; /* 地址 */ char *ai_canonname; /* 主机规范名 */ struct addrinfo *ai_next; /* 链表中的下一个结构 */ };
可以用 hints 来过滤得到的结构,它只使用 ai_flags 、 ai_family 、 ai_socktype 、 ai_protocol 字段,其他字段必须设为0或 NULL 。
ai_flags 用来指定如何处理地址和名字,可用标志有:
- AI_ADDRCONFIG :查询配置的地址类型(IPv4或IPv6)。
- AI_ALL :查找IPv4和IPv6地址,仅用于 AI_V4MAPPED 。
- AI_CANONNAME :需要一个规范名而不是别名。
- AI_NUMERICHOST :以数字格式返回主机地址。
- AI_NUMERICSERV :以端口号返回服务。
- AI_PASSIVE :套接字地址用于监听绑定。
- AI_V4MAPPED :如果没找到IPv6地址,返回映射到IPv6格式的IPv4地址。
flags 参数指定一些转换的控制方式,有:
- NI_DGRAM :服务基于数据报而非基于流。
- NI_NAMEREQD :如果找不到主机名,将其视作错误。
- NI_NOFQDN :对于本地主机,仅返回完全限定域名的节点名部分。
- NI_NUMERICHOST :以数字形式返回主机地址。
- NI_NUMERICSERV :以端口号返回服务地址。
绑定地址
对于服务器,需要给接收客户端请求的套接字绑定一个众所周知的地址。客户端则让系统选择一个默认地址即可。
可以用 bind 函数将地址绑定到一个套接字。
#include <sys/socket.h>
/* 将地址绑定到套接字
* @return 成功返回0,出错返回-1 */
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
对于地址,要求:
- 地址必须有效,不能指定其他机器的地址。
- 地址必须和套接字的地址族所支持的格式匹配。
- 如果不是超级用户,端口号不能小于1024。
- 一般只有套接字端点能够和地址绑定。
对于因特网域,如果指定IP地址为 INADDR_ANY ,套接字端点可以被绑定到所有的系统网络接口,这样它可以收到这个系统的所有网卡的数据包。
getsockname 函数可以获取绑定到套接字的地址。
#include <sys/socket.h>
/* 获取绑定到套接字的地址
* @return 成功返回0,出错返回-1 */
int getsockname(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
addrlen 指定 addr 的缓冲区大小,返回时会被设置为返回地址的大小,如果地址过大,则会被截断而不报错。
套接字已经和对方连接时,可以用 getpeername 函数获取对方的地址。
#include <sys/socket.h>
/* 获取绑定到套接字的地址
* @return 成功返回0,出错返回-1 */
int getpeername(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
建立连接
面向连接的网络服务在交换数据前需要首先在请求服务的套接字(客户端)和提供服务的套接字(服务器)之间建立连接。可以用 connect 函数建立连接。
#include <sys/socket.h>
/* 建立连接
* @return 成功返回0,出错返回-1 */
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
addr 为服务器的地址。如果 sockfd 还没有绑定地址,函数会给它绑定一个默认地址。
由于服务器的负载变化等问题, connect 可能会返回错误,通常会选择重连,如下面的指数补偿算法。
#include <unistd.h>
#include <sys/socket.h>
#define MAXSLEEP 128
int connect_retry(int sockfd, const struct sockaddr *addr, socklen_t alen) { int nsec; /* Try to connect with exponential backoff. */ for (nsec = 1; nsec <= MAXSLEEP; nsec <<= 1) { if (connect(sockfd, addr, alen) == 0) { /* Connection accepted. */ return(0); } /* Delay before trying again. */ if (nsec <= MAXSLEEP/2) sleep(nsec); } return(-1); }
connect 也可用于无连接网络服务。所有发送报文的目标地址被设为 addr ,并且只能接收来自 addr 的报文。
服务器使用 listen 函数来说明可以接受连接请求。
#include <sys/socket.h>
/* 说明可以接受连接
* @return 成功返回0,出错返回-1 */
int listen(int sockfd, int backlog);
backlog 建议连接请求的队列大小,实际值由系统决定,上限为 SOMAXCONN ,该值为128。队列满后,系统会拒绝多余的连接请求。
之后用 accept 函数获得连接请求并建立连接。
#include <sys/socket.h>
/* 获得连接请求,建立连接
* @return 成功返回文件描述符,出错返回-1 */
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
accept 会将客户端地址设置到 addr 指向的缓冲区并更新 addrlen 指向的值,若不关心客户端可将它们设为 NULL 。
函数返回连接到调用 connect 的客户端的套接字描述符,它和 sockfd 有相同的套接字类型和地址族, sockfd 会被保持可用状态接受其他连接请求。
如果没有连接请求, accept 会阻塞直到有请求到来,如果 sockfd 为非阻塞模式,则返回-1,并设 errno 为 EAGAIN 或 EWOULDBLOCK (两者等价)。服务器也可以用 poll 或 select 来等待请求,请求套接字会被作为可读的。
数据传输
首先,因为套接字端点用文件描述符表示,所以可以用 read 和 write 函数来交换数据,这会带来兼容性上的好处。但如果想获得更多的功能,需要使用 send 和 recv 函数族。
send 函数族用于发送数据。
#include <sys/types.h>
#include <sys/socket.h>
/* 发送数据
* @return 成功返回发送的字节数,出错返回-1 */
ssize_t send(int sockfd, const void *buf, size_t len, int flags); ssize_t sendto(int sockfd, const void *buf, size_t len, int flags, const struct sockaddr *dest_addr, socklen_t addrlen); ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags);
send 函数类似 write ,但它支持额外的参数 flags ,可用标志有:
- MSG_DONTROUTE :勿将数据路由出本地网络。
- MSG_DONTWAIT :允许非阻塞操作,等价于用 O_NONBLOCK 。
- MSG_EOR :如果协议支持,此为记录结束。
- MSG_OOB :如果协议支持,发送带外数据。
send 成功返回只代表数据已经正确发送到网络上,不表示连接另一端的进程接收数据。对于支持为报文设限的协议,如果报文大小超过协议支持的最大值, send 失败并设 errno 为 EMSGSIZE 。对于字节流协议, send 会阻塞直到整个数据被传输。
sendto 和 send 的区别是它支持在无连接的套接字上指定目标地址。无连接的套接字如果在调用 connect 时没有设置目标地址,则不能用 send 。
sendmsg 类似于 writev ,可以指定多重缓冲区来传输数据。结构 msghdr 的定义如下:
struct msghdr {
void *msg_name; /* 可选地址 */ socklen_t msg_namelen; /* 地址大小 */ struct iovec *msg_iov; /* I/O缓冲区数组 */ size_t msg_iovlen; /* 数组中元素数 */ void *msg_control; /* 辅助数据 */ size_t msg_controllen; /* 辅助数据大小 */ int msg_flags; /* 接收到的数据的标志 */ };
相应地, recv 函数族用于接收数据。
#include <sys/types.h>
#include <sys/socket.h>
/* 接收数据
* @return 成功返回接收的消息字节数,无可用消息或对方已按序结束返回0,出错返回-1 */
ssize_t recv(int sockfd, void *buf, size_t len, int flags); ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags, struct sockaddr *src_addr, socklen_t *addrlen); ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags);
recv 函数类似 read ,但同样它支持额外的参数 flags ,可用标志有:
- MSG_WAITALL :等待直到所有数据可用,只对 SOCK_STREAM 有效。
- MSG_TRUNC :返回报文的实际长度,即使被截断。
- MSG_PEEK :返回报文内容但不取走报文。
- MSG_OOB :如果协议支持,接收带外数据。
SOCK_DGRAM 和 SOCK_SEQPACKET 套接字类型一次读取就返回整个报文,所以 MSG_WAITALL 对它们没有作用。
如果发送者用 shutdown 结束传输,或网络协议支持顺序关闭且发送端已关闭,则数据接收完之后 recv 返回0。
recvfrom 可以得到发送者的源地址,通常用于无连接套接字。
recvmsg 类似于 readv ,可以将接收到的数据放入多个缓冲区,也可用于想接收辅助数据的情况。 msghdr 结构前面已经说明,从 recvmsg 返回时会设置 msg_flags 字段来表示接收的数据的特性,可能的值有:
- MSG_DONTWAIT : recvmsg 处于非阻塞模式。
- MSG_TRUNC :一般数据被截断。
- MSG_CTRUNC :控制数据被截断。
- MSG_EOR :接收到记录结束符。
- MSG_OOB :接收到带外数据。
套接字选项
有三种类型的套接字选项:
- 通用选项,适用于所有套接字类型。
- 特定套接字的选项,会依赖于下层协议。
- 特定协议的选项。
用 getsockopt 和 setsockopt 函数获取和设置套接字选项。
#include <sys/socket.h>
/* 获取和设置套接字选项
* @return 成功返回0,出错返回-1 */
int getsockopt(int sockfd, int level, int optname, void *optval, socklen_t *optlen); int setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen);
参数说明:
-
level
- 指定选项应用的协议。如果选项是通用的套接字选项,设为 SOL_SOCKET ,否则设为控制该选项的协议号。对TCP选项设为 IPPROTO_TCP ,对UDP选项设为 IPPROTO_UDP ,对IP选项设为 IPPROTO_IP 。 optname
-
指定套接字选项。通用套接字选项包括:
选项 参数 optval 类型 说明 SO_ACCEPTCONN int 返回信息指示该套接字是否能监听,仅 getsockopt SO_BROADCAST int 如果 *optval 非0,广播数据包 SO_DEBUG int 如果 *optval 非0,启动网络驱动调试功能 SO_DONTROUTE int 如果 *optval 非0,绕过通常路由 SO_ERROR int 返回挂起的套接字错误并清除,仅 getsockopt SO_KEEPALIVE int 如果 *optval 非0,启动周期性keep-alive消息 SO_LINGER struct linger 当有未发送消息并且套接字关闭时,延迟时间 SO_OOBINLINE int 如果 *optval 非0,将带外数据放到普通数据中 SO_RCVBUF int 接收缓冲区的字节大小 SO_RCVLOWAT int 接收调用中返回的数据最小字节数 SO_RCVTIMEO struct timeval 套接字接收调用的超时值 SO_REUSEADDR int 如果 *optval 非0,重用 bind 中的地址 SO_SNDBUF int 发送缓冲区的字节大小 SO_SNDLOWAT int 发送调用中发送的数据最小字节数 SO_SNDTIMEO struct timeval 套接字发送调用的超时值 SO_TYPE int 标识套接字类型,仅 getsockopt
optval
- 根据选项的不同指向一个数据结构或整数。
通常TCP不允许绑定同一个地址,可以用 SO_REUSEADDR 来越过这个限制。
#include <errno.h>
#include <sys/socket.h>
int initserver(int type, const struct sockaddr *addr, socklen_t alen, int qlen) { int fd, err; int reuse = 1; if ((fd = socket(addr->sa_family, type, 0)) < 0) return(-1); if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(int)) < 0) { err = errno; goto errout; } if (bind(fd, addr, alen) < 0) { err = errno; goto errout; } if (type == SOCK_STREAM || type == SOCK_SEQPACKET) { if (listen(fd, qlen) < 0) { err = errno; goto errout; } } return(fd); errout: close(fd); errno = err; return(-1); }
带外数据
带外数据是一些通信协议支持的可选特性,允许更高优先级的数据比普通数据优先传输。TCP支持带外数据,UDP不支持。
在TCP中带外数据称为紧急数据,TCP只支持1字节的紧急数据,允许紧急数据在普通数据数据流之外传输。在 send 函数族中指定 MSG_OOB 标志,就会产生紧急数据,取最后1个字节。
用 SO_OOBINLINE 套接字选项可以在普通数据中接收紧急数据,可以在TCP的普通数据流中查看紧急数据的位置,即紧急标记。
#include <sys/socket.h>
/* 下一个要读的字节在标志处返回1,没在标志处返回0,出错返回-1 */
int sockatmark(int sockfd);
在读取队列出现带外数据时, select 函数返回文件描述符并异常挂起。可在普通数据流或用加 MSG_OOB 标志的 recv 函数族接收紧急数据,后面的紧急数据会覆盖前面的。
UNIX域套接字
UNIX域套接字用于同一台机器上的进程间通信。因特网域套接字也可以实现但UNIX域套接字效率更高,后者只复制数据而不处理协议和其他和网络相关的工作。
UNIX域套接字有流和数据报两种接口,它的数据报服务是可靠的。
可以用 socketpair 函数创建一对非命名的、相互连接的UNIX域套接字。
#include <sys/socket.h>
/* 创建一对无名的相互连接的UNIX域套接字
* @return 成功返回0,出错返回-1 */
int socketpair(int domain, int type, int protocol, int sv[2]);
例:
#include <sys/socket.h>
/* Returns a full-duplex "stream" pipe (a UNIX domain socket) with the two file descriptors returned in fd[0] and fd[1]. */
int s_pipe(int fd[2]) { return(socketpair(AF_UNIX, SOCK_STREAM, 0, fd)); }
也可以用 socket 创建命名的UNIX域套接字,用标准的 bind 、 listen 、 accept 、 connect 进行处理。
UNIX域套接字的地址定义在 <sys/un.h> 中,由 sockaddr_un 结构表示:
struct sockaddr_un {
sa_family_t sun_family; /* AF_UNIX */ char sun_path[108]; /* 路径名 */ };
可以用 offsetof 函数获取 sun_path 的偏移量再加上 sun_path 的长度得到绑定地址的长度。
将地址绑定到UNIX域套接字时,系统会用该路径名创建一个 S_IFSOCK 类型的文件。它只用于向客户进程告诉套接字名字,不能打开,也不能由应用程序用于通信。如果文件已经存在,则 bind 会失败。关闭套接字时,不会自动删除文件,因此还需要在程序中手动删除。
使用套接字的示例
面向连接的ruptime
客户端:
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <netdb.h>
#include <errno.h>
#include <sys/socket.h> #include "error.h" #define MAXADDRLEN 256 #define BUFLEN 128 extern int connect_retry(int, const struct sockaddr *, socklen_t); void print_uptime(int sockfd) { int n; char buf[BUFLEN]; while ((n = recv(sockfd, buf, BUFLEN, 0)) > 0) write(STDOUT_FILENO, buf, n); if (n < 0) err_sys("recv error"); } int main(int argc, char *argv[]) { struct addrinfo *ailist, *aip; struct addrinfo hint; int sockfd, err; if (argc != 2) err_quit("usage: ruptime hostname"); hint.ai_flags = 0; hint.ai_family = 0; hint.ai_socktype = SOCK_STREAM; hint.ai_protocol = 0; hint.ai_addrlen = 0; hint.ai_canonname = NULL; hint.ai_addr = NULL; hint.ai_next = NULL; if ((err = getaddrinfo(argv[1], "ruptime", &hint, &ailist)) != 0) err_quit("getaddrinfo error: %s", gai_strerror(err)); for (aip = ailist; aip != NULL; aip = aip->ai_next) { if ((sockfd = socket(aip->ai_family, SOCK_STREAM, 0)) < 0) err = errno; if (connect_retry(sockfd, aip->ai_addr, aip->ai_addrlen) < 0) { err = errno; } else { print_uptime(sockfd); exit(0); } } fprintf(stderr, "can't connect to %s: %s\n", argv[1], strerror(err)); exit(1); }
服务器( popen 版本):
#include <stdio.h>
#include <stdlib.h>
#include <netdb.h>
#include <errno.h>
#include <syslog.h>
#include <sys/socket.h> #include "error.h" #define BUFLEN 128 #define QLEN 10 #ifndef HOST_NAME_MAX #define HOST_NAME_MAX 256 #endif extern int initserver(int, struct sockaddr *, socklen_t, int); void serve(int sockfd) { int clfd; FILE *fp; char buf[BUFLEN]; for (;;) { clfd = accept(sockfd, NULL, NULL); if (clfd < 0) { syslog(LOG_ERR, "ruptimed: accept error: %s", strerror(errno)); exit(1); } if ((fp = popen("/usr/bin/uptime", "r")) == NULL) { sprintf(buf, "error: %s\n", strerror(errno)); send(clfd, buf, strlen(buf), 0); } else { while (fgets(buf, BUFLEN, fp) != NULL) send(clfd, buf, strlen(buf), 0); pclose(fp); } close(clfd); } } int main(int argc, char *argv[]) { struct addrinfo *ailist, *aip; struct addrinfo hint; int sockfd, err, n; char *host; if (argc != 1) err_quit("usage: ruptimed"); #ifdef _SC_HOST_NAME_MAX n = sysconf(_SC_HOST_NAME_MAX); if (n < 0) /* best guess */ #endif n = HOST_NAME_MAX; host = malloc(n); if (host == NULL) err_sys("malloc error"); if (gethostname(host, n) < 0) err_sys("gethostname error"); daemonize("ruptimed"); hint.ai_flags = AI_CANONNAME; hint.ai_family = 0; hint.ai_socktype = SOCK_STREAM; hint.ai_protocol = 0; hint.ai_addrlen = 0; hint.ai_canonname = NULL; hint.ai_addr = NULL; hint.ai_next = NULL; if ((err = getaddrinfo(host, "ruptime", &hint, &ailist)) != 0) { syslog(LOG_ERR, "ruptimed: getaddrinfo error: %s", gai_strerror(err)); exit(1); } for (aip = ailist; aip != NULL; aip = aip->ai_next) { if ((sockfd = initserver(SOCK_STREAM, aip->ai_addr, aip->ai_addrlen, QLEN)) >= 0) { serve(sockfd); exit(0); } } exit(1); }
服务器( fork 版本):
#include <stdio.h>
#include <stdlib.h>
#include <netdb.h>
#include <errno.h>
#include <syslog.h>
#include <fcntl.h> #include <sys/socket.h> #include <sys/wait.h> #include "error.h" #define QLEN 10 #ifndef HOST_NAME_MAX #define HOST_NAME_MAX 256 #endif extern int initserver(int, struct sockaddr *, socklen_t, int); void serve(int sockfd) { int clfd, status; pid_t pid; for (;;) { clfd = accept(sockfd, NULL, NULL); if (clfd < 0) { syslog(LOG_ERR, "ruptimed: accept error: %s", strerror(errno)); exit(1); } if ((pid = fork()) < 0) { syslog(LOG_ERR, "ruptimed: fork error: %s", strerror(errno)); exit(1); } else if (pid == 0) { /* child */ /* * The parent called daemonize ({Prog daemoninit}), so * STDIN_FILENO, STDOUT_FILENO, and STDERR_FILENO * are already open to /dev/null. Thus, the call to * close doesn't need to be protected by checks that * clfd isn't already equal to one of these values. */ if (dup2(clfd, STDOUT_FILENO) != STDOUT_FILENO || dup2(clfd, STDERR_FILENO) != STDERR_FILENO) { syslog(LOG_ERR, "ruptimed: unexpected error"); exit(1); } close(clfd); execl("/usr/bin/uptime", "uptime", (char *)0); syslog(LOG_ERR, "ruptimed: unexpected return from exec: %s", strerror(errno)); } else { /* parent */ close(clfd); waitpid(pid, &status, 0); } } } int main(int argc, char *argv[]) { struct addrinfo *ailist, *aip; struct addrinfo hint; int sockfd, err, n; char *host; if (argc != 1) err_quit("usage: ruptimed"); #ifdef _SC_HOST_NAME_MAX n = sysconf(_SC_HOST_NAME_MAX); if (n < 0) /* best guess */ #endif n = HOST_NAME_MAX; host = malloc(n); if (host == NULL) err_sys("malloc error"); if (gethostname(host, n) < 0) err_sys("gethostname error"); daemonize("ruptimed"); hint.ai_flags = AI_CANONNAME; hint.ai_family = 0; hint.ai_socktype = SOCK_STREAM; hint.ai_protocol = 0; hint.ai_addrlen = 0; hint.ai_canonname = NULL; hint.ai_addr = NULL; hint.ai_next = NULL; if ((err = getaddrinfo(host, "ruptime", &hint, &ailist)) != 0) { syslog(LOG_ERR, "ruptimed: getaddrinfo error: %s", gai_strerror(err)); exit(1); } for (aip = ailist; aip != NULL; aip = aip->ai_next) { if ((sockfd = initserver(SOCK_STREAM, aip->ai_addr, aip->ai_addrlen, QLEN)) >= 0) { serve(sockfd); exit(0); } } exit(1); }
无连接的ruptime
客户端:
#include <stdio.h>
#include <stdlib.h>
#include <netdb.h>
#include <errno.h>
#include <sys/socket.h>
#include "error.h" #define BUFLEN 128 #define TIMEOUT 20 void sigalrm(int signo) {} void print_uptime(int sockfd, struct addrinfo *aip) { int n; char buf[BUFLEN]; buf[0] = 0; if (sendto(sockfd, buf, 1, 0, aip->ai_addr, aip->ai_addrlen) < 0) err_sys("sendto error"); alarm(TIMEOUT); if ((n = recvfrom(sockfd, buf, BUFLEN, 0, NULL, NULL)) < 0) { if (errno != EINTR) alarm(0); err_sys("recv error"); } alarm(0); write(STDOUT_FILENO, buf, n); } int main(int argc, char *argv[]) { struct addrinfo *ailist, *aip; struct addrinfo hint; int sockfd, err; struct sigaction sa; if (argc != 2) err_quit("usage: ruptime hostname"); sa.sa_handler = sigalrm; sa.sa_flags = 0; sigemptyset(&sa.sa_mask); if (sigaction(SIGALRM, &sa, NULL) < 0) err_sys("sigaction error"); hint.ai_flags = 0; hint.ai_family = 0; hint.ai_socktype = SOCK_DGRAM; hint.ai_protocol = 0; hint.ai_addrlen = 0; hint.ai_canonname = NULL; hint.ai_addr = NULL; hint.ai_next = NULL; if ((err = getaddrinfo(argv[1], "ruptime", &hint, &ailist)) != 0) err_quit("getaddrinfo error: %s", gai_strerror(err)); for (aip = ailist; aip != NULL; aip = aip->ai_next) { if ((sockfd = socket(aip->ai_family, SOCK_DGRAM, 0)) < 0) { err = errno; } else { print_uptime(sockfd, aip); exit(0); } } fprintf(stderr, "can't contact %s: %s\n", argv[1], strerror(err)); exit(1); }
服务器:
#include <stdio.h>
#include <stdlib.h>
#include <netdb.h>
#include <errno.h>
#include <syslog.h>
#include <sys/socket.h> #include "error.h" #define BUFLEN 128 #define MAXADDRLEN 256 #ifndef HOST_NAME_MAX #define HOST_NAME_MAX 256 #endif extern int initserver(int, struct sockaddr *, socklen_t, int); void serve(int sockfd) { int n; socklen_t alen; FILE *fp; char buf[BUFLEN]; char abuf[MAXADDRLEN]; for (;;) { alen = MAXADDRLEN; if ((n = recvfrom(sockfd, buf, BUFLEN, 0, (struct sockaddr *)abuf, &alen)) < 0) { syslog(LOG_ERR, "ruptimed: recvfrom error: %s", strerror(errno)); exit(1); } if ((fp = popen("/usr/bin/uptime", "r")) == NULL) { sprintf(buf, "error: %s\n", strerror(errno)); sendto(sockfd, buf, strlen(buf), 0, (struct sockaddr *)abuf, alen); } else { if (fgets(buf, BUFLEN, fp) != NULL)