git.pond.sub.org Git - empserver/blob - src/client/play.c

   1 /*
   2  *  Empire - A multi-player, client/server Internet based war game.
   3  *  Copyright (C) 1986-2013, Dave Pare, Jeff Bailey, Thomas Ruschak,
   4  *                Ken Stevens, Steve McClure, Markus Armbruster
   5  *
   6  *  Empire is free software: you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation, either version 3 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  *
  19  *  ---
  20  *
  21  *  See files README, COPYING and CREDITS in the root of the source
  22  *  tree for related information and legal notices.  It is expected
  23  *  that future projects/authors will amend these files as needed.
  24  *
  25  *  ---
  26  *
  27  *  play.c: Playing the game
  28  *
  29  *  Known contributors to this file:
  30  *     Markus Armbruster, 2007-2010
  31  *     Ron Koenderink, 2007-2009
  32  */
  33
  34 #include <config.h>
  35
  36 #include <assert.h>
  37 #include <errno.h>
  38 #include <signal.h>
  39 #include <stdio.h>
  40 #include <stdlib.h>
  41 #ifdef _WIN32
  42 #include <process.h>
  43 #include <sys/socket.h>
  44 #else
  45 #include <sys/select.h>
  46 #endif
  47 #include <unistd.h>
  48 #include "linebuf.h"
  49 #include "misc.h"
  50 #include "proto.h"
  51 #include "ringbuf.h"
  52 #include "secure.h"
  53
  54 #ifdef _WIN32
  55 static CRITICAL_SECTION signal_critical_section;
  56 static LPCRITICAL_SECTION signal_critical_section_ptr = NULL;
  57
  58 static unsigned char bounce_buf[RING_SIZE];
  59 /*
  60  * Set bounce_empty to indicate bounce_buf is available for the stdin thread
  61  * to use.
  62  */
  63 static HANDLE bounce_empty;
  64 /*
  65  * Set bounce_full to indicate bounce_buf is contains data from the
  66  * stdin thread and is available for recv_input
  67  */
  68 static HANDLE bounce_full;
  69 /* Ctrl-C (SIGINT) was detected, generate EINTR for the w32_select() */
  70 static HANDLE ctrl_c_event;
  71 static int bounce_status, bounce_error;
  72
  73 struct sigaction {
  74     int sa_flags;
  75     void (*sa_handler)(int sig);
  76 };
  77
  78 #define SIGPIPE -1
  79 static void (*ctrl_handler)(int sig) = { SIG_DFL };
  80
  81 /*
  82  * Ctrl-C handler for emulating the SIGINT in WIN32
  83  */
  84 static BOOL WINAPI
  85 w32_signal_handler(DWORD ctrl_type)
  86 {
  87     if (ctrl_type == CTRL_C_EVENT) {
  88         EnterCriticalSection(signal_critical_section_ptr);
  89         if (ctrl_handler != SIG_DFL) {
  90             ctrl_handler(SIGINT);
  91             LeaveCriticalSection(signal_critical_section_ptr);
  92             SetEvent(ctrl_c_event);
  93             return TRUE;
  94         } else
  95             LeaveCriticalSection(signal_critical_section_ptr);
  96     }
  97     return FALSE;
  98 }
  99
 100 /*
 101  * WIN32 equivalent for sigaction supports the following:
 102  * set handler for SIGINT using WIN32 Ctrl-C handler
 103  * reset handler SIGINT to SIG_DFL
 104  * ignore SIGPIPE
 105  */
 106 static int
 107 sigaction(int signal, struct sigaction *action, struct sigaction *oaction)
 108 {
 109     assert(!oaction);
 110     assert(action);
 111
 112     if (signal == SIGPIPE)
 113         assert(action->sa_handler == SIG_IGN);
 114     else {
 115         assert(signal == SIGINT && action->sa_handler != SIG_IGN);
 116         if (ctrl_handler == action->sa_handler)
 117             return 0;
 118         if (signal_critical_section_ptr == NULL) {
 119             signal_critical_section_ptr = &signal_critical_section;
 120             InitializeCriticalSection(signal_critical_section_ptr);
 121         }
 122         EnterCriticalSection(signal_critical_section_ptr);
 123         if (!SetConsoleCtrlHandler(w32_signal_handler,
 124                                    action->sa_handler != SIG_DFL)) {
 125             errno = GetLastError();
 126             LeaveCriticalSection(signal_critical_section_ptr);
 127             return -1;
 128         }
 129         ctrl_handler = action->sa_handler;
 130         LeaveCriticalSection(signal_critical_section_ptr);
 131     }
 132     return 0;
 133 }
 134
 135 /*
 136  * Read the stdin in WIN32 environment
 137  * WIN32 does not support select type function on console input
 138  * so the client uses a separate thread to read input
 139  */
 140 static void
 141 stdin_read_thread(void *dummy)
 142 {
 143     for (;;) {
 144         switch (WaitForSingleObject(bounce_empty, INFINITE)) {
 145         case WAIT_FAILED:
 146             bounce_status = -1;
 147             bounce_error = GetLastError();
 148             break;
 149         case WAIT_OBJECT_0:
 150             bounce_status = _read(0, bounce_buf, sizeof(bounce_buf));
 151             bounce_error = errno;
 152             break;
 153         case WAIT_ABANDONED:
 154             return;
 155         default:
 156             assert(0);
 157         }
 158         SetEvent(bounce_full);
 159     }
 160 }
 161
 162 /*
 163  * Initialize and start the stdin reading thread for WIN32
 164  */
 165 static void
 166 sysdep_stdin_init(void)
 167 {
 168     bounce_empty = CreateEvent(NULL, FALSE, TRUE, NULL);
 169     bounce_full = CreateEvent(NULL, TRUE, FALSE, NULL);
 170     ctrl_c_event = CreateEvent(NULL, FALSE, FALSE, NULL);
 171     _beginthread(stdin_read_thread, 0, NULL);
 172 }
 173
 174 /*
 175  * This function uses to WaitForMultipleObjects to wait for both
 176  * stdin and socket reading or writing.
 177  * Stdin is treated special in WIN32.  Waiting for stdin is done
 178  * via a bounce_full event which is set in the stdin thread.
 179  * Execute command file reading is done via handle.
 180  * WaitForMultipleObjects will only respond with one object,
 181  * so an additonal select is also done to determine
 182  * which individual events are active.
 183  */
 184 static int
 185 w32_select(int nfds, fd_set *rdfd, fd_set *wrfd, fd_set *errfd,
 186            struct timeval *time)
 187 {
 188     HANDLE handles[3];
 189     SOCKET sock;
 190     int inp, sockfd, result, s_result, num_handles;
 191     struct timeval tv_time = {0, 0};
 192     fd_set rdsock, wrsock;
 193
 194     switch (rdfd->fd_count) {
 195     case 1:
 196         inp = -1;
 197         sockfd = rdfd->fd_array[0];
 198         break;
 199     case 2:
 200         inp = rdfd->fd_array[0];
 201         sockfd = rdfd->fd_array[1];
 202         break;
 203     default:
 204         assert(0);
 205     }
 206     sock = w32_fd2socket(sockfd);
 207
 208     assert(wrfd->fd_count == 0
 209            || (wrfd->fd_count == 1 && wrfd->fd_array[0] == (SOCKET)sockfd));
 210     assert(inp < 0 || inp == input_fd);
 211
 212     num_handles = 0;
 213     handles[num_handles++] = ctrl_c_event;
 214     if (inp >= 0)
 215         handles[num_handles++]
 216             = inp ? (HANDLE)_get_osfhandle(inp) : bounce_full;
 217     /* always wait on the socket */
 218     handles[num_handles++] = WSACreateEvent();
 219
 220     if (wrfd->fd_count > 0)
 221         WSAEventSelect(sock, handles[num_handles - 1],
 222                        FD_READ | FD_WRITE | FD_CLOSE);
 223     else
 224         WSAEventSelect(sock, handles[num_handles - 1],
 225                        FD_READ | FD_CLOSE);
 226
 227     result = WaitForMultipleObjects(num_handles, handles, 0, INFINITE);
 228     if (result < 0) {
 229         errno = GetLastError();
 230         WSACloseEvent(handles[num_handles - 1]);
 231         return -1;
 232     }
 233     WSACloseEvent(handles[num_handles - 1]);
 234
 235     if (result == WAIT_OBJECT_0) {
 236         errno = EINTR;
 237         return -1;
 238     }
 239
 240     FD_ZERO(&rdsock);
 241     FD_ZERO(&wrsock);
 242     FD_SET(sock, &rdsock);
 243     if (wrfd->fd_count)
 244         FD_SET(sock, &wrsock);
 245     s_result = select(sock + 1, &rdsock, &wrsock, NULL, &tv_time);
 246
 247     if (s_result < 0) {
 248         w32_set_winsock_errno();
 249         return s_result;
 250     }
 251
 252     if (!FD_ISSET(sock, &rdsock))
 253         FD_CLR((SOCKET)sockfd, rdfd);
 254     if (!FD_ISSET(sock, &wrsock))
 255         FD_CLR((SOCKET)sockfd, wrfd);
 256     if (inp >= 0 && result == WAIT_OBJECT_0 + 1)
 257         s_result++;
 258     else
 259         FD_CLR((SOCKET)inp, rdfd);
 260
 261     return s_result;
 262 }
 263
 264 /*
 265  * Read input from the user either stdin or from file.
 266  * For stdin, read from bounce_buf which filled by the stdin thread
 267  * otherwise use the regular ring_from_file.
 268  */
 269 static int
 270 w32_ring_from_file_or_bounce_buf(struct ring *r, int fd)
 271 {
 272     int i, res;
 273
 274     if (fd)
 275         return ring_from_file(r, fd);
 276
 277     if (bounce_status < 0) {
 278         errno = bounce_error;
 279         res = bounce_status;
 280     } else {
 281         for (i = 0; i < bounce_status; i++) {
 282             if (ring_putc(r, bounce_buf[i]) == EOF) {
 283                 /* more work to do, hold on to bounce_buf */
 284                 memmove(bounce_buf, bounce_buf + i, bounce_status - i);
 285                 bounce_status -= i;
 286                 return i;
 287             }
 288         }
 289         res = i;
 290     }
 291
 292     ResetEvent(bounce_full);
 293     SetEvent(bounce_empty);
 294     return res;
 295 }
 296 #define ring_from_file w32_ring_from_file_or_bounce_buf
 297 #define select(nfds, rd, wr, error, time) \
 298         w32_select((nfds), (rd), (wr), (error), (time))
 299 #define sigemptyset(mask) ((void)0)
 300 #else
 301 #define sysdep_stdin_init() ((void)0)
 302 #endif
 303
 304 #define EOF_COOKIE "ctld\n"
 305 #define INTR_COOKIE "aborted\n"
 306
 307 int input_fd;
 308 int send_eof;                           /* need to send EOF_COOKIE */
 309 static volatile sig_atomic_t send_intr; /* need to send INTR_COOKIE */
 310
 311 /*
 312  * Receive and process server output from SOCK.
 313  * Return number of characters received on success, -1 on error.
 314  */
 315 static int
 316 recv_output(int sock)
 317 {
 318     /*
 319      * Read a chunk of server output and feed its characters into a
 320      * simple state machine.
 321      * Initial state is SCANNING_ID.
 322      * In state SCANNING_ID, buffer the character.  If it's a space,
 323      * decode the id that has been buffered, and enter state BUFFERING
 324      * or COPYING depending on its value.
 325      * In state BUFFERING, buffer the character.  If it's newline,
 326      * pass id and buffered text to servercmd(), then enter state
 327      * SCANNING_ID.
 328      * In state COPYING, pass the character to outch().  If it's
 329      * newline, enter state SCANNING_ID.
 330      */
 331     static enum {
 332         SCANNING_ID, BUFFERING, COPYING
 333     } state = SCANNING_ID;
 334     static int id;
 335     static struct lbuf lbuf;
 336     char buf[4096];
 337     ssize_t n;
 338     int i, ch, len;
 339     char *line;
 340
 341     n = read(sock, buf, sizeof(buf));
 342     if (n < 0)
 343         return -1;
 344
 345     for (i = 0; i < n; i++) {
 346         ch = buf[i];
 347         switch (state) {
 348         case SCANNING_ID:
 349             if (ch == '\n') {
 350                 /* FIXME gripe unexpected! */
 351                 lbuf_init(&lbuf);
 352                 break;
 353             }
 354             lbuf_putc(&lbuf, ch);
 355             if (ch != ' ')
 356                 break;
 357             line = lbuf_line(&lbuf);
 358             id = parseid(line);
 359             lbuf_init(&lbuf);
 360
 361             switch (id) {
 362             case C_PROMPT:
 363             case C_FLUSH:
 364             case C_EXECUTE:
 365             case C_EXIT:
 366             case C_FLASH:
 367             case C_INFORM:
 368             case C_PIPE:
 369             case C_REDIR:
 370                 state = BUFFERING;
 371                 break;
 372             default:
 373                 /* unknown or unexpected id, treat like C_DATA */
 374             case C_DATA:
 375                 state = COPYING;
 376                 break;
 377             }
 378             break;
 379
 380         case BUFFERING:
 381             len = lbuf_putc(&lbuf, ch);
 382             if (len) {
 383                 line = lbuf_line(&lbuf);
 384                 servercmd(id, line, len);
 385                 lbuf_init(&lbuf);
 386                 state = SCANNING_ID;
 387             }
 388             break;
 389
 390         case COPYING:
 391             outch(ch);
 392             if (ch == '\n')
 393                 state = SCANNING_ID;
 394         }
 395     }
 396
 397     return n;
 398 }
 399
 400 /*
 401  * Receive command input from FD into INBUF.
 402  * Return 1 on receipt of input, zero on EOF, -1 on error.
 403  */
 404 static int
 405 recv_input(int fd, struct ring *inbuf)
 406 {
 407     static struct lbuf cmdbuf;
 408     int n, i, ch;
 409     char *line;
 410     int res = 1;
 411
 412     n = ring_from_file(inbuf, fd);
 413     if (n < 0)
 414         return -1;
 415     if (n == 0) {
 416         /* EOF on input */
 417         if (lbuf_len(&cmdbuf)) {
 418             /* incomplete line */
 419             ring_putc(inbuf, '\n');
 420             n++;
 421         }
 422         /*
 423          * Can't put EOF cookie into INBUF here, it may not fit.
 424          * Leave it to caller.
 425          */
 426         res = 0;
 427     }
 428
 429     /* copy input to AUXFP etc. */
 430     for (i = -n; i < 0; i++) {
 431         ch = ring_peek(inbuf, i);
 432         assert(ch != EOF);
 433         if (ch != '\r' && lbuf_putc(&cmdbuf, ch) > 0) {
 434             line = lbuf_line(&cmdbuf);
 435             save_input(line);
 436             lbuf_init(&cmdbuf);
 437         }
 438         if (auxfp)
 439             putc(ch, auxfp);
 440     }
 441
 442     return res;
 443 }
 444
 445 static void
 446 intr(int sig)
 447 {
 448     send_intr = 1;
 449 }
 450
 451 /*
 452  * Play on SOCK.
 453  * The session must be in the playing phase.
 454  * Return 0 when the session ended, -1 on error.
 455  */
 456 int
 457 play(int sock)
 458 {
 459     /*
 460      * Player input flows from INPUT_FD through recv_input() into ring
 461      * buffer INBUF, which drains into SOCK.  This must not block.
 462      * Server output flows from SOCK into recv_output().  Reading SOCK
 463      * must not block.
 464      */
 465     struct sigaction sa;
 466     struct ring inbuf;          /* input buffer, draining to SOCK */
 467     int eof_fd0;                /* read fd 0 hit EOF? */
 468     int partial_line_sent;      /* partial input line sent? */
 469     fd_set rdfd, wrfd;
 470     int n;
 471
 472     sa.sa_flags = 0;
 473     sigemptyset(&sa.sa_mask);
 474     sa.sa_handler = intr;
 475     sigaction(SIGINT, &sa, NULL);
 476     sa.sa_handler = SIG_IGN;
 477     sigaction(SIGPIPE, &sa, NULL);
 478
 479     ring_init(&inbuf);
 480     eof_fd0 = partial_line_sent = send_eof = send_intr = 0;
 481     input_fd = 0;
 482     sysdep_stdin_init();
 483
 484     for (;;) {
 485         FD_ZERO(&rdfd);
 486         FD_ZERO(&wrfd);
 487
 488         /*
 489          * Want to read player input only when we don't need to send
 490          * cookies, and INPUT_FD is still open, and INBUF can accept
 491          * some.
 492          */
 493         if (!send_intr && !send_eof && input_fd >= 0 && ring_space(&inbuf))
 494             FD_SET(input_fd, &rdfd);
 495         /* Want to send player input only when we have something */
 496         if (send_intr || send_eof || ring_len(&inbuf))
 497             FD_SET(sock, &wrfd);
 498         /* Always want to read server output */
 499         FD_SET(sock, &rdfd);
 500
 501         n = select(MAX(input_fd, sock) + 1, &rdfd, &wrfd, NULL, NULL);
 502         if (n < 0) {
 503             if (errno != EINTR) {
 504                 perror("select");
 505                 return -1;
 506             }
 507         }
 508
 509         if ((send_eof || send_intr) && partial_line_sent
 510             && ring_putc(&inbuf, '\n') != EOF)
 511             partial_line_sent = 0;
 512         if (send_eof && !partial_line_sent
 513             && ring_putm(&inbuf, EOF_COOKIE, sizeof(EOF_COOKIE) - 1) >= 0)
 514             send_eof--;
 515         if (send_intr && !partial_line_sent
 516             && ring_putm(&inbuf, INTR_COOKIE, sizeof(INTR_COOKIE) - 1) >= 0) {
 517             send_intr = 0;
 518             if (input_fd) {
 519                 /* execute aborted, switch back to fd 0 */
 520                 close(input_fd);
 521                 input_fd = eof_fd0 ? -1 : 0;
 522             }
 523         }
 524
 525         if (n < 0)
 526             continue;
 527
 528         /* read player input */
 529         if (input_fd >= 0 && FD_ISSET(input_fd, &rdfd)) {
 530             n = recv_input(input_fd, &inbuf);
 531             if (n < 0) {
 532                 perror("read stdin"); /* FIXME stdin misleading, could be execing */
 533                 n = 0;
 534             }
 535             if (n == 0) {
 536                 /* EOF on input */
 537                 send_eof++;
 538                 if (input_fd) {
 539                     /* execute done, switch back to fd 0 */
 540                     close(input_fd);
 541                     input_fd = eof_fd0 ? -1 : 0;
 542                 } else {
 543                     /* stop reading input, drain socket ring buffers */
 544                     eof_fd0 = 1;
 545                     input_fd = -1;
 546                     sa.sa_handler = SIG_DFL;
 547                     sigaction(SIGINT, &sa, NULL);
 548                 }
 549             } else
 550                 partial_line_sent = ring_peek(&inbuf, -1) != '\n';
 551         }
 552
 553         /* send it to the server */
 554         if (FD_ISSET(sock, &wrfd)) {
 555             n = ring_to_file(&inbuf, sock);
 556             if (n < 0) {
 557                 perror("write socket");
 558                 return -1;
 559             }
 560         }
 561
 562         /* read server output and print it */
 563         if (FD_ISSET(sock, &rdfd)) {
 564             n = recv_output(sock);
 565             if (n < 0) {
 566                 perror("read socket");
 567                 return -1;
 568             }
 569             if (n == 0)
 570                 return 0;
 571         }
 572     }
 573 }