src/network.c

   1 /***********************************************************
   2 *  Rocks'n'Diamonds -- McDuffin Strikes Back!              *
   3 *----------------------------------------------------------*
   4 *  (c) 1995-98 Artsoft Entertainment                       *
   5 *              Holger Schemel                              *
   6 *              Oststrasse 11a                              *
   7 *              33604 Bielefeld                             *
   8 *              phone: ++49 +521 290471                     *
   9 *              email: aeglos@valinor.owl.de                *
  10 *----------------------------------------------------------*
  11 *  network.c                                               *
  12 ***********************************************************/
  13
  14 #include <stdio.h>
  15 #include <stdlib.h>
  16 #include <unistd.h>
  17 #include <signal.h>
  18 #include <sys/types.h>
  19 #include <sys/time.h>
  20 #include <sys/wait.h>
  21 #include <sys/socket.h>
  22 #include <netinet/in.h>
  23 #include <netinet/tcp.h>
  24 #include <arpa/inet.h>
  25 #include <netdb.h>
  26 #include <errno.h>
  27
  28 #include "network.h"
  29 #include "netserv.h"
  30 #include "game.h"
  31 #include "tape.h"
  32 #include "files.h"
  33 #include "tools.h"
  34 #include "buttons.h"
  35 #include "screens.h"
  36 #include "misc.h"
  37
  38 #define MAXNICKLEN 14
  39
  40 struct user
  41 {
  42   byte nr;
  43   char name[MAXNICKLEN+2];
  44   struct user *next;
  45 };
  46
  47 struct user me =
  48 {
  49   0,
  50   "no name",
  51   NULL
  52 };
  53
  54 static char msgbuf[300];
  55
  56 /* server stuff */
  57
  58 int sfd;
  59 unsigned char realbuf[512], readbuf[MAX_BUFFER_SIZE], writbuf[MAX_BUFFER_SIZE];
  60 unsigned char *buf = realbuf + 4;
  61 int nread = 0, nwrite = 0;
  62
  63 static void sysmsg(char *s)
  64 {
  65   if (verbose)
  66   {
  67     printf("** %s\n", s);
  68     fflush(stdout);
  69   }
  70 }
  71
  72 static void *mmalloc(int n)
  73 {
  74   void *r;
  75
  76   r = malloc(n);
  77   if (r == NULL)
  78     fatal("Out of memory");
  79   return r;
  80 }
  81
  82 static void u_sleep(int i)
  83 {
  84   struct timeval tm;
  85   tm.tv_sec = i / 1000000;
  86   tm.tv_usec = i % 1000000;
  87   select(0, NULL, NULL, NULL, &tm);
  88 }
  89
  90 static void flushbuf()
  91 {
  92   if (nwrite)
  93   {
  94     write(sfd, writbuf, nwrite);
  95     nwrite = 0;
  96   }
  97 }
  98
  99 static void sendbuf(int len)
 100 {
 101   if (network)
 102   {
 103     realbuf[0] = realbuf[1] = realbuf[2] = 0;
 104     realbuf[3] = (unsigned char)len;
 105     buf[0] = 0;
 106     if (nwrite + 4 + len >= MAX_BUFFER_SIZE)
 107       fatal("Internal error: send buffer overflow");
 108     memcpy(writbuf + nwrite, realbuf, 4 + len);
 109     nwrite += 4 + len;
 110
 111
 112     flushbuf();
 113
 114
 115   }
 116 }
 117
 118 struct user *finduser(unsigned char c)
 119 {
 120   struct user *u;
 121
 122   for (u = &me; u; u = u->next)
 123     if (u->nr == c)
 124       return u;
 125
 126   fatal("Protocol error: reference to non-existing user");
 127   return NULL; /* so that gcc -Wall doesn't complain */
 128 }
 129
 130 char *get_user_name(unsigned char c)
 131 {
 132   struct user *u;
 133
 134   if (c == 0)
 135     return("the server");
 136   else if (c == me.nr)
 137     return("you");
 138   else
 139     for (u = &me; u; u = u->next)
 140       if (u->nr == c && u->name && strlen(u->name))
 141         return(u->name);
 142
 143   return("no name");
 144 }
 145
 146 static void StartNetworkServer(int port)
 147 {
 148   switch (fork())
 149   {
 150     case 0:
 151       NetworkServer(port, serveronly);
 152
 153       /* never reached */
 154       exit(0);
 155
 156     case -1:
 157       Error(ERR_RETURN,
 158             "cannot create network server process - no network games");
 159       network = FALSE;
 160       return;
 161
 162     default:
 163       /* we are parent process -- resume normal operation */
 164       return;
 165   }
 166 }
 167
 168 BOOL ConnectToServer(char *host, int port)
 169 {
 170   struct hostent *hp;
 171   struct sockaddr_in s;
 172   struct protoent *tcpproto;
 173   int on = 1, i;
 174
 175   if (host)
 176   {
 177     if ((s.sin_addr.s_addr = inet_addr(host)) == -1)
 178     {
 179       hp = gethostbyname(host);
 180       if (!hp)
 181         fatal("Host not found");
 182       s.sin_addr = *(struct in_addr *)(hp->h_addr_list[0]);
 183     }
 184   }
 185   else
 186     s.sin_addr.s_addr = inet_addr("127.0.0.1");
 187
 188   if (port == 0)
 189     port = DEFAULTPORT;
 190
 191   s.sin_port = htons(port);
 192   s.sin_family = AF_INET;
 193   sfd = socket(PF_INET, SOCK_STREAM, 0);
 194   if (sfd < 0)
 195     fatal("Out of file descriptors");
 196   if ((tcpproto = getprotobyname("tcp")) != NULL)
 197     setsockopt(sfd, tcpproto->p_proto, TCP_NODELAY, (char *)&on, sizeof(int));
 198
 199   if (connect(sfd, (struct sockaddr *)&s, sizeof(s)) < 0)
 200   {
 201     if (!host)
 202     {
 203       printf("No rocksndiamonds server on localhost - starting up one ...\n");
 204
 205       StartNetworkServer(port);
 206
 207       for (i=0; i<6; i++)
 208       {
 209         u_sleep(500000);
 210         close(sfd);
 211         sfd = socket(PF_INET, SOCK_STREAM, 0);
 212         if (sfd < 0)
 213           fatal("Out of file descriptors");
 214         setsockopt(sfd, tcpproto->p_proto, TCP_NODELAY, (char *)&on, sizeof(int));
 215         if (connect(sfd, (struct sockaddr *)&s, sizeof(s)) >= 0)
 216           break;
 217       }
 218       if (i==6)
 219         fatal("Can't connect to server");
 220     }
 221     else
 222       fatal("Can't connect to server");
 223   }
 224
 225   return(TRUE);
 226 }
 227
 228 void SendToServer_Nickname(char *nickname)
 229 {
 230   static char msgbuf[300];
 231
 232   buf[1] = OP_NICKNAME;
 233   memcpy(&buf[2], nickname, strlen(nickname));
 234   sendbuf(2 + strlen(nickname));
 235   sprintf(msgbuf, "you set your nick to \"%s\"", nickname);
 236   sysmsg(msgbuf);
 237 }
 238
 239 void SendToServer_ProtocolVersion()
 240 {
 241   buf[1] = OP_PROTOCOL_VERSION;
 242   buf[2] = PROT_VERS_1;
 243   buf[3] = PROT_VERS_2;
 244   buf[4] = PROT_VERS_3;
 245
 246   sendbuf(5);
 247 }
 248
 249 void SendToServer_NrWanted(int nr_wanted)
 250 {
 251   buf[1] = OP_NUMBER_WANTED;
 252   buf[2] = nr_wanted;
 253
 254   sendbuf(3);
 255 }
 256
 257 void SendToServer_StartPlaying()
 258 {
 259   unsigned long new_random_seed = InitRND(NEW_RANDOMIZE);
 260
 261   buf[1] = OP_START_PLAYING;
 262   buf[2] = (byte)(level_nr >> 8);
 263   buf[3] = (byte)(level_nr & 0xff);
 264   buf[4] = (byte)(leveldir_nr >> 8);
 265   buf[5] = (byte)(leveldir_nr & 0xff);
 266
 267   buf[6] = (unsigned char)((new_random_seed >> 24) & 0xff);
 268   buf[7] = (unsigned char)((new_random_seed >> 16) & 0xff);
 269   buf[8] = (unsigned char)((new_random_seed >>  8) & 0xff);
 270   buf[9] = (unsigned char)((new_random_seed >>  0) & 0xff);
 271
 272   strcpy(&buf[10], leveldir[leveldir_nr].name);
 273
 274   sendbuf(10 + strlen(leveldir[leveldir_nr].name)+1);
 275 }
 276
 277 void SendToServer_PausePlaying()
 278 {
 279   buf[1] = OP_PAUSE_PLAYING;
 280
 281   sendbuf(2);
 282 }
 283
 284 void SendToServer_ContinuePlaying()
 285 {
 286   buf[1] = OP_CONTINUE_PLAYING;
 287
 288   sendbuf(2);
 289 }
 290
 291 void SendToServer_StopPlaying()
 292 {
 293   buf[1] = OP_STOP_PLAYING;
 294
 295   sendbuf(2);
 296 }
 297
 298 void SendToServer_MovePlayer(byte player_action)
 299 {
 300   buf[1] = OP_MOVE_FIGURE;
 301   buf[2] = player_action;
 302
 303   sendbuf(3);
 304 }
 305
 306 static void Handle_OP_BAD_PROTOCOL_VERSION()
 307 {
 308   Error(ERR_RETURN, "protocol version mismatch");
 309   Error(ERR_EXIT, "server expects %d.%d.x instead of %d.%d.%d",
 310         buf[2], buf[3], PROT_VERS_1, PROT_VERS_2, PROT_VERS_3);
 311 }
 312
 313 static void Handle_OP_YOUR_NUMBER()
 314 {
 315   int new_client_nr = buf[2];
 316   int new_index_nr = new_client_nr - 1;
 317   struct PlayerInfo *old_local_player = local_player;
 318   struct PlayerInfo *new_local_player = &stored_player[new_index_nr];
 319
 320   printf("OP_YOUR_NUMBER: %d\n", buf[0]);
 321   me.nr = new_client_nr;
 322
 323   if (old_local_player != new_local_player)
 324   {
 325     /* copy existing player settings and change to new player */
 326
 327     *new_local_player = *old_local_player;
 328     old_local_player->connected = FALSE;
 329     old_local_player->local = FALSE;
 330
 331     local_player = new_local_player;
 332   }
 333
 334   TestPlayer = new_index_nr;
 335
 336   if (me.nr > MAX_PLAYERS)
 337     Error(ERR_EXIT, "sorry - no more than %d players", MAX_PLAYERS);
 338
 339   sprintf(msgbuf, "you get client # %d", new_client_nr);
 340   sysmsg(msgbuf);
 341 }
 342
 343 static void Handle_OP_NUMBER_WANTED()
 344 {
 345   int client_nr_wanted = buf[2];
 346   int old_client_nr = buf[0];
 347   int new_client_nr = buf[3];
 348   int old_index_nr = old_client_nr - 1;
 349   int new_index_nr = new_client_nr - 1;
 350   int index_nr_wanted = client_nr_wanted - 1;
 351   struct PlayerInfo *old_player = &stored_player[old_index_nr];
 352   struct PlayerInfo *new_player = &stored_player[new_index_nr];
 353
 354   printf("OP_NUMBER_WANTED: %d\n", buf[0]);
 355
 356   if (new_client_nr == client_nr_wanted)        /* switching succeeded */
 357   {
 358     struct user *u;
 359
 360     if (old_client_nr != client_nr_wanted)      /* client's nr has changed */
 361     {
 362       sprintf(msgbuf, "client %d switches to # %d",
 363               old_client_nr, new_client_nr);
 364       sysmsg(msgbuf);
 365     }
 366     else if (old_client_nr == me.nr)            /* local player keeps his nr */
 367     {
 368       sprintf(msgbuf, "keeping client # %d", new_client_nr);
 369       sysmsg(msgbuf);
 370     }
 371
 372     if (old_client_nr != new_client_nr)
 373     {
 374       /* copy existing player settings and change to new player */
 375
 376       *new_player = *old_player;
 377       old_player->connected = FALSE;
 378       old_player->local = FALSE;
 379     }
 380
 381     u = finduser(old_client_nr);
 382     u->nr = new_client_nr;
 383
 384     if (old_client_nr == local_player->client_nr) /* local player switched */
 385       local_player = new_player;
 386
 387
 388
 389     TestPlayer = new_index_nr;
 390   }
 391   else if (old_client_nr == me.nr)              /* failed -- local player? */
 392   {
 393     char *color[] = { "yellow", "red", "green", "blue" };
 394
 395     sprintf(msgbuf, "Sorry ! %s player still exists ! You are %s player !",
 396             color[index_nr_wanted], color[new_index_nr]);
 397     Request(msgbuf, REQ_CONFIRM);
 398
 399     sprintf(msgbuf, "cannot switch -- you keep client # %d",
 400             new_client_nr);
 401     sysmsg(msgbuf);
 402   }
 403 }
 404
 405 static void Handle_OP_NICKNAME(unsigned int len)
 406 {
 407   struct user *u;
 408
 409   printf("OP_NICKNAME: %d\n", buf[0]);
 410   u = finduser(buf[0]);
 411   buf[len] = 0;
 412   sprintf(msgbuf, "client %d calls itself \"%s\"", buf[0], &buf[2]);
 413   sysmsg(msgbuf);
 414   strncpy(u->name, &buf[2], MAXNICKLEN);
 415 }
 416
 417 static void Handle_OP_PLAYER_CONNECTED()
 418 {
 419   struct user *u, *v = NULL;
 420   int new_client_nr = buf[0];
 421   int new_index_nr = new_client_nr - 1;
 422
 423   printf("OP_PLAYER_CONNECTED: %d\n", new_client_nr);
 424   sprintf(msgbuf, "new client %d connected", new_client_nr);
 425   sysmsg(msgbuf);
 426
 427   for (u = &me; u; u = u->next)
 428   {
 429     if (u->nr == new_client_nr)
 430       Error(ERR_EXIT, "multiplayer server sent duplicate player id");
 431     else
 432       v = u;
 433   }
 434
 435   v->next = u = mmalloc(sizeof(struct user));
 436   u->nr = new_client_nr;
 437   u->name[0] = '\0';
 438   u->next = NULL;
 439
 440   stored_player[new_index_nr].connected = TRUE;
 441 }
 442
 443 static void Handle_OP_PLAYER_DISCONNECTED()
 444 {
 445   struct user *u, *v;
 446
 447   printf("OP_PLAYER_DISCONNECTED: %d\n", buf[0]);
 448   u = finduser(buf[0]);
 449   sprintf(msgbuf, "client %d (%s) disconnected",
 450           buf[0], get_user_name(buf[0]));
 451   sysmsg(msgbuf);
 452
 453   for (v = &me; v; v = v->next)
 454     if (v->next == u)
 455       v->next = u->next;
 456   free(u);
 457 }
 458
 459 static void Handle_OP_START_PLAYING()
 460 {
 461   int new_level_nr, new_leveldir_nr;
 462   unsigned long new_random_seed;
 463   unsigned char *new_leveldir_name;
 464
 465   /*
 466     if (game_status == PLAYING)
 467     break;
 468   */
 469
 470   new_level_nr = (buf[2] << 8) + buf[3];
 471   new_leveldir_nr = (buf[4] << 8) + buf[5];
 472   new_random_seed =
 473     (buf[6] << 24) | (buf[7] << 16) | (buf[8] << 8) | (buf[9]);
 474   new_leveldir_name = &buf[10];
 475
 476   printf("OP_START_PLAYING: %d\n", buf[0]);
 477   sprintf(msgbuf, "client %d starts game [level %d from levedir %d (%s)]\n",
 478           buf[0],
 479           new_level_nr,
 480           new_leveldir_nr,
 481           new_leveldir_name);
 482   sysmsg(msgbuf);
 483
 484
 485   if (strcmp(leveldir[new_leveldir_nr].name, new_leveldir_name) != 0)
 486     Error(ERR_RETURN, "no such level directory: '%s'",new_leveldir_name);
 487
 488   leveldir_nr = new_leveldir_nr;
 489
 490   local_player->leveldir_nr = leveldir_nr;
 491   LoadPlayerInfo(PLAYER_LEVEL);
 492   SavePlayerInfo(PLAYER_SETUP);
 493
 494   level_nr = new_level_nr;
 495
 496   TapeErase();
 497   LoadLevelTape(level_nr);
 498
 499   GetPlayerConfig();
 500   LoadLevel(level_nr);
 501
 502
 503
 504   if (autorecord_on)
 505     TapeStartRecording();
 506
 507
 508
 509   if (tape.recording)
 510     tape.random_seed = new_random_seed;
 511
 512   InitRND(new_random_seed);
 513
 514
 515   /*
 516     printf("tape.random_seed == %d\n", tape.random_seed);
 517   */
 518
 519   game_status = PLAYING;
 520   InitGame();
 521 }
 522
 523 static void Handle_OP_PAUSE_PLAYING()
 524 {
 525   printf("OP_PAUSE_PLAYING: %d\n", buf[0]);
 526   sprintf(msgbuf, "client %d pauses game", buf[0]);
 527   sysmsg(msgbuf);
 528
 529   tape.pausing = TRUE;
 530   DrawVideoDisplay(VIDEO_STATE_PAUSE_ON,0);
 531 }
 532
 533 static void Handle_OP_CONTINUE_PLAYING()
 534 {
 535   printf("OP_CONTINUE_PLAYING: %d\n", buf[0]);
 536   sprintf(msgbuf, "client %d continues game", buf[0]);
 537   sysmsg(msgbuf);
 538
 539   tape.pausing = FALSE;
 540   DrawVideoDisplay(VIDEO_STATE_PAUSE_OFF,0);
 541 }
 542
 543 static void Handle_OP_STOP_PLAYING()
 544 {
 545   printf("OP_STOP_PLAYING: %d\n", buf[0]);
 546   sprintf(msgbuf, "client %d stops game", buf[0]);
 547   sysmsg(msgbuf);
 548
 549   game_status = MAINMENU;
 550   DrawMainMenu();
 551 }
 552
 553 static void Handle_OP_MOVE_FIGURE(unsigned int len)
 554 {
 555   int frame_nr;
 556   int i;
 557
 558   if (!network_playing)
 559     return;
 560
 561   frame_nr =
 562     (buf[2] << 24) | (buf[3] << 16) | (buf[4] << 8) | (buf[5]);
 563
 564   if (frame_nr != FrameCounter)
 565   {
 566     Error(ERR_RETURN, "client and servers frame counters out of sync");
 567     Error(ERR_RETURN, "frame counter of client is %d", FrameCounter);
 568     Error(ERR_RETURN, "frame counter of server is %d", frame_nr);
 569     Error(ERR_EXIT,   "this should not happen -- please debug");
 570   }
 571
 572   /* copy valid player actions */
 573   for (i=0; i<MAX_PLAYERS; i++)
 574     network_player_action[i] =
 575       (i < len - 6 && stored_player[i].active ? buf[6 + i] : 0);
 576
 577   network_player_action_received = TRUE;
 578
 579   /*
 580     sprintf(msgbuf, "frame %d: client %d moves player [0x%02x]",
 581     FrameCounter, buf[0], buf[2]);
 582     sysmsg(msgbuf);
 583   */
 584 }
 585
 586 static void handlemessages()
 587 {
 588   unsigned int len;
 589
 590   while (nread >= 4 && nread >= 4 + readbuf[3])
 591   {
 592     len = readbuf[3];
 593     if (readbuf[0] || readbuf[1] || readbuf[2])
 594       fatal("Wrong server line length");
 595
 596     memcpy(buf, &readbuf[4], len);
 597     nread -= 4 + len;
 598     copydown(readbuf, readbuf + 4 + len, nread);
 599
 600     switch(buf[1])
 601     {
 602       case OP_BAD_PROTOCOL_VERSION:
 603         Handle_OP_BAD_PROTOCOL_VERSION();
 604         break;
 605
 606       case OP_YOUR_NUMBER:
 607         Handle_OP_YOUR_NUMBER();
 608         break;
 609
 610       case OP_NUMBER_WANTED:
 611         Handle_OP_NUMBER_WANTED();
 612         break;
 613
 614       case OP_NICKNAME:
 615         Handle_OP_NICKNAME(len);
 616         break;
 617
 618       case OP_PLAYER_CONNECTED:
 619         Handle_OP_PLAYER_CONNECTED();
 620         break;
 621
 622       case OP_PLAYER_DISCONNECTED:
 623         Handle_OP_PLAYER_DISCONNECTED();
 624         break;
 625
 626       case OP_START_PLAYING:
 627         Handle_OP_START_PLAYING();
 628         break;
 629
 630       case OP_PAUSE_PLAYING:
 631         Handle_OP_PAUSE_PLAYING();
 632         break;
 633
 634       case OP_CONTINUE_PLAYING:
 635         Handle_OP_CONTINUE_PLAYING();
 636         break;
 637
 638       case OP_STOP_PLAYING:
 639         Handle_OP_STOP_PLAYING();
 640         break;
 641
 642       case OP_MOVE_FIGURE:
 643         Handle_OP_MOVE_FIGURE(len);
 644         break;
 645
 646       case OP_WON:
 647         printf("OP_WON: %d\n", buf[0]);
 648         sprintf(msgbuf, "client %d wins the game", buf[0]);
 649         sysmsg(msgbuf);
 650         break;
 651
 652       case OP_ZERO:
 653         printf("OP_ZERO: %d\n", buf[0]);
 654         sprintf(msgbuf, "client %d resets game counters", buf[0]);
 655         sysmsg(msgbuf);
 656         break;
 657
 658       case OP_MSG:
 659         printf("OP_MSG: %d\n", buf[0]);
 660         sprintf(msgbuf, "client %d sends message", buf[0]);
 661         break;
 662
 663       case OP_LOST:
 664         printf("OP_MSG: %d\n", buf[0]);
 665         sprintf(msgbuf, "client %d has lost", buf[0]);
 666         break;
 667
 668       case OP_LEVEL:
 669         printf("OP_MSG: %d\n", buf[0]);
 670         sprintf(msgbuf, "client %d sets level to %d", buf[0], buf[2]);
 671         break;
 672     }
 673   }
 674
 675   fflush(stdout);
 676 }
 677
 678 void HandleNetworking()
 679 {
 680   static struct timeval tv = { 0, 0 };
 681   fd_set rfds;
 682   int r = 0;
 683
 684   flushbuf();
 685
 686   FD_ZERO(&rfds);
 687   FD_SET(sfd, &rfds);
 688
 689   r = select(sfd + 1, &rfds, NULL, NULL, &tv);
 690
 691   if (r < 0 && errno != EINTR)
 692   {
 693     perror("select");
 694     fatal("fatal: select() failed");
 695   }
 696
 697   if (r < 0)
 698     FD_ZERO(&rfds);
 699
 700   if (FD_ISSET(sfd, &rfds))
 701   {
 702     int r;
 703
 704     r = read(sfd, readbuf + nread, MAX_BUFFER_SIZE - nread);
 705
 706     if (r < 0)
 707       fatal("Error reading from server");
 708     if (r == 0)
 709       fatal("Connection to server lost");
 710     nread += r;
 711
 712     handlemessages();
 713   }
 714 }