src/netserv.c

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