Blocking

Quote:

Original post by MaximusCranius Hi, so basically I'm working on a wrapper for a client/server setup. As of right now, the server is setup using select(), and I'm trying to figure out how to deal with blocking on the client side. In a game, I was planning on polling for new data at the beginning of every x frames. The problem is, with blocking sockets, I don't want it to hold. My question is, in games are blocking sockets used in combination with threading, or are non blocking sockets used? Any guidance would be appreciated.

Quote:

Original post by hplus0603 Using blocking sockets are usually not great, because you don't know how much data to ask for. With UDP, you can ask for a single datagram when select() returns ready, but with TCP, you only know there's a single byte available. Typically, games use non-blocking sockets and select() in conjunction. There are no WinSock problems with non-blocking sockets, although there are some MFC socket class problems -- you don't want to be using MFC sockets in general. If you put each blocking socket in its own thread, and use some hand-off to push data into the world update loop, then that will work, but will have scalability problems once you get into "lots" of players, where "lots" varies wildly depending on your implementation and OS.

  bool httpRequest(char * hostName,char * request,char * response,int maxResponseLength,int timeOut) {    if (!s.createTCP()) return false;    if (!s.setAddressAndConnect(hostName,80)) return false;    if (!s.send(request,strlen(request)))     return false;    int bytesRead=0;    if (!s.read(response,maxResponseLength,bytesRead,timeOut)) return false;    if (!cleanupResponse(response,bytesRead)) return false;    s.close();    return true;  } // httpRequest

  bool read(void * buff,int buffLength,int & bytesRead,int timeOut=0) { // For TCP reads    if (type != ST_TCP) return false;    char * data = (char *)buff;    while (1) {      bool error=false;      bool bytesReady = isReadable(error,timeOut);      if ((!timeOut || bytesReady) && !error) {        bytesRead = ::recv(s,data,buffLength,0);        if (bytesRead == SOCKET_ERROR) {          return false;        } // if        buffLength -= bytesRead;        if (buffLength == 0 || bytesRead == 0) {          bytesRead = data - (char *)buff;          return true;        } // if        if (buffLength < 0) return false;        data += bytesRead;      } else {        return false;      } // if    } // while  } // read

  // Also used for TCP listen()/accept(), if isReadable() after listen(), accept() won't block.  bool isReadable(bool & error,int timeOut=0) { // milliseconds    fd_set socketReadSet;    FD_ZERO(&socketReadSet);    FD_SET(s,&socketReadSet);    timeval tv;    if (timeOut) {      tv.tv_sec  = timeOut / 1000;      tv.tv_usec = (timeOut % 1000) * 1000;    } else {      tv.tv_sec  = 0;      tv.tv_usec = 0;    } // if    if (::select(s+1,&socketReadSet,0,0,&tv) == SOCKET_ERROR) {      error = true;      return false;    } // if    error = false;    return FD_ISSET(s,&socketReadSet) != 0;  } // isReadable  bool isWriteable(bool & error,int timeOut=0) { // milliseconds    fd_set socketWriteSet;    FD_ZERO(&socketWriteSet);    FD_SET(s,&socketWriteSet);    timeval tv;    if (timeOut) {      tv.tv_sec  = timeOut / 1000;      tv.tv_usec = (timeOut % 1000) * 1000;    } else {      tv.tv_sec  = 0;      tv.tv_usec = 0;    } // if    if (::select(s+1,0,&socketWriteSet,0,&tv) == SOCKET_ERROR) {      error = true;      return false;    } // if    error = false;    return FD_ISSET(s,&socketWriteSet) != 0;  } // isWriteable

Quote:

bytesRead = ::recv(s,data,buffLength,0);

Quote:

Original post by hplus0603 Quote: bytesRead = ::recv(s,data,buffLength,0); This line will block until you have read "buffLength" amount of data, or the connection on the other end closes, unless your socket is set to be non-blocking. A malicious user could connect to your server with telnet and send a single character, then nothing else, which would make you wait forever. Repeat N times in parallel, and your server will run out of sockets or threads, if you're threaded, or just lock out your server entirely, if you're single-threaded. Try it yourself! There is an ioctl() you can call to get the amount of data ready to be read; you can use that if you want to ensure you won't block in reading. However, it's easier to just set the socket as non-blocking, and it works fine (I see no need to toggle the socket back to non-blocking). One thing I've noticed in a lot of code is calling WSAStartup() with an old WinSock API version. There were certainly bugs and flakiness in older versions of WinSock, that the API will attempt to reproduce when you ask for an older version. I recommend requesting version 2.2, which will work fine on any modern version of Windows, or any non-modern version that has a modern Internet Explorer installed. I don't know if this caused the issue you saw, but it might be worth looking into. Last, calling select() for a single socket is a waste of CPU resources. Just make the socket non-blocking, or use the ioctl() to read the amount of data waiting (depending on your platform). select() is intended to be used where you want to service more than one socket at a time, to let you pick the sockets that need attention (i e, have data waiting).

Quote:

For connection-oriented sockets (type SOCK_STREAM for example), calling recv will return as much data as is currently available—up to the size of the buffer specified. If the socket has been configured for in-line reception of OOB data (socket option SO_OOBINLINE) and OOB data is yet unread, only OOB data will be returned. The application can use the ioctlsocket or WSAIoctl SIOCATMARK command to determine whether any more OOB data remains to be read.

  WSADATA wsaData;  ::memset(&wsaData,0,sizeof(wsaData));  int res = ::WSAStartup(WINSOCK_VERSION,&wsaData);  // WINSOCK_VERSION is currently 2.2.

  bool shutdown(void) { // Call only on TCP sockets before close. Socket should be set to blocking before this call.    if (type != ST_TCP) return false;    int res = ::shutdown(s,SD_SEND);    if (res == SOCKET_ERROR) return false;    bool error;    while (isReadable(error)) {      int buff,bytesRead;      if (receive(&buff,sizeof(buff),bytesRead)) {        if (bytesRead == 0) {          return true; // Successful shutdown.        } // if      } else {        return getLastError() == WSAECONNRESET; // Also OK to get a Reset.      }// if    } // while    return true;  } // shutdown  bool receive(void * buff,int maxLength,int & bytesRead) { // For UDP & TCP reads    bytesRead = ::recv(s,(char *)buff,maxLength,0);    if (bytesRead == SOCKET_ERROR) {      bytesRead = 0;      return false;    } // if    return true;  } // receive  int getLastError(void) {    return ::WSAGetLastError();  } // getLastError

Quote:

The transports allow an application to invoke send and receive operations from within the context of the socket I/O completion routine and guarantee that, for a given socket, I/O completion routines will not be nested. This permits time-sensitive data transmissions to occur entirely within a preemptive context.

Quote:

Are you saying that WS2 recv() is broken for TCP?