天天看點
傳回

wxSocket 實作分析和使用總結 1. wxSocket 實作 2. wxSocketBase::Read/Write 3. 使用wxBufferedInputStream  4. reference

本編文章分析了wxSocket在Linux作業系統中的實作，并總結了相關使用方法。

wxSocket 屬于wxWidgets的wxNet子module。wxSocket是對系統socket API的簡單封裝，對外提供了wxEvent通知機制，屏蔽了作業系統相關的實作細節。使用者可以通過wxSocketClient/wxSocketServer來很友善的使用。

Note: 此處使用的wxWidgets 庫的版本是 v2.8.9，主要涉及到代碼檔案 src/common/sckstrm.cpp， src/common/socket.cpp 和 src/unix/gsocket.cpp。

1. wxSocket 實作

wxSocket相關類UML圖：

wxSocket 實作分析和使用總結 1. wxSocket 實作 2. wxSocketBase::Read/Write 3. 使用wxBufferedInputStream  4. reference

在wx的線上manual裡，可以看到wxNet相關的所有類。

1.1 主要操作接口

wxSocket主要的操作如下：

  1. basic IO 
     
  1.  - Close            
    2.       
  2.  - Discard            
    3.       
  3.  - Peek            
    4.       
  4.  - Unread            
    5.       
  5.  - Read            
    6.       
  6.  - ReadMsg            
    7.       
  7.  - Write            
    8.       
  8.  - WriteMsg            
    9.
  1. Socket state 
     
  1.  2. Functions to retrieve current state and miscellaneous info.            
    2.       
  2.   
    3.       
  3.  - Error            
    4.       
  4.  - GetLocal/GetPeer            
    5.       
  5.  - IsData            
    6.       
  6.  - IsDisconnected/IsConnected            
    7.       
  7.  - LastCount            
    8.       
  8.  - LastError            
    9.       
  9.  - IsOk            
    10.       
  10.  - SaveState/RestoreState            
    11.       
  11.   
    12.       
  12.  2. Functions that perform a timed wait on a certain IO condition.            
    13.       
  13.   
    14.       
  14.  - InterruptWait            
    15.       
  15.  - Wait            
    16.       
  16.  - WaitForLost            
    17.       
  17.  - WaitForRead/WaitForWrite            
    18.       
  18.  - and also:            
    19.       
  19.  - wxSocketServer::WaitForAccept            
    20.       
  20.  - wxSocketClient::WaitOnConnect            
    21.       
  21.   
    22.       
  22.  2. Functions that allow applications to customize socket IO as needed.            
    23.       
  23.   
    24.       
  24.  - GetFlags/SetFlags            
    25.       
  25.  - SetTimeout            
    26.       
  26.  - SetLocal            
    27.
  1. Handling socket events 
     
  1.  - Notify/SetNotify            
    2.       
  2.  - GetClientData/SetClientData            
    3.       
  3.  - SetEventHandler            
    4.

使用者可以友善的通過SetNotify來訂閱想要通知的事件。基于此，可以完全把Read/Write操作事件化。

1.2 wxSocketFlags

wxSocketFlags用來控制socket的運作模式，主要的flag如下：

wxSocketFlags 含義
wxSOCKET_BLOCK Block the GUI (do not yield) while reading/writing data. 
wxSOCKET_NOWAIT  Read/write as much data as possible and return immediately. 
wxSOCKET_WAITALL  Wait for all required data to be read/written unless an error occurs.

a. wxSOCKET_BLOCK表示在調用wxSocketBase::Read/Write的時候，不會觸發yield的操作。如果wxSocket本身在main thread裡面進行讀寫操作，程式此時會不響應UI消息。而且由于yield操作本身可能會導緻socket相關的操作重入（reentrant），這很可能不是使用者代碼想要的。是以一般推薦在wxSocket_BLOCK+thread環境下使用wxSocket，這樣socket的讀寫操作就不會阻塞UI thread。

b. wxSOCKET_WAITALL與wxSOCKET_NOWAIT正好相反，分别用于同步和異步讀寫。

1.3 wxSocket實作

wxSocket 對 系統socket函數進行封裝，内部的socket fd采用非阻塞模式。

src/unix/gsocket.cpp

     
  1.  m_fd = socket(m_peer->m_realfamily,m_stream?SOCK_STREAM:SOCK_DGRAM,0);            
    2.       
  2.  if(m_fd == INVALID_SOCKET)            
    3.       
  3.  {            
    4.       
  4.  m_error = GSOCKIOERR;            
    5.       
  5.  return GSOCK_IOERR;            
    6.       
  6.  }            
    7.       
  7.  #ifdef SO_NOSIGPIPE            
    8.       
  8.  setsockopt(m_fd,SOL_SOCKET,SO_NOSIGPIPE,(const char*)&arg,sizeof(arg));            
    9.       
  9.  #endif            
    10.       
  10.  #if defined(__EMX__)||defined(__VISAGECPP__)            
    11.       
  11.  ioctl(m_fd,FIONBIO,(char*)&arg,sizeof(arg));            
    12.       
  12.  #else            
    13.       
  13.  ioctl(m_fd,FIONBIO,&arg);            
    14.       
  14.  #endif            
    15.

這裡arg的值為1，通過ioctl來設定socket fd為非阻塞。

2. wxSocketBase::Read/Write

wxSocket本質上是non-blocking socket。我們可以通過wxSocketBase::Read/Write直接讀寫資料。同時wxNet也提供了wxSocket stream （wxSocketInputStream, wxSocketOuputStream）來讀寫資料。

通過wxSocket stream來讀寫資料和直接通過wxSocket來讀寫基本一樣。但是wxSocket stream 的作用在于，我們可以利用wx庫提供的通用的stream操作類來處理socket相關的讀寫。比如： 利用wxBufferedInputStream 和 wxBufferedOutputStream來進行帶緩沖區的讀寫。

2.1 未設定wxSOCKET_WAITALL flag時的wxSocketBase::Read

問題： 假如直接調用wxSocketBase::Read或者wxSocketInputStream::Read讀取一大塊資料（e.g. 10MB），可能會發生什麼情況？

答案： wxSocketInputStream::Read傳回後，實際讀取的位元組數很随機，跟目前的系統狀态有很大關系。

當然這樣的行為和直接用系統函數recv(2)或read(2)從non-blocking socket 讀取資料類似。

 這個通過檢視wxSocketBase::_Read的實作(src/common/socket.cpp)，很容易弄清楚。

     
  1.   wxUint32 wxSocketBase::_Read(void* buffer, wxUint32 nbytes)            
    2.       
  2.  {            
    3.       
  3.  // ...            
    4.       
  4.  int ret;            
    5.       
  5.  if (m_flags & wxSOCKET_NOWAIT)            
    6.       
  6.  {            
    7.       
  7.  m_socket->SetNonBlocking(1);            
    8.       
  8.  ret = m_socket->Read((char *)buffer, nbytes);            
    9.       
  9.  m_socket->SetNonBlocking(0);            
    10.       
  10.  if (ret > 0)            
    11.       
  11.  total += ret;            
    12.       
  12.  }            
    13.       
  13.  else            
    14.       
  14.  {            
    15.       
  15.  bool more = true;            
    16.       
  16.  while (more)            
    17.       
  17.  {            
    18.       
  18.  if ( !(m_flags & wxSOCKET_BLOCK) && !WaitForRead() )            
    19.       
  19.  break;            
    20.       
  20.  ret = m_socket->Read((char *)buffer, nbytes);            
    21.       
  21.  if (ret > 0)            
    22.       
  22.  {            
    23.       
  23.  total  += ret;            
    24.       
  24.  nbytes -= ret;            
    25.       
  25.  buffer  = (char *)buffer + ret;            
    26.       
  26.  }            
    27.       
  27.  // If we got here and wxSOCKET_WAITALL is not set, we can leave            
    28.       
  28.  // now. Otherwise, wait until we recv all the data or until there            
    29.       
  29.  // is an error.            
    30.       
  30.  //            
    31.       
  31.  more = (ret > 0 && nbytes > 0 && (m_flags & wxSOCKET_WAITALL));            
    32.       
  32.  }            
    33.       
  33.  }            
    34.       
  34.  return total;            
    35.       
  35.  }            
    36.

_Read函數内的while循環的啟動條件 要求

“

ret > 0 && nbytes > 0 && (m_flags & wxSOCKET_WAITALL)”

，這意味着要求滿足如下條件：

  1. 設定 wxSOCKET_WAITALL
  2. 上次讀到資料
  3. 還有資料需要讀

即使設定了wxSOCKET_WAITALL， wxSocketBase::_Read也不能完全保證傳回時，請求的nbytes已經完全讀出，這是因為 代碼行 “ret = m_socket->Read((char *)buffer, nbytes);”的傳回值不能保證 “ret > 0”條件。

2.2 輔助調試類

這裡通過繼承wxSocketInputStream來列印更多調試資訊。

     
  1.  class wxGDSSocketInputStream : public wxSocketInputStream            
    2.       
  2.  {            
    3.       
  3.  public:            
    4.       
  4.  wxGDSSocketInputStream (wxSocketBase& s)            
    5.       
  5.  : wxSocketInputStream (s)            
    6.       
  6.  { }            
    7.       
  7.  protected:            
    8.       
  8.  size_t OnSysRead(void *buffer, size_t bufsize);            
    9.       
  9.  DECLARE_NO_COPY_CLASS(wxGDSSocketInputStream)            
    10.       
  10.  };            
    11.       
  11.   
    12.       
  12.  static void PrintSocketError(wxSocketBase* sock)            
    13.       
  13.  {            
    14.       
  14.  if (sock->LastError() == wxSOCKET_WOULDBLOCK)            
    15.       
  15.  {            
    16.       
  16.  LOG4TY_DEBUG("socket error: wxSOCKET_WOULDBLOCK");            
    17.       
  17.  }            
    18.       
  18.  else if (sock->LastError() == wxSOCKET_TIMEDOUT)            
    19.       
  19.  {            
    20.       
  20.  LOG4TY_DEBUG("socket error: wxSOCKET_TIMEDOUT");            
    21.       
  21.  }            
    22.       
  22.  else            
    23.       
  23.  {            
    24.       
  24.  LOG4TY_DEBUG("socket error: " << sock->LastError());            
    25.       
  25.  }             
    26.       
  26.  }            
    27.       
  27.   
    28.       
  28.  size_t wxGDSSocketInputStream::OnSysRead(void *buffer, size_t size)            
    29.       
  29.  {            
    30.       
  30.  size_t count = wxSocketInputStream::OnSysRead(buffer, size);            
    31.       
  31.  wxLogTrace(GDS_STREAM_MASK, "[OnSysRead] request %lu, receive %lu", size, count);            
    32.       
  32.  if (m_i_socket->Error()) ::PrintSocketError(m_i_socket);            
    33.       
  33.  return count;            
    34.       
  34.  }            
    35.

通過調試發現，wxSocketBase::Read在讀取大資料塊時，很可能會提前傳回，而且此時wxSocket内可能發生了錯誤（具體錯誤及原因見2.3節）。  

2.3 GSocket::Read分析

wxSocketBase::Read最終通過GSocket::Read實作讀資料（src/unix/gsocket.cpp）。

     
  1.  int GSocket::Read(char *buffer, int size)            
    2.       
  2.  {            
    3.       
  3.  int ret;            
    4.       
  4.  assert(this);            
    5.       
  5.  if (m_fd == INVALID_SOCKET || m_server)            
    6.       
  6.  {            
    7.       
  7.  m_error = GSOCK_INVSOCK;            
    8.       
  8.  return -1;            
    9.       
  9.  }            
    10.       
  10.  /* Disable events during query of socket status */            
    11.       
  11.  Disable(GSOCK_INPUT);            
    12.       
  12.  /* If the socket is blocking, wait for data (with a timeout) */            
    13.       
  13.  if (Input_Timeout() == GSOCK_TIMEDOUT) {            
    14.       
  14.  m_error = GSOCK_TIMEDOUT;            
    15.       
  15.  /* Don't return here immediately, otherwise socket events would not be            
    16.       
  16.  * re-enabled! */            
    17.       
  17.  ret = -1;            
    18.       
  18.  }            
    19.       
  19.  else            
    20.       
  20.  {            
    21.       
  21.  /* Read the data */            
    22.       
  22.  if (m_stream)            
    23.       
  23.  ret = Recv_Stream(buffer, size);            
    24.       
  24.  else            
    25.       
  25.  ret = Recv_Dgram(buffer, size);            
    26.       
  26.  /*            
    27.       
  27.  * If recv returned zero for a TCP socket (if m_stream == NULL, it's an UDP            
    28.       
  28.  * socket and empty datagrams are possible), then the connection has been            
    29.       
  29.  * gracefully closed.            
    30.       
  30.  *            
    31.       
  31.  * Otherwise, recv has returned an error (-1), in which case we have lost            
    32.       
  32.  * the socket only if errno does _not_ indicate that there may be more data            
    33.       
  33.  * to read.            
    34.       
  34.  */            
    35.       
  35.  if ((ret == 0) && m_stream)            
    36.       
  36.  {            
    37.       
  37.  /* Make sure wxSOCKET_LOST event gets sent and shut down the socket */            
    38.       
  38.  m_detected = GSOCK_LOST_FLAG;            
    39.       
  39.  Detected_Read();            
    40.       
  40.  return 0;            
    41.       
  41.  }            
    42.       
  42.  else if (ret == -1)            
    43.       
  43.  {            
    44.       
  44.  if ((errno == EWOULDBLOCK) || (errno == EAGAIN))            
    45.       
  45.  m_error = GSOCK_WOULDBLOCK;            
    46.       
  46.  else            
    47.       
  47.  m_error = GSOCK_IOERR;            
    48.       
  48.  }            
    49.       
  49.  }            
    50.       
  50.  /* Enable events again now that we are done processing */            
    51.       
  51.  Enable(GSOCK_INPUT);            
    52.       
  52.  return ret;            
    53.       
  53.  }            
    54.

GSocket::Read主要調用了兩個函數：Input_Timeout和Recv_Stream。

GSocket::Recv_Stream 通過調用system 函數 recv(2) 實作。

     
  1.  int GSocket::Recv_Stream(char *buffer, int size)            
    2.       
  2.  {            
    3.       
  3.  int ret;            
    4.       
  4.  do            
    5.       
  5.  {            
    6.       
  6.  ret = recv(m_fd, buffer, size, GSOCKET_MSG_NOSIGNAL);            
    7.       
  7.  }            
    8.       
  8.  while (ret == -1 && errno == EINTR); /* Loop until not interrupted */            
    9.       
  9.  return ret;            
    10.       
  10.  }            
    11.

可以通過如下方式來檢視socket 預設緩沖區大小：

     
  1.  pwang@p03bc ~$ cat /proc/sys/net/ipv4/tcp_rmem            
    2.       
  2.  4096 87380(85K 340B) 174760 //第一個表示最小值，第二個表示預設值，第三個表示最大值。            
    3.       
  3.  pwang@p03bc ~$ cat /proc/sys/net/ipv4/tcp_wmem            
    4.       
  4.  4096 16384(16k) 131072            
    5.

這裡read緩沖區最小4KB，最大170KB，預設約85KB。是以recv函數絕對不可能一次讀10MB資料。

GSocket::Input_Timeout函數（src/unix/gsocket.cpp）通過select(2)函數來計時。

     
  1.  GSocketError GSocket::Input_Timeout()            
    2.       
  2.  {            
    3.       
  3.  struct timeval tv;            
    4.       
  4.  fd_set readfds;            
    5.       
  5.  int ret;            
    6.       
  6.  /* Linux select() will overwrite the struct on return */            
    7.       
  7.  tv.tv_sec  = (m_timeout / 1000);            
    8.       
  8.  tv.tv_usec = (m_timeout % 1000) * 1000;            
    9.       
  9.  if (!m_non_blocking) // m_non_blocking預設為false            
    10.       
  10.  {            
    11.       
  11.  wxFD_ZERO(&readfds);            
    12.       
  12.  wxFD_SET(m_fd, &readfds);            
    13.       
  13.  ret = select(m_fd + 1, &readfds, NULL, NULL, &tv);            
    14.       
  14.  if (ret == 0)            
    15.       
  15.  {            
    16.       
  16.  GSocket_Debug(( "GSocket_Input_Timeout, select returned 0\n" ));            
    17.       
  17.  m_error = GSOCK_TIMEDOUT;            
    18.       
  18.  return GSOCK_TIMEDOUT;            
    19.       
  19.  }            
    20.       
  20.  if (ret == -1)            
    21.       
  21.  {            
    22.       
  22.  GSocket_Debug(( "GSocket_Input_Timeout, select returned -1\n" ));            
    23.       
  23.  if (errno == EBADF) { GSocket_Debug(( "Invalid file descriptor\n" )); }            
    24.       
  24.  if (errno == EINTR) { GSocket_Debug(( "A non blocked signal was caught\n" )); }            
    25.       
  25.  if (errno == EINVAL) { GSocket_Debug(( "The highest number descriptor is negative\n" )); }            
    26.       
  26.  if (errno == ENOMEM) { GSocket_Debug(( "Not enough memory\n" )); }            
    27.       
  27.  m_error = GSOCK_TIMEDOUT;            
    28.       
  28.  return GSOCK_TIMEDOUT;            
    29.       
  29.  }            
    30.       
  30.  }            
    31.       
  31.  return GSOCK_NOERROR;            
    32.       
  32.  }            
    33.

m_timeout的預設值是600秒，是以如果沒有資料可讀，等到timeout錯誤傳回，要等10分鐘。

如果設定了wxSOCKET_NOWAIT flag，GSocket::Input_Timeout 就會直接傳回。

2.4 wxSocketBase::Read/Write可能發生的錯誤

wxSocket 所有可能發生的錯誤如下：

error Note
wxSOCKET_NOERROR No error happened.
wxSOCKET_INVOP Invalid operation.
wxSOCKET_IOERR Input/Output error.
wxSOCKET_INVADDR Invalid address passed to wxSocket.
wxSOCKET_INVSOCK Invalid socket (uninitialized).
wxSOCKET_NOHOST No corresponding host.
wxSOCKET_INVPORT Invalid port.
wxSOCKET_WOULDBLOCK The socket is non-blocking and the operation would block.
wxSOCKET_TIMEDOUT The timeout for this operation expired.
wxSOCKET_MEMERR Memory exhausted.

調用wxSocketBase::Read可能會觸發哪些錯誤呢？

根據GSocket::Read的實作，如果socket連接配接沒有正常，則可能有如下錯誤：

error Note
wxSOCKET_WOULDBLOCK 沒有資料可讀或者目前socket不可寫（buffer已滿）。 Recv_Stream函數發生錯誤，recv(2)傳回-1，錯誤碼是 EWOULDBLOCK 或 EAGAIN。
wxSOCKET_IOERR  Recv_Stream函數發生錯誤，recv(2)傳回-1。
wxSOCKET_TIMEDOUT  一般由GSocket::Input\_Timeout觸發。 但并不見得就是真的timeout了，比如系統調用select出錯，提前傳回。

2.5 wxSOCKET_TIMEDOUT

通過SocketInputStream輔助類，當調用wxSocketBase::Read來讀大塊資料時，很可能發生wxSOCKET_TIMEDOUT錯誤。但是wxSocket的預設timeout是600秒，而Read函數明顯沒有等待那麼長時間，為什麼呢？

下面給出了一個程式發生timeout error時的堆棧：

     
  1.  Breakpoint 2, GSocket::Input_Timeout (this=0x1599430)            
    2.       
  2.  at ./src/unix/gsocket.cpp:1563            
    3.       
  3.  1563 m_error = GSOCK_TIMEDOUT;            
    4.       
  4.  (gdb) p errno            
    5.       
  5.  $10 = 4            
    6.       
  6.  (gdb) bt 10            
    7.       
  7.  #0 GSocket::Input_Timeout (this=0x1599430) at ./src/unix/gsocket.cpp:1563            
    8.       
  8.  #1 0x0000002aa65c7739 in GSocket::Read (this=0x1599430,            
    9.       
  9.  buffer=0x2ab4bec290 "", size=4117729) at ./src/unix/gsocket.cpp:1164            
    10.       
  10.  #2 0x0000002aa65c21c5 in wxSocketBase::_Read (this=0x1436e30,            
    11.       
  11.  buffer=0x2ab4bec290, nbytes=4117729) at ./src/common/socket.cpp:363            
    12.       
  12.  #3 0x0000002aa65c2068 in wxSocketBase::Read (this=0x1436e30,            
    13.       
  13.  buffer=0x2ab4bec290, nbytes=4117729) at ./src/common/socket.cpp:308            
    14.       
  14.  #4 0x0000002aa65c10b5 in wxSocketInputStream::OnSysRead (this=0x7fbfffa8c0,            
    15.       
  15.  buffer=0x2ab4bec290, size=4117729) at ./src/common/sckstrm.cpp:90            
    16.       
  16.  #5 0x0000002aa3f08eb1 in wxGDSSocketInputStream::OnSysRead (            
    17.       
  17.  this=0x7fbfffa8c0, buffer=0x2ab4bec290, size=4117729)            
    18.       
  18.  at GUI/libComm/src/wxGDSStream.cpp:54            
    19.       
  19.  #6 0x0000002aa655b9b1 in wxInputStream::Read (this=0x7fbfffa8c0,            
    20.       
  20.  buf=0x2ab4ae9010, size=4117729) at ./src/common/stream.cpp:846            
    21.

根據上面列出的GSocket::Input_Timeout函數的代碼，通過調試發現 select函數傳回值有時是-1， 此時發生系統錯誤EINTR （慢系統調用被中斷）。在這種情況下，Input_Timeout函數會提前傳回。

這說明wxSocketBase::Read來讀大塊資料時，有可能發生wxSOCKET_TIMEDOUT錯誤，但是這個wxSOCKET_TIMEDOUT error并不一定是真實的，很可能是由EINTR引起的。

2.6 wxSocketBase::LastCount函數

wxSocketBase::LastCount 會傳回前一個Read/Write操作中成功的位元組數。

根據wx manual，函數Discard(), Peek(), Read(), ReadMsg(), Unread(), Write(), WriteMsg() 都有可能修改LastCount的值。

LastCount函數内通過一個變量來記錄所有上述操作中成功的位元組數，是以LastCount不是線程安全的。

是以，禁止對于同一個socket：

  1. 一個線程調用Read，另一個線程調用Write
  2. 兩個線程同時Read或者Write

wx 3.0提供了接口wxSocketBase::LastReadCount 和 wxSocketBase::LastWriteCount 來解決這個問題。

3. 使用wxBufferedInputStream 

3.1 同時使用wxBufferedInputStream 和wxSOCKET_WAITALL flag

假設我們按照下面的方式初始化wxSocket：

initialize wxSocket

     
  1.  m_socket = new wxSocketClient();            
    2.       
  2.  m_is = new wxGDSSocketInputStream(*m_socket);            
    3.       
  3.  m_buf = new wxStreamBuffer(*m_is, wxStreamBuffer::read);            
    4.       
  4.  m_buf->SetBufferIO(1000000);            
    5.       
  5.  m_buf_is = new wxBufferedInputStream(*m_is, m_buf);            
    6.       
  6.  m_socket->SetFlags(wxSOCKET_BLOCK|wxSOCKET_WAITALL);            
    7.       
  7.  m_socket->SetNotify(wxSOCKET_LOST_FLAG);            
    8.       
  8.  m_socket->Notify(true);            
    9.

然後利用wxBufferedInputStream 讀資料，可能會發生什麼？

read through wxBufferedInputStream 

     
  1.  char ptr[5];            
    2.       
  2.  memset(ptr, 0x00, 5);            
    3.       
  3.  m_buf_is->Read(ptr,4);             
    4.

答案是程式很可能會阻塞在m_buf_is->Read函數裡。

下面是tachyon GUI按照上面的方式設定，GUI hang在那裡後，列印的堆棧資訊。

call stack  

     
  1.  (gdb) bt            
    2.       
  2.  #0 0x00000034cefbef86 in select () from /lib64/tls/libc.so.6            
    3.       
  3.  #1 0x0000002aa65e7233 in GSocket::Input_Timeout (this=0x15ba580) at ./src/unix/gsocket.cpp:1548            
    4.       
  4.  #2 0x0000002aa65e6739 in GSocket::Read (this=0x15ba580, buffer=0x14c727f "", size=994257) at ./src/unix/gsocket.cpp:1164            
    5.       
  5.  #3 0x0000002aa65e11c5 in wxSocketBase::_Read (this=0x14c5b40, buffer=0x14c727f, nbytes=994257) at ./src/common/socket.cpp:363 //請求的位元組數減少5473            
    6.       
  6.  #4 0x0000002aa65e1068 in wxSocketBase::Read (this=0x14c5b40, buffer=0x14c5c10, nbytes=1000000) at ./src/common/socket.cpp:308            
    7.       
  7.  #5 0x0000002aa65e00b5 in wxSocketInputStream::OnSysRead (this=0x14c5a80, buffer=0x14c5c10, size=1000000) at ./src/common/sckstrm.cpp:90            
    8.       
  8.  #6 0x0000002aa3f28eb1 in wxGDSSocketInputStream::OnSysRead (this=0x14c5a80, buffer=0x14c5c10, size=1000000) at GUI/libComm/src/wxGDSStream.cpp:54            
    9.       
  9.  #7 0x0000002aa65793a9 in wxStreamBuffer::FillBuffer (this=0x14c5ac0) at ./src/common/stream.cpp:204            
    10.       
  10.  #8 0x0000002aa6579539 in wxStreamBuffer::GetDataLeft (this=0x14c5ac0) at ./src/common/stream.cpp:241            
    11.       
  11.  #9 0x0000002aa6579a02 in wxStreamBuffer::Read (this=0x14c5ac0, buffer=0x409fed50, size=4) at ./src/common/stream.cpp:398            
    12.       
  12.  #10 0x0000002aa657bde6 in wxBufferedInputStream::Read (this=0x14c1e70, buf=0x409fed50, size=4) at ./src/common/stream.cpp:1230 //請求4Bytes            
    13.

根據調用棧可知，在frame 10的位置，我們調用了 wxBufferedInputStream::Read (buf, 4)， 但是此調用觸發了wxStreamBuffer::FillBuffer操作。于是，wxSocketInputStream::OnSysRead 比較野蠻的要求從socket讀整個buffer大小的内容。

實際上，socket端沒有這麼多資料，由于設定了 wxSOCKET_WAITALL flag，wxSocketBase::_Read 函數會一直等待，直到讀完要求的位元組，或者産生timeout錯誤後傳回。

3.2 安全使用socket Read

可見，wxBufferedInputStream和wxSOCKET_WAITALL不能同時使用，那我們的代碼該怎麼寫呢？

可行的辦法是在wxInputStream外封一個函數，就像下面的代碼：

     
  1.  Uint32 wxGDSStream::Read( void *buffer, Uint32 size )            
    2.       
  2.  {            
    3.       
  3.  wxLogTrace(GDS_STREAM_MASK, "[wxGDSStream::Read] request %u", size);            
    4.       
  4.  m_stream_impl.Read(buffer,size);            
    5.       
  5.  size_t read_size = m_stream_impl.LastRead();            
    6.       
  6.  while( read_size < size)            
    7.       
  7.  {            
    8.       
  8.  m_stream_impl.Read((char*)buffer + read_size, size - read_size);            
    9.       
  9.  read_size +=  m_stream_impl.LastRead();            
    10.       
  10.  wxLogTrace(GDS_STREAM_MASK, "[wxGDSStream::Read] continue read %lu, totally receive %lu",            
    11.       
  11.  m_stream_impl.LastRead(), read_size);            
    12.       
  12.  LOG4TY_DEBUG("continue read:" << m_stream_impl.LastRead() << ", totally receive " << read_size);            
    13.       
  13.  if (!m_sock->IsConnected()) break;            
    14.       
  14.  }            
    15.       
  15.  return read_size;            
    16.       
  16.  }             
    17.

此函數通過一個while循環來實作讀取要求大小的資料，同時要考慮socket出錯的情況。隻要socket沒有斷開，我們就可以繼續循環讀取資料。

3.3 安全使用socket Write

寫操作也類似，但略有不同： 1. 對于寫操作來說，目前協定要發送的資料的大小是已知的，讀操作則一般是在讀取的過程中才知道目前協定剩餘的資料還有多少。 2. 我們調用Write的時候，一般都會把所有要發送的資料先按照協定組織好，然後再發送。這樣就可以做到盡量少調用Write，進而少進行系統調用。

為了提高socket讀寫的效率，對于Read操作，我們一般傾向于使用帶緩沖區的方式。對于Write操作，則不會使用緩沖區，盡量讓資料盡早發送出去，在外部代碼裡面來控制盡量少調用Write。

在Write時不使用緩沖區，是以相對安全的Write操作有兩種實作：

1. 利用wxSOCKET_WAITALL flag.

     
  1.  int wxGDSSocket::Write( const void * buffer, Uint32 nbytes)            
    2.       
  2.  {               
    3.       
  3.  wxSocketFlags old_flag = m_socket->GetFlags();            
    4.       
  4.  m_socket->SetFlags(old_flag | wxSOCKET_WAITALL);            
    5.       
  5.  while (nbytes > 0)            
    6.       
  6.  {            
    7.       
  7.  int length = nbytes > m_max_write_length ? m_max_write_length : nbytes;            
    8.       
  8.  m_socket->Write((char*)buffer + write_size, length);            
    9.       
  9.  write_size += length;            
    10.       
  10.  nbytes -= length;            
    11.       
  11.  } // while            
    12.       
  12.  m_socket->SetFlags(old_flag);            
    13.       
  13.  }            
    14.

根據2.1節的結論，這個Write的實作其實也是有潛在問題的（wxSocketBase::Write函數傳回值不能完全保證length長度的資料寫成功），雖然可能很少發生 2. 不使用wxSOCKET_WAITALL

     
  1.  int wxGDSSocket::Write( const void * buffer, Uint32 nbytes)            
    2.       
  2.  {            
    3.       
  3.  //...            
    4.       
  4.  int write_size = 0;            
    5.       
  5.  while (nbytes > 0)            
    6.       
  6.  {            
    7.       
  7.  int length = nbytes > m_max_write_length ? m_max_write_length : nbytes;            
    8.       
  8.  m_socket->Write((char*)buffer + write_size, length);            
    9.       
  9.  length = m_socket->LastCount();            
    10.       
  10.  write_size += length;            
    11.       
  11.  nbytes -= length;            
    12.       
  12.  if (m_socket->Error()) ::PrintSocketError(m_socket);            
    13.       
  13.  if (!m_socket->IsConnected()) break;            
    14.       
  14.  } // while            
    15.       
  15.  return write_size;            
    16.       
  16.  }             
    17.

4. reference

  1. wx 3.0 wxSocketBase Class Reference
  2. wx 2.8.9 源碼
wxWidgets c++/c socket Linux
上一篇: wxWidgets架構下基于wxDialog程式的标準退出方法
下一篇: #define中的連接配接符（##）的使用

繼續閱讀