socket实现大型文件传输

最近需要做网络传输的项目，需要实现较大文件的传输。在网上收集了不少资料，但是各有各的做法，尤其是关于文件自动接收这一块不太清楚。 经过图书馆查阅后还是找到了一种解决办法，虽然做的不太专业，但是思路比较精简、清晰，也希望能给大家尤其是刚学习socket套接字的人一些启示。

                               

   对于套接字socket我其实也不太懂，并且一般资料都可以查找到，所以不交易累赘了，直接说如何实现文件的传输吧。

    对于发送文件，有三步：发送文件长度，发送文件名，发送文件内容。 

    关于发送文件内容，又可以根据文件大小进行直接传输和分块传输，如果是分块传输还需要多线程，否则会容易使程序失去响应。 在这里其实我也有一个疑惑，就是通过CFileDialog类GetFileName函数获取文件名，一般没有问题，但是当文件名很长（如大于60）时不能完整读取，导致接收方无法判别文件类型。 所以保险起见，我就从GetFilePath中截取出了文件名。

[cpp]  view plain copy print ?

1. void CChatDlg::OnSend()   
2. {  
3.     if(flag==-1)  
4.     {  
5.         MessageBox("处于未连接状态");  
6.         return;  
7.     }  
8.       
9.     CFileDialog  dlg(TRUE);  
10.     dlg.m_ofn.lpstrTitle="选择图片";  
11.     dlg.m_ofn.lpstrFilter="All Files";  
12.     CString path="";  
13.     CString name="";  
14.     if(dlg.DoModal()==IDOK)  
15.     {  
16.         path=dlg.GetPathName();//获取文件路径名  
17.         //name=dlg.GetFileName();//获取文件名  
18.     }  
19.     if(path=="")  
20.         return ;//表示没有选择任何元素  
21.   
22.      //不直接读取文件名，而是从路径名中截取  
23.     int pos=0,start=0;  
24.     while(1)  
25.     {  
26.         start=pos;  
27.         pos=path.Find('\\',start+1);  
28.         if(pos<0)  
29.             break;  
30.     }  
31.     name=path.Right(path.GetLength()-start-1);  
32.     file.Open(path,CFile::modeRead);//打开文件  
33.      dwlen=file.GetLength();//获取文件长度  
34.     m_se.SetRange32(0,dwlen);  
35.     CString te;  
36.     te.Format("%d",dwlen);  
37.     if(flag==0)//发送图片数据  
38.         send(m_accept, te.GetBuffer(0), 10, 0);//发送文件的长度  
39.     if(flag==1)  
40.         send(m_local, te.GetBuffer(0), 10, 0);  
41.     Sleep(500);//延时  
42.       
43.     if(flag==0)//发送图片数据  
44.         send(m_accept, name.GetBuffer(0), name.GetLength(), 0);//发送文件的名  
45.     if(flag==1)  
46.         send(m_local, name.GetBuffer(0), name.GetLength(), 0);  
47.     Sleep(500);//延时  
48.       
49.       
50.     if(dwlen<=1024*1024)//如果小于1M就直接传输  
51.     {  
52.         if(date!=NULL)  
53.         {  
54.             delete []date;  
55.             date=NULL;  
56.         }  
57.         date=new char[dwlen];//开辟neicun  
58.         memset(date,0,dwlen);//初始化  
59.         file.Read(date,dwlen);//读取文件  
60.         file.Close();  
61.         int n=0;  
62.         if(flag==0)//发送图片数据  
63.             n=send(m_accept, date, dwlen, 0);  
64.         if(flag==1)  
65.             n=send(m_local, date, dwlen, 0);  
66.         m_se.SetPos(n);  
67.         CString ss;  
68.         ss.Format("%d   %d",dwlen,n);    
69.         ss+="发送完成";  
70.         MessageBox(ss);  
71.         delete []date;  
72.         date=NULL;  
73.     }  
74.     else  
75.     {  
76.        //需要选择多线程，创建一个线程  
77.         p_thread=AfxBeginThread(SEND,this,0,0,0,NULL);//开启一个线程  
78.     }     
79. }  

    注解中的什么图片的是错误的，是可以传输任意格式的文件的。大家可以看到我提取文件名的过程繁琐，原因我

上面一段已经说明了，也希望大家更好的解决方法。其中flag的值时表示是服务端还是客户端，0-服务端，1-客户端，集合在了一个程序中。  

     注意：：： 其中的Sleep(500)的延时是因为为了让接受方有足够多的时间获取文件长度和文件名关键信息，如果不延时，接收方会先接受到文件内容后接收到文件长度和文件名，顺序是相反的，具体原因我也没弄清楚，希望大家指教。

      最后是关于一个线程的函数，具体如下：

[cpp]  view plain copy print ?

1. UINT SEND(LPVOID pThreadParam)//线程函数  
2. {  
3.     CChatDlg *dlg=(CChatDlg *)pThreadParam;  
4.     if(date!=NULL)  
5.         {  
6.             delete []date;  
7.             date=NULL;  
8.         }  
9.         int total=0,len=0;  
10.         while(total<dwlen)//直到全部发送完成  
11.         {   
12.                 if(dwlen-total>=1024*100)  
13.                 {  
14.                    date=new char[1024*100];  
15.                    memset(date,0,1024*100);  
16.                    file.Read(date,1024*100);  
17.                    if(dlg->flag==0)//发送数据  
18.                     len=send(dlg->m_accept, date, 1024*100, 0);  
19.                 if(dlg->flag==1)  
20.                     len=send(dlg->m_local, date, 1024*100, 0);  
21.                 }  
22.                 else  
23.                 {  
24.                     date=new char[dwlen-total];  
25.                      memset(date,0,dwlen-total);  
26.                     file.Read(date,dwlen-total);  
27.                     if(dlg->flag==0)//发送数据  
28.                     len=send(dlg->m_accept, date, dwlen-total, 0);  
29.                     if(dlg->flag==1)  
30.                     len=send(dlg->m_local, date, dwlen-total, 0);  
31.                 }  
32.             Sleep(1);  
33.             total+=len;//累计已经发送的数据  
34.             dlg->m_se.SetPos(total);  
35.             delete []date;  
36.             date=NULL; //回收内存空间  
37.         }  
38.         file.Close();  
39.         CString ss;  
40.         ss.Format("%d",total);    
41.         ss+="发送完成";  
42.         MessageBox(dlg->m_hWnd,ss,"提示",MB_OK);  
43.            
44.         DWORD exit=0;  
45.    
46.         BOOL ret=GetExitCodeThread(dlg->p_thread->m_hThread,&exit);//获取线程退出代码  
47.         if(exit==STILL_ACTIVE) //如果进程仍在进行  
48.         {  
49.             dlg->p_thread->ExitInstance();//退出进程  
50.             dlg->p_thread=NULL;  
51.         }  
52.       
53.     return 0;  
54. }  

   线程的好处是不会让程序失去响应，而且对于大型文件传输来说这是必须的。

    其次，关于文件的接受，就是一个注册的OnSocket中的FD_READ,通过这个方式设置WSAAsyncSelect模型的。

[cpp]  view plain copy print ?

1. int nRet = WSAAsyncSelect(m_local, m_hWnd, WM_SOCKET, FD_ACCEPT|FD_CONNECT|FD_READ|FD_WRITE|FD_CLOSE);  
2.     if (nRet != 0)  
3.     {  
4.         TRACE("设置WSAAsyncSelect模型失败");  
5.     }  
6.       

    关于OnSocket 函数完整如下，处理FD_READ|FD_CONNECT|FD_ACCEPT等消息

[cpp]  view plain copy print ?

1. void CChatDlg::OnSocket(WPARAM wParam,LPARAM lParam)  
2. {  
3.     int nError = WSAGETSELECTERROR(lParam);     //读取错误代码  
4.     int nEvent = WSAGETSELECTEVENT(lParam);     //读取网络事件  
5.     SOCKET sock = wParam;  
6.     switch (nEvent)   
7.     {  
8.     case FD_ACCEPT:  
9.         {  
10.             //接收客户端的连接  
11.             closesocket(m_accept);  
12.             sockaddr_in sockAddr;  
13.             int nAddrSize = sizeof(sockaddr_in);  
14.             m_accept = accept(sock, (sockaddr*)&sockAddr, &nAddrSize);  
15.             WSAAsyncSelect(m_accept, m_hWnd, WM_SOCKET, FD_CLOSE|FD_READ);  
16.             state=true;  
17.             flag=0; //表示作为服务器  
18.             m_connect.EnableWindow(FALSE);//由于被连接，需要是连接功能丧失  
19.             break;  
20.         }  
21.     case FD_READ:   //接收数据  
22.         {  
23.             switch(flag1)  
24.             {  
25.             case 1:  
26.                 memset(buffer,0,10);  
27.                 recv(sock, buffer, 10, 0);//这个语句用于接收文件的长  
28.                    m_length=atoi(buffer);  
29.                    UpdateData(false);  
30.                    flag1=2;  //做接下来一步  
31.                    m_get.SetRange32(0,m_length); //设置接受进度条的范围  
32.                    break;  
33.             case 2: recv(sock, filename, 200, 0); //接受文件名  
34.                 flag1=3;//做接下来一步  
35.                 f.Open(filename,CFile::modeCreate|CFile::modeWrite);//创建一个文件  
36.                 break;  
37.             case 3:if(temp!=NULL)  
38.                    {  
39.                        delete [] temp;  
40.                        temp=NULL;  
41.                    }  
42.                 temp=new char[1024*56];//开辟一个内存  
43.                 memset(temp,0,1024*56);  
44.                 x=recv(sock,temp,1024*56,0);  
45.                 f.Write(temp,x);  
46.                 total+=x;  
47.                 m_get.SetPos(total);  
48.                 delete []temp;  
49.                 temp=NULL;  
50.                 if(total>=m_length)//表示接受完成  
51.                 {  
52.                     f.Close();  
53.                     memset(filename,0,200);  
54.                     flag1=1;  
55.                   CString sd; sd.Format("%d",total);sd+="接受完成";  
56.                   MessageBox(sd);  
57.                   total=x=0;  
58.                 }  
59.                 break;  
60.             }  
61.         }  
62.         break;  
63.     case FD_CLOSE:  
64.         {  
65.             if(flag==0)  
66.                 closesocket(m_accept);  
67.             state= FALSE;  
68.             flag=-1;  
69.             m_connect.EnableWindow(TRUE);//是连接功能恢复正常  
70.             break;  
71.         }  
72.     case FD_CONNECT:                            //连接网络事件  
73.         {  
74.             if(nError == 0)                     //连接成功  
75.             {  
76.                 state= TRUE;  
77.                 flag=1;//表示作为客户端  
78.                 MessageBox("连接成功");  
79.             }  
80.             break;  
81.         }  
82.           
83.     }     
84. }  

     其中接受就在FD_READ消息中，flag1-1接受文件长度,flag1-2接受文件名，flag1-3接受文件内容。

     当然整个函数太长了，本来应该一些语句应该设置成一些函数的，那样也更直观。

     这基本上是这个工程的全部了，还是比较简洁的。在同一台电脑上测试结果是：732577734字节共耗时114秒，平均6.12M/s,也不是体太慢。

       整个项目还是有不少弊端的，有疑惑的可以相互交流讨论。

    完整工程下载地址：

    http://download.csdn.net/detail/jin123wang/3937052

转自：http://blog.csdn.net/jin123wang/article/details/7081814/