src/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_ip (const ENetAddress * address, char * name, size_t nameLength)
  78 {
  79     char * addr = inet_ntoa (* (struct in_addr *) & address -> host);
  80     if (addr == NULL)
  81         return -1;
  82     strncpy (name, addr, nameLength);
  83     return 0;
  84 }
  85
  86 int
  87 enet_address_get_host (const ENetAddress * address, char * name, size_t nameLength)
  88 {
  89     struct in_addr in;
  90     struct hostent * hostEntry;
  91
  92     in.s_addr = address -> host;
  93
  94     hostEntry = gethostbyaddr ((char *) & in, sizeof (struct in_addr), AF_INET);
  95     if (hostEntry == NULL)
  96       return enet_address_get_host_ip (address, name, nameLength);
  97
  98     strncpy (name, hostEntry -> h_name, nameLength);
  99
 100     return 0;
 101 }
 102
 103 ENetSocket
 104 enet_socket_create (ENetSocketType type, const ENetAddress * address)
 105 {
 106     ENetSocket newSocket = socket (PF_INET, type == ENET_SOCKET_TYPE_DATAGRAM ? SOCK_DGRAM : SOCK_STREAM, 0);
 107     struct sockaddr_in sin;
 108
 109     if (newSocket == ENET_SOCKET_NULL)
 110       return ENET_SOCKET_NULL;
 111
 112     memset (& sin, 0, sizeof (struct sockaddr_in));
 113
 114     sin.sin_family = AF_INET;
 115
 116     if (address != NULL)
 117     {
 118        sin.sin_port = ENET_HOST_TO_NET_16 (address -> port);
 119        sin.sin_addr.s_addr = address -> host;
 120     }
 121     else
 122     {
 123        sin.sin_port = 0;
 124        sin.sin_addr.s_addr = INADDR_ANY;
 125     }
 126
 127     if (bind (newSocket,
 128               (struct sockaddr *) & sin,
 129               sizeof (struct sockaddr_in)) == SOCKET_ERROR ||
 130         (type == ENET_SOCKET_TYPE_STREAM &&
 131           address != NULL &&
 132           address -> port != ENET_PORT_ANY &&
 133           listen (newSocket, SOMAXCONN) == SOCKET_ERROR))
 134     {
 135        closesocket (newSocket);
 136
 137        return ENET_SOCKET_NULL;
 138     }
 139
 140     return newSocket;
 141 }
 142
 143 int
 144 enet_socket_set_option (ENetSocket socket, ENetSocketOption option, int value)
 145 {
 146     int result = SOCKET_ERROR;
 147     switch (option)
 148     {
 149         case ENET_SOCKOPT_NONBLOCK:
 150         {
 151             u_long nonBlocking = (u_long) value;
 152             result = ioctlsocket (socket, FIONBIO, & nonBlocking);
 153             break;
 154         }
 155
 156         case ENET_SOCKOPT_BROADCAST:
 157             result = setsockopt (socket, SOL_SOCKET, SO_BROADCAST, (char *) & value, sizeof (int));
 158             break;
 159
 160         case ENET_SOCKOPT_RCVBUF:
 161             result = setsockopt (socket, SOL_SOCKET, SO_RCVBUF, (char *) & value, sizeof (int));
 162             break;
 163
 164         case ENET_SOCKOPT_SNDBUF:
 165             result = setsockopt (socket, SOL_SOCKET, SO_SNDBUF, (char *) & value, sizeof (int));
 166             break;
 167
 168         default:
 169             break;
 170     }
 171     return result == SOCKET_ERROR ? -1 : 0;
 172 }
 173
 174 int
 175 enet_socket_connect (ENetSocket socket, const ENetAddress * address)
 176 {
 177     struct sockaddr_in sin;
 178
 179     memset (& sin, 0, sizeof (struct sockaddr_in));
 180
 181     sin.sin_family = AF_INET;
 182     sin.sin_port = ENET_HOST_TO_NET_16 (address -> port);
 183     sin.sin_addr.s_addr = address -> host;
 184
 185     return connect (socket, (struct sockaddr *) & sin, sizeof (struct sockaddr_in));
 186 }
 187
 188 ENetSocket
 189 enet_socket_accept (ENetSocket socket, ENetAddress * address)
 190 {
 191     SOCKET result;
 192     struct sockaddr_in sin;
 193     int sinLength = sizeof (struct sockaddr_in);
 194
 195     result = accept (socket,
 196                      address != NULL ? (struct sockaddr *) & sin : NULL,
 197                      address != NULL ? & sinLength : NULL);
 198
 199     if (result == INVALID_SOCKET)
 200       return ENET_SOCKET_NULL;
 201
 202     if (address != NULL)
 203     {
 204         address -> host = (enet_uint32) sin.sin_addr.s_addr;
 205         address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);
 206     }
 207
 208     return result;
 209 }
 210
 211 void
 212 enet_socket_destroy (ENetSocket socket)
 213 {
 214     closesocket (socket);
 215 }
 216
 217 int
 218 enet_socket_send (ENetSocket socket,
 219                   const ENetAddress * address,
 220                   const ENetBuffer * buffers,
 221                   size_t bufferCount)
 222 {
 223     struct sockaddr_in sin;
 224     DWORD sentLength;
 225
 226     if (address != NULL)
 227     {
 228         memset (& sin, 0, sizeof (struct sockaddr_in));
 229
 230         sin.sin_family = AF_INET;
 231         sin.sin_port = ENET_HOST_TO_NET_16 (address -> port);
 232         sin.sin_addr.s_addr = address -> host;
 233     }
 234
 235     if (WSASendTo (socket,
 236                    (LPWSABUF) buffers,
 237                    (DWORD) bufferCount,
 238                    & sentLength,
 239                    0,
 240                    address != NULL ? (struct sockaddr *) & sin : 0,
 241                    address != NULL ? sizeof (struct sockaddr_in) : 0,
 242                    NULL,
 243                    NULL) == SOCKET_ERROR)
 244     {
 245        if (WSAGetLastError () == WSAEWOULDBLOCK)
 246          return 0;
 247
 248        return -1;
 249     }
 250
 251     return (int) sentLength;
 252 }
 253
 254 int
 255 enet_socket_receive (ENetSocket socket,
 256                      ENetAddress * address,
 257                      ENetBuffer * buffers,
 258                      size_t bufferCount)
 259 {
 260     INT sinLength = sizeof (struct sockaddr_in);
 261     DWORD flags = 0,
 262           recvLength;
 263     struct sockaddr_in sin;
 264
 265     if (WSARecvFrom (socket,
 266                      (LPWSABUF) buffers,
 267                      (DWORD) bufferCount,
 268                      & recvLength,
 269                      & flags,
 270                      address != NULL ? (struct sockaddr *) & sin : NULL,
 271                      address != NULL ? & sinLength : NULL,
 272                      NULL,
 273                      NULL) == SOCKET_ERROR)
 274     {
 275        switch (WSAGetLastError ())
 276        {
 277        case WSAEWOULDBLOCK:
 278        case WSAECONNRESET:
 279           return 0;
 280        }
 281
 282        return -1;
 283     }
 284
 285     if (flags & MSG_PARTIAL)
 286       return -1;
 287
 288     if (address != NULL)
 289     {
 290         address -> host = (enet_uint32) sin.sin_addr.s_addr;
 291         address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);
 292     }
 293
 294     return (int) recvLength;
 295 }
 296
 297 int
 298 enet_socket_wait (ENetSocket socket, enet_uint32 * condition, enet_uint32 timeout)
 299 {
 300     fd_set readSet, writeSet;
 301     struct timeval timeVal;
 302     int selectCount;
 303
 304     timeVal.tv_sec = timeout / 1000;
 305     timeVal.tv_usec = (timeout % 1000) * 1000;
 306
 307     FD_ZERO (& readSet);
 308     FD_ZERO (& writeSet);
 309
 310     if (* condition & ENET_SOCKET_WAIT_SEND)
 311       FD_SET (socket, & writeSet);
 312
 313     if (* condition & ENET_SOCKET_WAIT_RECEIVE)
 314       FD_SET (socket, & readSet);
 315
 316     selectCount = select (socket + 1, & readSet, & writeSet, NULL, & timeVal);
 317
 318     if (selectCount < 0)
 319       return -1;
 320
 321     * condition = ENET_SOCKET_WAIT_NONE;
 322
 323     if (selectCount == 0)
 324       return 0;
 325
 326     if (FD_ISSET (socket, & writeSet))
 327       * condition |= ENET_SOCKET_WAIT_SEND;
 328
 329     if (FD_ISSET (socket, & readSet))
 330       * condition |= ENET_SOCKET_WAIT_RECEIVE;
 331
 332     return 0;
 333 }
 334
 335 #endif
 336