src/network.c

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