net_udp.c

   1 /*
   2 Copyright (C) 1996-1997 Id Software, Inc.
   3
   4 This program is free software; you can redistribute it and/or
   5 modify it under the terms of the GNU General Public License
   6 as published by the Free Software Foundation; either version 2
   7 of the License, or (at your option) any later version.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  12
  13 See the GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18
  19 */
  20 #include "quakedef.h"
  21 #include "net_udp.h"
  22 #ifdef WIN32
  23 #include "winquake.h"
  24 #define MAXHOSTNAMELEN          256
  25 #else
  26 #include <unistd.h>
  27 #include <sys/types.h>
  28 #include <sys/socket.h>
  29 #include <netinet/in.h>
  30 #include <arpa/inet.h>
  31 #include <netdb.h>
  32 #include <sys/param.h>
  33 #include <sys/ioctl.h>
  34 #include <errno.h>
  35
  36 #ifdef __sun__
  37 #include <sys/filio.h>
  38 #endif
  39
  40 #ifdef NeXT
  41 #include <libc.h>
  42 #endif
  43 #endif
  44
  45 static int net_acceptsocket = -1;               // socket for fielding new connections
  46 static int net_controlsocket;
  47 static int net_broadcastsocket = 0;
  48 static struct qsockaddr broadcastaddr;
  49
  50 static union {int i;unsigned char d[4];} myAddr;
  51
  52 //=============================================================================
  53
  54 #ifdef WIN32
  55 WSADATA         winsockdata;
  56 #endif
  57
  58 int UDP_Init (void)
  59 {
  60         int i, j;
  61         struct hostent *local;
  62         char buff[MAXHOSTNAMELEN];
  63
  64         if (COM_CheckParm ("-noudp"))
  65                 return -1;
  66
  67 #ifdef WIN32
  68         if (WSAStartup (MAKEWORD(1, 1), &winsockdata))
  69         {
  70                 Con_SafePrintf ("Winsock initialization failed.\n");
  71                 return -1;
  72         }
  73 #endif
  74
  75         // loopback as a worst case fallback
  76         myAddr.i = htonl(INADDR_ANY);
  77
  78         net_controlsocket = -1;
  79         for (j = 0;net_controlsocket == -1;j++)
  80         {
  81                 myAddr.d[0] = 127;
  82                 myAddr.d[1] = 0;
  83                 myAddr.d[2] = 0;
  84                 myAddr.d[3] = 1;
  85                 switch(j)
  86                 {
  87                 case 0:
  88                         if ((i = COM_CheckParm("-ip")) != 0 && i < com_argc)
  89                                 myAddr.i = inet_addr(com_argv[i+1]);
  90                         break;
  91                 case 1:
  92                         myAddr.i = htonl(INADDR_ANY);
  93                         break;
  94                 case 2:
  95                         if (gethostname(buff, MAXHOSTNAMELEN) != -1)
  96                         {
  97                                 buff[MAXHOSTNAMELEN - 1] = 0;
  98                                 local = gethostbyname(buff);
  99                                 if (local != NULL)
 100                                         myAddr.i = *((int *)local->h_addr_list[0]);
 101                         }
 102                         break;
 103                 default:
 104                         Con_Printf("UDP_Init: Giving up, UDP networking support disabled.\n");
 105 #ifdef WIN32
 106                         WSACleanup ();
 107 #endif
 108                         return -1;
 109                 }
 110
 111                 if (myAddr.i != htonl(INADDR_LOOPBACK))
 112                 {
 113                         if (myAddr.i == htonl(INADDR_LOOPBACK))
 114                                 sprintf(my_tcpip_address, "INADDR_LOOPBACK");
 115                         else if (myAddr.i == htonl(INADDR_ANY))
 116                                 sprintf(my_tcpip_address, "INADDR_ANY");
 117                         else
 118                                 sprintf(my_tcpip_address, "%d.%d.%d.%d", myAddr.d[0], myAddr.d[1], myAddr.d[2], myAddr.d[3]);
 119                         Con_Printf("UDP_Init: Binding to IP Interface Address of %s...  ", my_tcpip_address);
 120                         if ((net_controlsocket = UDP_OpenSocket (0)) == -1)
 121                                 Con_Printf("failed\n");
 122                         else
 123                                 Con_Printf("succeeded\n");
 124                 }
 125         }
 126
 127         ((struct sockaddr_in *)&broadcastaddr)->sin_family = AF_INET;
 128         ((struct sockaddr_in *)&broadcastaddr)->sin_addr.s_addr = htonl(INADDR_BROADCAST);
 129         ((struct sockaddr_in *)&broadcastaddr)->sin_port = htons((unsigned short)net_hostport);
 130
 131         Con_Printf("UDP Initialized\n");
 132         tcpipAvailable = true;
 133
 134         return net_controlsocket;
 135 }
 136
 137 //=============================================================================
 138
 139 void UDP_Shutdown (void)
 140 {
 141         UDP_Listen (false);
 142         UDP_CloseSocket (net_controlsocket);
 143 #ifdef WIN32
 144         WSACleanup ();
 145 #endif
 146 }
 147
 148 //=============================================================================
 149
 150 void UDP_Listen (qboolean state)
 151 {
 152         // enable listening
 153         if (state)
 154         {
 155                 if (net_acceptsocket != -1)
 156                         return;
 157                 if ((net_acceptsocket = UDP_OpenSocket (net_hostport)) == -1)
 158                         Sys_Error ("UDP_Listen: Unable to open accept socket\n");
 159                 return;
 160         }
 161
 162         // disable listening
 163         if (net_acceptsocket == -1)
 164                 return;
 165         UDP_CloseSocket (net_acceptsocket);
 166         net_acceptsocket = -1;
 167 }
 168
 169 //=============================================================================
 170
 171 int UDP_OpenSocket (int port)
 172 {
 173         int newsocket;
 174         struct sockaddr_in address;
 175
 176         if ((newsocket = socket (PF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1)
 177                 return -1;
 178
 179         {
 180 #ifdef WIN32
 181                 u_long _true = 1;
 182                 if (ioctlsocket (newsocket, FIONBIO, &_true) == -1)
 183                 {
 184                         closesocket (newsocket);
 185 #else
 186                 char _true = 1;
 187                 if (ioctl (newsocket, FIONBIO, &_true) == -1)
 188                 {
 189                         close (newsocket);
 190 #endif
 191                         Sys_Error("UDP_OpenSocket: unable to do a ioctl FIONBIO on the socket\n");
 192                 }
 193         }
 194
 195         address.sin_family = AF_INET;
 196         address.sin_addr.s_addr = myAddr.i;
 197         address.sin_port = htons((unsigned short)port);
 198         if (bind(newsocket, (void *)&address, sizeof(address)) == -1)
 199         {
 200 #ifdef WIN32
 201                 closesocket(newsocket);
 202 #else
 203                 close(newsocket);
 204 #endif
 205                 Sys_Error ("UDP_OpenSocket: Unable to bind to %s", UDP_AddrToString((struct qsockaddr *)&address));
 206         }
 207
 208         return newsocket;
 209 }
 210
 211 //=============================================================================
 212
 213 int UDP_CloseSocket (int socket)
 214 {
 215         if (net_broadcastsocket == socket)
 216                 net_broadcastsocket = 0;
 217 #ifdef WIN32
 218         return closesocket (socket);
 219 #else
 220         return close (socket);
 221 #endif
 222 }
 223
 224 //=============================================================================
 225
 226 int UDP_Connect (int socket, struct qsockaddr *addr)
 227 {
 228         return 0;
 229 }
 230
 231 //=============================================================================
 232
 233 int UDP_CheckNewConnections (void)
 234 {
 235         char buf[4096];
 236 #ifndef WIN32
 237         unsigned long   available;
 238         struct sockaddr_in      from;
 239         socklen_t                       fromlen;
 240 #endif
 241
 242         if (net_acceptsocket == -1)
 243                 return -1;
 244
 245 #ifdef WIN32
 246         if (recvfrom (net_acceptsocket, buf, sizeof(buf), MSG_PEEK, NULL, NULL) >= 0)
 247                 return net_acceptsocket;
 248 #else
 249         if (ioctl (net_acceptsocket, FIONREAD, &available) == -1)
 250                 Sys_Error ("UDP: ioctlsocket (FIONREAD) failed\n");
 251         if (available)
 252                 return net_acceptsocket;
 253         recvfrom (net_acceptsocket, buf, 0, 0, (struct sockaddr *) &from, &fromlen);
 254 #endif
 255         return -1;
 256 }
 257
 258 //=============================================================================
 259
 260 int UDP_Recv (qbyte *buf, int len, struct qsockaddr *addr)
 261 {
 262         return UDP_Read (net_acceptsocket, buf, len, addr);
 263 }
 264
 265 //=============================================================================
 266
 267 int UDP_Send (qbyte *buf, int len, struct qsockaddr *addr)
 268 {
 269         return UDP_Write (net_acceptsocket, buf, len, addr);
 270 }
 271
 272 //=============================================================================
 273
 274 int UDP_Read (int socket, qbyte *buf, int len, struct qsockaddr *addr)
 275 {
 276         int addrlen = sizeof (struct qsockaddr);
 277         int ret;
 278
 279         ret = recvfrom (socket, buf, len, 0, (struct sockaddr *)addr, &addrlen);
 280         if (ret == -1)
 281         {
 282 #ifdef WIN32
 283                 int e = WSAGetLastError();
 284                 if (e == WSAEWOULDBLOCK || e == WSAECONNREFUSED)
 285                         return 0;
 286                 Con_Printf("UDP_Read(%i, %p, %i, <%s>): WSAGetLastError == %i\n", socket, buf, len, UDP_AddrToString(addr), e);
 287 #else
 288                 if (errno == EWOULDBLOCK || errno == ECONNREFUSED)
 289                         return 0;
 290                 Con_Printf("UDP_Read(%i, %p, %i, <%s>): errno == %i (%s)\n", socket, buf, len, UDP_AddrToString(addr), errno, strerror(errno));
 291 #endif
 292         }
 293         else if (developer_networking.integer)
 294         {
 295                 Con_Printf("UDP_Read(%i, %p, %i, <%s>) = %i\n", socket, buf, len, UDP_AddrToString(addr), ret);
 296                 Com_HexDumpToConsole(buf, ret);
 297         }
 298
 299         return ret;
 300 }
 301
 302 //=============================================================================
 303
 304 int UDP_MakeSocketBroadcastCapable (int socket)
 305 {
 306         int i = 1;
 307
 308         // make this socket broadcast capable
 309         if (setsockopt(socket, SOL_SOCKET, SO_BROADCAST, (char *)&i, sizeof(i)) < 0)
 310                 return -1;
 311         net_broadcastsocket = socket;
 312
 313         return 0;
 314 }
 315
 316 //=============================================================================
 317
 318 int UDP_Broadcast (int socket, qbyte *buf, int len)
 319 {
 320         int ret;
 321
 322         if (socket != net_broadcastsocket)
 323         {
 324                 if (net_broadcastsocket != 0)
 325                         Sys_Error("Attempted to use multiple broadcasts sockets\n");
 326                 ret = UDP_MakeSocketBroadcastCapable (socket);
 327                 if (ret == -1)
 328                 {
 329                         Con_Printf("Unable to make socket broadcast capable\n");
 330                         return ret;
 331                 }
 332         }
 333
 334         return UDP_Write (socket, buf, len, &broadcastaddr);
 335 }
 336
 337 //=============================================================================
 338
 339 int UDP_Write (int socket, qbyte *buf, int len, struct qsockaddr *addr)
 340 {
 341         int ret;
 342
 343         if (developer_networking.integer)
 344         {
 345                 Con_Printf("UDP_Write(%i, %p, %i, <%s>)\n", socket, buf, len, UDP_AddrToString(addr));
 346                 Com_HexDumpToConsole(buf, len);
 347         }
 348
 349         ret = sendto (socket, buf, len, 0, (struct sockaddr *)addr, sizeof(struct qsockaddr));
 350         if (ret == -1)
 351         {
 352 #ifdef WIN32
 353                 int e = WSAGetLastError();
 354                 if (e == WSAEWOULDBLOCK)
 355                         return 0;
 356                 Con_Printf("UDP_Write(%i, %p, %i, <%s>): WSAGetLastError == %i\n", socket, buf, len, UDP_AddrToString(addr), e);
 357 #else
 358                 if (errno == EWOULDBLOCK)
 359                         return 0;
 360                 Con_Printf("UDP_Write(%i, %p, %i, <%s>): errno == %i (%s)\n", socket, buf, len, UDP_AddrToString(addr), errno, strerror(errno));
 361 #endif
 362         }
 363         return ret;
 364 }
 365
 366 //=============================================================================
 367
 368 char *UDP_AddrToString (const struct qsockaddr *addr)
 369 {
 370         static char buffer[22]; // only 22 needed (3 + 1 + 3 + 1 + 3 + 1 + 3 + 1 + 5 + null)
 371         unsigned char *ip = (char *)(&((struct sockaddr_in *)addr)->sin_addr.s_addr);
 372         sprintf(buffer, "%d.%d.%d.%d:%d", ip[0], ip[1], ip[2], ip[3], ntohs(((struct sockaddr_in *)addr)->sin_port));
 373         return buffer;
 374 }
 375
 376 //=============================================================================
 377
 378 int UDP_StringToAddr (const char *string, struct qsockaddr *addr)
 379 {
 380         int ha[4], hp, ipaddr, j, numbers;
 381         const char *colon;
 382
 383         hp = net_hostport;
 384         colon = strrchr(string, ':');
 385         if (colon)
 386         {
 387                 hp = atoi(colon + 1);
 388                 if (hp == 0)
 389                         hp = net_hostport;
 390         }
 391         numbers = sscanf(string, "%d.%d.%d.%d", &ha[0], &ha[1], &ha[2], &ha[3]);
 392         for (ipaddr = 0, j = 0;j < numbers;j++)
 393                 ipaddr = (ipaddr << 8) | ha[j];
 394         // if the address is incomplete take most important numbers from myAddr
 395         if (numbers < 4)
 396                 ipaddr |= ntohl(myAddr.i) & (-1 << (numbers * 8));
 397
 398         addr->sa_family = AF_INET;
 399         ((struct sockaddr_in *)addr)->sin_addr.s_addr = htonl(ipaddr);
 400         ((struct sockaddr_in *)addr)->sin_port = htons((unsigned short)hp);
 401         if (ipaddr == INADDR_ANY)
 402                 return -1;
 403         else
 404                 return 0;
 405 }
 406
 407 //=============================================================================
 408
 409 int UDP_GetSocketAddr (int socket, struct qsockaddr *addr)
 410 {
 411         int ret;
 412         int addrlen = sizeof(struct qsockaddr);
 413         memset(addr, 0, sizeof(struct qsockaddr));
 414         ret = getsockname(socket, (struct sockaddr *)addr, &addrlen);
 415         if (ret == -1)
 416         {
 417 #ifdef WIN32
 418                 int e = WSAGetLastError();
 419                 Con_Printf("UDP_GetSocketAddr: WASGetLastError == %i\n", e);
 420 #else
 421                 Con_Printf("UDP_GetSocketAddr: errno == %i (%s)\n", errno, strerror(errno));
 422 #endif
 423         }
 424         return ret;
 425 }
 426
 427 //=============================================================================
 428
 429 int UDP_GetNameFromAddr (const struct qsockaddr *addr, char *name)
 430 {
 431         struct hostent *hostentry;
 432
 433         hostentry = gethostbyaddr ((char *)&((struct sockaddr_in *)addr)->sin_addr, sizeof(struct in_addr), AF_INET);
 434         if (hostentry)
 435         {
 436                 strncpy (name, (char *)hostentry->h_name, NET_NAMELEN - 1);
 437                 return 0;
 438         }
 439
 440         strcpy (name, UDP_AddrToString (addr));
 441         return 0;
 442 }
 443
 444 //=============================================================================
 445
 446 int UDP_GetAddrFromName(const char *name, struct qsockaddr *addr)
 447 {
 448         struct hostent *hostentry;
 449
 450         if (name[0] >= '0' && name[0] <= '9')
 451                 return UDP_StringToAddr (name, addr);
 452
 453         hostentry = gethostbyname (name);
 454         if (!hostentry)
 455                 return -1;
 456
 457         addr->sa_family = AF_INET;
 458         ((struct sockaddr_in *)addr)->sin_port = htons((unsigned short)net_hostport);
 459         ((struct sockaddr_in *)addr)->sin_addr.s_addr = *(int *)hostentry->h_addr_list[0];
 460
 461         return 0;
 462 }
 463
 464 //=============================================================================
 465
 466 int UDP_AddrCompare (const struct qsockaddr *addr1, const struct qsockaddr *addr2)
 467 {
 468         if (addr1->sa_family != addr2->sa_family)
 469                 return -1;
 470
 471         if (((struct sockaddr_in *)addr1)->sin_addr.s_addr != ((struct sockaddr_in *)addr2)->sin_addr.s_addr)
 472                 return -1;
 473
 474         if (((struct sockaddr_in *)addr1)->sin_port != ((struct sockaddr_in *)addr2)->sin_port)
 475                 return 1;
 476
 477         return 0;
 478 }
 479
 480 //=============================================================================
 481
 482 int UDP_GetSocketPort (struct qsockaddr *addr)
 483 {
 484         return ntohs(((struct sockaddr_in *)addr)->sin_port);
 485 }
 486
 487
 488 int UDP_SetSocketPort (struct qsockaddr *addr, int port)
 489 {
 490         ((struct sockaddr_in *)addr)->sin_port = htons((unsigned short)port);
 491         return 0;
 492 }
 493