enet/win32.c

   1 /**
   2  @file  win32.c
   3  @brief ENet Win32 system specific functions
   4 */
   5 #ifdef WIN32
   6
   7 #include <time.h>
   8 #define ENET_BUILDING_LIB 1
   9 #include "enet/enet.h"
  10
  11 static enet_uint32 timeBase = 0;
  12
  13 int
  14 enet_initialize (void)
  15 {
  16     WORD versionRequested = MAKEWORD (1, 1);
  17     WSADATA wsaData;
  18
  19     if (WSAStartup (versionRequested, & wsaData))
  20        return -1;
  21
  22     if (LOBYTE (wsaData.wVersion) != 1||
  23         HIBYTE (wsaData.wVersion) != 1)
  24     {
  25        WSACleanup ();
  26
  27        return -1;
  28     }
  29
  30     timeBeginPeriod (1);
  31
  32     return 0;
  33 }
  34
  35 void
  36 enet_deinitialize (void)
  37 {
  38     timeEndPeriod (1);
  39
  40     WSACleanup ();
  41 }
  42
  43 enet_uint32
  44 enet_time_get (void)
  45 {
  46     return (enet_uint32) timeGetTime () - timeBase;
  47 }
  48
  49 void
  50 enet_time_set (enet_uint32 newTimeBase)
  51 {
  52     timeBase = (enet_uint32) timeGetTime () - newTimeBase;
  53 }
  54
  55 int
  56 enet_address_set_host (ENetAddress * address, const char * name)
  57 {
  58     struct hostent * hostEntry;
  59
  60     hostEntry = gethostbyname (name);
  61     if (hostEntry == NULL ||
  62         hostEntry -> h_addrtype != AF_INET)
  63     {
  64         unsigned long host = inet_addr (name);
  65         if (host == INADDR_NONE)
  66             return -1;
  67         address -> host = host;
  68         return 0;
  69     }
  70
  71     address -> host = * (enet_uint32 *) hostEntry -> h_addr_list [0];
  72
  73     return 0;
  74 }
  75
  76 int
  77 enet_address_get_host (const ENetAddress * address, char * name, size_t nameLength)
  78 {
  79     struct in_addr in;
  80     struct hostent * hostEntry;
  81
  82     in.s_addr = address -> host;
  83
  84     hostEntry = gethostbyaddr ((char *) & in, sizeof (struct in_addr), AF_INET);
  85     if (hostEntry == NULL)
  86     {
  87         char * addr = inet_ntoa (* (struct in_addr *) & address -> host);
  88         if (addr == NULL)
  89             return -1;
  90         strncpy (name, addr, nameLength);
  91         return 0;
  92     }
  93
  94     strncpy (name, hostEntry -> h_name, nameLength);
  95
  96     return 0;
  97 }
  98
  99 ENetSocket
 100 enet_socket_create (ENetSocketType type, const ENetAddress * address)
 101 {
 102     ENetSocket newSocket = socket (PF_INET, type == ENET_SOCKET_TYPE_DATAGRAM ? SOCK_DGRAM : SOCK_STREAM, 0);
 103     u_long nonBlocking = 1;
 104     int receiveBufferSize = ENET_HOST_RECEIVE_BUFFER_SIZE,
 105         allowBroadcasting = 1;
 106     struct sockaddr_in sin;
 107
 108     if (newSocket == ENET_SOCKET_NULL)
 109       return ENET_SOCKET_NULL;
 110
 111     if (type == ENET_SOCKET_TYPE_DATAGRAM)
 112     {
 113         ioctlsocket (newSocket, FIONBIO, & nonBlocking);
 114
 115         setsockopt (newSocket, SOL_SOCKET, SO_RCVBUF, (char *) & receiveBufferSize, sizeof (int));
 116         setsockopt (newSocket, SOL_SOCKET, SO_BROADCAST, (char *) & allowBroadcasting, sizeof (int));
 117     }
 118
 119     memset (& sin, 0, sizeof (struct sockaddr_in));
 120
 121     sin.sin_family = AF_INET;
 122
 123     if (address != NULL)
 124     {
 125        sin.sin_port = ENET_HOST_TO_NET_16 (address -> port);
 126        sin.sin_addr.s_addr = address -> host;
 127     }
 128     else
 129     {
 130        sin.sin_port = 0;
 131        sin.sin_addr.s_addr = INADDR_ANY;
 132     }
 133
 134     if (bind (newSocket,
 135               (struct sockaddr *) & sin,
 136               sizeof (struct sockaddr_in)) == SOCKET_ERROR ||
 137         (type == ENET_SOCKET_TYPE_STREAM &&
 138           address != NULL &&
 139           listen (newSocket, SOMAXCONN) == SOCKET_ERROR))
 140     {
 141        closesocket (newSocket);
 142
 143        return ENET_SOCKET_NULL;
 144     }
 145
 146     return newSocket;
 147 }
 148
 149 int
 150 enet_socket_connect (ENetSocket socket, const ENetAddress * address)
 151 {
 152     struct sockaddr_in sin;
 153
 154     memset (& sin, 0, sizeof (struct sockaddr_in));
 155
 156     sin.sin_family = AF_INET;
 157     sin.sin_port = ENET_HOST_TO_NET_16 (address -> port);
 158     sin.sin_addr.s_addr = address -> host;
 159
 160     return connect (socket, (struct sockaddr *) & sin, sizeof (struct sockaddr_in));
 161 }
 162
 163 ENetSocket
 164 enet_socket_accept (ENetSocket socket, ENetAddress * address)
 165 {
 166     SOCKET result;
 167     struct sockaddr_in sin;
 168     int sinLength = sizeof (struct sockaddr_in);
 169
 170     result = accept (socket,
 171                      address != NULL ? (struct sockaddr *) & sin : NULL,
 172                      address != NULL ? & sinLength : NULL);
 173
 174     if (result == INVALID_SOCKET)
 175       return ENET_SOCKET_NULL;
 176
 177     if (address != NULL)
 178     {
 179         address -> host = (enet_uint32) sin.sin_addr.s_addr;
 180         address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);
 181     }
 182
 183     return result;
 184 }
 185
 186 void
 187 enet_socket_destroy (ENetSocket socket)
 188 {
 189     closesocket (socket);
 190 }
 191
 192 int
 193 enet_socket_send (ENetSocket socket,
 194                   const ENetAddress * address,
 195                   const ENetBuffer * buffers,
 196                   size_t bufferCount)
 197 {
 198     struct sockaddr_in sin;
 199     DWORD sentLength;
 200
 201     if (address != NULL)
 202     {
 203         sin.sin_family = AF_INET;
 204         sin.sin_port = ENET_HOST_TO_NET_16 (address -> port);
 205         sin.sin_addr.s_addr = address -> host;
 206     }
 207
 208     if (WSASendTo (socket,
 209                    (LPWSABUF) buffers,
 210                    (DWORD) bufferCount,
 211                    & sentLength,
 212                    0,
 213                    address != NULL ? (struct sockaddr *) & sin : 0,
 214                    address != NULL ? sizeof (struct sockaddr_in) : 0,
 215                    NULL,
 216                    NULL) == SOCKET_ERROR)
 217     {
 218        if (WSAGetLastError () == WSAEWOULDBLOCK)
 219          return 0;
 220
 221        return -1;
 222     }
 223
 224     return (int) sentLength;
 225 }
 226
 227 int
 228 enet_socket_receive (ENetSocket socket,
 229                      ENetAddress * address,
 230                      ENetBuffer * buffers,
 231                      size_t bufferCount)
 232 {
 233     INT sinLength = sizeof (struct sockaddr_in);
 234     DWORD flags = 0,
 235           recvLength;
 236     struct sockaddr_in sin;
 237
 238     if (WSARecvFrom (socket,
 239                      (LPWSABUF) buffers,
 240                      (DWORD) bufferCount,
 241                      & recvLength,
 242                      & flags,
 243                      address != NULL ? (struct sockaddr *) & sin : NULL,
 244                      address != NULL ? & sinLength : NULL,
 245                      NULL,
 246                      NULL) == SOCKET_ERROR)
 247     {
 248        switch (WSAGetLastError ())
 249        {
 250        case WSAEWOULDBLOCK:
 251        case WSAECONNRESET:
 252           return 0;
 253        }
 254
 255        return -1;
 256     }
 257
 258     if (flags & MSG_PARTIAL)
 259       return -1;
 260
 261     if (address != NULL)
 262     {
 263         address -> host = (enet_uint32) sin.sin_addr.s_addr;
 264         address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);
 265     }
 266
 267     return (int) recvLength;
 268 }
 269
 270 int
 271 enet_socket_wait (ENetSocket socket, enet_uint32 * condition, enet_uint32 timeout)
 272 {
 273     fd_set readSet, writeSet;
 274     struct timeval timeVal;
 275     int selectCount;
 276
 277     timeVal.tv_sec = timeout / 1000;
 278     timeVal.tv_usec = (timeout % 1000) * 1000;
 279
 280     FD_ZERO (& readSet);
 281     FD_ZERO (& writeSet);
 282
 283     if (* condition & ENET_SOCKET_WAIT_SEND)
 284       FD_SET (socket, & writeSet);
 285
 286     if (* condition & ENET_SOCKET_WAIT_RECEIVE)
 287       FD_SET (socket, & readSet);
 288
 289     selectCount = select (socket + 1, & readSet, & writeSet, NULL, & timeVal);
 290
 291     if (selectCount < 0)
 292       return -1;
 293
 294     * condition = ENET_SOCKET_WAIT_NONE;
 295
 296     if (selectCount == 0)
 297       return 0;
 298
 299     if (FD_ISSET (socket, & writeSet))
 300       * condition |= ENET_SOCKET_WAIT_SEND;
 301
 302     if (FD_ISSET (socket, & readSet))
 303       * condition |= ENET_SOCKET_WAIT_RECEIVE;
 304
 305     return 0;
 306 }
 307
 308 #endif
 309