[系统运维]TCP客户/服务器程序示例之简单的回射客户/服务器

概述

?TCP回射服务器程序

//#include "unp.h"

//C 标准头文件
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <errno.h>

//系统 I/O 头文件
#include <unistd.h>

//套接字头文件
#include <netinet/in.h>

#define MAXLINE 4096
#define LISTENQ 1024
#define SERV_PORT 9877
#define SA struct sockaddr

void err_sys(const char *str_err)
{
	fprintf(stderr,"%s\n",str_err);
	exit(-1);
}

int Socket(int family,int type,int protocol)
{
	int sockfd;
	if((sockfd = socket(family,type,protocol)) <0)
		err_sys("socket error");

	return sockfd;
}

void Bind(int sockfd,const struct sockaddr *myaddr,socklen_t addrlen)
{
	if(bind(sockfd,myaddr,addrlen) < 0)
		err_sys("bind error");
}

void Listen(int fd,int backlog)
{
	char *ptr;
	if((ptr = getenv("LISTENQ"))!=NULL)
		backlog = atoi(ptr);

	if(listen(fd,backlog) < 0)
		err_sys("listen error");
}

int Accept(int sockfd,struct sockaddr *cliaddr,socklen_t *addrlen)
{
	int connfd;
	connfd = accept(sockfd,cliaddr,addrlen);
	if (connfd < 0)
		err_sys("accept error");

	return connfd;
}

void Close(int sockfd)
{
	if(close(sockfd) < 0)
		err_sys("close error");
}

ssize_t writen(int fd,const void *vptr,size_t n)
{
	size_t nleft;
	ssize_t nwritten;
	const char *ptr;

	ptr = vptr;
	nleft = n;
	while(nleft > 0){
		if((nwritten = write(fd,ptr,nleft)) <= 0){
			if(nwritten <0 && errno == EINTR)
				nwritten = 0;
			else 
				return (-1);
		}

		nleft -= nwritten;
		ptr += nwritten;
	}

	return (n);
}

void Writen(int fd,void *ptr,size_t nbytes)
{	
	if(writen(fd,ptr,nbytes) != nbytes)
		err_sys("writen error");
}


void str_echo(int sockfd)
{
	ssize_t n;
	char buf[MAXLINE];

again:
	//读入缓冲区并回射其中内容
	//read函数从套接字读入数据，writen函数把其中内容回射给客户
	//如果客户关闭连接（这是正常情况），那么接收到客户的FIN将导致
	//服务器子进程的read函数返回0,这又导致str_echo函数的返回，从而
	//终止子进程。
	while((n = read(sockfd,buf,MAXLINE)) > 0)
		Writen(sockfd,buf,n);

	if (n<0 && errno == EINTR)
		goto again;
	else if(n < 0)
		err_sys("str_echo:read error");
}

//TCP回射服务其程序
int main(int argc,char **argv)
{
	int listenfd,connfd;
	pid_t childpid;
	socklen_t clilen;
	struct sockaddr_in cliaddr,servaddr;
	
	//创建套接字，捆绑服务器的众所周知的端口
	listenfd = Socket(AF_INET,SOCK_STREAM,0);
	bzero(&servaddr,sizeof(servaddr));

	servaddr.sin_family = AF_INET;
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	servaddr.sin_port = htons(SERV_PORT);

	Bind(listenfd,(SA *) &servaddr,sizeof(servaddr));

	//listen把该套接字转换成一个监听套接字
	Listen(listenfd,LISTENQ);

	for ( ; ; ){
		//等待完成客户连接
		clilen = sizeof(cliaddr);
		connfd = Accept(listenfd,(SA *) &cliaddr,&clilen);
		
		//并发服务器
		if ((childpid = fork()) == 0) {	//子进程
			Close(listenfd);	//关闭监听套接字
			
			str_echo(connfd);	//处理请求
		
			exit(0);
		}
		Close(connfd); //父进程关闭已连接套接字
	}
}

?TCP回射客户端程序

//#include "unp.h"

//C 标准头文件
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <errno.h>

//系统 I/O 头文件
#include <unistd.h>

//套接字头文件
#include <netinet/in.h>
#include <arpa/inet.h>

#define MAXLINE 4096
#define SERV_PORT 9877
#define SA struct sockaddr

void err_sys(const char *str_err)
{
	fprintf(stderr,"%s\n",str_err);
	exit(-1);
}

void err_quit(const char *str_err)
{
	fprintf(stderr,"%s\n",str_err);
	exit(-1);
}

int Socket(int family,int type,int protocol)
{
	int sockfd;
	if((sockfd = socket(family,type,protocol)) <0)
		err_sys("socket error");

	return sockfd;
}
 
void Connect(int sockfd, const struct sockaddr *myaddr, socklen_t addrlen)
{
	if (connect(sockfd, myaddr, addrlen) < 0)
		err_sys("connect error");
}


ssize_t writen(int fd,const void *vptr,size_t n)
{
	size_t nleft;
	ssize_t nwritten;
	const char *ptr;

	ptr = vptr;
	nleft = n;
	while(nleft > 0){
		if((nwritten = write(fd,ptr,nleft)) <= 0){
			if(nwritten <0 && errno == EINTR)
				nwritten = 0;
			else 
				return (-1);
		}

		nleft -= nwritten;
		ptr += nwritten;
	}

	return (n);
}

void Writen(int fd,void *ptr,size_t nbytes)
{	
	if(writen(fd,ptr,nbytes) != nbytes)
		err_sys("writen error");
}

static int	read_cnt;
static char	*read_ptr;
static char	read_buf[MAXLINE];
 
static	ssize_t my_read(int fd, char *ptr)
{
	if (read_cnt <= 0) {
		for ( ; ; ) {
			if ( (read_cnt = read(fd, read_buf, sizeof(read_buf))) < 0) {
				if (errno == EINTR) 
					continue;
				return -1;
			}else if (read_cnt == 0)
				return 0;
			 
			read_ptr = read_buf;		
			break;
		}
	}
 
	read_cnt--;
	*ptr = *read_ptr++;
	return 1;
}
 
ssize_t readline(int fd, void *vptr, size_t maxlen)
{
	ssize_t	n;
	ssize_t	rc;
	char	c;
	char	*ptr;
 
	ptr = vptr;
	for (n=1; n<maxlen; n++) {
		if ( (rc = my_read(fd, &c)) == 1) {
				*ptr++ = c;
				if (c == '\n')
					break;
		} else if (rc == 0) {
				*ptr = 0;		/* EOF, n - 1 bytes were read */
				return n-1;
		} else {
				return -1;
		}
	}
 
	*ptr = 0;
	return n;
}
 
ssize_t Readline(int fd, void *ptr, size_t maxlen)
{
	ssize_t	n;
 
	if ( (n = readline(fd, ptr, maxlen)) < 0)
		err_sys("readline error");
	return n;
}

char *Fgets(char *ptr,int n,FILE *stream)
{
	char *rptr;
	if((rptr = fgets(ptr,n,stream)) == NULL && ferror(stream))
		err_sys("fgets error");

	return rptr;
}

void Fputs(const char *ptr,FILE *stream)
{
	if(fputs(ptr,stream) == EOF)
		err_sys("puts error");
}

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

	//fgets读入一行文本，writen把改行发送给服务器
	while (Fgets(sendline,MAXLINE,fp) != NULL){
		Writen(sockfd,sendline,strlen(sendline));
		
		//readline从服务器读入回射行，fputs把它写到标准输出
		if(Readline(sockfd,recvline,MAXLINE) == 0)
			err_quit("str_cli: server terminated prematurely");

		Fputs(recvline,stdout);
	}
	//当遇到文件结束符或发生错误时，fgets将返回一个空指针，于是客户处理循环终止。
	//我们的Fgets包裹函数检查是否发生错误，若发生则终止进程，因此Fgets只是在遇到
	//文件结束符时才返回一个空指针，
}

//TCP回射客户程序
int main(int argc, char **argv)
{
	int sockfd;
	struct sockaddr_in servaddr;

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

	//创建套接字，装填网际网套接字地址结构
	sockfd = Socket(AF_INET,SOCK_STREAM,0);

	bzero(&servaddr,sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_port = htons(SERV_PORT);
	inet_pton(AF_INET,argv[1],&servaddr.sin_addr);

	//连接到服务器
	Connect(sockfd,(SA *) &servaddr,sizeof(servaddr));

	str_cli(stdin,sockfd);

	exit(0);
}

运行结果

??????? 首先我们在后台启动服务器，它调用socket,bind,linsten,accept ，并阻塞于accept调用（我们还没有启动客户）。在启动客户之前，我们运行netstat程序来检查服务器监听套接字的状态。

????????接着，在同一个主机上启动客户，并指定服务器主机的IP地址为 127.0.0.1（环回地址）。

客户调用socket,connect,后者引起TCP的三路握手过程。当三路握手完成后，客户中的connect和服务器中的accept均返回，连接于是建立。接着发生如下步骤：

正常终止

?????? 键入终端EOF字符（Ctrl+D）以终止客户。此时立即执行netstat命令，我们将看到如下效果：

??????? 当前连接的客户端进入了TIME_WAIT状态，而监听服务器仍在等待另一个客户的连接。（我们使命令netstat的输出通过管道作为grep的输入，从而只输出与服务器的众所周知端口相关的文本行，这样做也删除了标题行。）

正常终止客户和服务器的步骤：

• (1)? 当我们键入EOF字符时，fgets返回- 一个空指针，于是str_ cli函数返回。
• (2)? 当str_ _cli返回到客户的main函数时，main通过调用exit终止。
• (3)? 进程终止处理的部分工作是关闭所有打开的描述符，因此客户打开的套接字由内核关闭。这导致客户TCP发送一个FIN给服务器，服务器TCP则以ACK响应，这就是TCP连接终止序列的前半部分。至此，服务器套接字处于CLOSE _WAIT状态， 客户套接字则处于FIN _WAIT 2状态。
• (4)? 当服务器TCP接收FIN时，服务器子进程阻塞于readline调用， 于是readline返回0。这导致str_ echo函数返回服务器子进程的main函数。
• (5)? 服务器子进程通过调用exit来终止。
• (6)? 服务器子进程中打开的所有描述符随之关闭。由子进程来关闭已连接套接字会引发TCP连接终止序列的最后两个分节:一个从服务器到客户的FIN和一个从客户到服务器的ACK。 至此，连接完全终止，客户套接字进入TIME_ WAIT状态。
• (7)? 进程终止处理的另一部分内容是: 在服务器子进程终止时，给父进程发送一个SIGCHLD信号。这一点在本例中发生了，但是我们没有在代码中捕获该信号，而该信号的默认行为是被忽略。既然父进程未加处理，子进程于是进入僵死状态。

我们必须清理僵死进程，这就涉及Unix信号的处理。