《Unix网络编程》卷1：套接字联网API(第3版)：非阻塞I/O、ioctl操作、路由套接字

全书共31章+附录。


计划安排：吃透这本书，一天三章+源码，并实测代码做当天笔记，CSDN见。
时间安排：计划时间1.5个月 == 6个周末 == 12天。

2017.08.05    第01-03章：TCP/IP简介、传输层、套接字编程简介

2017.08.06    第04-06章：基本TCP编程、TCP客户端/服务器程序、I/O复用

2017.08.12    第07-09章：套接字选项、基本UDP编程、基本SCTP编程(略)

2017.08.13    第10-12章：SCTP客户端/服务器程序例子(略)、名字与地址互换、IPv4和IPv6互操作性

2017.08.19    第13-15章：守护进程和inetd超级服务器、高级I/O、Unix域协议

2017.08.20    第16-18章：非阻塞I/O、ioctl操作、路由套接字
2017.08.26    第19-21章：密钥管理套接字、广播、多播
2017.08.27    第22-24章：高级UDP编程、高级SCTP编程、带外数据
2017.09.02    第25-27章：信号驱动I/O、线程、IP选项
2017.09.03    第28-30章：原始套接字、数据链路访问、客户端/服务器程序设计范式
2017.09.09    第31章-附录：流。附录：IPv4/6协议、调试技术
2017.09.10    整理、总结：思维导图。

>>第16章丶非阻塞式I/O

套接字的默认状态是阻塞的。

这就意味着当发出一个不能立即完成的套接字调用时，其进程将被投入睡眠，等待相应操作完成。

可能阻塞的套接字调用可分为以下4类：

(1) 输入操作：read、readv、recv、recvfrom、recvmsg五个函数。

    如果某个进程对一个阻塞的TCP套接字调用这些输入函数之一，而且该套接字的接收缓冲区中没有数据可读，该进程将被投入睡眠，直到有一些数据到达。

(2) 输出操作：write、writev、send、sendto、sendmsg五个函数。

    对于阻塞的套接字，如果其发送缓冲区中没有空间，进程将被投入睡眠，直到有空间为止。

(3) 接受外来连接：accept函数。

    如果对一个阻塞的套接字调用accept函数，并且尚无新的连接到达，调用进程将被投入睡眠。

(4) 发起外出连接：connect函数(TCP)。

    TCP连接的建立涉及三路握手过程，而且connect函数一直要等到客户收到对于自己的SYN的ACK为止才返回。

非阻塞读和写：str_cli函数

使用非阻塞式I/O的版本，防止进程在可做任何有效工作期间发生阻塞。

/* str_cli函数代码演示 */
/* include nonb1 */
#include	"unp.h"

void
str_cli(FILE *fp, int sockfd)
{
int			maxfdp1, val, stdineof;
ssize_t		n, nwritten;
fd_set		rset, wset;
char		to[MAXLINE], fr[MAXLINE];
char		*toiptr, *tooptr, *friptr, *froptr;

// 使用fctnl把3个描述符都设置为非阻塞模式
val = Fcntl(sockfd, F_GETFL, 0);
Fcntl(sockfd, F_SETFL, val | O_NONBLOCK);

val = Fcntl(STDIN_FILENO, F_GETFL, 0);
Fcntl(STDIN_FILENO, F_SETFL, val | O_NONBLOCK);

val = Fcntl(STDOUT_FILENO, F_GETFL, 0);
Fcntl(STDOUT_FILENO, F_SETFL, val | O_NONBLOCK);

toiptr = tooptr = to;	/* initialize buffer pointers */
friptr = froptr = fr;
stdineof = 0;

maxfdp1 = max(max(STDIN_FILENO, STDOUT_FILENO), sockfd) + 1;
for ( ; ; ) {
FD_ZERO(&rset);
FD_ZERO(&wset);
if (stdineof == 0 && toiptr < &to[MAXLINE])
FD_SET(STDIN_FILENO, &rset);	/* read from stdin */
if (friptr < &fr[MAXLINE])
FD_SET(sockfd, &rset);			/* read from socket */
if (tooptr != toiptr)
FD_SET(sockfd, &wset);			/* data to write to socket */
if (froptr != friptr)
FD_SET(STDOUT_FILENO, &wset);	/* data to write to stdout */

Select(maxfdp1, &rset, &wset, NULL, NULL);
/* end nonb1 第一部分：初始化并调用select */
/* include nonb2 */
if (FD_ISSET(STDIN_FILENO, &rset)) {
if ( (n = read(STDIN_FILENO, toiptr, &to[MAXLINE] - toiptr)) < 0) {
if (errno != EWOULDBLOCK)
err_sys("read error on stdin");

} else if (n == 0) {
#ifdef	VOL2
fprintf(stderr, "%s: EOF on stdin\n", gf_time());
#endif
stdineof = 1;			/* all done with stdin */
if (tooptr == toiptr)
Shutdown(sockfd, SHUT_WR);/* send FIN */

} else {
#ifdef	VOL2
fprintf(stderr, "%s: read %d bytes from stdin\n", gf_time(), n);
#endif
toiptr += n;			/* # just read */
FD_SET(sockfd, &wset);	/* try and write to socket below */
}
}

if (FD_ISSET(sockfd, &rset)) {
if ( (n = read(sockfd, friptr, &fr[MAXLINE] - friptr)) < 0) {
if (errno != EWOULDBLOCK)
err_sys("read error on socket");

} else if (n == 0) {
#ifdef	VOL2
fprintf(stderr, "%s: EOF on socket\n", gf_time());
#endif
if (stdineof)
return;		/* normal termination */
else
err_quit("str_cli: server terminated prematurely");

} else {
#ifdef	VOL2
fprintf(stderr, "%s: read %d bytes from socket\n",
gf_time(), n);
#endif
friptr += n;		/* # just read */
FD_SET(STDOUT_FILENO, &wset);	/* try and write below */
}
}
/* end nonb2 第二部分：从标准输入或套接字读入 */
/* include nonb3 */
if (FD_ISSET(STDOUT_FILENO, &wset) && ( (n = friptr - froptr) > 0)) {
if ( (nwritten = write(STDOUT_FILENO, froptr, n)) < 0) {
if (errno != EWOULDBLOCK)
err_sys("write error to stdout");

} else {
#ifdef	VOL2
fprintf(stderr, "%s: wrote %d bytes to stdout\n",
gf_time(), nwritten);
#endif
froptr += nwritten;		/* # just written */
if (froptr == friptr)
froptr = friptr = fr;	/* back to beginning of buffer */
}
}

if (FD_ISSET(sockfd, &wset) && ( (n = toiptr - tooptr) > 0)) {
if ( (nwritten = write(sockfd, tooptr, n)) < 0) {
if (errno != EWOULDBLOCK)
err_sys("write error to socket");
} else {
#ifdef	VOL2
fprintf(stderr, "%s: wrote %d bytes to socket\n",
gf_time(), nwritten);
#endif
tooptr += nwritten;	/* # just written */
if (tooptr == toiptr) {
toiptr = tooptr = to;	/* back to beginning of buffer */
if (stdineof)
Shutdown(sockfd, SHUT_WR);	/* send FIN */
}
}
}
}
}
/* end nonb3 第三部分：写到标准输出或套接字 */

/* gf_time函数：返回指向时间字符串的指针，包括微秒(12:34:56.123456) */
char *gf_time(void)
{
struct timeval	tv;
time_t			t;
static char		str[30];
char			*ptr;

if (gettimeofday(&tv, NULL) < 0)
err_sys("gettimeofday error");

t = tv.tv_sec;	/* POSIX says tv.tv_sec is time_t; some BSDs don't agree. */
ptr = ctime(&t);
strcpy(str, &ptr[11]);
/* Fri Sep 13 00:00:00 1986\n\0 */
/* 0123456789012345678901234 5  */
snprintf(str+8, sizeof(str)-8, ".%06ld", tv.tv_usec);

return(str);
}

非阻塞connect：时间获取客户程序

/* 代码演示 */
#include	"unp.h"

int connect_nonb(int sockfd, const SA *saptr, socklen_t salen, int nsec)
{
int				flags, n, error;
socklen_t		len;
fd_set			rset, wset;
struct timeval	tval;

// fcntl把套接字设置为非阻塞模式
flags = Fcntl(sockfd, F_GETFL, 0);
Fcntl(sockfd, F_SETFL, flags | O_NONBLOCK);
// 发起非阻塞connect。EINPROGRESS表示连接建立已经启动但是尚未完成。
error = 0;
if ( (n = connect(sockfd, saptr, salen)) < 0)
if (errno != EINPROGRESS)
return(-1);

/* Do whatever we want while the connect is taking place. */
if (n == 0)
goto done;	/* 连接建立 connect completed immediately */

FD_ZERO(&rset);
FD_SET(sockfd, &rset);
wset = rset;
tval.tv_sec = nsec;
tval.tv_usec = 0;
// 调用select等待套接字变为可读或可写
if ( (n = Select(sockfd+1, &rset, &wset, NULL,
nsec ? &tval : NULL)) == 0) {
close(sockfd);		/* timeout */
errno = ETIMEDOUT;
return(-1);
}

if (FD_ISSET(sockfd, &rset) || FD_ISSET(sockfd, &wset)) {
len = sizeof(error);
if (getsockopt(sockfd, SOL_SOCKET, SO_ERROR, &error, &len) < 0)
return(-1);			/* Solaris pending error */
} else
err_quit("select error: sockfd not set");

done:
Fcntl(sockfd, F_SETFL, flags);	/* restore file status flags */

if (error) {
close(sockfd);		/* just in case */
errno = error;
return(-1);
}
return(0);
}

>>第17章丶ioctl操作

网络程序，特别是服务器程序，经常在程序启动执行后使用ioctl获取所在主机全部网络接口信息，包括：接口地址、是否支持广播、是否支持多播等等。

ioctl函数

此函数影响由fd参数引用的一个打开的文件。
#include <sys/ioctl.h>

int ioctl(int d, int request, .../* void *arg */);

网络相关的请求(request)划分为6类：
· 套接字操作(是否位于带外标记等)
· 文件操作(设置或清除非阻塞标志等)
· 接口操作(返回接口列表，获取广播地址等)
· ARP高速缓存操作(创建、修改、获取、删除)
· 路由表操作(增加或删除)
· 流系统

网络相关的ioctl请求总结：

/* 输出主机的硬件地址 - 代码演示 */
#include	"unpifi.h"
#include	<net/if_arp.h>

int main(int argc, char **argv)
{
int					sockfd;
struct ifi_info			*ifi;
unsigned char		*ptr;
struct arpreq		arpreq;
struct sockaddr_in	*sin;

sockfd = Socket(AF_INET, SOCK_DGRAM, 0);
for (ifi = get_ifi_info(AF_INET, 0); ifi != NULL; ifi = ifi->ifi_next) {
printf("%s: ", Sock_ntop(ifi->ifi_addr, sizeof(struct sockaddr_in)));

sin = (struct sockaddr_in *) &arpreq.arp_pa;
memcpy(sin, ifi->ifi_addr, sizeof(struct sockaddr_in));

if (ioctl(sockfd, SIOCGARP, &arpreq) < 0) {
err_ret("ioctl SIOCGARP");
continue;
}

ptr = &arpreq.arp_ha.sa_data[0];
printf("%x:%x:%x:%x:%x:%x\n", *ptr, *(ptr+1),
*(ptr+2), *(ptr+3), *(ptr+4), *(ptr+5));
}
exit(0);
}

>>第18章丶路由套接字

路由套接字支持3种类型的操作：

(1) <root>进程可以通过写出到路由套接字而往内核发送消息，比如路径的增加和删除。

(2) <root>进程可以通过从路由套接字读入而自内核接收消息。

(3) <all>进程可以使用sysctl函数倾泻出路由表或列出所有已配置的接口。

#include <net/if_dl.h>

struct sockaddr_dl {

    uint8_t     sdl_len;

    sa_family_t sdl_family;     /* AF_LINK */

    uint16_t    sdl_index;      /* system assigned index, if>0 */

    uint8_t     sdl_type;       /* IF_ETHER, ect. from <net/if_types.h> */

    uint8_t     sdl_nlen;       /* name length, starting in sdl_data[0] */

    uint8_t     sdl_alen;       /* link-layer address length */

    uint8_t     sdl_slen;       /* link-layer selector length */

    char        sdl_data[12];   /* mininum work area, can be larger; contains i/f name and link-layer address */

};

读和写相关结构体：

struct rt_msghdr;

struct if_msghdr;

struct ifa_msghdr;

struct ifma_msghdr;

struct if_announcemsghdr;

sysctl函数

这个函数使用类似简单网络管理协议中管理信息库的名字。
#include <sys/param.h>

#include <sys/sysctl.h>

int sysctl (int *name, u_int namelen, void *oldp, size_t *oldenp, void *newp, size_t newlen);

/* sysctl函数判断UDP校验是否开启 */
#include	"unproute.h"
#include	<netinet/udp.h>
#include	<netinet/ip_var.h>
#include	<netinet/udp_var.h>		/* for UDPCTL_xxx constants */

int main(int argc, char **argv)
{
int		mib[4], val;
size_t	len;

mib[0] = CTL_NET;
mib[1] = AF_INET;
mib[2] = IPPROTO_UDP;
mib[3] = UDPCTL_CHECKSUM;

len = sizeof(val);
Sysctl(mib, 4, &val, &len, NULL, 0);
printf("udp checksum flag: %d\n", val);

exit(0);
}

特别备注：
由于一些特定的网络编程头文件暂时没办法查找到，很多例程比较难以验证，从代码中先学习其中的编程特点吧，后续针对概述的知识面文字内容会多于例程。

2017.08.20

16-18章基本完成...