Socket在阻塞模式下的信息收发和文件接收

概述：

收发数据是网络编程的主题，在套接字上收发数据我们可以使用send和recv，当然还有Winsock2的WSASend和WSARecv。我们这里只讨论send和recv。

套接字可以工作在阻塞态和非阻塞态，，阻塞态就是函数调用会停住，非阻塞态就是函数调用会立刻返回，待到后面的某个时间点在去取得结果。我们这里先讨论阻塞态。

收发信息就是在Socket上收发二进制流。而收发文件实际上也就是收发信息，只是多了打开文件，把文件数据读成二进制流传到SOCKET上去和在接收端把二进制流写进一个文件里去这两步。

为什么要写这篇文章：

为什么要讨论这个主题呢？因为我在一个项目中使用信息收发的时候，发现会出现一些莫名其妙的现象，就是有时候某台机器可以顺利运行，但另外的机器又不能好好执行，而某台机器有时候正常运行，有时候在运行时又会出现运行时的错误。

我知道这肯定是一些内存的操作引起的，这涉及到具体的项目内容就不谈了，这里重点说一下如何正确的进行SOCKET上信息的收发和文件的收发。如果没耐心的人可以直接到下面去看代码，把这些函数运用到MFC程序里去会省去很多事。（代码用了Cstring，所以只适合MFC程序，如果要其他用途可以根据函数的算法来重写）。

关键问题（Key Point）：

关键问题在于send和recv这两个函数。

send函数原型：

int send(
  SOCKET s,             
  const char FAR *buf, 
  int len,              
  int flags             
);

这里S是套接字句柄，buf是存放准备发出去数据的缓冲区，长度是缓冲区中数据的长度。Flag给0吧。暂时不管（可以查看MSDN）。返回值是实际发出去的字节长度。（在非阻塞态实际发出的字节数可能会比指定的len的数量少，这是另一种情况）。

这就很好理解了，我给出一个本地的缓冲区，在len那里指定数据的长度，然后通过send 就发出去。这有什么难呢？别急，我们再来看看接收函数recv。

recv函数原型：

int recv(
  SOCKET s,      
  char FAR *buf, 
  int len,       
  int flags      
);

这里S是套接字句柄，buf是存放准备接收数据的缓冲区，长度是缓冲区的长度。Flag给0吧。暂时不管（可以查看MSDN）。返回值是实际接收到的字节长度。

问题就是这个recv收到的字节数不一定和我们给出的buf的字节数一样。会根据网络状态随机变化。那我们如何在发送端和接收端协调好这种字节的收发呢？（要知道，阻塞态的套接字讲究的就是字节的协调，就是这个阶段我给你多少字节，你就只能接收多少字节，多一个或者少一个都会把后面的字节流打乱了）。

所以我们要想个办法来定义好字节数量的收发。定个协议，检测头尾？也可以，这可以自己去发挥。为了说明问题，我们这里用的是最土的方法，就是每次都发送300个字节，接收方也接收300字节。

在接收方能不能这样？

recv(hSocket, szBuf,  300, 0)

这样就能把300个字节接收过来了吗？事实证明这样是不行的，你可能收到200、220、150等等没规律的数字，如果这样，那SOCKET上的字节流岂不是被搞乱了，对，就是被搞乱了，随之而来的就是程序的崩溃，莫名其妙的错误。

收发信息--解决方法

我们要如何解决这个问题呢？

首先第一个想法就是，如果收的字节没达到我的要求数目时，要继续接收，并且填在缓冲区中。好这个想法完全正确，那如何在代码中表现出来呢？首先我需要一个变量表示接收了多少，或者还有多少没接收，然后循环的接收，直到满足了我要接收的字节数，这才算一次成功的接收。收发的代码如下：

/*****************************************************************************\
 * hSocket:   套接字句柄
 * nRecvSize: 需要接收的字节数
 * strOut:    用字串返回接收到的字节流
\*****************************************************************************/
BOOL CDGSocket::Recv(SOCKET hSocket, int nRecvSize, CString &strOut)
{
 BOOL bRet = TRUE;
 char *pszBuf = new char[nRecvSize];
 int nLeftToRecv = nRecvSize;

 do
 {
  // 取得要开始写入的地址
  char *pLeftBuf = (char *) ( pszBuf + (nRecvSize - nLeftToRecv) );

  // 接收字节流
  int nRecvBytes = recv(hSocket, pLeftBuf, nLeftToRecv, 0);
  
  // 判断一下是否出错了
  if(nRecvBytes == SOCKET_ERROR)
  {
   MyOutput("My Recv Error!");
   bRet = FALSE;
   goto FINAL;   
  }
  
  nLeftToRecv -= nRecvBytes;
  
 } while(nLeftToRecv > 0);

    strOut = pszBuf;

FINAL:
 delete []pszBuf;
 return bRet;
}

/*****************************************************************************\
 * hSocket:   套接字句柄
 * nRecvSize: 需要发送的字节数
 * pStr:      要发送出去的字节流
\*****************************************************************************/
BOOL CDGSocket::Send(SOCKET hSocket, int nSendSize, LPCTSTR pStr)
{
 BOOL bRet = TRUE;

 if(send(hSocket, pStr, nSendSize, 0) == SOCKET_ERROR)
 {
         MyOutput("My Send Error!");
  bRet = FALSE;
 }

 return bRet;
}

收发文件--解决方法

上面已经说过收发文件实际也是收发信息，只是多了把文件信息变为字节流这一步。下面给出了配对的示例代码：

/*****************************************************************************\
 * hSocket:   套接字句柄
 * fName:    发送的本地文件路径
\*****************************************************************************/
BOOL CDGSocket::SendFile(SOCKET hSocket, CString fName)
{
 BOOL bRet = TRUE;
 int fileLength, cbLeftToSend;

 // pointer to buffer for sending data (memory is allocated after sending file size)
 BYTE* sendData = NULL;
 CFile sourceFile;
 CFileException fe;
 BOOL bFileIsOpen = FALSE;

 if( !( bFileIsOpen = sourceFile.Open( fName, CFile::modeRead | CFile::typeBinary, &fe ) ) )
 {
  TCHAR strCause[256];
  fe.GetErrorMessage( strCause, 255 );
  TRACE( "SendFileToRemoteRecipient encountered an error while opening the local file\n"
   "\tFile name = %s\n\tCause = %s\n\tm_cause = %d\n\tm_IOsError = %d\n",
   fe.m_strFileName, strCause, fe.m_cause, fe.m_lOsError );
  
  /* you should handle the error here */
  
  bRet = FALSE;
  goto PreReturnCleanup;
 }
 
 // first send length of file
 fileLength = sourceFile.GetLength();
 fileLength = htonl( fileLength );
 cbLeftToSend = sizeof( fileLength );
 
 do
 {
  int cbBytesSent;
  const char* bp = (const char*)(&fileLength) + sizeof(fileLength) - cbLeftToSend;
  cbBytesSent = send(hSocket, bp, cbLeftToSend, 0);
  
  // test for errors and get out if they occurred
  if ( cbBytesSent == SOCKET_ERROR )
  {
   int iErr = ::GetLastError();
   TRACE( "SendFileToRemoteRecipient returned a socket error while sending file length\n"
    "\tNumber of Bytes sent = %d\n"
    "\tGetLastError = %d\n", cbBytesSent, iErr );
   
   /* you should handle the error here */

   bRet = FALSE;
   goto PreReturnCleanup;
  }
  
  // data was successfully sent, so account for it with already-sent data
  cbLeftToSend -= cbBytesSent;
 }
 while ( cbLeftToSend > 0 );
 
 // now send the file's data
 
 sendData = new BYTE[SEND_BUFFER_SIZE];
 
 cbLeftToSend = sourceFile.GetLength();
 
 do
 {
  // read next chunk of SEND_BUFFER_SIZE bytes from file
  
  int sendThisTime, doneSoFar, buffOffset;
  
  sendThisTime = sourceFile.Read( sendData, SEND_BUFFER_SIZE );
  buffOffset = 0;
  
  do
  {
   doneSoFar = send(hSocket, (const char*)(sendData + buffOffset), sendThisTime, 0);
   
   // test for errors and get out if they occurred
   if ( doneSoFar == SOCKET_ERROR )
   {
    int iErr = ::GetLastError();
    TRACE( "SendFileToRemoteRecipient returned a socket error while sending chunked file data\n"
     "\tNumber of Bytes sent = %d\n"
     "\tGetLastError = %d\n", doneSoFar, iErr );
    
    /* you should handle the error here */
    
    bRet = FALSE;
    goto PreReturnCleanup;
   }
   
/***************************
  un-comment this code and put a breakpoint here to prove to yourself that sockets can send fewer bytes than requested
    
   if ( doneSoFar != sendThisTime )
   {
    int ii = 0;
   }
****************************/
   
   // data was successfully sent, so account for it with already-sent data
   
   buffOffset += doneSoFar;
   sendThisTime -= doneSoFar;
   cbLeftToSend -= doneSoFar;
  }
  while ( sendThisTime > 0 );
  
 }
 while ( cbLeftToSend > 0 );
 
 
PreReturnCleanup:  // labelled goto destination
 
 // free allocated memory
 // if we got here from a goto that skipped allocation, delete of NULL pointer
 // is permissible under C++ standard and is harmless
 delete[] sendData;
 
 if ( bFileIsOpen )
  sourceFile.Close();  // only close file if it's open (open might have failed above)
 
 return bRet;
}

/*****************************************************************************\
 * hSocket:   套接字句柄
 * fName:    要接收到本地的文件路径
\*****************************************************************************/
BOOL CDGSocket::RecvFile(SOCKET hSocket, CString fName)
{
 BOOL bRet = TRUE;        // return value
 
 int dataLength, cbBytesRet, cbLeftToReceive; // used to monitor the progress of a receive operation
 
 BYTE* recdData = NULL; // pointer to buffer for receiving data (memory is allocated after obtaining file size)
 
 CFile destFile;
 CFileException fe;
 BOOL bFileIsOpen = FALSE;
 
 // open/create target file that receives the transferred data
 
 if( !( bFileIsOpen = destFile.Open( fName, CFile::modeCreate | CFile::modeWrite | CFile::typeBinary, &fe ) ) )
 {
  TCHAR strCause[256];
  fe.GetErrorMessage( strCause, 255 );
  
  MyOutput(fName);

  CString strErrMsg;
  strErrMsg.Format("GetFileFromRemoteSender encountered an error while opening the local file\n"
   "\tFile name = %s\n\tCause = %s\n\tm_cause = %d\n\tm_IOsError = %d\n",
   fe.m_strFileName, strCause, fe.m_cause, fe.m_lOsError);

  MyOutput( strErrMsg );
  
  /* you should handle the error here */
  
  bRet = FALSE;
  goto PreReturnCleanup;
 }
 
 
 // get the file's size first
 
 cbLeftToReceive = sizeof( dataLength );
 
 do
 {
  char* bp = (char*)(&dataLength) + sizeof(dataLength) - cbLeftToReceive;
  cbBytesRet = recv(hSocket, bp, cbLeftToReceive, 0);
  
  // test for errors and get out if they occurred
  if ( cbBytesRet == SOCKET_ERROR || cbBytesRet == 0 )
  {
   int iErr = ::GetLastError();
   CString strErr;
   strErr.Format("GetFileFromRemoteSite returned a socket error while getting file length\n"
    "\tNumber of Bytes received (zero means connection was closed) = %d\n"
    "\tGetLastError = %d\n", cbBytesRet, iErr );
  
   /* you should handle the error here */
   
   MyOutput(strErr);

   bRet = FALSE;
   goto PreReturnCleanup;
  }
  
  // good data was retrieved, so accumulate it with already-received data
  cbLeftToReceive -= cbBytesRet;
  
 }
 while ( cbLeftToReceive > 0 );
 
 dataLength = ntohl( dataLength );
 
 
 // now get the file in RECV_BUFFER_SIZE chunks at a time
 
 recdData = new byte[RECV_BUFFER_SIZE];
 cbLeftToReceive = dataLength;
 
 do
 { 
  int iiGet, iiRecd;
  
  iiGet = (cbLeftToReceive<RECV_BUFFER_SIZE) ? cbLeftToReceive : RECV_BUFFER_SIZE ;
  iiRecd = recv(hSocket, (char *)recdData, iiGet, 0);
  
  // test for errors and get out if they occurred
  if ( iiRecd == SOCKET_ERROR || iiRecd == 0 )
  {
   int iErr = ::GetLastError();
   TRACE( "GetFileFromRemoteSite returned a socket error while getting chunked file data\n"
    "\tNumber of Bytes received (zero means connection was closed) = %d\n"
    "\tGetLastError = %d\n", iiRecd, iErr );
   
   /* you should handle the error here */
   
   bRet = FALSE;
   goto PreReturnCleanup;
  }

/************************* 
  un-comment this code and put a breakpoint here to prove to yourself that sockets can return fewer bytes than requested
   
   if ( iiGet != iiRecd )
   {
   int ii=0;
   }   
***************************/
  
  // good data was retrieved, so accumulate it with already-received data
  
  destFile.Write( recdData, iiRecd); // Write it
  cbLeftToReceive -= iiRecd;
  
 }
 while ( cbLeftToReceive > 0 );
 
 
PreReturnCleanup:  // labelled "goto" destination
 
 // free allocated memory
 // if we got here from a goto that skipped allocation, delete of NULL pointer
 // is permissible under C++ standard and is harmless
 delete[] recdData;  

 if ( bFileIsOpen )
  destFile.Close(); // only close file if it's open (open might have failed above)

 return bRet;
}

发表于 @ 2006年06月29日 15:28:00|评论(loading...)|编辑