TCP实现文件传输

TCP协议实现文件传输

 使用TCP协议实现传输文件
    程序分为发送端和接收端。首先在传输文件数据之前，发送端会把将装有文件名称和文件长度等
信息的数据包发送至接收端。接收端收到文件名称和文件长度信息后会创建好空白文件。接着开始传输
文件数据。下面介绍实现功能的主要过程：

1.创建套接字、绑定、监听、连接、接受连接
//创建TCP协议的套接字
    m_Socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if(SOCKET_ERROR == m_Socket)
        AfxMessageBox("Create Socket Error! ", 0, 0);

//绑定与监听
    SOCKADDR_IN   addrSrv;   
    addrSrv.sin_addr.s_addr = inet_addr(sIP);
    addrSrv.sin_family   =   AF_INET;   
    addrSrv.sin_port   =   htons(Port);   
    int   ret   =   bind(m_Socket,   (SOCKADDR   *)&addrSrv,   sizeof(SOCKADDR));   
    if(ret==SOCKET_ERROR)   
        AfxMessageBox("Bind Socket Error!", 0, 0);

//连接
    SOCKADDR_IN ServerAddr;
    ServerAddr.sin_addr.s_addr = inet_addr(ServerAddr_in);
    ServerAddr.sin_family = AF_INET;
    ServerAddr.sin_port = htons(ServerPort);
    int Result = connect(m_Socket, (struct sockaddr*)&ServerAddr, sizeof(struct sockaddr));
    if(SOCKET_ERROR == Result)
        AfxMessageBox("Connet Failed!");

//接受连接
    SOCKADDR_IN ClientAddr;
    int len = sizeof(SOCKADDR_IN);
    SOCKET ClientSock = accept(m_Socket, (struct sockaddr*)&ClientAddr, &len);
    if(SOCKET_ERROR == ClientSock)
        AfxMessageBox("Accept Failed!");

2.声明宏和结构体
声明套接字缓冲区和一次发送文件数据的缓冲区大小
#define SOCKET_BUFF 80000    //套接字缓冲区大小
#define PACK_BUFF 50000        //数据包缓冲区大小


声明文件I/O缓冲区和最大文件路径长度
#define FILE_NAME_MAX 100       //文件路径最大长度
#define FILE_IO_BUFF PACK_BUFF    //文件IO缓冲区    


//文件信息
typedef struct _FileInfor    
{
    u_long ulFileLen;
    char sFileName[ FILE_NAME_MAX ];
}_FileInfor;

//数据包
typedef struct _DataPack
{
    char cType;        //'D'为数据  'M'为文件信息
    int nPackLen;
    char sContent[ PACK_BUFF ];            //数据包缓冲区
    u_long nPosition;                //数据在文件中的位置
    int nContentLen;                //数据字节数
    _FileInfor    FileInfor;        //文件信息
}_DataPack;



3.发送端
//发送线程需要的全局变量
char sPath[FILE_NAME_MAX];        //文件地址
u_long FileByteCount;            //文件大小
SOCKET ClientSocket;            //


(1)设置套接字发送缓冲区大小，在32位Windows XP环境下，系统为每个套接字分配的默认发送数据缓
冲区为8192字节。由于传输的文件很大，可能几十兆，或者更大。那么系统为每个套接字分配的默认
缓冲区显然过小。为此在创建套接字之后，需要修改套接字发送数据缓冲尺寸。在这里我修改为80k，
差不多可以够用了。
    //设置套接字发送缓冲区
    int nBuf = SOCKET_BUFF;
    int nBufLen = sizeof(nBuf);
    int nRe = setsockopt(ClientSock, SOL_SOCKET, SO_SNDBUF, (char*)&nBuf, nBufLen);
    if(SOCKET_ERROR == nRe)
        AfxMessageBox("setsockopt error!");    
    //检查缓冲区是否设置成功
    nRe = getsockopt(ClientSock, SOL_SOCKET, SO_SNDBUF, (char*)&nBuf, &nBufLen);
    if(SOCKET_BUFF != nBuf)
        AfxMessageBox("检查缓冲区:setsockopt error!");

(2)测量文件大小并发送文件大小和名称给客户端

    首先使用C库函数对源文件进行测量
    //得到文件地址
    LPTSTR lpPath =     m_sPath.GetBuffer(    m_sPath.GetLength ());
    //打开文件
    FILE *File = fopen(lpPath, "rb"); 
    if(NULL == File)
        AfxMessageBox("打开文件失败!");
    //测量文件大小
    char Buff[PACK_BUFF];
    u_long ulFaceReadByte;
    FileByteCount = 0;
    fseek(File, 0, SEEK_SET);
    while(!feof(File))
    {
        ulFaceReadByte = fread(Buff, 1, 1, File);
        FileByteCount += ulFaceReadByte;
    }
    //关闭文件
    int nRe = fclose(File);
    if(nRe)
        AfxMessageBox("关闭文件失败!");
        
    此时以获取源文件的长度，我们将文件长度和文件名称放到数据包中，设置数据包为'M'类型。
    //打包
    _DataPack Pack;
    Pack.cType = 'M';
    Pack.nPackLen = sizeof(Pack);
    //取得文件名
    ZeroMemory(Pack.FileInfor.sFileName, FILE_NAME_MAX);
    GetFIieNameFromPath(lpPath, Pack.FileInfor.sFileName);
    Pack.FileInfor.ulFileLen = FileByteCount;
    
    接着使用send()将打包完成的数据包发送给接收端,把发送线程的全局变量初始化，并创建发送线
程，文件数据将由发送线程负责发送
    //发送数据包 文件大小和名称
    nRe = send(m_ClientSockFd.fd_array[0], (char*)&Pack, Pack.nPackLen, 0);
    if(SOCKET_ERROR == nRe)
            AfxMessageBox("Send File Size Failed!");
    //线程准备全局变量
    strcpy(sPath, m_sPath);
    ClientSocket = m_ClientSockFd.fd_array[0];
    //启动线程发送文件
    DWORD ID;
    m_hSendThread = CreateThread(0, 0, SendDataThrad, 0, 0, &ID);


(3)发送文件数据线程。先打开源文件，为了一次读取大量数据将文件缓冲区设置为FILE_IO_BUFF大小，
然后将读取的数据打包并发送。这样不断地读、不断地发送，直到将整个文件发送完为止。

DWORD __stdcall CServerDlg::SendDataThrad(LPVOID LpP)
{
    //打开文件
    FILE *File = fopen(sPath, "rb");
    if(NULL == File)
    {
        AfxMessageBox("SendDataThrad中打开文件失败!");
        return 1;
    }
    //设置文件缓冲区
    int nBuff = FILE_IO_BUFF;
    if(setvbuf(File, (char*)&nBuff, _IOFBF, sizeof(nBuff)))
        AfxMessageBox("设置文件缓冲区失败!");
    //读取文件数据并发送
    u_long ulFlagCount = 0;            //记录读了多少数据
    u_long FaceReadByte = 0;    //一次实际读取的字节数
    char sBuff[PACK_BUFF];    
    ZeroMemory(sBuff, PACK_BUFF);
    fseek(File, 0, SEEK_SET);
    while (!feof(File))
    {
        FaceReadByte = fread(sBuff, 1, PACK_BUFF, File);
        //打包
        _DataPack DataPack;
        DataPack.cType = 'D';
        DataPack.nPackLen = sizeof(DataPack);
        DataPack.nContentLen = FaceReadByte;
        CopyMemory(DataPack.sContent, sBuff, FaceReadByte);
        DataPack.nPosition = ulFlagCount;
        //发送
        int nResult = send(ClientSocket, (char*)&DataPack, DataPack.nPackLen, 0);
        if (SOCKET_ERROR == nResult)
        {
            AfxMessageBox("SendDataThrad中发送数据失败!");
        }else
            ulFlagCount += FaceReadByte;        //记录发送字节数
    }
    AfxMessageBox("发送结束");
    //关闭
    int nRe = fclose(File);
    if(nRe)
        AfxMessageBox("SendDataThrad中关闭文件失败!");
    return 0;
}

4.接收端
//接收线程用的全局变量
_FileInfor FileInfor;        //文件信息
u_long ulWriteByte;            //记录总共写入的字节
char lpPath[FILE_NAME_MAX];    //文件路径
char sFilePathAndName[FILE_NAME_MAX];        //完整的文件路径

(1)设置套接字接收缓冲区大小。
//设置套接字接收缓冲区
    int nBuf = SOCKET_BUFF;
    int nBufLen = sizeof(nBuf);
    SOCKET ClientSock = m_Sock.GetSocket();
    int nRe = setsockopt(ClientSock, SOL_SOCKET, SO_RCVBUF, (char*)&nBuf, nBufLen);
    if(SOCKET_ERROR == nRe)
            AfxMessageBox("setsockopt error!");
    //检查缓冲区是否设置成功
    nRe = getsockopt(ClientSock, SOL_SOCKET, SO_RCVBUF, (char*)&nBuf, &nBufLen);
    if(SOCKET_BUFF != nBuf)
        AfxMessageBox("检查缓冲区:setsockopt error!");
        
(2)接收文件信息和文件数据线程。先判断数据包是属于文件信息还是文件类型，如果是文件信息就根
据信息创建空文件，如果是文件数据就将数据已追加的方式写进目的文件中。

DWORD __stdcall CClientDlg::ReceiveDataPro(LPVOID LpP)
{
    CSocket_Win32 *pCSock = (CSocket_Win32*)LpP;
    u_long ulWriteByteCount = 0;
    while (1)
    {
        _DataPack DataPack;
        ZeroMemory(&DataPack, sizeof(DataPack));
        if(!(*pCSock).Receive(&DataPack, sizeof(DataPack)))
        {
            AfxMessageBox("Receive DataPack Failed!");
        }
        //判断数据包类型
        if('M' == DataPack.cType)    //包为文件信息
        {
            //接收文件信息
            FileInfor.ulFileLen = DataPack.FileInfor.ulFileLen;  //获取文件长度
            strcpy(FileInfor.sFileName, DataPack.FileInfor.sFileName); //获取文件名称
            //得到文件目录
            char sFilePath[FILE_NAME_MAX];
            ZeroMemory(sFilePath, FILE_NAME_MAX);
            strcpy(sFilePath, lpPath);
            strcat(sFilePath, FileInfor.sFileName);
            strcat(sFilePathAndName, sFilePath);    //保存完整的文件路径
            //创建文件
            SECURITY_ATTRIBUTES attr;
            attr.nLength = FileInfor.ulFileLen;
            attr.lpSecurityDescriptor = NULL;
            HANDLE hRe = CreateFile(sFilePath, GENERIC_WRITE, FILE_SHARE_WRITE, &attr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
            if(INVALID_HANDLE_VALUE == hRe)
                AfxMessageBox("创建文件失败!");
            bool bRe = ::CloseHandle(hRe);
            //可以开始接受文件
            bIsStartReceive = true;
        }else if('D' == DataPack.cType)        //包为文件数据
        {
            //打开文件
            char sPath[FILE_NAME_MAX];
            strcpy(sPath, sFilePathAndName);
            FILE *File = fopen(sPath, "ab");
            if(0 == File)
                AfxMessageBox("打开文件失败!");
            //设置文件缓冲区
            int nBuff = FILE_IO_BUFF;
            if(setvbuf(File, (char*)&nBuff, _IOFBF, sizeof(nBuff)))
                AfxMessageBox("设置文件缓冲区失败!");
            //定位文件
            u_long nPosition = DataPack.nPosition;
            int nRe = fseek(File, nPosition, SEEK_SET);
            if(nRe)
                AfxMessageBox("SendDataThrad中定位失败!");
            //写文件
            u_long nNumberOfBytesWritten = fwrite(&DataPack.sContent, 1, DataPack.nContentLen, File);
            if(DataPack.nContentLen != nNumberOfBytesWritten)
                AfxMessageBox("写文件失败!");
            else
            {
                ulWriteByteCount += nNumberOfBytesWritten;
            }
            fflush(File);                                //清除文件缓冲区
            //关闭文件
            nRe = fclose(File);
            if(nRe)
                AfxMessageBox("关闭文件失败!");

            if(ulWriteByteCount >= FileInfor.ulFileLen)
            {
                AfxMessageBox("接收结束");
                break;
            }    
        }
    }
    return 0;
}