UNIX网络编程卷1 回射客户程序 TCP客户程序设计范式

时间：2014-08-25 23:00:15 阅读：580 评论：0 收藏：0 [点我收藏+]

本文为senlie原创，转载请保留此地址：http://blog.csdn.net/zhengsenlie

下面我会介绍同一个使用 TCP 协议的客户端程序的几个不同版本，分别是停等版本、select 加阻塞式 I/O 版本、

非阻塞式 I/O 版本、fork 版本、线程化版本。它们都由同一个 main 函数调用来实现同一个功能，即回射程序客户端。
它从标准输入读入一行文本，写到服务器上，读取服务器对该行的回射，并把回射行写到标准输出上。

其中，非阻塞式 I/O 版本是所有版本中执行速度最快的，但它的代码比较复杂。
创建一个新线程通常比使用 fork 派生一个新进程快得多，
下面代码中的线程化版本执行速度略快于 fork版本，稍慢于非阻塞式 I/O。一般编程推荐使用线程版本。
下面是《Unix 网络编程：卷1》中给出的各个版本的性能测试结果：
354.0秒，停等版本
12.3秒， select加阻塞式I/O版本
6.9秒，非阻塞式I/O版本
8.7秒， fork 版本
8.5秒，线程化版本

下面是 main 函数的代码

#include	"unp.h"


int
main(int argc, char **argv)
{
	int					sockfd;
	struct sockaddr_in	servaddr;


	if (argc != 2)
		err_quit("usage: tcpcli <IPaddress>");


	//1.创建 TCP 套接字
	sockfd = Socket(AF_INET, SOCK_STREAM, 0);


	//2.指定服务器的 IP 地址和端口
	bzero(&servaddr, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_port = htons(SERV_PORT);
	Inet_pton(AF_INET, argv[1], &servaddr.sin_addr);


	//3.建立与服务器的连接
	Connect(sockfd, (SA *) &servaddr, sizeof(servaddr));


	//4.str_cli 函数完成剩余部分的客户处理工作
	str_cli(stdin, sockfd);		


	exit(0);
}

最初代码(停等版本)：

#include	"unp.h"


void
str_cli(FILE *fp, int sockfd)
{
	char	sendline[MAXLINE], recvline[MAXLINE];


	//1.从 fp 读入一行，存放到 sendline
	while (Fgets(sendline, MAXLINE, fp) != NULL) {
		//2.将 sendline 的内容写到 sockfd 连接的服务器
		Writen(sockfd, sendline, strlen(sendline));


		//3.从服务器读入回射行，存放到 recvline
		if (Readline(sockfd, recvline, MAXLINE) == 0)
			err_quit("str_cli: server terminated prematurely");


		//4.将 recvline 的内容写到标准输出
		Fputs(recvline, stdout);
	}
}

问题1：当套接字上发生某些事件时，客户可能阻塞于 fgets 调用
改善1：使用 select 重写 str_cli 函数，阻塞于 select 调用，或是等待标准输入可读，
或是等待套接字可读。这样服务器一终止，客户就能马上得到通知。

/**
* TCP 使用 select
**/
#include	"unp.h"


void
str_cli(FILE *fp, int sockfd)
{
	int			maxfdp1; //  maxfdpl 参数指定待测定的描述符个数
	fd_set		rset;   //可读描述符集合
	char		sendline[MAXLINE], recvline[MAXLINE];


	//1.调用 select
	FD_ZERO(&rset); //初始化 rset
	for ( ; ; ) {
		FD_SET(fileno(fp), &rset); // 打开标准I/O文件指针 fp 对应的位
		FD_SET(sockfd, &rset); 	  // 打开套接字 sockfd 对应的位
		maxfdp1 = max(fileno(fp), sockfd) + 1;
		//调用 select 阻塞到某个描述符就绪为止
		Select(maxfdp1, &rset, NULL, NULL, NULL);


		//2.处理可读套接字
		if (FD_ISSET(sockfd, &rset)) {	
			//使用 readline 读入回射文本，再用 fputs 输出到 stdout
			if (Readline(sockfd, recvline, MAXLINE) == 0)
				err_quit("str_cli: server terminated prematurely");
			Fputs(recvline, stdout);
		}


		//3.处理可读输入
		if (FD_ISSET(fileno(fp), &rset)) { 
			//使用 fgets 读入一行文本，再用 writen 把它写到套接字中
			if (Fgets(sendline, MAXLINE, fp) == NULL)
				return;		/* all done */
			Writen(sockfd, sendline, strlen(sendline));
		}
	}
}

改善1的问题：批量方式运行用 select 编写的回射客户程序，发现即使已经遇到了用户输入结尾，
仍可能有数据处于运往或来自服务器的管道中。
改善2(select加阻塞式I/O版本)：使用 shutdown 函数利用上 TCP 的半关闭特性
下面代码使用了 select 和 shutdown，前者只要服务器关闭它那一端的连接就会通知客户，
后者允许客户正确地处理批量输入。这个版本还废弃了以文本行为为中心的代码，发布针对缓冲区操作。

/**
* TCP 使用 select 并操纵缓冲区
**/
#include	"unp.h"


void
str_cli(FILE *fp, int sockfd)
{
	//stdineof 表示标准输入是否结束
	int			maxfdp1, stdineof; 
	fd_set		rset;
	char		buf[MAXLINE];
	int		n;


	//1.调用 select
	stdineof = 0;
	FD_ZERO(&rset);
	for ( ; ; ) {
		if (stdineof == 0)
			FD_SET(fileno(fp), &rset);
		FD_SET(sockfd, &rset);
		maxfdp1 = max(fileno(fp), sockfd) + 1;
		Select(maxfdp1, &rset, NULL, NULL, NULL);


		//2.处理可读套接字
		if (FD_ISSET(sockfd, &rset)) {	/* socket is readable */
			if ( (n = Read(sockfd, buf, MAXLINE)) == 0) {
				if (stdineof == 1) //如果在套接字上读到 EOF，并且已在标准输入上遇到 EOF，那就是正常的终止
					return;		
				else //否则，服务器进程过早终止了
					err_quit("str_cli: server terminated prematurely");
			}


			Write(fileno(stdout), buf, n);
		}


		//3.处理可读输入
		if (FD_ISSET(fileno(fp), &rset)) {  
			//如果在标准输入上碰到 EOF 时，把 stdineof 置为 1
			//并调用 shutdown 函数向服务器发送 FIN，关闭客户端向服务器的写操作
			if ( (n = Read(fileno(fp), buf, MAXLINE)) == 0) { 
				stdineof = 1;
				Shutdown(sockfd, SHUT_WR);	
				FD_CLR(fileno(fp), &rset);
				continue;
			}


			Writen(sockfd, buf, n);
		}
	}
}

改善2问题：阻塞式I/O
例如，如果在标准输入有一行文本可读，我们就调用 read 读入它，再调用 writen 把它发送给服务器。
然而如果套接字发送缓冲区已满， writen 调用将会阻塞。在进程阻塞于 writen 调用期间，可能有来自套接字接收缓冲区的数据可供读取。
类似的，如果从套接字有一行输入文本可读，那么一旦标准输出比网络还要慢，进程照样可能阻塞于后续的 write 调用。
改善3(非阻塞式I/O版本)：使用非阻塞式 I/O

/* 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];
	//to 容纳从标准输入到服务器去的数据
	//from 容纳自服务器到标准输出来的数据
	char		*toiptr, *tooptr, *friptr, *froptr;


	//1.把描述符设置为非阻塞
	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); //标准输出


	//2.初始化缓冲区指针
	toiptr = tooptr = to;	
	friptr = froptr = fr;
	stdineof = 0;
	maxfdp1 = max(max(STDIN_FILENO, STDOUT_FILENO), sockfd) + 1;
	
	//3.主循环：调用 select 
	//一个 select 调用后对所关注各个条件进行单独测试
	for ( ; ; ) {
		//指定所关注的描述符
		FD_ZERO(&rset);
		FD_ZERO(&wset);
		if (stdineof == 0 && toiptr < &to[MAXLINE])
			FD_SET(STDIN_FILENO, &rset);	/* 打开读描述符集中对应标准输入的位 */
		if (friptr < &fr[MAXLINE])
			FD_SET(sockfd, &rset);			/* 打开读描述符集中对应套接字的位 */
		if (tooptr != toiptr)
			FD_SET(sockfd, &wset);			/* 打开写描述符集中对应套接字的位 */
		if (froptr != friptr)
			FD_SET(STDOUT_FILENO, &wset);	/* 打开写描述符集中对应标准输出的位 */
		//调用 select
		Select(maxfdp1, &rset, &wset, NULL, NULL);
/* end nonb1 */
/* include nonb2 */
		//4.对所关注各个条件进行单独测试
		//从标准输入 read
		if (FD_ISSET(STDIN_FILENO, &rset)) {
			//read 返回错误。 EWOULDBLOCK 是正常的错误，表明这个描述符还处在阻塞中，应该忽略该错误
			if ( (n = read(STDIN_FILENO, toiptr, &to[MAXLINE] - toiptr)) < 0) {
				if (errno != EWOULDBLOCK) 
					err_sys("read error on stdin");


			} 
			//read 返回 EOF，标准输入处理结束
			else if (n == 0) {
#ifdef	VOL2
				fprintf(stderr, "%s: EOF on stdin\n", gf_time());
#endif
				stdineof = 1;			/* 标志标准输入结束 */
				if (tooptr == toiptr)   // to 缓冲区中已经没有数据要发送
					Shutdown(sockfd, SHUT_WR);/* 关闭客户端向服务器的写操作 */


			} 
			//read 返回数据
			else {
#ifdef	VOL2
				fprintf(stderr, "%s: read %d bytes from stdin\n", gf_time(), n);
#endif
				toiptr += n;			//增加 toiptr
				FD_SET(sockfd, &wset);	//打开写描述符集中对应套接字的位
			}
		}


		//从套接字 read
		if (FD_ISSET(sockfd, &rset)) {
			//read 返回错误。 EWOULDBLOCK 是正常的错误，表明这个描述符还处在阻塞中，应该忽略该错误
			if ( (n = read(sockfd, friptr, &fr[MAXLINE] - friptr)) < 0) {
				if (errno != EWOULDBLOCK) 
					err_sys("read error on socket");


			} 
			//read 返回 EOF，服务器返回数据结束
			else if (n == 0) {
#ifdef	VOL2
				fprintf(stderr, "%s: EOF on socket\n", gf_time());
#endif
				if (stdineof) //如果遇到来自服务器的 EOF ，并且已经在标准输入上遇到 EOF ,则正常结束；否则就是服务器过早终止了
					return;		/* normal termination */
				else
					err_quit("str_cli: server terminated prematurely");


			} 
			//read 返回数据
			else {
#ifdef	VOL2
				fprintf(stderr, "%s: read %d bytes from socket\n",
								gf_time(), n);
#endif
				friptr += n;		//增加 friptr
				FD_SET(STDOUT_FILENO, &wset);	// 打开写描述符集中对应标准输出的位
			}
		}
/* end nonb2 */
/* include nonb3 */
		//write 到标准输出
		if (FD_ISSET(STDOUT_FILENO, &wset) && ( (n = friptr - froptr) > 0)) {
			//write 返回错误。 
			if ( (nwritten = write(STDOUT_FILENO, froptr, n)) < 0) {
				if (errno != EWOULDBLOCK)
					err_sys("write error to stdout");


			} 
			//write 成功
			else {
#ifdef	VOL2
				fprintf(stderr, "%s: wrote %d bytes to stdout\n",
								gf_time(), nwritten);
#endif
				froptr += nwritten;		//增加写出字节数
				if (froptr == friptr)
					froptr = friptr = fr;	//如果输出指针追上输入指针， 这两个指针不同时恢复为指向缓冲区开始处
			}
		}


		//write 到套接字
		if (FD_ISSET(sockfd, &wset) && ( (n = toiptr - tooptr) > 0)) {
			//write 失败
			if ( (nwritten = write(sockfd, tooptr, n)) < 0) {
				if (errno != EWOULDBLOCK)
					err_sys("write error to socket");


			} 
			//write 成功
			else {
#ifdef	VOL2
				fprintf(stderr, "%s: wrote %d bytes to socket\n",
								gf_time(), nwritten);
#endif
				tooptr += nwritten;	
				if (tooptr == toiptr) { //
					toiptr = tooptr = to;	
					if (stdineof) //如果标准输入已经读完，并且已经缓冲区的数据都已经发送给服务器，就关闭写套接字
						Shutdown(sockfd, SHUT_WR);	/* send FIN */
				}
			}
		}
	}
}
/* end nonb3 */

改善3问题：非阻塞式版本比较复杂
改善4：需要使用非阻塞I/O时，更简单的方法是把应用程序任务划分到多个进程(使用 fork) 或多个线程

fork 版本：

/**
* TCP 使用两个进程 (fork)
**/
#include	"unp.h"


void
str_cli(FILE *fp, int sockfd)
{
	pid_t	pid;
	char	sendline[MAXLINE], recvline[MAXLINE];


	//子进程：从服务器读取数据并输出到 stdout
	if ( (pid = Fork()) == 0) {		
		while (Readline(sockfd, recvline, MAXLINE) > 0)
			Fputs(recvline, stdout);
		
		kill(getppid(), SIGTERM);	/* 子进程向父进程发送一个 SIGTERM 信号，终止父进程 */
		exit(0);
	}


	//父进程：从 stdin 读取数据并发送到服务器
	while (Fgets(sendline, MAXLINE, fp) != NULL)
		Writen(sockfd, sendline, strlen(sendline));


	//在 stdin 读取 EOF，输入结束，关闭写套接字
	Shutdown(sockfd, SHUT_WR);	/* EOF on stdin, send FIN */
	
	//父进程完成数据凰调用 pause 让自己进入睡眠状态
	pause();
	return;
}

线程化版本：

/**
* TCP 使用两个线程
**/
#include	"unpthread.h"


void	*copyto(void *);


static int	sockfd;		/* global for both threads to access */
static FILE	*fp;


void
str_cli(FILE *fp_arg, int sockfd_arg)
{
	char		recvline[MAXLINE];
	pthread_t	tid;


	//1.把参数保存在外部变量中
	sockfd = sockfd_arg;	/* copy arguments to externals */
	fp = fp_arg;


	//2.创建新线程
	Pthread_create(&tid, NULL, copyto, NULL);


	//3.主线程循环：从套接字到标准输出复制
	while (Readline(sockfd, recvline, MAXLINE) > 0)
		Fputs(recvline, stdout);
}


//4.copyto 线程：从标准输入到套接字复制
void *
copyto(void *arg)
{
	char	sendline[MAXLINE];


	while (Fgets(sendline, MAXLINE, fp) != NULL)
		Writen(sockfd, sendline, strlen(sendline));


	Shutdown(sockfd, SHUT_WR);	/* EOF on stdin, send FIN */


	return(NULL);
		/* 4return (i.e., thread terminates) when EOF on stdin */
}

UNIX网络编程卷1 回射客户程序 TCP客户程序设计范式

原文：http://blog.csdn.net/zhengsenlie/article/details/38826819

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)