src/netserv.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(PLATFORM_UNIX)
  17
  18 #include <fcntl.h>
  19 #include <sys/time.h>
  20 #include <signal.h>
  21 #include <sys/socket.h>
  22 #include <errno.h>
  23 #include <netinet/in.h>
  24 #include <netinet/tcp.h>
  25 #include <arpa/inet.h>
  26 #include <netdb.h>
  27 #include <sys/select.h>                 /* apparently needed for OS/2 port */
  28
  29 #include "libgame/libgame.h"
  30
  31 #include "netserv.h"
  32
  33 static int clients = 0;
  34 static int onceonly = 0;
  35
  36 struct NetworkServerPlayerInfo
  37 {
  38   int fd;
  39   char player_name[16];
  40   unsigned char number;
  41   struct NetworkServerPlayerInfo *next;
  42   char active;
  43   char introduced;
  44   unsigned char readbuffer[MAX_BUFFER_SIZE];
  45   unsigned char writbuffer[MAX_BUFFER_SIZE];
  46   int nread, nwrite;
  47   byte action;
  48   boolean action_received;
  49 };
  50
  51 static struct NetworkServerPlayerInfo *first_player = NULL;
  52
  53 #define NEXT(player) ((player)->next ? (player)->next : first_player)
  54
  55 static struct sockaddr_in saddr;
  56 static int lfd;
  57 static unsigned char realbuffer[512], *buffer = realbuffer + 4;
  58
  59 static int interrupt;
  60 static int tcp = -1;
  61
  62 static unsigned long ServerFrameCounter = 0;
  63
  64 static fd_set fds;
  65
  66 static void addtobuffer(struct NetworkServerPlayerInfo *player,
  67                         unsigned char *b, int len)
  68 {
  69   if (player->nwrite + len >= MAX_BUFFER_SIZE)
  70     Error(ERR_EXIT_NETWORK_SERVER,
  71           "internal error: network send buffer overflow");
  72
  73   memcpy(player->writbuffer + player->nwrite, b, len);
  74   player->nwrite += len;
  75 }
  76
  77 static void flushuser(struct NetworkServerPlayerInfo *player)
  78 {
  79   if (player->nwrite)
  80   {
  81     write(player->fd, player->writbuffer, player->nwrite);
  82     player->nwrite = 0;
  83   }
  84 }
  85
  86 static void broadcast(struct NetworkServerPlayerInfo *except,
  87                       int len, int activeonly)
  88 {
  89   struct NetworkServerPlayerInfo *player;
  90
  91   realbuffer[0] = realbuffer[1] = realbuffer[2] = 0;
  92   realbuffer[3] = (unsigned char)len;
  93   for (player = first_player; player; player = player->next)
  94     if (player != except && player->introduced &&
  95         (player->active || !activeonly))
  96       addtobuffer(player, realbuffer, 4 + len);
  97 }
  98
  99 static void sendtoone(struct NetworkServerPlayerInfo *to, int len)
 100 {
 101   realbuffer[0] = realbuffer[1] = realbuffer[2] = 0;
 102   realbuffer[3] = (unsigned char)len;
 103   addtobuffer(to, realbuffer, 4 + len);
 104 }
 105
 106 static void RemovePlayer(struct NetworkServerPlayerInfo *player)
 107 {
 108   struct NetworkServerPlayerInfo *v;
 109
 110   if (options.verbose)
 111     Error(ERR_NETWORK_SERVER, "dropping client %d (%s)",
 112           player->number, player->player_name);
 113
 114   if (player == first_player)
 115     first_player = player->next;
 116   else
 117   {
 118     for (v = first_player; v; v = v->next)
 119     {
 120       if (v->next && v->next == player)
 121       {
 122         v->next = player->next;
 123         break;
 124       }
 125     }
 126   }
 127   close(player->fd);
 128
 129   if (player->introduced)
 130   {
 131     buffer[0] = player->number;
 132     buffer[1] = OP_PLAYER_DISCONNECTED;
 133     broadcast(player, 2, 0);
 134   }
 135
 136   free(player);
 137   clients--;
 138
 139   if (onceonly && clients == 0)
 140   {
 141     if (options.verbose)
 142     {
 143       Error(ERR_NETWORK_SERVER, "no clients left");
 144       Error(ERR_NETWORK_SERVER, "aborting");
 145     }
 146     exit(0);
 147   }
 148 }
 149
 150 static void AddPlayer(int fd)
 151 {
 152   struct NetworkServerPlayerInfo *player, *v;
 153   unsigned char nxn;
 154   boolean again = TRUE;
 155
 156   player = checked_malloc(sizeof (struct NetworkServerPlayerInfo));
 157
 158   player->fd = fd;
 159   player->player_name[0] = 0;
 160   player->next = first_player;
 161   player->active = 0;
 162   player->nread = 0;
 163   player->nwrite = 0;
 164   player->introduced = 0;
 165   player->action = 0;
 166   player->action_received = FALSE;
 167
 168   first_player = player;
 169
 170   nxn = 1;
 171
 172 #if 1
 173   while (again)
 174   {
 175     again = FALSE;
 176     v = player->next;
 177
 178     while (v)
 179     {
 180       if (v->number == nxn)
 181       {
 182         nxn++;
 183
 184         again = TRUE;
 185         break;
 186       }
 187       v = v->next;
 188     }
 189   }
 190 #else
 191  again:
 192   v = player->next;
 193   while (v)
 194   {
 195     if (v->number == nxn)
 196     {
 197       nxn++;
 198       goto again;
 199     }
 200     v = v->next;
 201   }
 202 #endif
 203
 204   player->number = nxn;
 205   if (options.verbose)
 206     Error(ERR_NETWORK_SERVER, "client %d connecting from %s",
 207           nxn, inet_ntoa(saddr.sin_addr));
 208   clients++;
 209
 210   buffer[0] = 0;
 211   buffer[1] = OP_YOUR_NUMBER;
 212   buffer[2] = player->number;
 213   sendtoone(player, 3);
 214 }
 215
 216 static void Handle_OP_PROTOCOL_VERSION(struct NetworkServerPlayerInfo *player,
 217                                        unsigned int len)
 218 {
 219   if (len != 5 ||
 220       buffer[2] != PROTOCOL_VERSION_1 ||
 221       buffer[3] != PROTOCOL_VERSION_2)
 222   {
 223     if (options.verbose)
 224       Error(ERR_NETWORK_SERVER,
 225             "client %d (%s) has wrong protocol version %d.%d.%d",
 226             player->number, player->player_name, buffer[2], buffer[3], buffer[4]);
 227
 228     buffer[0] = 0;
 229     buffer[1] = OP_BAD_PROTOCOL_VERSION;
 230     buffer[2] = PROTOCOL_VERSION_1;
 231     buffer[3] = PROTOCOL_VERSION_2;
 232     buffer[4] = PROTOCOL_VERSION_3;
 233     sendtoone(player, 5);
 234     flushuser(player);
 235
 236     RemovePlayer(player);
 237     interrupt = 1;
 238   }
 239   else
 240   {
 241     if (options.verbose)
 242       Error(ERR_NETWORK_SERVER,
 243             "client %d (%s) uses protocol version %d.%d.%d",
 244             player->number, player->player_name, buffer[2], buffer[3], buffer[4]);
 245   }
 246 }
 247
 248 static void Handle_OP_NUMBER_WANTED(struct NetworkServerPlayerInfo *player)
 249 {
 250   struct NetworkServerPlayerInfo *v;
 251   int client_nr = player->number;
 252   int nr_wanted = buffer[2];
 253   int nr_is_free = 1;
 254
 255   if (options.verbose)
 256       Error(ERR_NETWORK_SERVER, "client %d (%s) wants to switch to # %d",
 257             player->number, player->player_name, nr_wanted);
 258
 259   for (v = first_player; v; v = v->next)
 260   {
 261     if (v->number == nr_wanted)
 262     {
 263       nr_is_free = 0;
 264       break;
 265     }
 266   }
 267
 268   if (options.verbose)
 269   {
 270     if (nr_is_free)
 271       Error(ERR_NETWORK_SERVER, "client %d (%s) switches to # %d",
 272             player->number, player->player_name, nr_wanted);
 273     else if (player->number == nr_wanted)
 274       Error(ERR_NETWORK_SERVER, "client %d (%s) still has # %d",
 275             player->number, player->player_name, nr_wanted);
 276     else
 277       Error(ERR_NETWORK_SERVER,
 278             "client %d (%s) cannot switch (client %d still exists)",
 279             player->number, player->player_name, nr_wanted);
 280   }
 281
 282   if (nr_is_free)
 283     player->number = nr_wanted;
 284
 285   buffer[0] = client_nr;
 286   buffer[1] = OP_NUMBER_WANTED;
 287   buffer[2] = nr_wanted;
 288   buffer[3] = player->number;
 289
 290   /*
 291   sendtoone(player, 4);
 292   */
 293
 294   broadcast(NULL, 4, 0);
 295 }
 296
 297 static void Handle_OP_PLAYER_NAME(struct NetworkServerPlayerInfo *player,
 298                                   unsigned int len)
 299 {
 300   struct NetworkServerPlayerInfo *v;
 301   int i;
 302
 303   if (len>16)
 304     len=16;
 305   memcpy(player->player_name, &buffer[2], len-2);
 306   player->player_name[len-2] = 0;
 307   for (i = 0; i < len - 2; i++)
 308   {
 309     if (player->player_name[i] < ' ' ||
 310         ((unsigned char)(player->player_name[i]) > 0x7e &&
 311          (unsigned char)(player->player_name[i]) <= 0xa0))
 312     {
 313       player->player_name[i] = 0;
 314       break;
 315     }
 316   }
 317
 318   if (!player->introduced)
 319   {
 320     buffer[0] = player->number;
 321     buffer[1] = OP_PLAYER_CONNECTED;
 322     broadcast(player, 2, 0);
 323   }
 324
 325   if (options.verbose)
 326     Error(ERR_NETWORK_SERVER, "client %d calls itself \"%s\"",
 327           player->number, player->player_name);
 328   buffer[1] = OP_PLAYER_NAME;
 329   broadcast(player, len, 0);
 330
 331   if (!player->introduced)
 332   {
 333     for (v = first_player; v; v = v->next)
 334     {
 335       if (v != player && v->introduced)
 336       {
 337         buffer[0] = v->number;
 338         buffer[1] = OP_PLAYER_CONNECTED;
 339         sendtoone(player, 2);
 340         buffer[1] = OP_PLAYER_NAME;
 341         memcpy(&buffer[2], v->player_name, 14);
 342         sendtoone(player, 2+strlen(v->player_name));
 343       }
 344     }
 345   }
 346
 347   player->introduced = 1;
 348 }
 349
 350 static void Handle_OP_START_PLAYING(struct NetworkServerPlayerInfo *player)
 351 {
 352   struct NetworkServerPlayerInfo *v, *w;
 353
 354   if (options.verbose)
 355     Error(ERR_NETWORK_SERVER,
 356           "client %d (%s) starts game [level %d from levedir %d (%s)]",
 357           player->number, player->player_name,
 358           (buffer[2] << 8) + buffer[3],
 359           (buffer[4] << 8) + buffer[5],
 360           &buffer[6]);
 361
 362   for (w = first_player; w; w = w->next)
 363     if (w->introduced)
 364       w->active = 1;
 365
 366   /* reset frame counter */
 367   ServerFrameCounter = 0;
 368
 369   /* reset player actions */
 370   for (v = first_player; v; v = v->next)
 371   {
 372     v->action = 0;
 373     v->action_received = FALSE;
 374   }
 375
 376   broadcast(NULL, 10 + strlen((char *)&buffer[10])+1, 0);
 377 }
 378
 379 static void Handle_OP_PAUSE_PLAYING(struct NetworkServerPlayerInfo *player)
 380 {
 381   if (options.verbose)
 382     Error(ERR_NETWORK_SERVER, "client %d (%s) pauses game",
 383           player->number, player->player_name);
 384   broadcast(NULL, 2, 0);
 385 }
 386
 387 static void Handle_OP_CONTINUE_PLAYING(struct NetworkServerPlayerInfo *player)
 388 {
 389   if (options.verbose)
 390     Error(ERR_NETWORK_SERVER, "client %d (%s) continues game",
 391           player->number, player->player_name);
 392   broadcast(NULL, 2, 0);
 393 }
 394
 395 static void Handle_OP_STOP_PLAYING(struct NetworkServerPlayerInfo *player)
 396 {
 397   if (options.verbose)
 398     Error(ERR_NETWORK_SERVER, "client %d (%s) stops game",
 399           player->number, player->player_name);
 400   broadcast(NULL, 2, 0);
 401 }
 402
 403 static void Handle_OP_MOVE_PLAYER(struct NetworkServerPlayerInfo *player)
 404 {
 405   struct NetworkServerPlayerInfo *v;
 406   int last_client_nr = 0;
 407   int i;
 408
 409   /* store player action */
 410   for (v = first_player; v; v = v->next)
 411   {
 412     if (v->number == player->number)
 413     {
 414       v->action = buffer[2];
 415       v->action_received = TRUE;
 416     }
 417   }
 418
 419   /* check if server received action from each player */
 420   for (v = first_player; v; v = v->next)
 421   {
 422     if (!v->action_received)
 423       return;
 424
 425     if (v->number > last_client_nr)
 426       last_client_nr = v->number;
 427   }
 428
 429   /* initialize all player actions to zero */
 430   for (i = 0; i < last_client_nr; i++)
 431     buffer[6 + i] = 0;
 432
 433   /* broadcast actions of all players to all players */
 434   for (v = first_player; v; v = v->next)
 435   {
 436     buffer[6 + v->number-1] = v->action;
 437     v->action = 0;
 438     v->action_received = FALSE;
 439   }
 440
 441   buffer[2] = (unsigned char)((ServerFrameCounter >> 24) & 0xff);
 442   buffer[3] = (unsigned char)((ServerFrameCounter >> 16) & 0xff);
 443   buffer[4] = (unsigned char)((ServerFrameCounter >>  8) & 0xff);
 444   buffer[5] = (unsigned char)((ServerFrameCounter >>  0) & 0xff);
 445
 446   broadcast(NULL, 6 + last_client_nr, 0);
 447
 448   ServerFrameCounter++;
 449 }
 450
 451 void NetworkServer(int port, int serveronly)
 452 {
 453   int i, sl, on;
 454   struct NetworkServerPlayerInfo *player;
 455   int mfd;
 456   int r;
 457   unsigned int len;
 458   struct protoent *tcpproto;
 459   struct timeval tv;
 460   int is_daemon = 0;
 461
 462 #ifndef NeXT
 463   struct sigaction sact;
 464 #endif
 465
 466   if (port == 0)
 467     port = DEFAULT_SERVER_PORT;
 468
 469   if (!serveronly)
 470     onceonly = 1;
 471
 472   if ((tcpproto = getprotobyname("tcp")) != NULL)
 473     tcp = tcpproto->p_proto;
 474
 475 #ifdef NeXT
 476   signal(SIGPIPE, SIG_IGN);
 477 #else
 478   sact.sa_handler = SIG_IGN;
 479   sigemptyset(&sact.sa_mask);
 480   sact.sa_flags = 0;
 481   sigaction(SIGPIPE, &sact, NULL);
 482 #endif
 483
 484
 485   if ((lfd = socket(PF_INET, SOCK_STREAM, 0)) < 0)
 486     Error(ERR_EXIT_NETWORK_SERVER, "socket() failed");
 487
 488   saddr.sin_family = AF_INET;
 489   saddr.sin_addr.s_addr = htonl(INADDR_ANY);
 490   saddr.sin_port = htons(port);
 491
 492   on = 1;
 493
 494   setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, (char *)&on, sizeof(int));
 495   if (bind(lfd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0)
 496     Error(ERR_EXIT_NETWORK_SERVER, "bind() failed");
 497
 498   listen(lfd, 5);
 499
 500   if (is_daemon)
 501   {
 502     /* become a daemon, breaking all ties with the controlling terminal */
 503     options.verbose = FALSE;
 504     for (i = 0; i < 255; i++)
 505     {
 506       if (i != lfd)
 507         close(i);
 508     }
 509
 510     if (fork())
 511       exit(0);
 512     setsid();
 513     if (fork())
 514       exit(0);
 515     chdir("/");
 516
 517     /* open a fake stdin, stdout, stderr, just in case */
 518     open("/dev/null", O_RDONLY);
 519     open("/dev/null", O_WRONLY);
 520     open("/dev/null", O_WRONLY);
 521   }
 522
 523   if (options.verbose)
 524   {
 525     Error(ERR_NETWORK_SERVER, "started up, listening on port %d", port);
 526     Error(ERR_NETWORK_SERVER, "using protocol version %d.%d.%d",
 527           PROTOCOL_VERSION_1, PROTOCOL_VERSION_2, PROTOCOL_VERSION_3);
 528   }
 529
 530   while (1)
 531   {
 532     interrupt = 0;
 533
 534     for (player = first_player; player; player = player->next)
 535       flushuser(player);
 536
 537     FD_ZERO(&fds);
 538     mfd = lfd;
 539     player = first_player;
 540     while (player)
 541     {
 542       FD_SET(player->fd, &fds);
 543       if (player->fd > mfd)
 544         mfd = player->fd;
 545       player = player->next;
 546     }
 547     FD_SET(lfd, &fds);
 548     tv.tv_sec = 0;
 549     tv.tv_usec = 500000;
 550     if ((sl = select(mfd + 1, &fds, NULL, NULL, &tv)) < 0)
 551     {
 552       if (errno != EINTR)
 553         Error(ERR_EXIT_NETWORK_SERVER, "select() failed");
 554       else
 555         continue;
 556     }
 557
 558     if (sl < 0)
 559       continue;
 560
 561     if (sl == 0)
 562       continue;
 563
 564     if (FD_ISSET(lfd, &fds))
 565     {
 566       int newfd, slen;
 567
 568       slen = sizeof(saddr);
 569       newfd = accept(lfd, (struct sockaddr *)&saddr, &slen);
 570       if (newfd < 0)
 571       {
 572         if (errno != EINTR)
 573           Error(ERR_EXIT_NETWORK_SERVER, "accept() failed");
 574       }
 575       else
 576       {
 577         if (tcp != -1)
 578         {
 579           on = 1;
 580           setsockopt(newfd, tcp, TCP_NODELAY, (char *)&on, sizeof(int));
 581         }
 582         AddPlayer(newfd);
 583       }
 584       continue;
 585     }
 586
 587     player = first_player;
 588
 589     do
 590     {
 591       if (FD_ISSET(player->fd, &fds))
 592       {
 593         r = read(player->fd, player->readbuffer + player->nread, MAX_BUFFER_SIZE - player->nread);
 594         if (r <= 0)
 595         {
 596           if (options.verbose)
 597             Error(ERR_NETWORK_SERVER, "EOF from client %d (%s)",
 598                   player->number, player->player_name);
 599           RemovePlayer(player);
 600           interrupt = 1;
 601           break;
 602         }
 603         player->nread += r;
 604         while (player->nread >= 4 && player->nread >= 4 + player->readbuffer[3])
 605         {
 606           len = player->readbuffer[3];
 607           if (player->readbuffer[0] || player->readbuffer[1] || player->readbuffer[2])
 608           {
 609             if (options.verbose)
 610               Error(ERR_NETWORK_SERVER, "crap from client %d (%s)",
 611                     player->number, player->player_name);
 612             RemovePlayer(player);
 613             interrupt = 1;
 614             break;
 615           }
 616           memcpy(buffer, &player->readbuffer[4], len);
 617           player->nread -= 4 + len;
 618           memmove(player->readbuffer, player->readbuffer + 4 + len, player->nread);
 619
 620           buffer[0] = player->number;
 621           if (!player->introduced && buffer[1] != OP_PLAYER_NAME)
 622           {
 623             if (options.verbose)
 624               Error(ERR_NETWORK_SERVER, "!(client %d)->introduced && buffer[1]==%d (expected OP_PLAYER_NAME)", buffer[0], buffer[1]);
 625
 626             RemovePlayer(player);
 627             interrupt = 1;
 628             break;
 629           }
 630
 631           switch(buffer[1])
 632           {
 633             case OP_PLAYER_NAME:
 634               Handle_OP_PLAYER_NAME(player, len);
 635               break;
 636
 637             case OP_PROTOCOL_VERSION:
 638               Handle_OP_PROTOCOL_VERSION(player, len);
 639               break;
 640
 641             case OP_NUMBER_WANTED:
 642               Handle_OP_NUMBER_WANTED(player);
 643               break;
 644
 645             case OP_START_PLAYING:
 646               Handle_OP_START_PLAYING(player);
 647               break;
 648
 649             case OP_PAUSE_PLAYING:
 650               Handle_OP_PAUSE_PLAYING(player);
 651               break;
 652
 653             case OP_CONTINUE_PLAYING:
 654               Handle_OP_CONTINUE_PLAYING(player);
 655               break;
 656
 657             case OP_STOP_PLAYING:
 658               Handle_OP_STOP_PLAYING(player);
 659               break;
 660
 661             case OP_MOVE_PLAYER:
 662               Handle_OP_MOVE_PLAYER(player);
 663               break;
 664
 665             case OP_BROADCAST_MESSAGE:
 666               buffer[len] = '\0';
 667               if (options.verbose)
 668                 Error(ERR_NETWORK_SERVER, "client %d (%s) sends message: %s",
 669                       player->number, player->player_name, &buffer[2]);
 670               broadcast(player, len, 0);
 671               break;
 672
 673             default:
 674               if (options.verbose)
 675                 Error(ERR_NETWORK_SERVER,
 676                       "unknown opcode %d from client %d (%s)",
 677                       buffer[0], player->number, player->player_name);
 678           }
 679         }
 680       }
 681
 682       if (player && !interrupt)
 683         player = player->next;
 684     }
 685     while (player && !interrupt);
 686   }
 687 }
 688
 689 #endif /* PLATFORM_UNIX */