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 (!standalone)
 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       standalone = TRUE;
 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
 318   printf("OP_YOUR_NUMBER: %d\n", buf[0]);
 319   me.nr = new_client_nr;
 320
 321   stored_player[new_index_nr] = *local_player;
 322   local_player = &stored_player[new_index_nr];
 323
 324   TestPlayer = new_index_nr;
 325
 326   if (me.nr > MAX_PLAYERS)
 327     Error(ERR_EXIT, "sorry - no more than %d players", MAX_PLAYERS);
 328
 329   sprintf(msgbuf, "you get client # %d", new_client_nr);
 330   sysmsg(msgbuf);
 331 }
 332
 333 static void Handle_OP_NUMBER_WANTED()
 334 {
 335   int client_nr_wanted = buf[2];
 336   int new_client_nr = buf[3];
 337   int new_index_nr = new_client_nr - 1;
 338
 339   printf("OP_NUMBER_WANTED: %d\n", buf[0]);
 340
 341   if (new_client_nr != client_nr_wanted)
 342   {
 343     char *color[] = { "yellow", "red", "green", "blue" };
 344
 345     sprintf(msgbuf, "Sorry ! You are %s player !",
 346             color[new_index_nr]);
 347     Request(msgbuf, REQ_CONFIRM);
 348
 349     sprintf(msgbuf, "cannot switch -- you keep client # %d",
 350             new_client_nr);
 351     sysmsg(msgbuf);
 352   }
 353   else
 354   {
 355     if (me.nr != client_nr_wanted)
 356       sprintf(msgbuf, "switching to client # %d", new_client_nr);
 357     else
 358       sprintf(msgbuf, "keeping client # %d", new_client_nr);
 359     sysmsg(msgbuf);
 360
 361     me.nr = new_client_nr;
 362
 363     stored_player[new_index_nr] = *local_player;
 364     local_player = &stored_player[new_index_nr];
 365
 366     TestPlayer = new_index_nr;
 367   }
 368 }
 369
 370 static void Handle_OP_NICKNAME(unsigned int len)
 371 {
 372   struct user *u;
 373
 374   printf("OP_NICKNAME: %d\n", buf[0]);
 375   u = finduser(buf[0]);
 376   buf[len] = 0;
 377   sprintf(msgbuf, "client %d calls itself \"%s\"", buf[0], &buf[2]);
 378   sysmsg(msgbuf);
 379   strncpy(u->name, &buf[2], MAXNICKLEN);
 380 }
 381
 382 static void Handle_OP_PLAYER_CONNECTED()
 383 {
 384   struct user *u, *v = NULL;
 385
 386   printf("OP_PLAYER_CONNECTED: %d\n", buf[0]);
 387   sprintf(msgbuf, "new client %d connected", buf[0]);
 388   sysmsg(msgbuf);
 389
 390   for (u = &me; u; u = u->next)
 391   {
 392     if (u->nr == buf[0])
 393       Error(ERR_EXIT, "multiplayer server sent duplicate player id");
 394     else
 395       v = u;
 396   }
 397
 398   v->next = u = mmalloc(sizeof(struct user));
 399   u->nr = buf[0];
 400   u->name[0] = '\0';
 401   u->next = NULL;
 402 }
 403
 404 static void Handle_OP_PLAYER_DISCONNECTED()
 405 {
 406   struct user *u, *v;
 407
 408   printf("OP_PLAYER_DISCONNECTED: %d\n", buf[0]);
 409   u = finduser(buf[0]);
 410   sprintf(msgbuf, "client %d (%s) disconnected",
 411           buf[0], get_user_name(buf[0]));
 412   sysmsg(msgbuf);
 413
 414   for (v = &me; v; v = v->next)
 415     if (v->next == u)
 416       v->next = u->next;
 417   free(u);
 418 }
 419
 420 static void Handle_OP_START_PLAYING()
 421 {
 422   int new_level_nr, new_leveldir_nr;
 423   unsigned long new_random_seed;
 424   unsigned char *new_leveldir_name;
 425
 426   /*
 427     if (game_status == PLAYING)
 428     break;
 429   */
 430
 431   new_level_nr = (buf[2] << 8) + buf[3];
 432   new_leveldir_nr = (buf[4] << 8) + buf[5];
 433   new_random_seed =
 434     (buf[6] << 24) | (buf[7] << 16) | (buf[8] << 8) | (buf[9]);
 435   new_leveldir_name = &buf[10];
 436
 437   printf("OP_START_PLAYING: %d\n", buf[0]);
 438   sprintf(msgbuf, "client %d starts game [level %d from levedir %d (%s)]\n",
 439           buf[0],
 440           new_level_nr,
 441           new_leveldir_nr,
 442           new_leveldir_name);
 443   sysmsg(msgbuf);
 444
 445
 446   if (strcmp(leveldir[new_leveldir_nr].name, new_leveldir_name) != 0)
 447     Error(ERR_RETURN, "no such level directory: '%s'",new_leveldir_name);
 448
 449   leveldir_nr = new_leveldir_nr;
 450
 451   local_player->leveldir_nr = leveldir_nr;
 452   LoadPlayerInfo(PLAYER_LEVEL);
 453   SavePlayerInfo(PLAYER_SETUP);
 454
 455   level_nr = new_level_nr;
 456
 457   TapeErase();
 458   LoadLevelTape(level_nr);
 459
 460   GetPlayerConfig();
 461   LoadLevel(level_nr);
 462
 463
 464
 465   if (autorecord_on)
 466     TapeStartRecording();
 467
 468
 469
 470   if (tape.recording)
 471     tape.random_seed = new_random_seed;
 472
 473   InitRND(new_random_seed);
 474
 475
 476   /*
 477     printf("tape.random_seed == %d\n", tape.random_seed);
 478   */
 479
 480   game_status = PLAYING;
 481   InitGame();
 482 }
 483
 484 static void Handle_OP_PAUSE_PLAYING()
 485 {
 486   printf("OP_PAUSE_PLAYING: %d\n", buf[0]);
 487   sprintf(msgbuf, "client %d pauses game", buf[0]);
 488   sysmsg(msgbuf);
 489
 490   tape.pausing = TRUE;
 491   DrawVideoDisplay(VIDEO_STATE_PAUSE_ON,0);
 492 }
 493
 494 static void Handle_OP_CONTINUE_PLAYING()
 495 {
 496   printf("OP_CONTINUE_PLAYING: %d\n", buf[0]);
 497   sprintf(msgbuf, "client %d continues game", buf[0]);
 498   sysmsg(msgbuf);
 499
 500   tape.pausing = FALSE;
 501   DrawVideoDisplay(VIDEO_STATE_PAUSE_OFF,0);
 502 }
 503
 504 static void Handle_OP_STOP_PLAYING()
 505 {
 506   printf("OP_STOP_PLAYING: %d\n", buf[0]);
 507   sprintf(msgbuf, "client %d stops game", buf[0]);
 508   sysmsg(msgbuf);
 509
 510   game_status = MAINMENU;
 511   DrawMainMenu();
 512 }
 513
 514 static void Handle_OP_MOVE_FIGURE()
 515 {
 516   int frame_nr;
 517   int i;
 518
 519   frame_nr =
 520     (buf[2] << 24) | (buf[3] << 16) | (buf[4] << 8) | (buf[5]);
 521
 522   if (frame_nr != FrameCounter)
 523   {
 524     Error(ERR_RETURN, "client and servers frame counters out of sync");
 525     Error(ERR_RETURN, "frame counter of client is %d", FrameCounter);
 526     Error(ERR_RETURN, "frame counter of server is %d", frame_nr);
 527     Error(ERR_EXIT,   "this should not happen -- please debug");
 528   }
 529
 530   for (i=0; i<MAX_PLAYERS; i++)
 531   {
 532     if (stored_player[i].active)
 533       network_player_action[i] = buf[6 + i];
 534   }
 535
 536   network_player_action_received = TRUE;
 537
 538   /*
 539     sprintf(msgbuf, "frame %d: client %d moves player [0x%02x]",
 540     FrameCounter, buf[0], buf[2]);
 541     sysmsg(msgbuf);
 542   */
 543 }
 544
 545 static void handlemessages()
 546 {
 547   unsigned int len;
 548
 549   while (nread >= 4 && nread >= 4 + readbuf[3])
 550   {
 551     len = readbuf[3];
 552     if (readbuf[0] || readbuf[1] || readbuf[2])
 553       fatal("Wrong server line length");
 554
 555     memcpy(buf, &readbuf[4], len);
 556     nread -= 4 + len;
 557     copydown(readbuf, readbuf + 4 + len, nread);
 558
 559     switch(buf[1])
 560     {
 561       case OP_BAD_PROTOCOL_VERSION:
 562         Handle_OP_BAD_PROTOCOL_VERSION();
 563         break;
 564
 565       case OP_YOUR_NUMBER:
 566         Handle_OP_YOUR_NUMBER();
 567         break;
 568
 569       case OP_NUMBER_WANTED:
 570         Handle_OP_NUMBER_WANTED();
 571         break;
 572
 573       case OP_NICKNAME:
 574         Handle_OP_NICKNAME(len);
 575         break;
 576
 577       case OP_PLAYER_CONNECTED:
 578         Handle_OP_PLAYER_CONNECTED();
 579         break;
 580
 581       case OP_PLAYER_DISCONNECTED:
 582         Handle_OP_PLAYER_DISCONNECTED();
 583         break;
 584
 585       case OP_START_PLAYING:
 586         Handle_OP_START_PLAYING();
 587         break;
 588
 589       case OP_PAUSE_PLAYING:
 590         Handle_OP_PAUSE_PLAYING();
 591         break;
 592
 593       case OP_CONTINUE_PLAYING:
 594         Handle_OP_CONTINUE_PLAYING();
 595         break;
 596
 597       case OP_STOP_PLAYING:
 598         Handle_OP_STOP_PLAYING();
 599         break;
 600
 601       case OP_MOVE_FIGURE:
 602         Handle_OP_MOVE_FIGURE();
 603         break;
 604
 605       case OP_WON:
 606         printf("OP_WON: %d\n", buf[0]);
 607         sprintf(msgbuf, "client %d wins the game", buf[0]);
 608         sysmsg(msgbuf);
 609         break;
 610
 611       case OP_ZERO:
 612         printf("OP_ZERO: %d\n", buf[0]);
 613         sprintf(msgbuf, "client %d resets game counters", buf[0]);
 614         sysmsg(msgbuf);
 615         break;
 616
 617       case OP_MSG:
 618         printf("OP_MSG: %d\n", buf[0]);
 619         sprintf(msgbuf, "client %d sends message", buf[0]);
 620         break;
 621
 622       case OP_LOST:
 623         printf("OP_MSG: %d\n", buf[0]);
 624         sprintf(msgbuf, "client %d has lost", buf[0]);
 625         break;
 626
 627       case OP_LEVEL:
 628         printf("OP_MSG: %d\n", buf[0]);
 629         sprintf(msgbuf, "client %d sets level to %d", buf[0], buf[2]);
 630         break;
 631     }
 632   }
 633
 634   fflush(stdout);
 635 }
 636
 637 void HandleNetworking()
 638 {
 639   static struct timeval tv = { 0, 0 };
 640   fd_set rfds;
 641   int r = 0;
 642
 643   if (standalone)
 644     return;
 645
 646   flushbuf();
 647
 648   FD_ZERO(&rfds);
 649   FD_SET(sfd, &rfds);
 650
 651   r = select(sfd + 1, &rfds, NULL, NULL, &tv);
 652
 653   if (r < 0 && errno != EINTR)
 654   {
 655     perror("select");
 656     fatal("fatal: select() failed");
 657   }
 658
 659   if (r < 0)
 660     FD_ZERO(&rfds);
 661
 662   if (FD_ISSET(sfd, &rfds))
 663   {
 664     int r;
 665
 666     r = read(sfd, readbuf + nread, MAX_BUFFER_SIZE - nread);
 667
 668     if (r < 0)
 669       fatal("Error reading from server");
 670     if (r == 0)
 671       fatal("Connection to server lost");
 672     nread += r;
 673
 674     handlemessages();
 675   }
 676 }