网络编程试验报告

本文格式为Word版，下载可任意编辑——网络编程试验报告

程序实践报告

一、程序实践概述1、题目名称：

Linux程序设计基础2、时间进度：

2023年6月19日到2023年7月5日3、开发环境：

Ubunto10.04二、问题分析1、功能说明：

①编程实现快速排序算法；

②实现文本文件拷贝函数copy(f_source,f_target)；即实现如下功能：$./copyf1f2

以上程序执行后当前目录会形成一个新的文件f2，且其内容与f1完全一致。

③编写一个程序，要求：输入N个学生的学号和成绩，并保存在stu.txt文本文件中，对学生成绩进行排序并把排序后的结果输出到score.txt文件中,同时在屏幕上输出高于平均成绩的学生的学号和成绩。

④编写一个程序找出串str1和串str2的所有最长公共子串。

2、解决方案：（1）

将原问题分解为若干个规模更小但结构与原问题相像的子问题。递归地解这些子问题，然后将这些子问题的解组合为原问题的解。（2）

定义文件指针FILE*fp；表示fp是指向FILE结构的指针变量，通过fp即可找存放某个文件信息的结构变量，然后按结构变量提供的信息找到该文件，实施对文件的操作。（3）

创立一个结构体储存学生的学号和成绩，利用文件操作写入文档。对成绩进行排序，将大于平均成绩的输出到屏幕。（4）

创立两个数组，探寻字符串，寻觅最大的匹配子串。三、方案设计1、模块结构：

模块功能图和模块描述（1）

在a[left..right]中任选一个记录作为基准，以此基准将当前无序区划分为左、右两个较小的子区间a[left..pivotpos-1)和a[pivotpos+1..right]，并使左边子区间中所有记录的关键字均小于等于基准记录(不妨记为pivot)的关键字pivot.key，右边的子区间中所有记录的关键字均大于等于pivot.key，而基准记录pivot则位于正确的位置(pivotpos)上，

它无须参与后续的排序。

划分的关键是要求出基准记录所在的位置pivotpos。划分的结果可以简单地表示为：

a[left..pivotpos-1].keys≤a[pivotpos].key≤a[pivotpos+1..right].keys其中left≤pivotpos≤right。（2）fopen函数

用来开启一个文件，其调用的一般形式为：文件指针名=fopen(文件名，使用文件方式)。其中，“文件指针名〞必需是被说明为FILE类型的指针变量，“文件名〞是被开启文件的文件名。“使用文件方式〞是指文件的类型和操作要求。“文件名〞是字符串常量或字符串数组。fclose函数

调用的一般形式是：fclose(文件指针)；正常完成关闭文件操作时，fclose函数返回值为0。如返回非零值则表示有错误发生。文件的读写对文件的读和写是最常用的文件操作。（3）

创立一个结构体储存学生的学号和成绩，每个学生的信息都储存在一个数组里。利用文件操作写入文档。

对成绩进行排序，更新数组信息，将大于平均成绩的输出到屏幕。（4）

将两个字符串储存在数组里，从首地址开始查找一致字符。假使遇到一致字符则开始记录位置，从该位置开始计数，到不匹配位置。重新探寻，假使最大长度超过记录则更新。2、数据结构：（1）链表，递归（2）文件操作

（3）文件操作，数组（4）数组3、总体流程：给出流程图（1）

第一步：(初始化)设置两个指针i和j，它们的初值分别为区间的下界和上界，即i=low，i=high；选取无序区的第一个记录R[i](即R[low])作为基准记录，并将它保存在变量pivot中；

其次步：令j自high起向左扫描，直到找到第1个关键字小于pivot.key的记录R[j]，将R[j])移至i所指的位置上，这相当于R[j]和基准R[i](即pivot)进行了交换，使关键字小于基准关键字pivot.key的记录移到了基准的左边，交换后R[j]中相当于是pivot；然后，令i指针自i+1位置开始向右扫描，直至找到第1个关键字大于pivot.key的记录R[i]，将R[i]移到i所指的位置上，这相当于交换了R[i]和基准R[j]，使关键字大于基准关键字的记录移到了基准的右边，交换后R[i]中又相当于存放了pivot；接着令指针j自位置j-1开始向左扫描，如此交替改变扫描方向，从两端各自往中间靠拢，直至i=j时，i便是基准pivot最终的位置，将pivot放在此位置上就完成了一次划分。（2）开启f1文件

1

开启f2文件，假使没有将创立

开启成功

将f1写入f2

关闭f1,f2文件

（3）从屏幕获取学生信息

写入文件

求取成绩平均值

将学生按成绩排序

输出大于平均值的学生

（4）找到第一个相等的字符，记录下位置。查找最大的一致字符，假使有大于前一次探寻的，则更新长度。4、关键算法：给出关键算法描述（1）

voidquickSort(inta[],intleft,intright){inti,j,temp;i=left;j=right;temp=a[left];if(left>right)return;while(i!=j)

2

{

while(a[j]>=tempif(j>i)

a[i++]=a[j];

while(a[i]i)

a[j--]=a[i];}

a[i]=temp;

quickSort(a,left,i-1);quickSort(a,i+1,right);}

（2）

#include

voidmain(intargc,char*argv[]){

FILE*f1,*f2;charc;

f1=fopen(argv[1],\);f2=fopen(argv[2],\);while((c=getc(f1))!=EOF){

printf(\,c);putc(c,f2);}

fclose(f1);fclose(f2);}

（3）

for(i=0;istu[j+1].score){

temp.num=stu[j].num;temp.score=stu[j].score;stu[j].num=stu[j+1].num;stu[j].score=stu[j+1].score;stu[j+1].num=temp.num;stu[j+1].score=temp.score;

3

}}}

（4）

for(i=1;imax?gg[i][j]:max;}else{

gg[i][j]=0;}}}

for(i=len1+1;i>0;--i){

for(j=len2+1;j>0;--j){

if(gg[i][j]==max){

str[max-1]=str2[j-1];max--;break;}}

}

程序实践概述1、题目名称：

Socket编程基础（1）时间服务器

（2）远程文件备份服务器

2、时间进度：2023年6月19日到2023年7月5日

3、开发环境：Ubuntu10.04二、问题分析1、功能说明：

4

①编程实现时间服务器

编写一个网络时间服务器timeserver，该服务器能应具有如下功能：

?够为网络上的用户提供时间服务，即为网络用户返回服务器的当前时间；?记录发出请求的网络用户的IP地址（保存到文件中），格式如下：IP地址请求时间

编写时间服务客户端timeclient，该客户端能够向服务器发送时间服务请求，并把获得的时间返回给用户。

②编程实现远程文件备份服务器

分别采用TCP或UDP协议编写一个远程数据备份服务器，运行客户端将本地文件备份到远程的服务器中。

服务器的功能：接受客户端请求，把客户端的文件进行备份（可以备份到指定的文件夹）。

客户端的功能：与远程服务器进行连接，在连接后把本地的文件发送给远程备份服务器。

2、解决方案：

服务器端过程就是socket->bind->listen->accpet->Read,write

而对于客户端则是socket->connect->read,write三、方案设计1、模块结构：

模块功能图和模块描述

服务器端：

1、创立套接字；使用socket()

#include#include

intsocket(intdomain，inttype，intprotocol)建立服务器端的socket套接字

2、绑定套接字到一个IP地址和一个端口上；使用bind()

#include#include

intbind(intsockfd,structsockaddr*myaddr,intaddrlen)；

3、将套接字设置为监听模式，以等待连接请求；使用listen()

#include

intlisten(intsockfd，intbacklog)

4、请求到来后，接受连接请求，并返回一个与此次连接对应的套接字；使用accept()

#include

5

intaccept(intsockfd，structsockaddr*addr，int*addrlen)

此时新建连接，并创立新的Socket套接字，此时addr为客户端的addr信息。

5、用返回的套接字和客户端进行通信；使用recv()和send()

intread(intfd，char*buf，intlen)intwrite(intfd，char*buf，intlen)

6、关闭当前的连接，进入等待状态，继续等待客户端的连接；使用close()

#include

intclose(intsockfd)；

7、关闭服务器端的套接字描述符；使用close()

#include

intclose(intsockfd)；

客户端：

1、创立客户端套接字；使用socket()

#include#include

intsocket(intdomain，inttype，intprotocol)

2、向服务器发出连接请求；使用connect()

#include#include

intconnect（intsockfd，structsockaddr*servaddr，intaddrlen）

其中参数servaddr指定远程服务器的套接字地址，包括服务器的IP地址和端口号

3、和服务器端进行网络通信；使用recv()和send()

intread(intfd，char*buf，intlen)intwrite(intfd，char*buf，intlen)

4、关闭套接字；使用close()

#include

intclose(intsockfd)；

2、数据结构：

6

文件操作，socket3、总体流程：

server

Socket()Bind()

Listen()clientSocket()Accept()建立连接Connect()阻塞，直到客户端的连接到达

Recv()

处理接收到的数据

Send()

Close()

4、关键算法：给出关键算法描述1.

Send()DatarequestRecv()DatareplyClose()Client:

recv_msg=recv(sockfd,buf,20,0);//尝试接收数据buf[recv_msg]='\\0';

printf(\

7

server:

while(1)//尝试获得数据{

sin_size=sizeof(structsockaddr_in);if((client_fd=accept(sockfd,(structsockaddr*)}t=time(NULL);

2.client:

fp=fopen(filename,\

if(fp==-1)

printf(\

fread(buf,sizeof(buf),1,fp);fp=fopen(\

server:

buf[recv_msg]=\printf(\

fwrite(buf,strlen(buf),1,fp);fcose(fp);

//开启文件//读取文件//写入文件8

一、程序实践概述1、题目名称：

Libpcap开发包使用

2、时间进度：2023年6月19日到2023年7月5日3、开发环境：Ubuntu10.04二、问题分析1、功能说明：

（1）获取网络接口名字和掩码等信息

（2）捕获数据包（单个数据包和多个数据包两种状况）（3）以太网数据报捕获（4）ARP数据包捕获2、解决方案：

1、开启、读取设备，设置过滤器部分。1.1pcap_read()

1.2pcap_t*pcap_open_live(char*device,intsnaplen,intpromisc,intto_ms,char*errbuf);该函数用于获取一个抽象的包捕获句柄，

1.3intpcap_setfilter(pcap_t*p,structbpf_program*fp);该函数用于设置pcap_compile()解析完毕的过滤规则2、编译、优化、调试过滤规则表达式部分

2.1intpcap_compile(pcap_t*p,structbpf_program*fp,char*str,intoptimize,bpf_u_int32netmask);该函数用于解析过滤规则串，填写bpf_program结构。3、脱机方式监听部分。3.1pcap_open_offline()3.2pcap_offline_read()4、本地网络设置检测部分。

4.1char*pcap_lookupdev(char*errbuf);该函数返回一个网络设备接口名，

4.2intpcap_lookupnet(char*device,bpf_u_int32*netp,bpf_u_int32*maskp,char*errbuf);该函数用于获取指定网络接口的IP地址、子网掩码。5.主控程序及版本部分6.关闭程序

voidpcap_close(pcap_t*p)关闭句柄，释放资源

三、方案设计1、模块结构：

模块功能图和模块描述(1)

charerror_content[PCAP_ERRBUF_SIZE];/*错误信息*/

structpcap_pkthdrprotocol_header;/*数据包头*/

pcap_t*pcap_handle;/*Libpcap句柄*/

structbpf_programbpf_filter;/*bpf过滤规则*/

charbpf_filter_string[]=\/*过滤规则*/

constu_char*packet_content;/*数据包内容*/

bpf_u_int32net_mask;/*网络掩码*/

bpf_u_int32net_ip;/*网络地址*/

char*net_interface;/*网络接口*/

net_interface=pcap_lookupdev(error_content);/*获取网络接口*/

pcap_lookupnet(net_interface,/*获取网络地址和掩码地址*/

pcap_handle=pcap_open_live(net_interface,/*网络接口*/BUFSIZ,/*数据包大小*/1,/*混杂模式*/0,/*等待时间*/

error_content);/*错误信息*//*开启网络接口*/

pcap_compile(pcap_handle,/*Libpcap句柄*//*网络地址*//*编译过滤规则*/

pcap_setfilter(pcap_handle,/*Libpcap句柄*//*BPF过滤规则*/

/*设置过滤规则*/

packet_content=pcap_next(pcap_handle,/*Libpcap句柄*//*数据包信息*/

/*捕获一个数据包，返回此数据包的内容*/

printf(\/*输出网络接口名字*/

printf(\/*输出捕获的数据包的长度*/pcap_close(pcap_handle);/*关闭Libpcap操作*/

1

return0;}(2)①

intmain(){

charerror_content[PCAP_ERRBUF_SIZE];structpcap_pkthdrprotocol_header;pcap_t*pcap_handle;structbpf_programbpf_filter;charbpf_filter_string[]=\constu_char*packet_content;bpf_u_int32net_mask;bpf_u_int32net_ip;char*net_interface;

net_interface=pcap_lookupdev(error_content);

pcap_lookupnet(net_interface,pcap_handle=pcap_open_live(net_interface,BUFSIZ,1,0,error_content);pcap_compile(pcap_handle,pap_setfilter(pcap_handle,

packet_content=pcap_next(pcap_handle,

printf(\printf(\pcap_close(pcap_handle);}②

voidmain(){

pcap_t*pcap_handle;

charerror_content[PCAP_ERRBUF_SIZE];char*net_interface;

structbpf_programbpf_filter;charbpf_filter_string[]=\

2

bpf_u_int32net_mask;bpf_u_int32net_ip;

net_interface=pcap_lookupdev(error_content);pcap_lookupnet(net_interface,

pcap_handle=pcap_open_live(net_interface,BUFSIZ,1,0,error_content);pcap_compile(pcap_handle,pcap_setfilter(pcap_handle,pcap_loop(pcap_handle,10,callback,

NULL);pcap_close(pcap_handle);}（3）

structether_header{

u_int8_tether_dhost[6];u_int8_tether_shost[6];u_int16_tether_type;};

voidmain(){

charerror_content[PCAP_ERRBUF_SIZE];pcap_t*pcap_handle;

constu_char*packet_content;u_char*mac_string;u_shortethernet_type;bpf_u_int32net_mask;bpf_u_int32net_ip;char*net_interface;

structpcap_pkthdrprotocol_header;structbpf_programbpf_filter;

3

structether_header*ethernet_protocol;charbpf_filter_string[]=\

net_interface=pcap_lookupdev(error_content);pcap_lookupnet(net_interface,

pcap_handle=pcap_open_live(net_interface,BUFSIZ,1,0,error_content);pcap_compile(pcap_handle,pcap_setfilter(pcap_handle,if(pcap_datalink(pcap_handle)!=DLT_EN10MB)return;

packet_content=pcap_next(pcap_handle,printf(\printf(\printf(\

printf(\printf(\printf(\

ethernet_protocol=(structether_header*)packet_content;printf(\

ethernet_type=ntohs(ethernet_protocol->ether_type);printf(\switch(ethernet_type){

case0x0800:printf(\case0x0806:printf(\case0x8035:printf(\default:break;}

printf(\

mac_string=ethernet_protocol->ether_shost;

printf(\ing+2),*(mac_string+3),*(mac_string+4),*(mac_string+5));printf(\mac_string=ethernet_protocol->ether_dhost;

printf(\ing+2),*(mac_string+3),*(mac_string+4),*(mac_string+5));pcap_close(pcap_handle);}（4）

structether_header{

4

u_int8_tether_dhost[6];u_int8_tether_shost[6];u_int16_tether_type;};

typedefu_int32_tint_addr_t;structin_addr{

int_addr_ts_addr;};

structarp_header{

u_int16_tarp_hardware_type;u_int16_tarp_protocol_type;u_int8_tarp_hardware_length;u_int8_tarp_protocol_length;u_int16_tarp_operation_code;

u_int8_tarp_source_ethernet_address[6];u_int8_tarp_source_ip_address[4];

u_int8_tarp_destination_ethernet_address[6];u_int8_tarp_destination_ip_address[4];};

voidarp_protocol_packet_callback(u_char*argument,conststructpcap_pkthdr*packet_header,constu_char*packet_content){

structarp_header*arp_protocol;u_shortprotocol_type;u_shorthardware_type;u_shortoperation_code;u_char*mac_string;structin_addrsource_ip_address;

structin_addrdestination_ip_address;u_charhardware_length;u_charprotocol_length;printf(\

arp_protocol=(structarp_header*)(packet_content+14);hardware_type=ntohs(arp_protocol->arp_hardware_type);protocol_type=ntohs(arp_protocol->arp_protocol_type);operation_code=ntohs(arp_protocol->arp_operation_code);hardware_length=arp_protocol->arp_hardware_length;protocol_length=arp_protocol->arp_protocol_length;printf(\printf(\printf(\printf(\

5

printf(\switch(operation_code){

case1:printf(\case2:printf(\case3:printf(\case4:printf(\default:break;}

printf(\

mac_string=arp_protocol->arp_source_ethernet_address;

printf(\ing+2),*(mac_string+3),*(mac_string+4),*(mac_string+5));memcpy((void*)printf(\printf(\

mac_string=arp_protocol->arp_destination_ethernet_address;

printf(\(mac_string+2),*(mac_string+3),*(mac_string+4),*(mac_string+5));memcpy((void*)

printf(\}voidethernet_protocol_packet_callback(u_char*argument,conststructpcap_pkthdr*packet_header,constu_char*packet_content){

u_shortethernet_type;

structether_header*ethernet_protocol;u_char*mac_string;staticintpacket_number=1;

printf(\printf(\

ethernet_protocol=(structether_header*)packet_content;

printf(\

ethernet_type=ntohs(ethernet_protocol->ether_type);printf(\switch(ethernet_type){

case0x0800:printf(\case0x0806:printf(\case0x8035:printf(\

6

default:break;}

printf(\

mac_string=ethernet_protocol->ether_shost;

printf(\(mac_string+2),*(mac_string+3),*(mac_string+4),*(mac_string+5));printf(\mac_string=ethernet_protocol->ether_dhost;

printf(\(mac_string+2),*(mac_string+3),*(mac_string+4),*(mac_string+5));switch(ethernet_type){

case0x0806:arp_protocol_packet_callback(argument,packet_header,packet_content);break;default:break;}

packet_number++;}

intmain(){

pcap_t*pcap_handle;

charerror_content[PCAP_ERRBUF_SIZE];char*net_interface;

structbpf_programbpf_filter;charbpf_filter_string[]=\bpf_u_int32net_mask;bpf_u_int32net_ip;

net_interface=pcap_lookupdev(error_content);

pcap_lookupnet(net_interface,pcap_handle=pcap_open_live(net_interface,BUFSIZ,1,0,error_content);pcap_compile(pcap_handle,pcap_setfilter(pcap_handle,if(pcap_datalink(pcap_handle)!=DLT_EN10MB)return;

pcap_loop(pcap_handle,-1,ethernet_protocol_packet_callback,NULL);pcap_close(pcap_handle);return0;}

2、数据结构：libpcap

4、总体流程：给出流程图

7

开启、读取设备，设置过滤器部分编译、优化、调试过滤规则表达式部分脱机方式监听部分

本地网络设置检测部

分

主控程序及版本部分

关闭句柄，释放资源

4、关键算法：给出关键算法描述

(1)charerror_content[PCAP_ERRBUF_SIZE];

structin_addrnet_ip_address;获得ip地址structin_addrnet_mask_address;获得子网掩码char*net_interface;char*net_ip_string;char*net_mask_string;(2)

捕获一个数据包：

packet_content=pcap_next(pcap_handle,捕获多个数据包：

pcap_loop(pcap_handle,10,