m_fd = socket(m_peer->m_realfamily,m_stream?SOCK_STREAM:SOCK_DGRAM,0);
if(m_fd == INVALID_SOCKET)
{
	m_error = GSOCKIOERR;
	return GSOCK_IOERR;
}
#ifdef SO_NOSIGPIPE
	setsockopt(m_fd,SOL_SOCKET,SO_NOSIGPIPE,(const char*)&arg,sizeof(arg));
#endif
#if defined(__EMX__)||defined(__VISAGECPP__)
	ioctl(m_fd,FIONBIO,(char*)&arg,sizeof(arg));
#else
	ioctl(m_fd,FIONBIO,&arg);
#endif

 wxUint32 wxSocketBase::_Read(void* buffer, wxUint32 nbytes)
    {
      // ...
      int ret;
      if (m_flags & wxSOCKET_NOWAIT)
      {
	    m_socket->SetNonBlocking(1);
	    ret = m_socket->Read((char *)buffer, nbytes);
	    m_socket->SetNonBlocking(0);
	    if (ret > 0)
      		total += ret;
      }
      else
      {
	    bool more = true;
	    while (more)
	    {
	      if ( !(m_flags & wxSOCKET_BLOCK) && !WaitForRead() )
		    break;
	      ret = m_socket->Read((char *)buffer, nbytes);
      	  if (ret > 0)
	      {
		    total  += ret;
		    nbytes -= ret;
		    buffer  = (char *)buffer + ret;
	      }
	      // If we got here and wxSOCKET_WAITALL is not set, we can leave
	      // now. Otherwise, wait until we recv all the data or until there
	      // is an error.
	      //
	      more = (ret > 0 && nbytes > 0 && (m_flags & wxSOCKET_WAITALL));
    	}
      }
      return total;
    }

class wxGDSSocketInputStream : public wxSocketInputStream
	{
	public:
	    wxGDSSocketInputStream (wxSocketBase& s)
	        : wxSocketInputStream (s)
    	{ }
	protected:
	    size_t OnSysRead(void *buffer, size_t bufsize);
	    DECLARE_NO_COPY_CLASS(wxGDSSocketInputStream)
	};
     
    static void PrintSocketError(wxSocketBase* sock)
    {
    	if (sock->LastError() == wxSOCKET_WOULDBLOCK)
	    {
  		    LOG4TY_DEBUG("socket error: wxSOCKET_WOULDBLOCK");
  	    }
    	else if (sock->LastError() == wxSOCKET_TIMEDOUT)
    	{
    		LOG4TY_DEBUG("socket error: wxSOCKET_TIMEDOUT");
    	}
    	else
    	{
    		LOG4TY_DEBUG("socket error: " << sock->LastError());
    	} 
    }
     
    size_t wxGDSSocketInputStream::OnSysRead(void *buffer, size_t size)
    {
    	size_t count = wxSocketInputStream::OnSysRead(buffer, size);
    	wxLogTrace(GDS_STREAM_MASK, "[OnSysRead] request %lu, receive %lu", size, count);
    	if (m_i_socket->Error()) ::PrintSocketError(m_i_socket);
    	return count;
    }

int GSocket::Read(char *buffer, int size)
{
  int ret;
  assert(this);
  if (m_fd == INVALID_SOCKET || m_server)
  {
    m_error = GSOCK_INVSOCK;
    return -1;
  }
  /* Disable events during query of socket status */
  Disable(GSOCK_INPUT);
  /* If the socket is blocking, wait for data (with a timeout) */
  if (Input_Timeout() == GSOCK_TIMEDOUT) {
    m_error = GSOCK_TIMEDOUT;
    /* Don't return here immediately, otherwise socket events would not be
     * re-enabled! */
    ret = -1;
  }
  else
  {
    /* Read the data */
    if (m_stream)
      ret = Recv_Stream(buffer, size);
    else
      ret = Recv_Dgram(buffer, size);
    /*
     * If recv returned zero for a TCP socket (if m_stream == NULL, it's an UDP
     * socket and empty datagrams are possible), then the connection has been
     * gracefully closed.
     *
     * Otherwise, recv has returned an error (-1), in which case we have lost
     * the socket only if errno does _not_ indicate that there may be more data
     * to read.
     */
    if ((ret == 0) && m_stream)
    {
      /* Make sure wxSOCKET_LOST event gets sent and shut down the socket */
      m_detected = GSOCK_LOST_FLAG;
      Detected_Read();
      return 0;
    }
    else if (ret == -1)
    {
      if ((errno == EWOULDBLOCK) || (errno == EAGAIN))
        m_error = GSOCK_WOULDBLOCK;
      else
        m_error = GSOCK_IOERR;
    }
  }
  /* Enable events again now that we are done processing */
  Enable(GSOCK_INPUT);
  return ret;
}

int GSocket::Recv_Stream(char *buffer, int size)
{
  int ret;
  do
  {
    ret = recv(m_fd, buffer, size, GSOCKET_MSG_NOSIGNAL);
  }
  while (ret == -1 && errno == EINTR); /* Loop until not interrupted */
  return ret;
}

pwang@p03bc ~$ cat /proc/sys/net/ipv4/tcp_rmem
4096 87380(85K 340B) 174760 //第一个表示最小值，第二个表示默认值，第三个表示最大值。
pwang@p03bc ~$ cat /proc/sys/net/ipv4/tcp_wmem
4096 16384(16k) 131072

GSocketError GSocket::Input_Timeout()
{
  struct timeval tv;
  fd_set readfds;
  int ret;
  /* Linux select() will overwrite the struct on return */
  tv.tv_sec  = (m_timeout / 1000);
  tv.tv_usec = (m_timeout % 1000) * 1000;
  if (!m_non_blocking) // m_non_blocking默认为false
  {
    wxFD_ZERO(&readfds);
    wxFD_SET(m_fd, &readfds);
    ret = select(m_fd + 1, &readfds, NULL, NULL, &tv);
    if (ret == 0)
    {
      GSocket_Debug(( "GSocket_Input_Timeout, select returned 0\n" ));
      m_error = GSOCK_TIMEDOUT;
      return GSOCK_TIMEDOUT;
    }
    if (ret == -1)
    {
      GSocket_Debug(( "GSocket_Input_Timeout, select returned -1\n" ));
      if (errno == EBADF) { GSocket_Debug(( "Invalid file descriptor\n" )); }
      if (errno == EINTR) { GSocket_Debug(( "A non blocked signal was caught\n" )); }
      if (errno == EINVAL) { GSocket_Debug(( "The highest number descriptor is negative\n" )); }
      if (errno == ENOMEM) { GSocket_Debug(( "Not enough memory\n" )); }
      m_error = GSOCK_TIMEDOUT;
      return GSOCK_TIMEDOUT;
    }
  }
  return GSOCK_NOERROR;
}

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

m_socket = new wxSocketClient();
m_is = new wxGDSSocketInputStream(*m_socket);
m_buf = new wxStreamBuffer(*m_is, wxStreamBuffer::read);
m_buf->SetBufferIO(1000000);
m_buf_is = new wxBufferedInputStream(*m_is, m_buf);
m_socket->SetFlags(wxSOCKET_BLOCK|wxSOCKET_WAITALL);
m_socket->SetNotify(wxSOCKET_LOST_FLAG);
m_socket->Notify(true);

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

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

Uint32 wxGDSStream::Read( void *buffer, Uint32 size )
{
    wxLogTrace(GDS_STREAM_MASK, "[wxGDSStream::Read] request %u", size);
    m_stream_impl.Read(buffer,size);
    size_t read_size = m_stream_impl.LastRead();
    while( read_size < size)
    {
        m_stream_impl.Read((char*)buffer + read_size, size - read_size);
        read_size +=  m_stream_impl.LastRead();
        wxLogTrace(GDS_STREAM_MASK, "[wxGDSStream::Read] continue read %lu, totally receive %lu",
            m_stream_impl.LastRead(), read_size);
        LOG4TY_DEBUG("continue read:" << m_stream_impl.LastRead() << ", totally receive " << read_size);
        if (!m_sock->IsConnected()) break;
    }
    return read_size;
} 

int wxGDSSocket::Write( const void * buffer, Uint32 nbytes)
{   
    wxSocketFlags old_flag = m_socket->GetFlags();
    m_socket->SetFlags(old_flag | wxSOCKET_WAITALL);
    while (nbytes > 0)
    {
        int length = nbytes > m_max_write_length ? m_max_write_length : nbytes;
        m_socket->Write((char*)buffer + write_size, length);
        write_size += length;
        nbytes -= length;
    } // while
    m_socket->SetFlags(old_flag);
}

int wxGDSSocket::Write( const void * buffer, Uint32 nbytes)
{
    //...
     int write_size = 0;
    while (nbytes > 0)
    {
        int length = nbytes > m_max_write_length ? m_max_write_length : nbytes;
        m_socket->Write((char*)buffer + write_size, length);
        length = m_socket->LastCount();
        write_size += length;
        nbytes -= length;
        if (m_socket->Error()) ::PrintSocketError(m_socket);
        if (!m_socket->IsConnected()) break;
    } // while
    return write_size;
}