TCP/IP网络编程——习题答案

/*****************************tcp_serv.c*********************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include#include#includevoid error_handling(char *message);

int main(int argc, char *argv[])
{
	int serv_sock;
	int clnt_sock;

	struct sockaddr_in serv_addr;
	struct sockaddr_in clnt_addr;
	socklen_t clnt_addr_size;

	char message[]="Hello World!";
	
	if(argc!=2){
		printf("Usage : %s\n", argv[0]);
		exit(1);
	}
	
	serv_sock=socket(PF_INET, SOCK_STREAM, 0);
	if(serv_sock == -1)
		error_handling("socket() error");
	
	memset(&serv_addr, 0, sizeof(serv_addr));
	serv_addr.sin_family=AF_INET;
	serv_addr.sin_addr.s_addr=htonl(INADDR_ANY);
	serv_addr.sin_port=htons(atoi(argv[1]));
	
	if(bind(serv_sock, (struct sockaddr*) &serv_addr, sizeof(serv_addr))==-1)
		error_handling("bind() error"); 
	
	if(listen(serv_sock, 5)==-1)
		error_handling("listen() error");
	
	clnt_addr_size=sizeof(clnt_addr);  
	clnt_sock=accept(serv_sock, (struct sockaddr*)&clnt_addr,&clnt_addr_size);
	if(clnt_sock==-1)
		error_handling("accept() error");  
	
	write(clnt_sock, message, 4);            //多次次调用write函数传输数据 write(clnt_sock, message+4, 4);
	write(clnt_sock, message+8, 4);
	write(clnt_sock, message+12, sizeof(message)-12);

	close(clnt_sock);
	return 0;
}

void error_handling(char *message)
{
	fputs(message, stderr);
	fputc('\n', stderr);
	exit(1);
}

/*****************************tcp_clnt.c*********************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include#include#includevoid error_handling(char *message);

int main(int argc, char* argv[])
{
	int sock;
	struct sockaddr_in serv_addr;
	char message[30];
	int str_len=0;
	int idx=0, read_len=0, i;
	
	if(argc!=3){
		printf("Usage : %s\n", argv[0]);
		exit(1);
	}
	
	sock=socket(PF_INET, SOCK_STREAM, 0);
	if(sock == -1)
		error_handling("socket() error");
	
	memset(&serv_addr, 0, sizeof(serv_addr));
	serv_addr.sin_family=AF_INET;
	serv_addr.sin_addr.s_addr=inet_addr(argv[1]);
	serv_addr.sin_port=htons(atoi(argv[2]));
		
	if(connect(sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr))==-1) 
		error_handling("connect() error!");

	for(i=0; i<100; i++) //busy waiting!! printf("Wait time %d \n", i); read(sock, message, sizeof(message)); printf("Message from server: %s \n", message); close(sock); return 0; } void error_handling(char *message) { fputs(message, stderr); fputc('\n', stderr); exit(1); }</unistd.h></string.h></stdlib.h></stdio.h></unistd.h></string.h></stdlib.h></stdio.h>

第三章 地址族与数据序列

(1)IP地址族IPv4和IPv6有何区别？在何种背景下诞生了IPv6?

IPV4是4字节地址族，IPV6是16字节地址族。IPV6的诞生是为了应对2010年前后IP地址耗尽的问题而提出的标准。

(2)通过IPV4网络ID、主机ID及路由器的关系说明向公司局域网中的计算机传输数据的过程

向目标主机传输数据，首先向目标IP所属的网络传输数据。此时使用的是IP地址中的网络ID。数据传到路由器，路由器将参照IP地址的主机号查找路由表，从对应的网口发送数据，数据经过路由器转发最终送到目标主机。

(3)套接字地址分为IP地址和端口号。为什么需要IP地址和端口号？或者说，通过IP可以区分哪些对象？通过端口号可以区分哪些对象？

IP地址是为了区分网络上的主机。端口号是区分同一主机下的不同的SOCKET，以确保程序进程都能准确收发数据。

(4)请说明IP地址分类方法，并说出下面这些IP地址的分类

(5)计算机通过路由器或交换机连接到互联网。请说出路由器和交换机的作用

路由器：是连接两个或多个网络的硬件设备，在网络间起网关的作用，是读取每一个数据包中的地址然后决定如何传送的专用智能性的网络设备。(作用于网络层，寻址，转发(依靠 IP 地址)）
交换机：是一种用于电（光）信号转发的网络设备。(一般作用于链路层，过滤，转发(依靠 MAC 地址))

(6)什么是知名端口？其范围是多少？知名端口中具有代表性的HTTP合同FTP端口号各是多少？

“知名端口(Well-known PROT)”是指预定分配给特定操作的端口。其范围是0~1023，其中最知名的端口是HTTP:80端口和TCP:21。

(7)题目大概意思是：为什么bind中第二个参数是sockaddr，但是传入的是sockaddr_in

bind函数第二个参数类型sockaddr结构体，很难分配IP地址和端口号的空间大小(因为结构体sockaddr并非只为IPv4设计，所以要兼容)，所以sockaddr结构体内将IP地址和端口号合并到一起，用一个成员 sa_data 表示。因此对于不同类型网络的IP地址和PORT号的分配是可先通过sockaddr_in完成，之后再强制转换成sockaddr类型。（因为两个结构体的长度相同，都是16字节，强制转换类型时不会丢失字节，也没有多余的字节）

(8)请解释大端序、小端序、网络字节序，并说明为何需要网络字节序

小端序是把高位字节存储到高位地址上；大端序是把高位字节存储到低位地址上。因为保存栈的方式有差异，所以对网络传输数据的过程制定了标准，这就是“网路字节序”。而且，在网络字节序中，数据传输的标准是“大端序”。

(9)大端计算机希望将4字节整型数据12传到小端序计算机。请说出数据传输过程中发生的字节序变换过程

因为网络字节序的顺序标准是“大端序”，所以大端序的计算机在网络传输中不需要先转换字节顺序，直接传输。但是接受数据的是小端序计算机，因此，要经过网络转本地序的过程，再保存到存储设备上。

(10)怎么表示回送地址？其含义是什么？如果向回送地址传输数据将会发生什么情况？

回送地址表示计算机本身，为127.0.0.1。因此，如果将数据传送到IP地址127.0.0.1，数据不进行网络传输而是直接返回。

第四章 基于TCP的服务器端/客户端(1)

(1)请说明TCP/IP的4层协议栈，并说明TCP和UDP套接字经过的层级结构差异

链路层—>IP层—>TCP层—>应用层
链路层—>IP层—>UDP层—>应用层

(2)请说出TCP/IP协议栈中链路层和IP层的作用，并给出两者关系。

数据链路层通过各种控制协议，将有差错的物理信道变为无差错的、能可靠传输数据帧的数据链路。为IP 层提供数据传送服务。
网络层通过路由选择算法，为分组选择最适当的路径，实现两个端系统之间的数据透明传送。

(3)为何需要把TCP/IP协议栈分成4层（或7层）？结合开放式系统回答

(4)客户端调用connect函数向服务器端发送连接请求。服务器端调用哪个函数后，客户端可以调用connect函数？

调用listen函数设置好服务端监听套接字后。

(5)什么时候创建连接请求等待队列？它有何作用？与accept有什么关系

调用listen函数时创建了连接请求等待队列。它是存储客户端连接请求信息的空间。accept函数调用后，将从连接请求队列中取出连接请求信息，并与相应客户端建立连接。

(6)客户端中为何不需要调用bind函数分配地址？如果不调用bind函数，那何时、如何向套接字分配IP地址和端口号？

客户端是请求连接的程序，不是一个接收连接的程序。所以，服务器的地址信息是更重要的因素，没有必要通过bind函数明确地分配地址信息。但是，要想和服务器通信，必须将自己的地址信息分配到套接字上，因此，在connect函数调用时，自动把IP地址和端口号输入到套接字上。

(7)把第1章的hello_server.c和hello_server_win.c改成迭代服务器端，并理由客户端测试更改是否准确

#include  #include  #include  #include  #include  #include  void error_handling(char *message); int main(int argc, char *argv[]) { int serv_sock; int clnt_sock; struct sockaddr_in serv_addr; struct sockaddr_in clnt_addr; socklen_t clnt_addr_size; char message[]="Hello World!"; if(argc!=2){ printf("Usage : %s\n", argv[0]); exit(1);
    }
    
    serv_sock=socket(PF_INET, SOCK_STREAM, 0); if(serv_sock == -1)
        error_handling("socket() error"); memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family=AF_INET;
    serv_addr.sin_addr.s_addr=htonl(INADDR_ANY);
    serv_addr.sin_port=htons(atoi(argv[1])); if( bind(serv_sock, (struct sockaddr*) &serv_addr, sizeof(serv_addr))==-1 )
        error_handling("bind() error"); if( listen(serv_sock, 5)==-1 )
        error_handling("listen() error");
    
    clnt_addr_size=sizeof(clnt_addr); while(1)
    {
        clnt_sock=accept(serv_sock, (struct sockaddr*)&clnt_addr,&clnt_addr_size); if(clnt_sock==-1) break;  
        
        write(clnt_sock, message, sizeof(message));
        close(clnt_sock);
    }
    close(serv_sock); return 0;
}  void error_handling(char *message) { fputs(message, stderr);
    fputc('\n', stderr); exit(1);
}

第五章 基于TCP的服务器端/客户端(2)

(1)请说明TCP套接字连接设置的三次握手过程。尤其是3次数据交换过程每次收发的数据内容

• 第一次握手：客户端给服务端发一个 SYN 报文段，并指明客户端的初始化序列号 ISN(c)。此时客户端处于 SYN_SENT 状态。（在SYN报文段中同步位SYN=1，初始序号seq=x）SYN=1的报文段不能携带数据，但要消耗掉一个序号。
• 第二次握手：服务器收到客户端的 SYN 报文段之后，会以自己的 SYN 报文段作为应答，并且也是指定了自己的初始化序列号 ISN(s)。同时会把客户端的 ISN(c) + 1 作为ACK 的值，表示自己已经收到了客户端的 SYN报文，此时服务器处于 SYN_RCVD 的状态。（在SYN ACK报文段中SYN=1，ACK=1，确认号ack=x+1，初始序号seq=y）
• 第三次握手：客户端收到 SYN 报文之后，会发送一个 ACK 报文，当然，也是一样把服务器的 ISN(s) + 1 作为 ACK 的值，表示已经收到了服务端的 SYN 报文，此时客户端处于 ESTABLISHED 状态。服务器收到 ACK 报文之后，也处于 ESTABLISHED 状态，此时，双方已建立起了连接。（在ACK报文段中ACK=1，确认号ack=y+1，序号seq=x+1）ACK报文段可以携带数据，不携带数据则不消耗序号（第二次握手的既是ACK也是SYN报文段所以不可以）

(2)TCP是可靠的数据传输协议，但在通过网络通信的过程可能丢失数据。请通过ACK和SEQ说明TCP通过何种机制保证丢失数据的可靠传输。

(3)TCP套接字中调用write和read函数时数据如何移动？结合I/O缓冲进行说明

(4)对方主机的输入缓冲剩余50字节空间时，若本方主机通过write函数请求传输70字节，问TCP如何处理这种情况？

(5)第2章示例tcp_server.c(第一章的hello_server.c)和tcp_client.c中，客户端接收服务器端传输的字符串后便退出。现更改程序，使服务器端和客户端各传送1次字符串。考虑到使用TCP协议，所以传输字符串前先以4字节整数型方式传递字符串长度。另外，不限制字符串传输顺序及种类，但必须进行3次数据交换。

/**********************************sendrecv_serv.c***********************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include#include#includevoid error_handling(char *message);

int main(int argc, char *argv[])
{
	int serv_sock;
	int clnt_sock;
	int str_len, i;

	struct sockaddr_in serv_addr;
	struct sockaddr_in clnt_addr;
	socklen_t clnt_addr_size;

	char msg1[]="Hello client!";
	char msg2[]="I'm server.";
	char msg3[]="Nice to meet you.";
	char* str_arr[]={msg1, msg2, msg3};        //指针数组，保存三个字符串指针
	char read_buf[100];
	
	if(argc!=2){
		printf("Usage : %s\n", argv[0]);
		exit(1);
	}
	
	serv_sock=socket(PF_INET, SOCK_STREAM, 0);
	if(serv_sock == -1)
		error_handling("socket() error");
	
	memset(&serv_addr, 0, sizeof(serv_addr));
	serv_addr.sin_family=AF_INET;
	serv_addr.sin_addr.s_addr=htonl(INADDR_ANY);
	serv_addr.sin_port=htons(atoi(argv[1]));
	
	if(bind(serv_sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr))==-1)
		error_handling("bind() error"); 
	
	if(listen(serv_sock, 5)==-1)
		error_handling("listen() error");
	
	clnt_addr_size=sizeof(clnt_addr);  
	clnt_sock=accept(serv_sock, (struct sockaddr*)&clnt_addr,&clnt_addr_size);
	if(clnt_sock==-1)
		error_handling("accept() error");  
	
	for(i=0; i<3; i++) { str_len=strlen(str_arr[i])+1; write(clnt_sock, (char*)(&str_len), 4); write(clnt_sock, str_arr[i], str_len); read(clnt_sock, (char*)(&str_len), 4); read(clnt_sock, read_buf, str_len); puts(read_buf); } close(clnt_sock); close(serv_sock); return 0; } void error_handling(char *message) { fputs(message, stderr); fputc('\n', stderr); exit(1); } /***************************************recvsend_clnt.c***************************/ #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include#include#includevoid error_handling(char *message);

int main(int argc, char* argv[])
{
	int sock;
	struct sockaddr_in serv_addr;

	char msg1[]="Hello server!";
	char msg2[]="I'm client.";
	char msg3[]="Nice to meet you too!";
	char* str_arr[]={msg1, msg2, msg3};         //指针数组，保存三个字符串指针
	char read_buf[100];

	int str_len, i;
	
	if(argc!=3){
		printf("Usage : %s\n", argv[0]);
		exit(1);
	}
	
	sock=socket(PF_INET, SOCK_STREAM, 0);
	if(sock == -1)
		error_handling("socket() error");
	
	memset(&serv_addr, 0, sizeof(serv_addr));
	serv_addr.sin_family=AF_INET;
	serv_addr.sin_addr.s_addr=inet_addr(argv[1]);
	serv_addr.sin_port=htons(atoi(argv[2]));
	
	if(connect(sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr))==-1) 
		error_handling("connect() error!");

	for(i=0; i<3; i++) { read(sock, (char*)(&str_len), 4); //因为服务端是先写，所以客户端对应要先读 read(sock, read_buf, str_len); puts(read_buf); str_len=strlen(str_arr[i])+1; write(sock, (char*)(&str_len), 4); write(sock, str_arr[i], str_len); } close(sock); return 0; } void error_handling(char *message) { fputs(message, stderr); fputc('\n', stderr); exit(1); }</unistd.h></string.h></stdlib.h></stdio.h></unistd.h></string.h></stdlib.h></stdio.h>

(6)创建收发文件的服务器端/客户端

/**********************************file_serv.c***********************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include#include#define BUF_SIZE 30
void error_handling(char *message);

int main(int argc, char *argv[])
{
	int serv_sd, clnt_sd;
	FILE * fp;
	char buf[BUF_SIZE];
	char file_name[BUF_SIZE];
	int read_cnt;
	
	struct sockaddr_in serv_adr, clnt_adr;
	socklen_t clnt_adr_sz;
	
	if(argc!=2) {
		printf("Usage: %s\n", argv[0]);
		exit(1);
	}
	
	serv_sd=socket(PF_INET, SOCK_STREAM, 0);   
	
	memset(&serv_adr, 0, sizeof(serv_adr));
	serv_adr.sin_family=AF_INET;
	serv_adr.sin_addr.s_addr=htonl(INADDR_ANY);
	serv_adr.sin_port=htons(atoi(argv[1]));
	
	bind(serv_sd, (struct sockaddr*)&serv_adr, sizeof(serv_adr));
	listen(serv_sd, 5);
	
	clnt_adr_sz=sizeof(clnt_adr);    
	clnt_sd=accept(serv_sd, (struct sockaddr*)&clnt_adr, &clnt_adr_sz);
	
	read(clnt_sd, file_name, BUF_SIZE);   
	fp=fopen(file_name, "rb");           //尝试打开客户端请求的文件
	if(fp!=NULL)              //如果文件存在，则传送给客户端
	{
		while(1)
		{
			read_cnt=fread((void*)buf, 1, BUF_SIZE, fp);
			if(read_cnt#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include#include#define BUF_SIZE 30
void error_handling(char *message);

int main(int argc, char *argv[])
{
	int sd;
	FILE *fp;
	
	char buf[BUF_SIZE];
	char file_name[BUF_SIZE];
	int read_cnt;
	struct sockaddr_in serv_adr;
	if(argc!=3) {
		printf("Usage: %s\n", argv[0]);
		exit(1);
	}
	
	printf("Input file name: ");  
	scanf("%s", file_name);               //输入请求服务端传输文件的文件名
	fp=fopen(file_name, "wb");

	sd=socket(PF_INET, SOCK_STREAM, 0);   
	memset(&serv_adr, 0, sizeof(serv_adr));
	serv_adr.sin_family=AF_INET;
	serv_adr.sin_addr.s_addr=inet_addr(argv[1]);
	serv_adr.sin_port=htons(atoi(argv[2]));

	connect(sd, (struct sockaddr*)&serv_adr, sizeof(serv_adr));
	write(sd, file_name, strlen(file_name)+1);	

	while((read_cnt=read(sd, buf, BUF_SIZE))!=0)        //如果服务端存在该文件，则打印服务端传来的文件
		fwrite((void*)buf, 1, read_cnt, fp);        
	
	fclose(fp);
	close(sd);
	return 0;
}

void error_handling(char *message)
{
	fputs(message, stderr);
	fputc('\n', stderr);
	exit(1);
}</unistd.h></string.h></stdlib.h></unistd.h></string.h></stdlib.h></stdio.h>

/********************************uchar_server.c***********************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include#include#define BUF_SIZE 30
void error_handling(char *message);

int main(int argc, char *argv[])
{
	int serv_sock;
	char message[BUF_SIZE];
	int str_len;
	socklen_t clnt_adr_sz;
	
	struct sockaddr_in serv_adr, clnt_adr;
	if(argc!=2){
		printf("Usage : %s\n", argv[0]);
		exit(1);
	}
	
	serv_sock=socket(PF_INET, SOCK_DGRAM, 0);
	if(serv_sock==-1)
		error_handling("UDP socket creation error");
	
	memset(&serv_adr, 0, sizeof(serv_adr));
	serv_adr.sin_family=AF_INET;
	serv_adr.sin_addr.s_addr=htonl(INADDR_ANY);
	serv_adr.sin_port=htons(atoi(argv[1]));
	
	if(bind(serv_sock, (struct sockaddr*)&serv_adr, sizeof(serv_adr))==-1)
		error_handling("bind() error");
	
	clnt_adr_sz=sizeof(clnt_adr);
	while(1) 
	{
		str_len=recvfrom(serv_sock, message, BUF_SIZE, 0, (struct sockaddr*)&clnt_adr, &clnt_adr_sz);        //客户端先发，服务端先收
		message[str_len]=0;
		printf("Message from client: %s", message);

		fputs("Insert message(q to quit): ", stdout);
		fgets(message, sizeof(message), stdin);
		if(!strcmp(message,"q\n") || !strcmp(message,"Q\n"))	
			break;

		sendto(serv_sock, message, strlen(message), 0, (struct sockaddr*)&clnt_adr, clnt_adr_sz);
	}	
	close(serv_sock);
	return 0;
}

void error_handling(char *message)
{
	fputs(message, stderr);
	fputc('\n', stderr);
	exit(1);
}


/********************************uchar_client.c***********************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include#include#define BUF_SIZE 30
void error_handling(char *message);

int main(int argc, char *argv[])
{
	int sock;
	char message[BUF_SIZE];
	int str_len;
	socklen_t adr_sz;
	
	struct sockaddr_in serv_adr, from_adr;
	if(argc!=3){
		printf("Usage : %s\n", argv[0]);
		exit(1);
	}
	
	sock=socket(PF_INET, SOCK_DGRAM, 0);   
	if(sock==-1)
		error_handling("socket() error");
	
	memset(&serv_adr, 0, sizeof(serv_adr));
	serv_adr.sin_family=AF_INET;
	serv_adr.sin_addr.s_addr=inet_addr(argv[1]);
	serv_adr.sin_port=htons(atoi(argv[2]));
	
	while(1)
	{
		fputs("Insert message(q to quit): ", stdout);
		fgets(message, sizeof(message), stdin);     
		if(!strcmp(message,"q\n") || !strcmp(message,"Q\n"))	
			break;
		  
		sendto(sock, message, strlen(message), 0, (struct sockaddr*)&serv_adr, sizeof(serv_adr));        //客户端先发，服务端先收
		adr_sz=sizeof(from_adr);
		str_len=recvfrom(sock, message, BUF_SIZE, 0, (struct sockaddr*)&from_adr, &adr_sz);   

		message[str_len]=0;
		printf("Message from server: %s", message);
	}	
	close(sock);
	return 0;
}

void error_handling(char *message)
{
	fputs(message, stderr);
	fputc('\n', stderr);
	exit(1);
}</unistd.h></string.h></stdlib.h></stdio.h></unistd.h></string.h></stdlib.h></stdio.h>

#include <stdio.h>
#include <unistd.h>
#include <sys socket&#46;h="">

int main(int argc, char *argv[])
{
	pid_t pid;
	int sockfd=socket(PF_INET, SOCK_STREAM, 0);
	
	pid=fork();		
	
	if(pid==0)
		printf("Child sock fd: [%d] \n", sockfd);
	else
		printf("Parent sock fd: [%d] \n", sockfd);
	return 0;
}

显示
Parent sock fd: [3] 
Child sock fd: [3] </sys></unistd.h></stdio.h>

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>

void ctrl_handler(int sig);

int main(int argc, char *argv[])
{
	struct sigaction act;
	act.sa_handler=ctrl_handler;
	sigemptyset(&act.sa_mask);
	act.sa_flags=0;
	sigaction(SIGINT, &act, 0);

	while(1)
	{
		sleep(1);
		puts("Have a nice day~");
	}

	return 0;
}


void ctrl_handler(int sig)
{
	char ex;
	fputs("Do you want exit(Y to exit)? ", stdout);
	scanf("%c", &ex);
	if(ex=='y' || ex=='Y')
		exit(1);
}

</signal.h></stdlib.h></stdio.h>