src/network.c

   1 // ============================================================================
   2 // Rocks'n'Diamonds - McDuffin Strikes Back!
   3 // ----------------------------------------------------------------------------
   4 // (c) 1995-2014 by Artsoft Entertainment
   5 //                  Holger Schemel
   6 //                  info@artsoft.org
   7 //                  http://www.artsoft.org/
   8 // ----------------------------------------------------------------------------
   9 // network.c
  10 // ============================================================================
  11
  12 #include "libgame/platform.h"
  13
  14 #if defined(NETWORK_AVALIABLE)
  15
  16 #include <signal.h>
  17 #include <sys/time.h>
  18
  19 #if defined(TARGET_SDL)
  20 #include "main.h"
  21 #else
  22 #include <sys/wait.h>
  23 #include <sys/socket.h>
  24 #include <netinet/in.h>
  25 #include <netinet/tcp.h>
  26 #include <arpa/inet.h>
  27 #include <netdb.h>
  28 #endif
  29
  30 #include "libgame/libgame.h"
  31
  32 #include "network.h"
  33 #include "netserv.h"
  34 #include "game.h"
  35 #include "tape.h"
  36 #include "files.h"
  37 #include "tools.h"
  38 #include "screens.h"
  39
  40 struct NetworkClientPlayerInfo
  41 {
  42   byte nr;
  43   char name[MAX_PLAYER_NAME_LEN + 1];
  44   struct NetworkClientPlayerInfo *next;
  45 };
  46
  47 static struct NetworkClientPlayerInfo first_player =
  48 {
  49   0,
  50   EMPTY_PLAYER_NAME,
  51   NULL
  52 };
  53
  54 /* server stuff */
  55
  56 #if defined(TARGET_SDL)
  57 static TCPsocket sfd;           /* server socket */
  58 static SDLNet_SocketSet rfds;   /* socket set */
  59 #else
  60 static int sfd;                 /* server socket */
  61 #endif
  62
  63 static byte realbuffer[512];
  64 static byte readbuffer[MAX_BUFFER_SIZE], writbuffer[MAX_BUFFER_SIZE];
  65 static byte *buffer = realbuffer + 4;
  66 static int nread = 0, nwrite = 0;
  67 static boolean stop_network_game = FALSE;
  68
  69 static void SendBufferToServer(int size)
  70 {
  71   if (!options.network)
  72     return;
  73
  74   realbuffer[0] = realbuffer[1] = realbuffer[2] = 0;
  75   realbuffer[3] = (byte)size;
  76   buffer[0] = 0;
  77
  78   if (nwrite + 4 + size >= MAX_BUFFER_SIZE)
  79     Error(ERR_EXIT, "internal error: network send buffer overflow");
  80
  81   memcpy(writbuffer + nwrite, realbuffer, 4 + size);
  82   nwrite += 4 + size;
  83
  84   /* directly send the buffer to the network server */
  85 #if defined(TARGET_SDL)
  86   SDLNet_TCP_Send(sfd, writbuffer, nwrite);
  87 #else
  88   if (write(sfd, writbuffer, nwrite) == -1)
  89     Error(ERR_WARN, "write() failed; %s", strerror(errno));
  90 #endif
  91   nwrite = 0;
  92 }
  93
  94 struct NetworkClientPlayerInfo *getNetworkPlayer(int player_nr)
  95 {
  96   struct NetworkClientPlayerInfo *player = NULL;
  97
  98   for (player = &first_player; player; player = player->next)
  99     if (player->nr == player_nr)
 100       break;
 101
 102   if (player == NULL)   /* should not happen */
 103     Error(ERR_EXIT, "protocol error: reference to non-existing player %d",
 104           player_nr);
 105
 106   return player;
 107 }
 108
 109 char *getNetworkPlayerName(int player_nr)
 110 {
 111   struct NetworkClientPlayerInfo *player;
 112
 113   if (player_nr == 0)
 114     return("the network game server");
 115   else if (player_nr == first_player.nr)
 116     return("you");
 117   else
 118     for (player = &first_player; player; player = player->next)
 119       if (player->nr == player_nr && player->name && strlen(player->name))
 120         return(player->name);
 121
 122   return(EMPTY_PLAYER_NAME);
 123 }
 124
 125 static void StartNetworkServer(int port)
 126 {
 127 #if defined(TARGET_SDL)
 128   static int p;
 129
 130   p = port;
 131 #if defined(TARGET_SDL2)
 132   server_thread = SDL_CreateThread(NetworkServerThread,
 133                                    "NetworkServerThread", &p);
 134 #else
 135   server_thread = SDL_CreateThread(NetworkServerThread, &p);
 136 #endif
 137   network_server = TRUE;
 138
 139 #else
 140
 141   switch (fork())
 142   {
 143     case 0:
 144       NetworkServer(port, options.serveronly);
 145
 146       /* never reached */
 147       exit(0);
 148
 149     case -1:
 150       Error(ERR_WARN,
 151             "cannot create network server process - no network playing");
 152       options.network = FALSE;
 153       return;
 154
 155     default:
 156       /* we are parent process -- resume normal operation */
 157       return;
 158   }
 159 #endif
 160 }
 161
 162 #if defined(TARGET_SDL)
 163 boolean ConnectToServer(char *hostname, int port)
 164 {
 165   IPaddress ip;
 166   int i;
 167
 168   if (port == 0)
 169     port = DEFAULT_SERVER_PORT;
 170
 171   rfds = SDLNet_AllocSocketSet(1);
 172
 173   if (hostname)
 174   {
 175     SDLNet_ResolveHost(&ip, hostname, port);
 176     if (ip.host == INADDR_NONE)
 177       Error(ERR_EXIT, "cannot locate host '%s'", hostname);
 178   }
 179   else
 180   {
 181     SDLNet_Write32(0x7f000001, &ip.host);       /* 127.0.0.1 */
 182     SDLNet_Write16(port, &ip.port);
 183   }
 184
 185   sfd = SDLNet_TCP_Open(&ip);
 186
 187   if (sfd)
 188   {
 189     SDLNet_TCP_AddSocket(rfds, sfd);
 190     return TRUE;
 191   }
 192   else
 193   {
 194     printf("SDLNet_TCP_Open(): %s\n", SDLNet_GetError());
 195   }
 196
 197   if (hostname)                 /* connect to specified server failed */
 198     return FALSE;
 199
 200   printf("No rocksndiamonds server on localhost -- starting up one ...\n");
 201   StartNetworkServer(port);
 202
 203   /* wait for server to start up and try connecting several times */
 204   for (i = 0; i < 6; i++)
 205   {
 206     Delay(500);                 /* wait 500 ms == 0.5 seconds */
 207
 208     if ((sfd = SDLNet_TCP_Open(&ip)))           /* connected */
 209     {
 210       SDLNet_TCP_AddSocket(rfds, sfd);
 211       return TRUE;
 212     }
 213   }
 214
 215   /* when reaching this point, connect to newly started server has failed */
 216   return FALSE;
 217 }
 218
 219 #else
 220
 221 boolean ConnectToServer(char *hostname, int port)
 222 {
 223   struct sockaddr_in s;
 224   struct protoent *tcpproto;
 225   int on = 1, i;
 226
 227   if (hostname)
 228   {
 229     if ((s.sin_addr.s_addr = inet_addr(hostname)) == -1)
 230     {
 231       struct hostent *host;
 232
 233       if ((host = gethostbyname(hostname)) == NULL)
 234         Error(ERR_EXIT, "cannot locate host '%s'", hostname);
 235
 236       s.sin_addr = *(struct in_addr *)(host->h_addr_list[0]);
 237     }
 238   }
 239   else
 240     s.sin_addr.s_addr = inet_addr("127.0.0.1");         /* localhost */
 241
 242   if (port == 0)
 243     port = DEFAULT_SERVER_PORT;
 244
 245   s.sin_port = htons(port);
 246   s.sin_family = AF_INET;
 247
 248   sfd = socket(PF_INET, SOCK_STREAM, 0);
 249   if (sfd < 0)
 250     Error(ERR_EXIT, "out of file descriptors");
 251
 252   if ((tcpproto = getprotobyname("tcp")) != NULL)
 253     setsockopt(sfd, tcpproto->p_proto, TCP_NODELAY, (char *)&on, sizeof(int));
 254
 255   if (connect(sfd, (struct sockaddr *)&s, sizeof(s)) == 0)      /* connected */
 256     return TRUE;
 257
 258   if (hostname) /* connect to specified server failed */
 259     return FALSE;
 260
 261   printf("No rocksndiamonds server on localhost -- starting up one ...\n");
 262   StartNetworkServer(port);
 263
 264   /* wait for server to start up and try connecting several times */
 265   for (i = 0; i < 6; i++)
 266   {
 267     Delay(500);         /* wait 500 ms == 0.5 seconds */
 268     close(sfd);
 269
 270     sfd = socket(PF_INET, SOCK_STREAM, 0);
 271     if (sfd < 0)
 272       Error(ERR_EXIT, "out of file descriptors");
 273
 274     setsockopt(sfd, tcpproto->p_proto, TCP_NODELAY, (char *)&on, sizeof(int));
 275
 276     if (connect(sfd, (struct sockaddr *)&s, sizeof(s)) >= 0)    /* connected */
 277       return TRUE;
 278   }
 279
 280   /* when reaching this point, connect to newly started server has failed */
 281   return FALSE;
 282 }
 283 #endif  /* defined(TARGET_SDL) */
 284
 285 void SendToServer_PlayerName(char *player_name)
 286 {
 287   int len_player_name = strlen(player_name);
 288
 289   buffer[1] = OP_PLAYER_NAME;
 290   memcpy(&buffer[2], player_name, len_player_name);
 291   SendBufferToServer(2 + len_player_name);
 292   Error(ERR_NETWORK_CLIENT, "you set your player name to \"%s\"", player_name);
 293 }
 294
 295 void SendToServer_ProtocolVersion()
 296 {
 297   buffer[1] = OP_PROTOCOL_VERSION;
 298   buffer[2] = PROTOCOL_VERSION_1;
 299   buffer[3] = PROTOCOL_VERSION_2;
 300   buffer[4] = PROTOCOL_VERSION_3;
 301
 302   SendBufferToServer(5);
 303 }
 304
 305 void SendToServer_NrWanted(int nr_wanted)
 306 {
 307   buffer[1] = OP_NUMBER_WANTED;
 308   buffer[2] = nr_wanted;
 309
 310   SendBufferToServer(3);
 311 }
 312
 313 void SendToServer_StartPlaying()
 314 {
 315   unsigned int new_random_seed = InitRND(level.random_seed);
 316
 317   int dummy = 0;                /* !!! HAS NO MEANING ANYMORE !!! */
 318                                 /* the name of the level must be enough */
 319
 320   buffer[1] = OP_START_PLAYING;
 321   buffer[2] = (byte)(level_nr >> 8);
 322   buffer[3] = (byte)(level_nr & 0xff);
 323   buffer[4] = (byte)(dummy >> 8);
 324   buffer[5] = (byte)(dummy & 0xff);
 325
 326   buffer[6] = (unsigned char)((new_random_seed >> 24) & 0xff);
 327   buffer[7] = (unsigned char)((new_random_seed >> 16) & 0xff);
 328   buffer[8] = (unsigned char)((new_random_seed >>  8) & 0xff);
 329   buffer[9] = (unsigned char)((new_random_seed >>  0) & 0xff);
 330
 331   strcpy((char *)&buffer[10], leveldir_current->identifier);
 332
 333   SendBufferToServer(10 + strlen(leveldir_current->identifier) + 1);
 334 }
 335
 336 void SendToServer_PausePlaying()
 337 {
 338   buffer[1] = OP_PAUSE_PLAYING;
 339
 340   SendBufferToServer(2);
 341 }
 342
 343 void SendToServer_ContinuePlaying()
 344 {
 345   buffer[1] = OP_CONTINUE_PLAYING;
 346
 347   SendBufferToServer(2);
 348 }
 349
 350 void SendToServer_StopPlaying(int cause_for_stopping)
 351 {
 352   buffer[1] = OP_STOP_PLAYING;
 353   buffer[2] = cause_for_stopping;
 354
 355   SendBufferToServer(3);
 356 }
 357
 358 void SendToServer_MovePlayer(byte player_action)
 359 {
 360   buffer[1] = OP_MOVE_PLAYER;
 361   buffer[2] = player_action;
 362
 363   SendBufferToServer(3);
 364 }
 365
 366 static void Handle_OP_BAD_PROTOCOL_VERSION()
 367 {
 368   Error(ERR_WARN, "protocol version mismatch");
 369   Error(ERR_EXIT, "server expects %d.%d.x instead of %d.%d.%d",
 370         buffer[2], buffer[3],
 371         PROTOCOL_VERSION_1, PROTOCOL_VERSION_2, PROTOCOL_VERSION_3);
 372 }
 373
 374 static void Handle_OP_YOUR_NUMBER()
 375 {
 376   int new_client_nr = buffer[2];
 377   int new_index_nr = new_client_nr - 1;
 378   struct PlayerInfo *old_local_player = local_player;
 379   struct PlayerInfo *new_local_player = &stored_player[new_index_nr];
 380
 381   printf("OP_YOUR_NUMBER: %d\n", buffer[0]);
 382   first_player.nr = new_client_nr;
 383
 384   if (old_local_player != new_local_player)
 385   {
 386     /* copy existing player settings and change to new player */
 387
 388     *new_local_player = *old_local_player;
 389     old_local_player->connected = FALSE;
 390     local_player = new_local_player;
 391   }
 392
 393   if (first_player.nr > MAX_PLAYERS)
 394     Error(ERR_EXIT, "sorry, more than %d players not allowed", MAX_PLAYERS);
 395
 396   Error(ERR_NETWORK_CLIENT, "you get client # %d", new_client_nr);
 397 }
 398
 399 static void Handle_OP_NUMBER_WANTED()
 400 {
 401   int client_nr_wanted = buffer[2];
 402   int old_client_nr = buffer[0];
 403   int new_client_nr = buffer[3];
 404   int old_index_nr = old_client_nr - 1;
 405   int new_index_nr = new_client_nr - 1;
 406   int index_nr_wanted = client_nr_wanted - 1;
 407   struct PlayerInfo *old_player = &stored_player[old_index_nr];
 408   struct PlayerInfo *new_player = &stored_player[new_index_nr];
 409
 410   printf("OP_NUMBER_WANTED: %d\n", buffer[0]);
 411
 412   if (new_client_nr == client_nr_wanted)        /* switching succeeded */
 413   {
 414     struct NetworkClientPlayerInfo *player;
 415
 416     if (old_client_nr != client_nr_wanted)      /* client's nr has changed */
 417       Error(ERR_NETWORK_CLIENT, "client %d switches to # %d",
 418             old_client_nr, new_client_nr);
 419     else if (old_client_nr == first_player.nr)  /* local player keeps his nr */
 420       Error(ERR_NETWORK_CLIENT, "keeping client # %d", new_client_nr);
 421
 422     if (old_client_nr != new_client_nr)
 423     {
 424       /* copy existing player settings and change to new player */
 425
 426       *new_player = *old_player;
 427       old_player->connected = FALSE;
 428     }
 429
 430     player = getNetworkPlayer(old_client_nr);
 431     player->nr = new_client_nr;
 432
 433     if (old_player == local_player)             /* local player switched */
 434       local_player = new_player;
 435   }
 436   else if (old_client_nr == first_player.nr)    /* failed -- local player? */
 437   {
 438     char request[100];
 439
 440     sprintf(request, "Sorry! Player %d already exists! You are player %d!",
 441             index_nr_wanted + 1, new_index_nr + 1);
 442
 443     Request(request, REQ_CONFIRM);
 444
 445     Error(ERR_NETWORK_CLIENT, "cannot switch -- you keep client # %d",
 446           new_client_nr);
 447   }
 448 }
 449
 450 static void Handle_OP_PLAYER_NAME(unsigned int len)
 451 {
 452   struct NetworkClientPlayerInfo *player;
 453   int player_nr = (int)buffer[0];
 454
 455   printf("OP_PLAYER_NAME: %d\n", player_nr);
 456   player = getNetworkPlayer(player_nr);
 457   buffer[len] = 0;
 458   Error(ERR_NETWORK_CLIENT, "client %d calls itself \"%s\"",
 459         buffer[0], &buffer[2]);
 460   strncpy(player->name, (char *)&buffer[2], MAX_PLAYER_NAME_LEN);
 461 }
 462
 463 static void Handle_OP_PLAYER_CONNECTED()
 464 {
 465   struct NetworkClientPlayerInfo *player, *last_player = NULL;
 466   int new_client_nr = (int)buffer[0];
 467   int new_index_nr = new_client_nr - 1;
 468
 469   printf("OP_PLAYER_CONNECTED: %d\n", new_client_nr);
 470   Error(ERR_NETWORK_CLIENT, "new client %d connected", new_client_nr);
 471
 472   for (player = &first_player; player; player = player->next)
 473   {
 474     if (player->nr == new_client_nr)
 475       Error(ERR_EXIT, "multiplayer server sent duplicate player id");
 476
 477     last_player = player;
 478   }
 479
 480   last_player->next = player =
 481     checked_malloc(sizeof(struct NetworkClientPlayerInfo));
 482   player->nr = new_client_nr;
 483   player->name[0] = '\0';
 484   player->next = NULL;
 485
 486   stored_player[new_index_nr].connected = TRUE;
 487 }
 488
 489 static void Handle_OP_PLAYER_DISCONNECTED()
 490 {
 491   struct NetworkClientPlayerInfo *player, *player_disconnected;
 492   int player_nr = (int)buffer[0];
 493
 494   printf("OP_PLAYER_DISCONNECTED: %d\n", player_nr);
 495   player_disconnected = getNetworkPlayer(player_nr);
 496   Error(ERR_NETWORK_CLIENT, "client %d (%s) disconnected",
 497         player_nr, getNetworkPlayerName(buffer[0]));
 498
 499   for (player = &first_player; player; player = player->next)
 500     if (player->next == player_disconnected)
 501       player->next = player_disconnected->next;
 502   free(player_disconnected);
 503 }
 504
 505 static void Handle_OP_START_PLAYING()
 506 {
 507   LevelDirTree *new_leveldir;
 508   int new_level_nr;
 509   unsigned int new_random_seed;
 510   char *new_leveldir_identifier;
 511
 512   new_level_nr = (buffer[2] << 8) + buffer[3];
 513   new_random_seed =
 514     (buffer[6] << 24) | (buffer[7] << 16) | (buffer[8] << 8) | (buffer[9]);
 515   new_leveldir_identifier = (char *)&buffer[10];
 516
 517   new_leveldir = getTreeInfoFromIdentifier(leveldir_first,
 518                                            new_leveldir_identifier);
 519   if (new_leveldir == NULL)
 520   {
 521     Error(ERR_WARN, "no such level identifier: '%s'", new_leveldir_identifier);
 522
 523     new_leveldir = leveldir_first;
 524     Error(ERR_WARN, "using default level set: '%s'", new_leveldir->identifier);
 525   }
 526
 527   printf("OP_START_PLAYING: %d\n", buffer[0]);
 528   Error(ERR_NETWORK_CLIENT,
 529         "client %d starts game [level %d from level identifier '%s']\n",
 530         buffer[0], new_level_nr, new_leveldir->identifier);
 531
 532   leveldir_current = new_leveldir;
 533   level_nr = new_level_nr;
 534
 535   TapeErase();
 536   LoadTape(level_nr);
 537   LoadLevel(level_nr);
 538
 539   StartGameActions(FALSE, setup.autorecord, new_random_seed);
 540 }
 541
 542 static void Handle_OP_PAUSE_PLAYING()
 543 {
 544   printf("OP_PAUSE_PLAYING: %d\n", buffer[0]);
 545   Error(ERR_NETWORK_CLIENT, "client %d pauses game", buffer[0]);
 546
 547   tape.pausing = TRUE;
 548   DrawVideoDisplay(VIDEO_STATE_PAUSE_ON,0);
 549 }
 550
 551 static void Handle_OP_CONTINUE_PLAYING()
 552 {
 553   printf("OP_CONTINUE_PLAYING: %d\n", buffer[0]);
 554   Error(ERR_NETWORK_CLIENT, "client %d continues game", buffer[0]);
 555
 556   tape.pausing = FALSE;
 557   DrawVideoDisplay(VIDEO_STATE_PAUSE_OFF,0);
 558 }
 559
 560 static void Handle_OP_STOP_PLAYING()
 561 {
 562   printf("OP_STOP_PLAYING: %d [%d]\n", buffer[0], buffer[2]);
 563   Error(ERR_NETWORK_CLIENT, "client %d stops game [%d]", buffer[0], buffer[2]);
 564
 565   if (game_status == GAME_MODE_PLAYING)
 566   {
 567     if (buffer[2] == NETWORK_STOP_BY_PLAYER)
 568       Request("Network game stopped by player!", REQ_CONFIRM);
 569     else if (buffer[2] == NETWORK_STOP_BY_ERROR)
 570       Request("Network game stopped due to internal error!", REQ_CONFIRM);
 571     else
 572       Request("Network game stopped!", REQ_CONFIRM);
 573   }
 574
 575   game_status = GAME_MODE_MAIN;
 576   DrawMainMenu();
 577 }
 578
 579 static void Handle_OP_MOVE_PLAYER(unsigned int len)
 580 {
 581   int server_frame_counter;
 582   int i;
 583
 584   if (!network_playing)
 585     return;
 586
 587   server_frame_counter =
 588     (buffer[2] << 24) | (buffer[3] << 16) | (buffer[4] << 8) | (buffer[5]);
 589
 590 #if 0
 591   Error(ERR_NETWORK_CLIENT, "receiving server frame counter value %d [%d]",
 592         server_frame_counter, FrameCounter);
 593 #endif
 594
 595   if (server_frame_counter != FrameCounter)
 596   {
 597     Error(ERR_INFO, "client and servers frame counters out of sync");
 598     Error(ERR_INFO, "frame counter of client is %d", FrameCounter);
 599     Error(ERR_INFO, "frame counter of server is %d", server_frame_counter);
 600     Error(ERR_INFO, "this should not happen -- please debug");
 601
 602     stop_network_game = TRUE;
 603
 604     return;
 605   }
 606
 607   /* copy valid player actions */
 608   for (i = 0; i < MAX_PLAYERS; i++)
 609     stored_player[i].effective_action =
 610       (i < len - 6 && stored_player[i].active ? buffer[6 + i] : 0);
 611
 612   network_player_action_received = TRUE;
 613 }
 614
 615 static void HandleNetworkingMessages()
 616 {
 617   unsigned int message_length;
 618
 619   stop_network_game = FALSE;
 620
 621   while (nread >= 4 && nread >= 4 + readbuffer[3])
 622   {
 623     message_length = readbuffer[3];
 624     if (readbuffer[0] || readbuffer[1] || readbuffer[2])
 625       Error(ERR_EXIT, "wrong network server line length");
 626
 627     memcpy(buffer, &readbuffer[4], message_length);
 628     nread -= 4 + message_length;
 629     memmove(readbuffer, readbuffer + 4 + message_length, nread);
 630
 631     switch (buffer[1])
 632     {
 633       case OP_BAD_PROTOCOL_VERSION:
 634         Handle_OP_BAD_PROTOCOL_VERSION();
 635         break;
 636
 637       case OP_YOUR_NUMBER:
 638         Handle_OP_YOUR_NUMBER();
 639         break;
 640
 641       case OP_NUMBER_WANTED:
 642         Handle_OP_NUMBER_WANTED();
 643         break;
 644
 645       case OP_PLAYER_NAME:
 646         Handle_OP_PLAYER_NAME(message_length);
 647         break;
 648
 649       case OP_PLAYER_CONNECTED:
 650         Handle_OP_PLAYER_CONNECTED();
 651         break;
 652
 653       case OP_PLAYER_DISCONNECTED:
 654         Handle_OP_PLAYER_DISCONNECTED();
 655         break;
 656
 657       case OP_START_PLAYING:
 658         Handle_OP_START_PLAYING();
 659         break;
 660
 661       case OP_PAUSE_PLAYING:
 662         Handle_OP_PAUSE_PLAYING();
 663         break;
 664
 665       case OP_CONTINUE_PLAYING:
 666         Handle_OP_CONTINUE_PLAYING();
 667         break;
 668
 669       case OP_STOP_PLAYING:
 670         Handle_OP_STOP_PLAYING();
 671         break;
 672
 673       case OP_MOVE_PLAYER:
 674         Handle_OP_MOVE_PLAYER(message_length);
 675         break;
 676
 677       case OP_BROADCAST_MESSAGE:
 678         printf("OP_BROADCAST_MESSAGE: %d\n", buffer[0]);
 679         Error(ERR_NETWORK_CLIENT, "client %d sends message", buffer[0]);
 680         break;
 681     }
 682   }
 683
 684   fflush(stdout);
 685
 686   /* in case of internal error, stop network game */
 687   if (stop_network_game)
 688     SendToServer_StopPlaying(NETWORK_STOP_BY_ERROR);
 689 }
 690
 691 /* TODO */
 692
 693 void HandleNetworking()
 694 {
 695 #if !defined(TARGET_SDL)
 696   static struct timeval tv = { 0, 0 };
 697   fd_set rfds;
 698 #endif
 699   int r = 0;
 700
 701   do
 702   {
 703 #if defined(TARGET_SDL)
 704     if ((r = SDLNet_CheckSockets(rfds, 1)) < 0)
 705       Error(ERR_EXIT, "HandleNetworking(): SDLNet_CheckSockets() failed");
 706
 707 #else
 708
 709     FD_ZERO(&rfds);
 710     FD_SET(sfd, &rfds);
 711
 712     r = select(sfd + 1, &rfds, NULL, NULL, &tv);
 713
 714     if (r < 0 && errno != EINTR)
 715       Error(ERR_EXIT, "HandleNetworking(): select() failed");
 716
 717     if (r < 0)
 718       FD_ZERO(&rfds);
 719 #endif
 720
 721 #if defined(TARGET_SDL)
 722     if (r > 0)
 723 #else
 724     if (FD_ISSET(sfd, &rfds))
 725 #endif
 726     {
 727 #if defined(TARGET_SDL)
 728       r = SDLNet_TCP_Recv(sfd, readbuffer + nread, 1);
 729 #else
 730       r = read(sfd, readbuffer + nread, MAX_BUFFER_SIZE - nread);
 731 #endif
 732
 733       if (r < 0)
 734         Error(ERR_EXIT, "error reading from network server");
 735
 736       if (r == 0)
 737         Error(ERR_EXIT, "connection to network server lost");
 738
 739       nread += r;
 740
 741       HandleNetworkingMessages();
 742     }
 743   }
 744   while (r > 0);
 745 }
 746
 747 #endif /* PLATFORM_UNIX */