socket 发送文件

服务器端:

1. UINT CFileTransferServerView::ThreadedSendFileToRemoteRecipient(LPVOID pVoid)
2. {
3.     CFileTransferServerView* pThis = (CFileTransferServerView*)pVoid;
4.     pThis->PostMessage( UWM_FILESENDEVENT, FSE_THREADSTART, 0L );
5.     
6.     AfxSocketInit(NULL);    // make certain this is done somewhere in each thread (usually in InitInstance for main thread)
7.     CSocket sockSrvr; 
8.     sockSrvr.Create(PRE_AGREED_PORT); // Creates our server socket
9.     sockSrvr.Listen(); // Start listening for the client at PORT
10.     CSocket sockConnection;
11.     sockSrvr.Accept(sockConnection); // Use another CSocket to accept the connection
12.     
13.     pThis->PostMessage( UWM_FILESENDEVENT, FSE_STATUSCONNECTED, 0L );
14.     
15.     // local variables used in file transfer (declared here to avoid "goto skips definition"-style compiler errors)
17.     int fileLength, cbLeftToSend;   // used to monitor the progress of a sending operation
18.     int simulate;   // used to simulate mismatch events (if designated by user)
19.     
20.     BYTE* sendData = NULL;  // pointer to buffer for sending data (memory is allocated after sending file size)
21.     
22.     int pbInterval = 0; int curPB = 0;  // progress bar variables
23.     
24.     
25.     CFile sourceFile;
26.     CFileException fe;
27.     BOOL bFileIsOpen = FALSE;
28.     
29.     if( !( bFileIsOpen = sourceFile.Open( pThis->m_strFileName, CFile::modeRead | CFile::typeBinary, &fe ) ) )
30.     {
31.         TCHAR strCause[256];
32.         fe.GetErrorMessage( strCause, 255 );
33.         TRACE( "SendFileToRemoteRecipient encountered an error while opening the local file/n"
34.             "/tFile name = %s/n/tCause = %s/n/tm_cause = %d/n/tm_IOsError = %d/n",
35.             fe.m_strFileName, strCause, fe.m_cause, fe.m_lOsError );
37.         /* you should handle the error here */
39.         goto PreReturnCleanup;
40.     }
42.     
43.     
44.     // first send length of file
45.     
46.     fileLength = sourceFile.GetLength();
47.     fileLength = htonl( fileLength );
48.     
49.     cbLeftToSend = sizeof( fileLength );
50.     
51.     // Inject mismatch events (if selected by user)
52.     // Seed the random-number generator with current time 
53.     srand( (unsigned)time( NULL ) );
54.     
55.     simulate = 1 + rand() % 2;  // either 1 or 2
56.     simulate = ( pThis->m_bSimulateEvents ) ? simulate : 0; // zero if user de-selected event simulation
57.     
58.     do
59.     {
60.         int cbBytesSent;
61.         BYTE* bp = (BYTE*)(&fileLength) + sizeof(fileLength) - cbLeftToSend;
62.         cbBytesSent = sockConnection.Send( bp, cbLeftToSend - simulate );
63.         simulate = 0;
64.         
65.         // test for errors and get out if they occurred
66.         if ( cbBytesSent == SOCKET_ERROR )
67.         {
68.             int iErr = ::GetLastError();
69.             TRACE( "SendFileToRemoteRecipient returned a socket error while sending file length/n"
70.                 "/tNumber of Bytes sent = %d/n"
71.                 "/tGetLastError = %d/n", cbBytesSent, iErr );
72.             
73.             /* you should handle the error here */
74.             
75.             goto PreReturnCleanup;
76.         }
77.         
78.         // data was successfully sent, so account for it with already-sent data
79.         cbLeftToSend -= cbBytesSent;
80.     }
81.     while ( cbLeftToSend>0 );
82.     
83.     
84.     // now send the file's data
85.     
86.     sendData = new BYTE[SEND_BUFFER_SIZE]; 
87.     
88.     cbLeftToSend = sourceFile.GetLength();
89.     
90.     
91.     // set up progress bar
92.     
93.     fileLength = cbLeftToSend;
94.     pbInterval = fileLength>>7;     // divide by 128
95.     curPB = 0;
96.     
97.     pThis->m_ctlProgressSend.PostMessage( PBM_SETPOS, (WPARAM) curPB, 0L );
98.     
99.     do
100.     {
101.         // read next chunk of SEND_BUFFER_SIZE bytes from file
102.     
103.         int sendThisTime, doneSoFar, buffOffset;
104.         
105.         sendThisTime = sourceFile.Read( sendData, SEND_BUFFER_SIZE );
106.         buffOffset = 0;
107.         
108.         // simulate mismatch events
109.         
110.         simulate = rand();
111.         simulate = ( simulate>RAND_MAX/10 ) ? 0 : 2560*simulate/RAND_MAX ;  // up to 256 but only inject mismatches 10% of the time
112.         simulate = ( pThis->m_bSimulateEvents ) ? simulate : 0 ;    // zero if user de-selected event simulation
113.         
114.         do
115.         {
116.             doneSoFar = sockConnection.Send( sendData + buffOffset, sendThisTime - simulate ); 
117.             simulate = 0;
118.             
119.             // test for errors and get out if they occurred
120.             if ( doneSoFar == SOCKET_ERROR )
121.             {
122.                 int iErr = ::GetLastError();
123.                 TRACE( "SendFileToRemoteRecipient returned a socket error while sending chunked file data/n"
124.                     "/tNumber of Bytes sent = %d/n"
125.                     "/tGetLastError = %d/n", doneSoFar, iErr );
126.                 
127.                 /* you should handle the error here */
128.                 
129.                 goto PreReturnCleanup;
130.             }
131.             
132.             // data was successfully sent, so account for it with already-sent data
133.             // but first, advise main thread of a send mismatch if everything was not sent in one shot
134.             
135.             if ( doneSoFar != sendThisTime )
136.             {
137.                 pThis->m_iNumMismatches++;
138.                 pThis->PostMessage( UWM_FILESENDEVENT, FSE_UPDATECONTROLS, 0L );
139.             }
140.             
141.             buffOffset += doneSoFar;
142.             sendThisTime -= doneSoFar;
143.             cbLeftToSend -= doneSoFar;
144.         }
145.         while ( sendThisTime > 0 );
146.         
147.         // update progress bar
148.         
149.         if ( pbInterval*curPB < (fileLength-cbLeftToSend) )
150.         {
151.             curPB++;
152.             pThis->m_ctlProgressSend.PostMessage( PBM_SETPOS, (WPARAM) curPB, 0L );
153.         }
154.         
155.     }
156.     while ( cbLeftToSend > 0 );
157.     
158.     
159. PreReturnCleanup:       // labelled goto destination
160.     
161.     // free allocated memory
162.     // if we got here from a goto that skipped allocation, delete of NULL pointer
163.     // is permissible under C++ standard and is harmless
164.     delete[] sendData;
165.     
166.     if ( bFileIsOpen )
167.         sourceFile.Close();     // only close file if it's open (open might have failed above)
168.     
169.     sockConnection.Close();
170.     
171.     // advise main thread that we're completed
172.     pThis->PostMessage( UWM_FILESENDEVENT, FSE_THREADCOMPLETE, 0L );
173.     
174.     return 0;
175.     
176. }

 

客户端:

1. UINT CFileTransferClientView::ThreadedGetFileFromRemoteSender(LPVOID pVoid)
2. {
3.     CFileTransferClientView* pThis = (CFileTransferClientView*)pVoid;
4.     
5.     // advise main thread that this thread has started
6.     
7.     pThis->PostMessage( UWM_GETFILEEVENT, GFE_THREADSTART, 0L );
8.     
9.     // create client socket and connect to server
11.     AfxSocketInit(NULL);    // make certain this is done somewhere in each thread (usually in InitInstance for main thread)
12.     CSocket sockClient;
13.     sockClient.Create();
14.     
15.     sockClient.Connect( pThis->m_strTargetIP, PRE_AGREED_PORT );    // PRE_AGREED_PORT is #define'd as 8686
17.     pThis->PostMessage( UWM_GETFILEEVENT, GFE_STATUSCONNECTED, 0L );
20.     // local variables used in file transfer (declared here to avoid "goto skips definition"-style compiler errors)
22.     int dataLength, cbBytesRet, cbLeftToReceive;    // used to monitor the progress of a receive operation
23.     int simulate;       // used to simulate mismatch events (if designated by user)
25.     BYTE* recdData = NULL;  // pointer to buffer for receiving data (memory is allocated after obtaining file size)
27.     int pbInterval = 0; int curPB = 0;  // progress bar variables
29.     CFile destFile;
30.     CFileException fe;
31.     BOOL bFileIsOpen = FALSE;
32.     
33.     // open/create target file that receives the transferred data
35.     if( !( bFileIsOpen = destFile.Open( pThis->m_strFileName, 
36.         CFile::modeCreate | CFile::modeWrite | CFile::typeBinary, &fe ) ) )
37.     {
38.         TCHAR strCause[256];
39.         fe.GetErrorMessage( strCause, 255 );
40.         TRACE( "GetFileFromRemoteSender encountered an error while opening the local file/n"
41.             "/tFile name = %s/n/tCause = %s/n/tm_cause = %d/n/tm_IOsError = %d/n",
42.             fe.m_strFileName, strCause, fe.m_cause, fe.m_lOsError );
44.         /* you should handle the error here */
46.         goto PreReturnCleanup;
47.     }
50.     // get the file's size first
51.     
52.     cbLeftToReceive = sizeof( dataLength );
54.     // Inject mismatch events (if selected by user)
55.     // Seed the random-number generator with current time 
56.     srand( (unsigned)time( NULL ) );
58.     simulate = 1 + rand() % 2;  // either 1 or 2
59.     simulate = ( pThis->m_bSimulateEvents ) ? simulate : 0; // zero if user de-selected event simulation
61.     do
62.     {
63.         BYTE* bp = (BYTE*)(&dataLength) + sizeof(dataLength) - cbLeftToReceive;
64.         cbBytesRet = sockClient.Receive( bp, cbLeftToReceive - simulate );
65.         simulate = 0;
67.         // test for errors and get out if they occurred
68.         if ( cbBytesRet == SOCKET_ERROR || cbBytesRet == 0 )
69.         {
70.             int iErr = ::GetLastError();
71.             TRACE( "GetFileFromRemoteSite returned a socket error while getting file length/n"
72.                 "/tNumber of Bytes received (zero means connection was closed) = %d/n"
73.                 "/tGetLastError = %d/n", cbBytesRet, iErr );
74.             
75.             /* you should handle the error here */
76.             
77.             goto PreReturnCleanup;
78.         }
80.         // good data was retrieved, so accumulate it with already-received data
81.         cbLeftToReceive -= cbBytesRet;
83.     }
84.     while ( cbLeftToReceive > 0 );
86.     dataLength = ntohl( dataLength );
88.     
89.     // set up progress bar based on expected length of file
91.     pbInterval = dataLength>>7;     // divide by 128
92.     curPB = 0;
94.     pThis->m_ctlProgressGet.PostMessage( PBM_SETPOS, (WPARAM) curPB, 0L );
97.     // now get the file in RECV_BUFFER_SIZE chunks at a time
98.     
99.     recdData = new byte[RECV_BUFFER_SIZE];
100.     cbLeftToReceive = dataLength;
101.     
102.     do
103.     {   
104.         int iiGet, iiRecd;
106.         // simulate mismatch events
107.         
108.         simulate = rand();
109.         simulate = ( simulate>RAND_MAX/10 ) ? 0 : 2560*simulate/RAND_MAX ;  // up to 256 but only inject mismatches 10% of the time
110.         simulate = ( pThis->m_bSimulateEvents ) ? simulate : 0 ;    // zero if user de-selected event simulation
111.         
112.         iiGet = (cbLeftToReceive<RECV_BUFFER_SIZE) ? cbLeftToReceive : RECV_BUFFER_SIZE ;
113.         iiRecd = sockClient.Receive( recdData, iiGet - simulate );
114.         simulate = 0;
115.         
116.         // test for errors and get out if they occurred
117.         if ( iiRecd == SOCKET_ERROR || iiRecd == 0 )
118.         {
119.             int iErr = ::GetLastError();
120.             TRACE( "GetFileFromRemoteSite returned a socket error while getting chunked file data/n"
121.                 "/tNumber of Bytes received (zero means connection was closed) = %d/n"
122.                 "/tGetLastError = %d/n", iiRecd, iErr );
124.             /* you should handle the error here */
125.             
126.             goto PreReturnCleanup;
127.         }
129.         // good data was retrieved, so accumulate it with already-received data
130.         // but first, advise main thread of a receive mismatch if we have not yet received everything expected
132.         if ( iiGet != iiRecd )
133.         {
134.             pThis->m_iNumMismatches++;
135.             pThis->PostMessage( UWM_GETFILEEVENT, GFE_UPDATECONTROLS, 0L );
136.         }
138.         destFile.Write( recdData, iiRecd); // Write it
139.         cbLeftToReceive -= iiRecd;
141.         // update progress bar
143.         if ( pbInterval*curPB < (dataLength-cbLeftToReceive) )
144.         {
145.             curPB++;
146.             pThis->m_ctlProgressGet.PostMessage( PBM_SETPOS, (WPARAM) curPB, 0L );
147.         }
149.     } 
150.     while ( cbLeftToReceive > 0 );
153.     
154. PreReturnCleanup:       // labelled "goto" destination
156.     // free allocated memory
157.     // if we got here from a goto that skipped allocation, delete of NULL pointer
158.     // is permissible under C++ standard and is harmless
159.     delete[] recdData;      
161.     if ( bFileIsOpen )
162.         destFile.Close();   // only close file if it's open (open might have failed above)
164.     sockClient.Close();
166.     pThis->PostMessage( UWM_GETFILEEVENT, GFE_THREADCOMPLETE, 0L );
167.     
168.     return 0;
169. }

这个程序是从服务器发送数据到客户端,第一步先发送要发送的文件的大小.然后才开始发送文件.