计算机网络文件传输及管理系统课程设计报告.docx

计算机网络文件传输及管理系统课程设计报告.docx

《计算机网络文件传输及管理系统课程设计报告.docx》由会员分享，可在线阅读，更多相关《计算机网络文件传输及管理系统课程设计报告.docx（32页珍藏版）》请在冰豆网上搜索。

计算机网络文件传输及管理系统课程设计报告

目录

摘要3

第一章课程设计要求4

一、设计任务4

1.1.1课程设计内容4

1.1.2、课程设计的基本要求4

二、设计基本思路及相关理论4

1.2.1、TCP/IP协议4

1.2.2、客户机/服务器模型5

1.2.3、设计基本思路5

第二章设计概要6

2.1功能设计6

2.2程序系统功能模块7

2.3功能分析8

2.3.1功能流程图：

8

2.3.2程序主要功能说明8

第三章调试分析与测试结果24

3.1服务器端与客户端24

3.2文件管理的过程27

第四章设计总结29

参考文献29

课程设计评分表30

摘要

网络的Socket数据传输是一种特殊的I/O，Socket也是一种文件描述符。

Socket也具有一个类似于打开文件的函数调用Socket（），该函数返回一个整型的Socket描述符，随后的连接建立、数据传输等操作都是通过该Socket实现的。

Socket接口是TCP/IP网络的API，Socket接口定义了许多函数或例程，程序员可以用它们来开发TCP/IP网络上的应用程序。

要学Internet上的TCP/IP网络编程，必须理解Socket接口。

　Socket接口设计者最先是将接口放在Unix操作系统里面的。

如果了解Unix系统的输入和输出的话，就很容易了解Socket了。

常用的Socket类型有两种：

流式Socket（SOCK_STREAM）和数据报式Socket（SOCK_DGRAM）。

流式是一种面向连接的Socket，针对于面向连接的TCP服务应用；数据报式Socket是一种无连接的Socket，对应于无连接的UDP服务应用。

Socket接口是TCP/IP网络的API，Socket接口定义了许多函数或例程，程序员可以用它们来开发TCP/IP网络上的应用程序。

要学Internet上的TCP/IP网络编程，必须理解Socket接口。

关键字：

Socket、文件传输、多线程

第1章课程设计要求

一、设计任务

1.1.1课程设计内容

文件传输协议的简单设计与实现：

学会利用已有网络环境设计并实现简单应用层协议，掌握TCP/IP网络应用程序基本的设计方法和实现技巧，加深对客户/服务器的工作模式的认识。

用socket编程接口编写程序，分别为客户程序（ftpclient.cpp）和服务器程序（ftpserver.cpp）和管理程序。

1.1.2、课程设计的基本要求

.巩固和加深对计算机网络原理的理解，提高综合运用本课程所学知识的能力。

.培养选用参考书，查阅手册及文献资料的能力。

培养独立思考，深入研究，分析问题、解决问题的能力。

.通过实际分析设计、编程调试，掌握计算机网络通信的基本规程，以及协议的利用方法，体会体系结构分层的思路。

.能够按要求编写课程设计报告书，能正确阐述设计和设计结果、正确绘制系统和程序框图。

.通过课程设计，培养严谨的科学态度，严肃认真的工作作风，和团队协作精神。

二、设计基本思路及相关理论

1.2.1、TCP/IP协议

TCP/IP协议是Internet最基本的协议、Internet国际互联网络的基础，由网络层的IP协议和传输层的TCP协议组成。

TCP/IP定义了电子设备如何连入因特网，以及数据如何在它们之间传输的标准。

协议采用了4层的层级结构，每一层都呼叫它的下一层所提供的网络来完成自己的需求。

通俗而言：

TCP负责发现传输的问题，一有问题就发出信号，要求重新传输，直到所有数据安全正确地传输到目的地。

TCP是面向连接的通信协议，通过三次握手建立连接，通讯完成时要拆除连接，由于TCP是面向连接的所以只能用于点对点的通讯。

TCP提供的是一种可靠的数据流服务，采用一种称为“滑动窗口”的方式进行流量控制。

TCP将它的信息送到更高层的应用程序，例如Telnet的服务程序和客户程序。

应用程序轮流将信息送回TCP层，TCP层便将它们向下传送到IP层，设备驱动程序和物理介质，最后到接收方。

1.2.2、客户机/服务器模型

网络应用层程序一般都是以客户机/服务器模型的方式工作的，而因特网便是客户机/服务器模型的一个典型应用。

在这种工作方式中，一个服务器程序先启动，并在一个熟知端口侦听对服务器的请求，当客户机应用程序需要某种服务时，须向提供这种服务的服务器发出请求，服务器在接收到请求后，向客户机发出响应请求信息。

这样客户机用用程序和服务器程序之间变建立了连接，此后可以进行数据通信。

通信任务完成后需要关闭它们之间的通信连接。

图1客户机/服务器模型的工作流程

1.2.3、设计基本思路

设计程序使客户端连接的时候，服务器将会向客户端发回一条消息告知它的IP地址，然后关闭连接并继续接收端口的连接。

建立各个命令功能对应的函数，发送请求，等待服务器端的服务。

服务器端初始化WinSock，创建SOCKET，获取主机信息，并对客户端进行会话，发送回复讯息给客户端，响应完毕后关闭连接，释放WinSock。

模拟TCP/IP协议的工作模式，在双方工作的时候开设一个熟知端口（4523），进行数据的传送与接收。

模拟TCP工作机制，确定数据端口传送数据时，进行分组传送。

服务器从打开开始，保持监听控制端口，当用户登陆成功后，主动分配该用户服务线程。

在传送数据的时候，为了确保不影响原程序的工作，应独立分配线程。

本设计基本图如下：

第二章设计概要

2.1功能设计

本项目是为了实现基于Socket进行文件传输的功能。

项目的分析及设计要求如下：

1）整个系统中分为服务器端（Server）和客户端（Client）

2）服务器端可以对文件进行管理，包括上传，下载，删除文件，重命名等

3）客服端可以实现文件的上传、下载以及查看服务器下默认目录的文件列表

4）在程序中应用多线程来实现多个客户端同时对一个服务器端进行请求操作

2.2程序系统功能模块

图2.1

2.3功能分析

2.3.1功能流程图：

图2.2面向连接的客户机/服务器程序工作模型

2.3.2程序主要功能说明

主要功能实现代码如下：

1.服务器端

//server.cpp

#include

#include

#include

#include

#defineLISTENPORT12345

#pragmacomment（lib,"Wsock32"）

#pragmacomment（lib,"ws2_32"）

sendFile（SOCKETconSock）

{

printf（"Praparetosendfile\n"）;

char*sendBuf=newchar[100];

FILE*in;

charinfile[50];

printf（"选择要传输的文件"）;

scanf（"%[^\n]s",infile）;

if（（in=fopen（infile,"rb"））==NULL）

{

printf（"Can'topenthesourcefile"）;

exit（0）;

}

printf（"Filenameis%s\n",infile）;

//sendfilenametotheclient

send（conSock,infile,sizeof（infile）,0）;

inthandle=open（infile,0x0001）;

longfile_len=filelength（handle）;

longfile_len_bak=file_len;

printf（"Sizeofthefileis%d\n",file_len）;

//storethelengthofthefileinsendBuffer

inti;

for（i=0;file_len>9;i++）

{

sendBuf[i]=（file_len%10）;

file_len=file_len/10;

}

sendBuf[i]=file_len%10;

send（conSock,sendBuf,i+1,0）;

printf（"Transmissionstarted\n"）;

Sleep

（1）;

charch;

charchack;

while（file_len_bak!

=0）

{

ch=fgetc（in）;

send（conSock,&ch,1,0）;

recv（conSock,&chack,1,0）;

file_len_bak--;

printf（"."）;

}

ch=EOF;

send（conSock,&ch,1,0）;

printf（"\nTransmissionfinished"）;

}

intmain（）

{

WSADATAwords;

if（WSAStartup（MAKEWORD（2,2）,&words）!

=0）

{

printf（"Winsockinitfailed!

\n"）;

}

SOCKETlistenSock,conSock;

sockaddr_inremoteAddr;

intremoteAddrLen,intServerAddrLen;

listenSock=socket（AF_INET,SOCK_STREAM,IPPROTO_TCP）;

if（listenSock==INVALID_SOCKET）

{

printf（"ListenSocketcreatefailed!

\n"）;

return0;

}

sockaddr_insin;

sin.sin_family=AF_INET;

sin.sin_port=htons（LISTENPORT）;

sin.sin_addr.S_un.S_addr=INADDR_ANY;

ServerAddrLen=sizeof（sin）;

if（bind（listenSock,（sockaddr*）&sin,ServerAddrLen）==SOCKET_ERROR）

{

printf（"Binderror!

\n"）;

return0;

}

if（listen（listenSock,2）==SOCKET_ERROR）

{

printf（"Can'tlisten!

\n"）;

return0;

}

remoteAddrLen=sizeof（remoteAddr）;

while（TRUE）

{

conSock=accept（listenSock,（sockaddr*）&remoteAddr,&remoteAddrLen）;

if（conSock==INVALID_SOCKET）

{

printf（"Acceptfailed!

\n"）;

continue;

}

else

{

printf（"Acceptanewconnect:

%s\r\n",inet_ntoa（remoteAddr.sin_addr））;

sendFile（conSock）;

}

}

closesocket（conSock）;

closesocket（listenSock）;

WSACleanup（）;

return1;

}

2.客户端

//client.cpp

#include

#include

#include

#include

usingnamespacestd;

#defineSERVERPORT12345

#pragmacomment（lib,"Wsock32"）

#pragmacomment（lib,"ws2_32"）

receiveFile（SOCKETconsock）

{

printf（"Preparetoreceivefile\n"）;

FILE*dest;

chardestfile[50];

charrecvBuff[100];

//Receivenameofthefile

intnamelen=recv（consock,recvBuff,100,0）;

memcpy（destfile,recvBuff,namelen）;

printf（"Nameofthefileis%s\n",destfile）;

if（（dest=fopen（destfile,"wb"））==NULL）

{

printf（"Can'topenthedestfile"）;

exit（0）;

}

//Receivesizeofthefile

intflag_file_len=recv（consock,recvBuff,100,0）;

longfile_len=0;

for（inti=0;flag_file_len!

=0;i++）

{

longtemp=recvBuff[i];

for（intj=0;j!

=i;j++）

{

temp=temp*10;

}

file_len=file_len+temp;

flag_file_len--;

}

printf（"Sizeofthefileis%ld\n",file_len）;

printf（"Readytoreceivefile\n"）;

charch;

charchack=1;

intn;

while（recv（consock,&ch,1,0））

{

fputc（ch,dest）;

send（consock,&chack,1,0）;

file_len--;

if（file_len==0）

{

break;

}

printf（"."）;

}

printf（"\nTransmissionfinished\n"）;

}

intmain（）

{

WSADATAwords;

if（WSAStartup（MAKEWORD（2,2）,&words）!

=0）

{

printf（"Winsockinitfailed\n"）;

}

SOCKETconSock;

conSock=socket（AF_INET,SOCK_STREAM,IPPROTO_TCP）;

if（conSock==INVALID_SOCKET）

{

printf（"Socketcreatefailed\n"）;

return0;

}

sockaddr_inservAddr;

servAddr.sin_family=AF_INET;

servAddr.sin_port=htons（SERVERPORT）;

servAddr.sin_addr.S_un.S_addr=inet_addr（"127.0.0.1"）;

if（connect（conSock,（sockaddr*）&servAddr,sizeof（servAddr））==-1）

{

printf（"Connectfailed\n"）;

return0;

}

else

{

printf（"Connecttoserversucceed\n"）;

receiveFile（conSock）;

}

closesocket（conSock）;

WSACleanup（）;

return1;

}

3.管理系统

#include

#include

#include

#include

#include

#defineSYS_SIZE0XFFFFF*100

#defineBLOCK_SIZE512

FILE*f;

structfilsys{

ints_nfree;

longs_free[100];

ints_ninode;

ints_inode[96];

}*p;

structindex_block{

ints_nfree;

longs_free[96];

}q;

structfilelist{

charname[14];

intinode_num;

}file;

structinode{

inti_size;

intblock_amount;

longi_addr[16];

charcreate_time[25];

}inode;

structfcb{

charname[12];

intinode_num;

intused;

inti_size;

intblock_amount;

longi_addr[16];

}fcb[5],*ptr;

structopen_file_table{

intoffset;

structfcb*f_node;

}table[5];

structfd{

structopen_file_table*t_node;

}fd[5];

FILE*apply_room（char*sys_name）

{

f=fopen（sys_name,"w+b"）;//创建一个新的可读写的二进制文件

fseek（f,SYS_SIZE,SEEK_SET）;

fputc（EOF,f）;

fclose（f）;

returnfopen（sys_name,"r+b"）;//打开一个可读写的二进制文件

}

voidmyfree（longblock_num）

{

inti;

if（p->s_nfree<100）

{

p->s_free[p->s_nfree]=block_num;

p->s_nfree++;

}

else

{

q.s_nfree=p->s_nfree;

for（i=0;i<100;i++）

q.s_free[i]=p->s_free[i];

fseek（f,（block_num-1）*BLOCK_SIZE,SEEK_SET）;

fwrite（&q,sizeof（structindex_block）,1,f）;

p->s_nfree=1;

p->s_free[0]=block_num;

}

}

longmyalloc（）

{

inti;

longa;

p->s_nfree--;

if（p->s_nfree==0）{

a=p->s_free[0];

fseek（f,（a-1）*BLOCK_SIZE,SEEK_SET）;

fread（&q,sizeof（structindex_block）,1,f）;

p->s_nfree=q.s_nfree;

for（i=0;i<100;i++）

p->s_free[i]=q.s_free[i];

returna;

}elsereturnp->s_free[p->s_nfree];

}

voidinit（）

{

intj;

longi;

p->s_nfree=1;

p->s_free[0]=0;

p->s_ninode=96;

for（i=0;i<96;i++）

p->s_inode[i]=-1;

for（i=22;i<=SYS_SIZE/BLOCK_SIZE;i++）

myfree（i）;

j=p->s_nfree+1;

while（j<100）

p->s_free[j++]=0;

fseek（f,0,SEEK_SET）;

fwrite（p,sizeof（structfilsys）,1,f）;

}

intialloc（）{

inti=0;

while（p->s_inode[i]>=0）i++;

p->s_inode[i]=0;

p->s_ninode--;

returni;

}

intnamei（char*name）

{

intk=0;

while（k<96）{

if（p->s_inode[k]!

=-1）{

fseek（f,BLOCK_SIZE+k*16,SEEK_SET）;

fread（&file,sizeof（structfilelist）,1,f）;

if（!

strcmp（file.name,name））

returnfile.inode_num;

}

k++;

};

return-1;

}

intname_i（char*name）

{

intk=0;

do

{

if（fcb[k].used==1）

{

if（!

strcmp（fcb[k].name,name））

returnfcb[k].inode_num;

}

k++;

}while（k<5）;

return-1;

}

voidcreate（）

{

inti,inode_num;

longt;

charname[12];

printf（"inputfilename:

"）;

scanf（"%s",name）;

getchar（）;

if（namei（name）!

=-1）printf（"fileexited!

\n"）;

else

{

inode_num=ialloc（）;

strcpy（file.name,name）;

file.inode_num=inode_num;

fseek（f,BLOCK_SIZE+inode_num*16,SEEK_SET）;

fwrite（&file,sizeof（structfilelist）,1,f）;

inode.i_size=0;

inode.block_amount=0;

for（i=0;i<16;i++）inode.i_addr[i]=0;

time（&t）;

strcpy（inode.creat