1 /* 2 * Copyright (c) 1983-2003, Regents of the University of California. 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions are 7 * met: 8 * 9 * + Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * + Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * + Neither the name of the University of California, San Francisco nor 15 * the names of its contributors may be used to endorse or promote 16 * products derived from this software without specific prior written 17 * permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS 20 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A 22 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 23 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 24 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 25 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 26 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 27 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 28 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 29 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 * 31 * $OpenBSD: driver.c,v 1.17 2007/04/02 14:55:16 jmc Exp $ 32 * $NetBSD: driver.c,v 1.5 1997/10/20 00:37:16 lukem Exp $ 33 * $DragonFly: src/games/hunt/huntd/driver.c,v 1.3 2008/11/10 15:28:13 swildner Exp $ 34 */ 35 36 #include <sys/ioctl.h> 37 #include <sys/stat.h> 38 #include <sys/time.h> 39 #include <sys/socket.h> 40 41 #include <netinet/in.h> 42 #include <arpa/inet.h> 43 44 #include <err.h> 45 #include <errno.h> 46 #include <signal.h> 47 #include <stdlib.h> 48 #include <string.h> 49 #include <unistd.h> 50 #include <stdio.h> 51 #include <tcpd.h> 52 #include <syslog.h> 53 #include <netdb.h> 54 #include <paths.h> 55 #include <fcntl.h> 56 #include "hunt.h" 57 #include "conf.h" 58 #include "server.h" 59 60 char *First_arg; /* pointer to argv[0] */ 61 u_int16_t Server_port; 62 int Server_socket; /* test socket to answer datagrams */ 63 FLAG should_announce = TRUE; /* true if listening on standard port */ 64 u_short sock_port; /* port # of tcp listen socket */ 65 u_short stat_port; /* port # of statistics tcp socket */ 66 in_addr_t Server_addr = INADDR_ANY; /* address to bind to */ 67 68 static void clear_scores(void); 69 static int havechar(PLAYER *); 70 static void init(void); 71 int main(int, char *[]); 72 static void makeboots(void); 73 static void send_stats(void); 74 static void zap(PLAYER *, FLAG); 75 static void announce_game(void); 76 static void siginfo(int); 77 static void print_stats(FILE *); 78 static void handle_wkport(int); 79 80 /* 81 * main: 82 * The main program. 83 */ 84 int 85 main(int ac, char **av) 86 { 87 PLAYER *pp; 88 int had_char; 89 static fd_set read_fds; 90 static FLAG first = TRUE; 91 static FLAG server = FALSE; 92 int c; 93 static struct timeval linger = { 0, 0 }; 94 static struct timeval timeout = { 0, 0 }, *to; 95 struct spawn *sp, *spnext; 96 int ret; 97 int nready; 98 int fd; 99 100 First_arg = av[0]; 101 102 config(); 103 104 while ((c = getopt(ac, av, "sp:a:D:")) != -1) { 105 switch (c) { 106 case 's': 107 server = TRUE; 108 break; 109 case 'p': 110 should_announce = FALSE; 111 Server_port = atoi(optarg); 112 break; 113 case 'a': 114 if (!inet_aton(optarg, (struct in_addr *)&Server_addr)) 115 err(1, "bad interface address: %s", optarg); 116 break; 117 case 'D': 118 config_arg(optarg); 119 break; 120 default: 121 erred: 122 fprintf(stderr, 123 "usage: %s [-s] [-a addr] [-Dvar=value ...] " 124 "[-p port]\n", 125 av[0]); 126 exit(2); 127 } 128 } 129 if (optind < ac) 130 goto erred; 131 132 /* Open syslog: */ 133 openlog("huntd", LOG_PID | (conf_logerr && !server? LOG_PERROR : 0), 134 LOG_DAEMON); 135 136 /* Initialise game parameters: */ 137 init(); 138 139 again: 140 do { 141 /* First, poll to see if we can get input */ 142 do { 143 read_fds = Fds_mask; 144 errno = 0; 145 timerclear(&timeout); 146 nready = select(Num_fds, &read_fds, NULL, NULL, 147 &timeout); 148 if (nready < 0 && errno != EINTR) { 149 logit(LOG_ERR, "select"); 150 cleanup(1); 151 } 152 } while (nready < 0); 153 154 if (nready == 0) { 155 /* 156 * Nothing was ready. We do some work now 157 * to see if the simulation has any pending work 158 * to do, and decide if we need to block 159 * indefinitely or just timeout. 160 */ 161 do { 162 if (conf_simstep && can_moveshots()) { 163 /* 164 * block for a short time before continuing 165 * with explosions, bullets and whatnot 166 */ 167 to = &timeout; 168 to->tv_sec = conf_simstep / 1000000; 169 to->tv_usec = conf_simstep % 1000000; 170 } else 171 /* 172 * since there's nothing going on, 173 * just block waiting for external activity 174 */ 175 to = NULL; 176 177 read_fds = Fds_mask; 178 errno = 0; 179 nready = select(Num_fds, &read_fds, NULL, NULL, 180 to); 181 if (nready < 0 && errno != EINTR) { 182 logit(LOG_ERR, "select"); 183 cleanup(1); 184 } 185 } while (nready < 0); 186 } 187 188 /* Remember which descriptors are active: */ 189 Have_inp = read_fds; 190 191 /* Answer new player connections: */ 192 if (FD_ISSET(Socket, &Have_inp)) 193 answer_first(); 194 195 /* Continue answering new player connections: */ 196 for (sp = Spawn; sp; ) { 197 spnext = sp->next; 198 fd = sp->fd; 199 if (FD_ISSET(fd, &Have_inp) && answer_next(sp)) { 200 /* 201 * Remove from the spawn list. (fd remains in 202 * read set). 203 */ 204 *sp->prevnext = sp->next; 205 if (sp->next) 206 sp->next->prevnext = sp->prevnext; 207 free(sp); 208 209 /* We probably consumed all data. */ 210 FD_CLR(fd, &Have_inp); 211 212 /* Announce game if this is the first spawn. */ 213 if (first && should_announce) 214 announce_game(); 215 first = FALSE; 216 } 217 sp = spnext; 218 } 219 220 /* Process input and move bullets until we've exhausted input */ 221 had_char = TRUE; 222 while (had_char) { 223 224 moveshots(); 225 for (pp = Player; pp < End_player; ) 226 if (pp->p_death[0] != '\0') 227 zap(pp, TRUE); 228 else 229 pp++; 230 for (pp = Monitor; pp < End_monitor; ) 231 if (pp->p_death[0] != '\0') 232 zap(pp, FALSE); 233 else 234 pp++; 235 236 had_char = FALSE; 237 for (pp = Player; pp < End_player; pp++) 238 if (havechar(pp)) { 239 execute(pp); 240 pp->p_nexec++; 241 had_char = TRUE; 242 } 243 for (pp = Monitor; pp < End_monitor; pp++) 244 if (havechar(pp)) { 245 mon_execute(pp); 246 pp->p_nexec++; 247 had_char = TRUE; 248 } 249 } 250 251 /* Handle a datagram sent to the server socket: */ 252 if (FD_ISSET(Server_socket, &Have_inp)) 253 handle_wkport(Server_socket); 254 255 /* Answer statistics connections: */ 256 if (FD_ISSET(Status, &Have_inp)) 257 send_stats(); 258 259 /* Flush/synchronize all the displays: */ 260 for (pp = Player; pp < End_player; pp++) { 261 if (FD_ISSET(pp->p_fd, &read_fds)) { 262 sendcom(pp, READY, pp->p_nexec); 263 pp->p_nexec = 0; 264 } 265 flush(pp); 266 } 267 for (pp = Monitor; pp < End_monitor; pp++) { 268 if (FD_ISSET(pp->p_fd, &read_fds)) { 269 sendcom(pp, READY, pp->p_nexec); 270 pp->p_nexec = 0; 271 } 272 flush(pp); 273 } 274 } while (Nplayer > 0); 275 276 /* No more players! */ 277 278 /* No players yet or a continuous game? */ 279 if (first || conf_linger < 0) 280 goto again; 281 282 /* Wait a short while for one to come back: */ 283 read_fds = Fds_mask; 284 linger.tv_sec = conf_linger; 285 while ((ret = select(Num_fds, &read_fds, NULL, NULL, &linger)) < 0) { 286 if (errno != EINTR) { 287 logit(LOG_WARNING, "select"); 288 break; 289 } 290 read_fds = Fds_mask; 291 linger.tv_sec = conf_linger; 292 linger.tv_usec = 0; 293 } 294 if (ret > 0) 295 /* Someone returned! Resume the game: */ 296 goto again; 297 /* else, it timed out, and the game is really over. */ 298 299 /* If we are an inetd server, we should re-init the map and restart: */ 300 if (server) { 301 clear_scores(); 302 makemaze(); 303 clearwalls(); 304 makeboots(); 305 first = TRUE; 306 goto again; 307 } 308 309 /* Get rid of any attached monitors: */ 310 for (pp = Monitor; pp < End_monitor; ) 311 zap(pp, FALSE); 312 313 /* Fin: */ 314 cleanup(0); 315 exit(0); 316 } 317 318 /* 319 * init: 320 * Initialize the global parameters. 321 */ 322 static void 323 init(void) 324 { 325 int i; 326 struct sockaddr_in test_port; 327 int true = 1; 328 socklen_t len; 329 struct sockaddr_in addr; 330 struct sigaction sact; 331 struct servent *se; 332 333 (void) setsid(); 334 if (setpgid(getpid(), getpid()) == -1) 335 err(1, "setpgid"); 336 337 sact.sa_flags = SA_RESTART; 338 sigemptyset(&sact.sa_mask); 339 340 /* Ignore HUP, QUIT and PIPE: */ 341 sact.sa_handler = SIG_IGN; 342 if (sigaction(SIGHUP, &sact, NULL) == -1) 343 err(1, "sigaction SIGHUP"); 344 if (sigaction(SIGQUIT, &sact, NULL) == -1) 345 err(1, "sigaction SIGQUIT"); 346 if (sigaction(SIGPIPE, &sact, NULL) == -1) 347 err(1, "sigaction SIGPIPE"); 348 349 /* Clean up gracefully on INT and TERM: */ 350 sact.sa_handler = cleanup; 351 if (sigaction(SIGINT, &sact, NULL) == -1) 352 err(1, "sigaction SIGINT"); 353 if (sigaction(SIGTERM, &sact, NULL) == -1) 354 err(1, "sigaction SIGTERM"); 355 356 /* Handle INFO: */ 357 sact.sa_handler = siginfo; 358 if (sigaction(SIGINFO, &sact, NULL) == -1) 359 err(1, "sigaction SIGINFO"); 360 361 if (chdir("/") == -1) 362 warn("chdir"); 363 (void) umask(0777); 364 365 /* Initialize statistics socket: */ 366 addr.sin_family = AF_INET; 367 addr.sin_addr.s_addr = Server_addr; 368 addr.sin_port = 0; 369 370 Status = socket(AF_INET, SOCK_STREAM, 0); 371 if (bind(Status, (struct sockaddr *) &addr, sizeof addr) < 0) { 372 logit(LOG_ERR, "bind"); 373 cleanup(1); 374 } 375 if (listen(Status, 5) == -1) { 376 logit(LOG_ERR, "listen"); 377 cleanup(1); 378 } 379 380 len = sizeof (struct sockaddr_in); 381 if (getsockname(Status, (struct sockaddr *) &addr, &len) < 0) { 382 logit(LOG_ERR, "getsockname"); 383 cleanup(1); 384 } 385 stat_port = ntohs(addr.sin_port); 386 387 /* Initialize main socket: */ 388 addr.sin_family = AF_INET; 389 addr.sin_addr.s_addr = Server_addr; 390 addr.sin_port = 0; 391 392 Socket = socket(AF_INET, SOCK_STREAM, 0); 393 394 if (bind(Socket, (struct sockaddr *) &addr, sizeof addr) < 0) { 395 logit(LOG_ERR, "bind"); 396 cleanup(1); 397 } 398 if (listen(Socket, 5) == -1) { 399 logit(LOG_ERR, "listen"); 400 cleanup(1); 401 } 402 403 len = sizeof (struct sockaddr_in); 404 if (getsockname(Socket, (struct sockaddr *) &addr, &len) < 0) { 405 logit(LOG_ERR, "getsockname"); 406 cleanup(1); 407 } 408 sock_port = ntohs(addr.sin_port); 409 410 /* Initialize minimal select mask */ 411 FD_ZERO(&Fds_mask); 412 FD_SET(Socket, &Fds_mask); 413 FD_SET(Status, &Fds_mask); 414 Num_fds = ((Socket > Status) ? Socket : Status) + 1; 415 416 /* Find the port that huntd should run on */ 417 if (Server_port == 0) { 418 se = getservbyname("hunt", "udp"); 419 if (se != NULL) 420 Server_port = ntohs(se->s_port); 421 else 422 Server_port = HUNT_PORT; 423 } 424 425 /* Check if stdin is a socket: */ 426 len = sizeof (struct sockaddr_in); 427 if (getsockname(STDIN_FILENO, (struct sockaddr *) &test_port, &len) >= 0 428 && test_port.sin_family == AF_INET) { 429 /* We are probably running from inetd: don't log to stderr */ 430 Server_socket = STDIN_FILENO; 431 conf_logerr = 0; 432 if (test_port.sin_port != htons((u_short) Server_port)) { 433 /* Private game */ 434 should_announce = FALSE; 435 Server_port = ntohs(test_port.sin_port); 436 } 437 } else { 438 /* We need to listen on a socket: */ 439 test_port = addr; 440 test_port.sin_port = htons((u_short) Server_port); 441 442 Server_socket = socket(AF_INET, SOCK_DGRAM, 0); 443 444 /* Permit multiple huntd's on the same port. */ 445 if (setsockopt(Server_socket, SOL_SOCKET, SO_REUSEPORT, &true, 446 sizeof true) < 0) 447 logit(LOG_ERR, "setsockopt SO_REUSEADDR"); 448 449 if (bind(Server_socket, (struct sockaddr *) &test_port, 450 sizeof test_port) < 0) { 451 logit(LOG_ERR, "bind port %d", Server_port); 452 cleanup(1); 453 } 454 455 /* Datagram sockets do not need a listen() call. */ 456 } 457 458 /* We'll handle the broadcast listener in the main loop: */ 459 FD_SET(Server_socket, &Fds_mask); 460 if (Server_socket + 1 > Num_fds) 461 Num_fds = Server_socket + 1; 462 463 /* Initialise the random seed: */ 464 srandomdev(); 465 466 /* Dig the maze: */ 467 makemaze(); 468 469 /* Create some boots, if needed: */ 470 makeboots(); 471 472 /* Construct a table of what objects a player can see over: */ 473 for (i = 0; i < NASCII; i++) 474 See_over[i] = TRUE; 475 See_over[DOOR] = FALSE; 476 See_over[WALL1] = FALSE; 477 See_over[WALL2] = FALSE; 478 See_over[WALL3] = FALSE; 479 See_over[WALL4] = FALSE; 480 See_over[WALL5] = FALSE; 481 482 logx(LOG_INFO, "game started"); 483 } 484 485 /* 486 * makeboots: 487 * Put the boots in the maze 488 */ 489 static void 490 makeboots(void) 491 { 492 int x, y; 493 PLAYER *pp; 494 495 if (conf_boots) { 496 do { 497 x = rand_num(WIDTH - 1) + 1; 498 y = rand_num(HEIGHT - 1) + 1; 499 } while (Maze[y][x] != SPACE); 500 Maze[y][x] = BOOT_PAIR; 501 } 502 503 for (pp = Boot; pp < &Boot[NBOOTS]; pp++) 504 pp->p_flying = -1; 505 } 506 507 508 /* 509 * checkdam: 510 * Apply damage to the victim from an attacker. 511 * If the victim dies as a result, give points to 'credit', 512 */ 513 void 514 checkdam(PLAYER *victim, PLAYER *attacker, IDENT *credit, int damage, 515 char stype) 516 { 517 const char *cp; 518 int y; 519 520 /* Don't do anything if the victim is already in the throes of death */ 521 if (victim->p_death[0] != '\0') 522 return; 523 524 /* Weaken slime attacks by 0.5 * number of boots the victim has on: */ 525 if (stype == SLIME) 526 switch (victim->p_nboots) { 527 default: 528 break; 529 case 1: 530 damage = (damage + 1) / 2; 531 break; 532 case 2: 533 if (attacker != NULL) 534 message(attacker, "He has boots on!"); 535 return; 536 } 537 538 /* The victim sustains some damage: */ 539 victim->p_damage += damage; 540 541 /* Check if the victim survives the hit: */ 542 if (victim->p_damage <= victim->p_damcap) { 543 /* They survive. */ 544 outyx(victim, STAT_DAM_ROW, STAT_VALUE_COL, "%2d", 545 victim->p_damage); 546 return; 547 } 548 549 /* Describe how the victim died: */ 550 switch (stype) { 551 default: 552 cp = "Killed"; 553 break; 554 case FALL: 555 cp = "Killed on impact"; 556 break; 557 case KNIFE: 558 cp = "Stabbed to death"; 559 victim->p_ammo = 0; /* No exploding */ 560 break; 561 case SHOT: 562 cp = "Shot to death"; 563 break; 564 case GRENADE: 565 case SATCHEL: 566 case BOMB: 567 cp = "Bombed"; 568 break; 569 case MINE: 570 case GMINE: 571 cp = "Blown apart"; 572 break; 573 case SLIME: 574 cp = "Slimed"; 575 if (credit != NULL) 576 credit->i_slime++; 577 break; 578 case LAVA: 579 cp = "Baked"; 580 break; 581 case DSHOT: 582 cp = "Eliminated"; 583 break; 584 } 585 586 if (credit == NULL) { 587 const char *blame; 588 589 /* 590 * Nobody is taking the credit for the kill. 591 * Attribute it to either a mine or 'act of God'. 592 */ 593 switch (stype) { 594 case MINE: 595 case GMINE: 596 blame = "a mine"; 597 break; 598 default: 599 blame = "act of God"; 600 break; 601 } 602 603 /* Set the death message: */ 604 (void) snprintf(victim->p_death, sizeof victim->p_death, 605 "| %s by %s |", cp, blame); 606 607 /* No further score crediting needed. */ 608 return; 609 } 610 611 /* Set the death message: */ 612 (void) snprintf(victim->p_death, sizeof victim->p_death, 613 "| %s by %s |", cp, credit->i_name); 614 615 if (victim == attacker) { 616 /* No use killing yourself. */ 617 credit->i_kills--; 618 credit->i_bkills++; 619 } 620 else if (victim->p_ident->i_team == ' ' 621 || victim->p_ident->i_team != credit->i_team) { 622 /* A cross-team kill: */ 623 credit->i_kills++; 624 credit->i_gkills++; 625 } 626 else { 627 /* They killed someone on the same team: */ 628 credit->i_kills--; 629 credit->i_bkills++; 630 } 631 632 /* Compute the new credited score: */ 633 credit->i_score = credit->i_kills / (double) credit->i_entries; 634 635 /* The victim accrues one death: */ 636 victim->p_ident->i_deaths++; 637 638 /* Account for 'Stillborn' deaths */ 639 if (victim->p_nchar == 0) 640 victim->p_ident->i_stillb++; 641 642 if (attacker) { 643 /* Give the attacker player a bit more strength */ 644 attacker->p_damcap += conf_killgain; 645 attacker->p_damage -= conf_killgain; 646 if (attacker->p_damage < 0) 647 attacker->p_damage = 0; 648 649 /* Tell the attacker his new strength: */ 650 outyx(attacker, STAT_DAM_ROW, STAT_VALUE_COL, "%2d/%2d", 651 attacker->p_damage, attacker->p_damcap); 652 653 /* Tell the attacker his new 'kill count': */ 654 outyx(attacker, STAT_KILL_ROW, STAT_VALUE_COL, "%3d", 655 (attacker->p_damcap - conf_maxdam) / 2); 656 657 /* Update the attacker's score for everyone else */ 658 y = STAT_PLAY_ROW + 1 + (attacker - Player); 659 outyx(ALL_PLAYERS, y, STAT_NAME_COL, 660 "%5.2f", attacker->p_ident->i_score); 661 } 662 } 663 664 /* 665 * zap: 666 * Kill off a player and take them out of the game. 667 * The 'was_player' flag indicates that the player was not 668 * a monitor and needs extra cleaning up. 669 */ 670 static void 671 zap(PLAYER *pp, FLAG was_player) 672 { 673 int len; 674 BULLET *bp; 675 PLAYER *np; 676 int x, y; 677 int savefd; 678 679 if (was_player) { 680 /* If they died from a shot, clean up shrapnel */ 681 if (pp->p_undershot) 682 fixshots(pp->p_y, pp->p_x, pp->p_over); 683 /* Let the player see their last position: */ 684 drawplayer(pp, FALSE); 685 /* Remove from game: */ 686 Nplayer--; 687 } 688 689 /* Display the cause of death in the centre of the screen: */ 690 len = strlen(pp->p_death); 691 x = (WIDTH - len) / 2; 692 outyx(pp, HEIGHT / 2, x, "%s", pp->p_death); 693 694 /* Put some horizontal lines around and below the death message: */ 695 memset(pp->p_death + 1, '-', len - 2); 696 pp->p_death[0] = '+'; 697 pp->p_death[len - 1] = '+'; 698 outyx(pp, HEIGHT / 2 - 1, x, "%s", pp->p_death); 699 outyx(pp, HEIGHT / 2 + 1, x, "%s", pp->p_death); 700 701 /* Move to bottom left */ 702 cgoto(pp, HEIGHT, 0); 703 704 savefd = pp->p_fd; 705 706 if (was_player) { 707 int expl_charge; 708 int expl_type; 709 int ammo_exploding; 710 711 /* Check all the bullets: */ 712 for (bp = Bullets; bp != NULL; bp = bp->b_next) { 713 if (bp->b_owner == pp) 714 /* Zapped players can't own bullets: */ 715 bp->b_owner = NULL; 716 if (bp->b_x == pp->p_x && bp->b_y == pp->p_y) 717 /* Bullets over the player are now over air: */ 718 bp->b_over = SPACE; 719 } 720 721 /* Explode a random fraction of the player's ammo: */ 722 ammo_exploding = rand_num(pp->p_ammo); 723 724 /* Determine the type and amount of detonation: */ 725 expl_charge = rand_num(ammo_exploding + 1); 726 if (pp->p_ammo == 0) 727 /* Ignore the no-ammo case: */ 728 expl_charge = expl_type = 0; 729 else if (ammo_exploding >= pp->p_ammo - 1) { 730 /* Maximal explosions always appear as slime: */ 731 expl_charge = pp->p_ammo; 732 expl_type = SLIME; 733 } else { 734 /* 735 * Figure out the best effective explosion 736 * type to use, given the amount of charge 737 */ 738 int btype, stype; 739 for (btype = MAXBOMB - 1; btype > 0; btype--) 740 if (expl_charge >= shot_req[btype]) 741 break; 742 for (stype = MAXSLIME - 1; stype > 0; stype--) 743 if (expl_charge >= slime_req[stype]) 744 break; 745 /* Pick the larger of the bomb or slime: */ 746 if (btype >= 0 && stype >= 0) { 747 if (shot_req[btype] > slime_req[btype]) 748 btype = -1; 749 } 750 if (btype >= 0) { 751 expl_type = shot_type[btype]; 752 expl_charge = shot_req[btype]; 753 } else 754 expl_type = SLIME; 755 } 756 757 if (expl_charge > 0) { 758 char buf[BUFSIZ]; 759 760 /* Detonate: */ 761 (void) add_shot(expl_type, pp->p_y, pp->p_x, 762 pp->p_face, expl_charge, NULL, 763 TRUE, SPACE); 764 765 /* Explain what the explosion is about. */ 766 snprintf(buf, sizeof buf, "%s detonated.", 767 pp->p_ident->i_name); 768 message(ALL_PLAYERS, buf); 769 770 while (pp->p_nboots-- > 0) { 771 /* Throw one of the boots away: */ 772 for (np = Boot; np < &Boot[NBOOTS]; np++) 773 if (np->p_flying < 0) 774 break; 775 #ifdef DIAGNOSTIC 776 if (np >= &Boot[NBOOTS]) 777 err(1, "Too many boots"); 778 #endif 779 /* Start the boots from where the player is */ 780 np->p_undershot = FALSE; 781 np->p_x = pp->p_x; 782 np->p_y = pp->p_y; 783 /* Throw for up to 20 steps */ 784 np->p_flying = rand_num(20); 785 np->p_flyx = 2 * rand_num(6) - 5; 786 np->p_flyy = 2 * rand_num(6) - 5; 787 np->p_over = SPACE; 788 np->p_face = BOOT; 789 showexpl(np->p_y, np->p_x, BOOT); 790 } 791 } 792 /* No explosion. Leave the player's boots behind. */ 793 else if (pp->p_nboots > 0) { 794 if (pp->p_nboots == 2) 795 Maze[pp->p_y][pp->p_x] = BOOT_PAIR; 796 else 797 Maze[pp->p_y][pp->p_x] = BOOT; 798 if (pp->p_undershot) 799 fixshots(pp->p_y, pp->p_x, 800 Maze[pp->p_y][pp->p_x]); 801 } 802 803 /* Any unexploded ammo builds up in the volcano: */ 804 volcano += pp->p_ammo - expl_charge; 805 806 /* Volcano eruption: */ 807 if (conf_volcano && rand_num(100) < volcano / 808 conf_volcano_max) { 809 /* Erupt near the middle of the map */ 810 do { 811 x = rand_num(WIDTH / 2) + WIDTH / 4; 812 y = rand_num(HEIGHT / 2) + HEIGHT / 4; 813 } while (Maze[y][x] != SPACE); 814 815 /* Convert volcano charge into lava: */ 816 (void) add_shot(LAVA, y, x, LEFTS, volcano, 817 NULL, TRUE, SPACE); 818 volcano = 0; 819 820 /* Tell eveyone what's happening */ 821 message(ALL_PLAYERS, "Volcano eruption."); 822 } 823 824 /* Drone: */ 825 if (conf_drone && rand_num(100) < 2) { 826 /* Find a starting place near the middle of the map: */ 827 do { 828 x = rand_num(WIDTH / 2) + WIDTH / 4; 829 y = rand_num(HEIGHT / 2) + HEIGHT / 4; 830 } while (Maze[y][x] != SPACE); 831 832 /* Start the drone going: */ 833 add_shot(DSHOT, y, x, rand_dir(), 834 shot_req[conf_mindshot + 835 rand_num(MAXBOMB - conf_mindshot)], 836 NULL, FALSE, SPACE); 837 } 838 839 /* Tell the zapped player's client to shut down. */ 840 sendcom(pp, ENDWIN, ' '); 841 (void) fclose(pp->p_output); 842 843 /* Close up the gap in the Player array: */ 844 End_player--; 845 if (pp != End_player) { 846 /* Move the last player into the gap: */ 847 memcpy(pp, End_player, sizeof *pp); 848 outyx(ALL_PLAYERS, 849 STAT_PLAY_ROW + 1 + (pp - Player), 850 STAT_NAME_COL, 851 "%5.2f%c%-10.10s %c", 852 pp->p_ident->i_score, stat_char(pp), 853 pp->p_ident->i_name, pp->p_ident->i_team); 854 } 855 856 /* Erase the last player from the display: */ 857 cgoto(ALL_PLAYERS, STAT_PLAY_ROW + 1 + Nplayer, STAT_NAME_COL); 858 ce(ALL_PLAYERS); 859 } 860 else { 861 /* Zap a monitor */ 862 863 /* Close the session: */ 864 sendcom(pp, ENDWIN, LAST_PLAYER); 865 (void) fclose(pp->p_output); 866 867 /* shuffle the monitor table */ 868 End_monitor--; 869 if (pp != End_monitor) { 870 memcpy(pp, End_monitor, sizeof *pp); 871 outyx(ALL_PLAYERS, 872 STAT_MON_ROW + 1 + (pp - Player), STAT_NAME_COL, 873 "%5.5s %-10.10s %c", " ", 874 pp->p_ident->i_name, pp->p_ident->i_team); 875 } 876 877 /* Erase the last monitor in the list */ 878 cgoto(ALL_PLAYERS, 879 STAT_MON_ROW + 1 + (End_monitor - Monitor), 880 STAT_NAME_COL); 881 ce(ALL_PLAYERS); 882 } 883 884 /* Update the file descriptor sets used by select: */ 885 FD_CLR(savefd, &Fds_mask); 886 if (Num_fds == savefd + 1) { 887 Num_fds = Socket; 888 if (Server_socket > Socket) 889 Num_fds = Server_socket; 890 for (np = Player; np < End_player; np++) 891 if (np->p_fd > Num_fds) 892 Num_fds = np->p_fd; 893 for (np = Monitor; np < End_monitor; np++) 894 if (np->p_fd > Num_fds) 895 Num_fds = np->p_fd; 896 Num_fds++; 897 } 898 } 899 900 /* 901 * rand_num: 902 * Return a random number in a given range. 903 */ 904 int 905 rand_num(int range) 906 { 907 if (range == 0) 908 return 0; 909 return (random() % range); 910 } 911 912 /* 913 * havechar: 914 * Check to see if we have any characters in the input queue; if 915 * we do, read them, stash them away, and return TRUE; else return 916 * FALSE. 917 */ 918 static int 919 havechar(PLAYER *pp) 920 { 921 int ret; 922 923 /* Do we already have characters? */ 924 if (pp->p_ncount < pp->p_nchar) 925 return TRUE; 926 /* Ignore if nothing to read. */ 927 if (!FD_ISSET(pp->p_fd, &Have_inp)) 928 return FALSE; 929 /* Remove the player from the read set until we have drained them: */ 930 FD_CLR(pp->p_fd, &Have_inp); 931 932 /* Suck their keypresses into a buffer: */ 933 check_again: 934 errno = 0; 935 ret = read(pp->p_fd, pp->p_cbuf, sizeof pp->p_cbuf); 936 if (ret == -1) { 937 if (errno == EINTR) 938 goto check_again; 939 if (errno == EAGAIN) { 940 #ifdef DEBUG 941 warn("Have_inp is wrong for %d", pp->p_fd); 942 #endif 943 return FALSE; 944 } 945 logit(LOG_INFO, "read"); 946 } 947 if (ret > 0) { 948 /* Got some data */ 949 pp->p_nchar = ret; 950 } else { 951 /* Connection was lost/closed: */ 952 pp->p_cbuf[0] = 'q'; 953 pp->p_nchar = 1; 954 } 955 /* Reset pointer into read buffer */ 956 pp->p_ncount = 0; 957 return TRUE; 958 } 959 960 /* 961 * cleanup: 962 * Exit with the given value, cleaning up any droppings lying around 963 */ 964 void 965 cleanup(int eval) 966 { 967 PLAYER *pp; 968 969 /* Place their cursor in a friendly position: */ 970 cgoto(ALL_PLAYERS, HEIGHT, 0); 971 972 /* Send them all the ENDWIN command: */ 973 sendcom(ALL_PLAYERS, ENDWIN, LAST_PLAYER); 974 975 /* And close their connections: */ 976 for (pp = Player; pp < End_player; pp++) 977 (void) fclose(pp->p_output); 978 for (pp = Monitor; pp < End_monitor; pp++) 979 (void) fclose(pp->p_output); 980 981 /* Close the server socket: */ 982 (void) close(Socket); 983 984 /* The end: */ 985 logx(LOG_INFO, "game over"); 986 exit(eval); 987 } 988 989 /* 990 * send_stats: 991 * Accept a connection to the statistics port, and emit 992 * the stats. 993 */ 994 static void 995 send_stats(void) 996 { 997 FILE *fp; 998 int s; 999 struct sockaddr_in sockstruct; 1000 socklen_t socklen; 1001 struct request_info ri; 1002 int flags; 1003 1004 /* Accept a connection to the statistics socket: */ 1005 socklen = sizeof sockstruct; 1006 s = accept(Status, (struct sockaddr *) &sockstruct, &socklen); 1007 if (s < 0) { 1008 if (errno == EINTR) 1009 return; 1010 logx(LOG_ERR, "accept"); 1011 return; 1012 } 1013 1014 /* Check for access permissions: */ 1015 request_init(&ri, RQ_DAEMON, "huntd", RQ_FILE, s, 0); 1016 fromhost(&ri); 1017 if (hosts_access(&ri) == 0) { 1018 logx(LOG_INFO, "rejected connection from %s", eval_client(&ri)); 1019 close(s); 1020 return; 1021 } 1022 1023 /* Don't allow the writes to block: */ 1024 flags = fcntl(s, F_GETFL, 0); 1025 flags |= O_NDELAY; 1026 (void) fcntl(s, F_SETFL, flags); 1027 1028 fp = fdopen(s, "w"); 1029 if (fp == NULL) { 1030 logit(LOG_ERR, "fdopen"); 1031 (void) close(s); 1032 return; 1033 } 1034 1035 print_stats(fp); 1036 1037 (void) fclose(fp); 1038 } 1039 1040 /* 1041 * print_stats: 1042 * emit the game statistics 1043 */ 1044 void 1045 print_stats(FILE *fp) 1046 { 1047 IDENT *ip; 1048 PLAYER *pp; 1049 1050 /* Send the statistics as raw text down the socket: */ 1051 fputs("Name\t\tScore\tDucked\tAbsorb\tFaced\tShot\tRobbed\tMissed\tSlimeK\n", fp); 1052 for (ip = Scores; ip != NULL; ip = ip->i_next) { 1053 fprintf(fp, "%s%c%c%c\t", ip->i_name, 1054 ip->i_team == ' ' ? ' ' : '[', 1055 ip->i_team, 1056 ip->i_team == ' ' ? ' ' : ']' 1057 ); 1058 if (strlen(ip->i_name) + 3 < 8) 1059 putc('\t', fp); 1060 fprintf(fp, "%.2f\t%d\t%d\t%d\t%d\t%d\t%d\t%d\n", 1061 ip->i_score, ip->i_ducked, ip->i_absorbed, 1062 ip->i_faced, ip->i_shot, ip->i_robbed, 1063 ip->i_missed, ip->i_slime); 1064 } 1065 fputs("\n\nName\t\tEnemy\tFriend\tDeaths\tStill\tSaved\tConnect\n", fp); 1066 for (ip = Scores; ip != NULL; ip = ip->i_next) { 1067 fprintf(fp, "%s%c%c%c\t", ip->i_name, 1068 ip->i_team == ' ' ? ' ' : '[', 1069 ip->i_team, 1070 ip->i_team == ' ' ? ' ' : ']' 1071 ); 1072 if (strlen(ip->i_name) + 3 < 8) 1073 putc('\t', fp); 1074 fprintf(fp, "%d\t%d\t%d\t%d\t%d\t", 1075 ip->i_gkills, ip->i_bkills, ip->i_deaths, 1076 ip->i_stillb, ip->i_saved); 1077 for (pp = Player; pp < End_player; pp++) 1078 if (pp->p_ident == ip) 1079 putc('p', fp); 1080 for (pp = Monitor; pp < End_monitor; pp++) 1081 if (pp->p_ident == ip) 1082 putc('m', fp); 1083 putc('\n', fp); 1084 } 1085 } 1086 1087 1088 /* 1089 * Send the game statistics to the controlling tty 1090 */ 1091 static void 1092 siginfo(int sig __unused) 1093 { 1094 int tty; 1095 FILE *fp; 1096 1097 if ((tty = open(_PATH_TTY, O_WRONLY)) >= 0) { 1098 fp = fdopen(tty, "w"); 1099 print_stats(fp); 1100 answer_info(fp); 1101 fclose(fp); 1102 } 1103 } 1104 1105 /* 1106 * clear_scores: 1107 * Clear the Scores list. 1108 */ 1109 static void 1110 clear_scores(void) 1111 { 1112 IDENT *ip, *nextip; 1113 1114 /* Release the list of scores: */ 1115 for (ip = Scores; ip != NULL; ip = nextip) { 1116 nextip = ip->i_next; 1117 free((char *) ip); 1118 } 1119 Scores = NULL; 1120 } 1121 1122 /* 1123 * announce_game: 1124 * Publically announce the game 1125 */ 1126 static void 1127 announce_game(void) 1128 { 1129 1130 /* TODO: could use system() to do something user-configurable */ 1131 } 1132 1133 /* 1134 * Handle a UDP packet sent to the well known port. 1135 */ 1136 static void 1137 handle_wkport(int fd) 1138 { 1139 struct sockaddr fromaddr; 1140 socklen_t fromlen; 1141 u_int16_t query; 1142 u_int16_t response; 1143 struct request_info ri; 1144 1145 request_init(&ri, RQ_DAEMON, "huntd", RQ_FILE, fd, 0); 1146 fromhost(&ri); 1147 fromlen = sizeof fromaddr; 1148 if (recvfrom(fd, &query, sizeof query, 0, &fromaddr, &fromlen) == -1) 1149 { 1150 logit(LOG_WARNING, "recvfrom"); 1151 return; 1152 } 1153 1154 #ifdef DEBUG 1155 fprintf(stderr, "query %d (%s) from %s:%d\n", query, 1156 query == C_MESSAGE ? "C_MESSAGE" : 1157 query == C_SCORES ? "C_SCORES" : 1158 query == C_PLAYER ? "C_PLAYER" : 1159 query == C_MONITOR ? "C_MONITOR" : "?", 1160 inet_ntoa(((struct sockaddr_in *)&fromaddr)->sin_addr), 1161 ntohs(((struct sockaddr_in *)&fromaddr)->sin_port)); 1162 #endif 1163 1164 /* Do we allow access? */ 1165 if (hosts_access(&ri) == 0) { 1166 logx(LOG_INFO, "rejected connection from %s", eval_client(&ri)); 1167 return; 1168 } 1169 1170 query = ntohs(query); 1171 1172 switch (query) { 1173 case C_MESSAGE: 1174 if (Nplayer <= 0) 1175 /* Don't bother replying if nobody to talk to: */ 1176 return; 1177 /* Return the number of people playing: */ 1178 response = Nplayer; 1179 break; 1180 case C_SCORES: 1181 /* Someone wants the statistics port: */ 1182 response = stat_port; 1183 break; 1184 case C_PLAYER: 1185 case C_MONITOR: 1186 /* Someone wants to play or watch: */ 1187 if (query == C_MONITOR && Nplayer <= 0) 1188 /* Don't bother replying if there's nothing to watch: */ 1189 return; 1190 /* Otherwise, tell them how to get to the game: */ 1191 response = sock_port; 1192 break; 1193 default: 1194 logit(LOG_INFO, "unknown udp query %d", query); 1195 return; 1196 } 1197 1198 response = ntohs(response); 1199 if (sendto(fd, &response, sizeof response, 0, 1200 &fromaddr, sizeof fromaddr) == -1) 1201 logit(LOG_WARNING, "sendto"); 1202 } 1203