a33541ab31c86b3a57d3969a39335acc8b1cbd98
[empserver] / src / client / play.c
1 /*
2  *  Empire - A multi-player, client/server Internet based war game.
3  *  Copyright (C) 1986-2017, 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-2017
31  *     Ron Koenderink, 2007-2009
32  *     Martin Haukeli, 2015
33  */
34
35 #include <config.h>
36
37 #include <assert.h>
38 #include <errno.h>
39 #include <signal.h>
40 #include <stdio.h>
41 #include <stdlib.h>
42 #ifdef _WIN32
43 #include <process.h>
44 #include <sys/socket.h>
45 #else
46 #include <sys/select.h>
47 #endif
48 #include <unistd.h>
49 #include "linebuf.h"
50 #include "misc.h"
51 #include "proto.h"
52 #include "ringbuf.h"
53 #include "secure.h"
54
55 #ifdef HAVE_LIBREADLINE
56 #include <readline/readline.h>
57 #include <readline/history.h>
58 #endif
59
60 #define EOF_COOKIE "ctld\n"
61 #define INTR_COOKIE "aborted\n"
62
63 /*
64  * Player input file descriptor
65  * 0 while reading interactive input
66  * >0 while reading a batch file
67  * <0 during error handling
68  */
69 static int input_fd;
70
71 static volatile sig_atomic_t send_intr; /* need to send INTR_COOKIE */
72
73 #ifdef _WIN32
74 static CRITICAL_SECTION signal_critical_section;
75 static LPCRITICAL_SECTION signal_critical_section_ptr = NULL;
76
77 static unsigned char bounce_buf[RING_SIZE];
78 /*
79  * Set bounce_empty to indicate bounce_buf is available for the stdin thread
80  * to use.
81  */
82 static HANDLE bounce_empty;
83 /*
84  * Set bounce_full to indicate bounce_buf is contains data from the
85  * stdin thread and is available for recv_input
86  */
87 static HANDLE bounce_full;
88 /* Ctrl-C (SIGINT) was detected, generate EINTR for the w32_select() */
89 static HANDLE ctrl_c_event;
90 static int bounce_status, bounce_error;
91
92 struct sigaction {
93     int sa_flags;
94     void (*sa_handler)(int sig);
95 };
96
97 #define SIGPIPE -1
98 static void (*ctrl_handler)(int sig) = { SIG_DFL };
99
100 /*
101  * Ctrl-C handler for emulating the SIGINT in WIN32
102  */
103 static BOOL WINAPI
104 w32_signal_handler(DWORD ctrl_type)
105 {
106     if (ctrl_type == CTRL_C_EVENT) {
107         EnterCriticalSection(signal_critical_section_ptr);
108         if (ctrl_handler != SIG_DFL) {
109             ctrl_handler(SIGINT);
110             LeaveCriticalSection(signal_critical_section_ptr);
111             SetEvent(ctrl_c_event);
112             return TRUE;
113         } else
114             LeaveCriticalSection(signal_critical_section_ptr);
115     }
116     return FALSE;
117 }
118
119 /*
120  * WIN32 equivalent for sigaction supports the following:
121  * set handler for SIGINT using WIN32 Ctrl-C handler
122  * reset handler SIGINT to SIG_DFL
123  * ignore SIGPIPE
124  */
125 static int
126 sigaction(int signal, struct sigaction *action, struct sigaction *oaction)
127 {
128     assert(!oaction);
129     assert(action);
130
131     if (signal == SIGPIPE)
132         assert(action->sa_handler == SIG_IGN);
133     else {
134         assert(signal == SIGINT && action->sa_handler != SIG_IGN);
135         if (ctrl_handler == action->sa_handler)
136             return 0;
137         if (signal_critical_section_ptr == NULL) {
138             signal_critical_section_ptr = &signal_critical_section;
139             InitializeCriticalSection(signal_critical_section_ptr);
140         }
141         EnterCriticalSection(signal_critical_section_ptr);
142         if (!SetConsoleCtrlHandler(w32_signal_handler,
143                                    action->sa_handler != SIG_DFL)) {
144             errno = GetLastError();
145             LeaveCriticalSection(signal_critical_section_ptr);
146             return -1;
147         }
148         ctrl_handler = action->sa_handler;
149         LeaveCriticalSection(signal_critical_section_ptr);
150     }
151     return 0;
152 }
153
154 /*
155  * Read the stdin in WIN32 environment
156  * WIN32 does not support select type function on console input
157  * so the client uses a separate thread to read input
158  */
159 static void
160 stdin_read_thread(void *dummy)
161 {
162     for (;;) {
163         switch (WaitForSingleObject(bounce_empty, INFINITE)) {
164         case WAIT_FAILED:
165             bounce_status = -1;
166             bounce_error = GetLastError();
167             break;
168         case WAIT_OBJECT_0:
169             bounce_status = _read(0, bounce_buf, sizeof(bounce_buf));
170             bounce_error = errno;
171             break;
172         case WAIT_ABANDONED:
173             return;
174         default:
175             assert(0);
176         }
177         SetEvent(bounce_full);
178     }
179 }
180
181 /*
182  * Initialize and start the stdin reading thread for WIN32
183  */
184 static void
185 sysdep_stdin_init(void)
186 {
187     bounce_empty = CreateEvent(NULL, FALSE, TRUE, NULL);
188     bounce_full = CreateEvent(NULL, TRUE, FALSE, NULL);
189     ctrl_c_event = CreateEvent(NULL, FALSE, FALSE, NULL);
190     _beginthread(stdin_read_thread, 0, NULL);
191 }
192
193 /*
194  * This function uses to WaitForMultipleObjects to wait for both
195  * stdin and socket reading or writing.
196  * Stdin is treated special in WIN32.  Waiting for stdin is done
197  * via a bounce_full event which is set in the stdin thread.
198  * Execute command file reading is done via handle.
199  * WaitForMultipleObjects will only respond with one object,
200  * so an additonal select is also done to determine
201  * which individual events are active.
202  */
203 static int
204 w32_select(int nfds, fd_set *rdfd, fd_set *wrfd, fd_set *errfd,
205            struct timeval *time)
206 {
207     HANDLE handles[3];
208     SOCKET sock;
209     int inp, sockfd, result, s_result, num_handles;
210     struct timeval tv_time = {0, 0};
211     fd_set rdsock, wrsock;
212
213     switch (rdfd->fd_count) {
214     case 1:
215         inp = -1;
216         sockfd = rdfd->fd_array[0];
217         break;
218     case 2:
219         inp = rdfd->fd_array[0];
220         sockfd = rdfd->fd_array[1];
221         break;
222     default:
223         assert(0);
224     }
225     sock = w32_fd2socket(sockfd);
226
227     assert(wrfd->fd_count == 0
228            || (wrfd->fd_count == 1 && wrfd->fd_array[0] == (SOCKET)sockfd));
229     assert(inp < 0 || inp == input_fd);
230
231     num_handles = 0;
232     handles[num_handles++] = ctrl_c_event;
233     if (inp >= 0)
234         handles[num_handles++]
235             = inp ? (HANDLE)_get_osfhandle(inp) : bounce_full;
236     /* always wait on the socket */
237     handles[num_handles++] = WSACreateEvent();
238
239     if (wrfd->fd_count > 0)
240         WSAEventSelect(sock, handles[num_handles - 1],
241                        FD_READ | FD_WRITE | FD_CLOSE);
242     else
243         WSAEventSelect(sock, handles[num_handles - 1],
244                        FD_READ | FD_CLOSE);
245
246     result = WaitForMultipleObjects(num_handles, handles, 0, INFINITE);
247     if (result < 0) {
248         errno = GetLastError();
249         WSACloseEvent(handles[num_handles - 1]);
250         return -1;
251     }
252     WSACloseEvent(handles[num_handles - 1]);
253
254     if (result == WAIT_OBJECT_0) {
255         errno = EINTR;
256         return -1;
257     }
258
259     FD_ZERO(&rdsock);
260     FD_ZERO(&wrsock);
261     FD_SET(sock, &rdsock);
262     if (wrfd->fd_count)
263         FD_SET(sock, &wrsock);
264     s_result = select(sock + 1, &rdsock, &wrsock, NULL, &tv_time);
265
266     if (s_result < 0) {
267         w32_set_winsock_errno();
268         return s_result;
269     }
270
271     if (!FD_ISSET(sock, &rdsock))
272         FD_CLR((SOCKET)sockfd, rdfd);
273     if (!FD_ISSET(sock, &wrsock))
274         FD_CLR((SOCKET)sockfd, wrfd);
275     if (inp >= 0 && result == WAIT_OBJECT_0 + 1)
276         s_result++;
277     else
278         FD_CLR((SOCKET)inp, rdfd);
279
280     return s_result;
281 }
282
283 /*
284  * Read input from the user either stdin or from file.
285  * For stdin, read from bounce_buf which filled by the stdin thread
286  * otherwise use the regular ring_from_file.
287  */
288 static int
289 w32_ring_from_file_or_bounce_buf(struct ring *r, int fd)
290 {
291     int i, res;
292
293     if (fd)
294         return ring_from_file(r, fd);
295
296     if (bounce_status < 0) {
297         errno = bounce_error;
298         res = bounce_status;
299     } else {
300         for (i = 0; i < bounce_status; i++) {
301             if (ring_putc(r, bounce_buf[i]) == EOF) {
302                 /* more work to do, hold on to bounce_buf */
303                 memmove(bounce_buf, bounce_buf + i, bounce_status - i);
304                 bounce_status -= i;
305                 return i;
306             }
307         }
308         res = i;
309     }
310
311     ResetEvent(bounce_full);
312     SetEvent(bounce_empty);
313     return res;
314 }
315 #define ring_from_file w32_ring_from_file_or_bounce_buf
316 #define select(nfds, rd, wr, error, time) \
317         w32_select((nfds), (rd), (wr), (error), (time))
318 #define sigemptyset(mask) ((void)0)
319 #else
320 #define sysdep_stdin_init() ((void)0)
321 #endif
322
323 /*
324  * Receive and process server output from @sock.
325  * Return number of characters received on success, -1 on error.
326  */
327 static int
328 recv_output(int sock)
329 {
330     /*
331      * Read a chunk of server output and feed its characters into a
332      * simple state machine.
333      * Initial state is SCANNING_ID.
334      * In state SCANNING_ID, buffer the character.  If it's a space,
335      * decode the ID that has been buffered, and enter state BUFFERING
336      * or COPYING depending on its value.
337      * In state BUFFERING, buffer the character.  If it's newline,
338      * pass ID and buffered text to servercmd(), then enter state
339      * SCANNING_ID.
340      * In state COPYING, pass the character to outch().  If it's
341      * newline, enter state SCANNING_ID.
342      */
343     static enum {
344         SCANNING_ID, BUFFERING, COPYING
345     } state = SCANNING_ID;
346     static int id;
347     static struct lbuf lbuf;
348     char buf[4096];
349     ssize_t n;
350     int i, ch, len, fd;
351     char *line;
352
353     n = read(sock, buf, sizeof(buf));
354     if (n < 0)
355         return -1;
356
357     for (i = 0; i < n; i++) {
358         ch = buf[i];
359         switch (state) {
360         case SCANNING_ID:
361             if (ch == '\n') {
362                 /* FIXME gripe unexpected! */
363                 lbuf_init(&lbuf);
364                 break;
365             }
366             lbuf_putc(&lbuf, ch);
367             if (ch != ' ')
368                 break;
369             line = lbuf_line(&lbuf);
370             id = parseid(line);
371             lbuf_init(&lbuf);
372
373             switch (id) {
374             case C_PROMPT:
375             case C_FLUSH:
376             case C_EXECUTE:
377             case C_EXIT:
378             case C_FLASH:
379             case C_INFORM:
380             case C_PIPE:
381             case C_REDIR:
382                 state = BUFFERING;
383                 break;
384             default:
385                 /* unknown or unexpected ID, treat like C_DATA */
386             case C_DATA:
387                 state = COPYING;
388                 break;
389             }
390             break;
391
392         case BUFFERING:
393             len = lbuf_putc(&lbuf, ch);
394             if (len) {
395                 line = lbuf_line(&lbuf);
396                 fd = servercmd(id, line, len);
397                 if (fd < 0) {
398                     /* failed execute */
399                     if (input_fd)
400                         close(input_fd);
401                     input_fd = 0;
402                     send_intr = 1;
403                 } else if (fd > 0) {
404                     /* successful execute, switch to batch file */
405                     assert(!input_fd);
406                     input_fd = fd;
407                 }
408                 lbuf_init(&lbuf);
409                 state = SCANNING_ID;
410             }
411             break;
412
413         case COPYING:
414             outch(ch);
415             if (ch == '\n')
416                 state = SCANNING_ID;
417         }
418     }
419
420     return n;
421 }
422
423 #ifdef HAVE_LIBREADLINE
424 static int use_readline;
425 static char *input_from_rl;
426 static int has_rl_input;
427
428 static void
429 input_handler(char *line)
430 {
431     input_from_rl = line;
432     has_rl_input = 1;
433     if (line && *line)
434         add_history(line);
435 }
436
437 static int
438 ring_from_rl(struct ring *inbuf)
439 {
440     size_t len;
441     int n;
442
443     assert(has_rl_input && input_from_rl);
444
445     len = strlen(input_from_rl);
446     n = ring_space(inbuf);
447     assert(n);
448
449     if (len >= (size_t)n) {
450         ring_putm(inbuf, input_from_rl, n);
451         memmove(input_from_rl, input_from_rl + n, len - n + 1);
452     } else {
453         ring_putm(inbuf, input_from_rl, len);
454         ring_putc(inbuf, '\n');
455         free(input_from_rl);
456         has_rl_input = 0;
457         n = len + 1;
458     }
459
460     return n;
461 }
462 #endif /* HAVE_LIBREADLINE */
463
464 /*
465  * Receive player input from @fd into @inbuf.
466  * Return 1 on receipt of input, zero on EOF, -1 on error.
467  */
468 static int
469 recv_input(int fd, struct ring *inbuf)
470 {
471     int n;
472     int res = 1;
473
474 #ifdef HAVE_LIBREADLINE
475     if (fd == 0 && use_readline) {
476         if (!has_rl_input)
477             rl_callback_read_char();
478         if (!has_rl_input)
479             return 1;
480         if (input_from_rl) {
481             n = ring_from_rl(inbuf);
482         } else
483             n = 0;
484     } else
485 #endif
486         n = ring_from_file(inbuf, fd);
487     if (n < 0)
488         return -1;
489     if (n == 0) {
490         /*
491          * Can't put EOF cookie into @inbuf here, it may not fit.
492          * Leave it to caller.
493          */
494         res = 0;
495     }
496
497     return res;
498 }
499
500 static int
501 send_input(int fd, struct ring *inbuf)
502 {
503     struct iovec iov[2];
504     int cnt, i, ch;
505     ssize_t res;
506
507     cnt = ring_to_iovec(inbuf, iov);
508     res = writev(fd, iov, cnt);
509     if (res < 0)
510         return res;
511
512     /* Copy input to @auxfp etc. */
513     for (i = 0; i < res; i++) {
514         ch = ring_getc(inbuf);
515         assert(ch != EOF);
516         if (ch != '\r')
517             save_input(ch);
518         if (auxfp)
519             putc(ch, auxfp);
520     }
521
522 #ifdef HAVE_LIBREADLINE
523     if (fd == 0 && use_readline && has_rl_input && input_from_rl)
524         ring_from_rl(inbuf);
525 #endif
526
527     return res;
528 }
529
530 static void
531 intr(int sig)
532 {
533     send_intr = 1;
534 }
535
536 /*
537  * Play on @sock.
538  * @history_file is the name of the history file, or null.
539  * The session must be in the playing phase.
540  * Return 0 when the session ended, -1 on error.
541  */
542 int
543 play(int sock, char *history_file)
544 {
545     /*
546      * Player input flows from @input_fd through recv_input() into
547      * ring buffer @inbuf, which drains into @sock.  This must not
548      * block.  Server output flows from @sock into recv_output().
549      * Reading @sock must not block.
550      */
551     struct sigaction sa;
552     struct ring inbuf;          /* input buffer, draining to SOCK */
553     int eof_fd0;                /* read fd 0 hit EOF? */
554     int partial_line_sent;      /* partial input line sent? */
555     int send_eof;               /* need to send EOF_COOKIE */
556     fd_set rdfd, wrfd;
557     int n;
558     int ret = -1;
559
560     sa.sa_flags = 0;
561     sigemptyset(&sa.sa_mask);
562     sa.sa_handler = intr;
563     sigaction(SIGINT, &sa, NULL);
564     sa.sa_handler = SIG_IGN;
565     sigaction(SIGPIPE, &sa, NULL);
566 #ifdef HAVE_LIBREADLINE
567     if (isatty(0)) {
568         use_readline = 1;
569         rl_already_prompted = 1;
570         rl_readline_name = "Empire";
571         if (history_file)
572             read_history(history_file);
573         rl_bind_key('\t', rl_insert);  /* Disable tab completion */
574         rl_callback_handler_install("", input_handler);
575     }
576 #endif /* HAVE_LIBREADLINE */
577
578     ring_init(&inbuf);
579     eof_fd0 = partial_line_sent = send_eof = send_intr = 0;
580     input_fd = 0;
581     sysdep_stdin_init();
582
583     for (;;) {
584         FD_ZERO(&rdfd);
585         FD_ZERO(&wrfd);
586
587         /*
588          * Want to read player input only when we don't need to send
589          * cookies, haven't reached EOF on fd 0, and @inbuf can accept
590          * some.
591          */
592         if (!send_intr && !send_eof && (input_fd || !eof_fd0)
593             && ring_space(&inbuf))
594             FD_SET(input_fd, &rdfd);
595         /* Want to send player input only when we have something */
596         if (send_intr || send_eof || ring_len(&inbuf))
597             FD_SET(sock, &wrfd);
598         /* Always want to read server output */
599         FD_SET(sock, &rdfd);
600
601         n = select(MAX(input_fd, sock) + 1, &rdfd, &wrfd, NULL, NULL);
602         if (n < 0) {
603             if (errno != EINTR) {
604                 perror("select");
605                 break;
606             }
607         }
608
609         if ((send_eof || send_intr) && partial_line_sent
610             && ring_putc(&inbuf, '\n') != EOF)
611             partial_line_sent = 0;
612         if (send_eof && !partial_line_sent
613             && ring_putm(&inbuf, EOF_COOKIE, sizeof(EOF_COOKIE) - 1) >= 0)
614             send_eof = 0;
615         if (send_intr && !partial_line_sent
616             && ring_putm(&inbuf, INTR_COOKIE, sizeof(INTR_COOKIE) - 1) >= 0) {
617             send_intr = 0;
618             if (input_fd) {
619                 /* execute aborted, switch back to fd 0 */
620                 close(input_fd);
621                 input_fd = 0;
622             }
623         }
624         if (n < 0)
625             continue;
626
627         /* read player input */
628         if (FD_ISSET(input_fd, &rdfd) && ring_space(&inbuf)) {
629             n = recv_input(input_fd, &inbuf);
630             if (n <= 0) {
631                 if (input_fd) {
632                     /* execute done, switch back to fd 0 */
633                     if (n < 0) {
634                         perror("read batch file");
635                         send_intr = 1;
636                     } else
637                         send_eof = 1;
638                     close(input_fd);
639                     input_fd = 0;
640                 } else {
641                     /* stop reading input, drain socket ring buffers */
642                     if (n < 0)
643                         perror("read stdin");
644                     send_eof = 1;
645                     eof_fd0 = 1;
646                     sa.sa_handler = SIG_DFL;
647                     sigaction(SIGINT, &sa, NULL);
648                     send_intr = 0;
649                 }
650             } else if (ring_len(&inbuf) > 0)
651                 partial_line_sent = ring_peek(&inbuf, -1) != '\n';
652         }
653
654         /* send it to the server */
655         if (FD_ISSET(sock, &wrfd)) {
656             n = send_input(sock, &inbuf);
657             if (n < 0) {
658                 perror("write socket");
659                 break;
660             }
661         }
662
663         /* read server output and print it */
664         if (FD_ISSET(sock, &rdfd)) {
665             n = recv_output(sock);
666             if (n < 0) {
667                 perror("read socket");
668                 break;
669             }
670             if (n == 0) {
671                 ret = 0;
672                 break;
673             }
674         }
675     }
676
677 #ifdef HAVE_LIBREADLINE
678     if (use_readline) {
679         rl_callback_handler_remove();
680         if (history_file)
681             write_history(history_file);
682     }
683 #endif
684     return ret;
685 }
686
687 void
688 prompt(int code, char *prompt, char *teles)
689 {
690     char pr[1024];
691
692     snprintf(pr, sizeof(pr), "%s%s", teles, prompt);
693 #ifdef HAVE_LIBREADLINE
694     if (use_readline) {
695         rl_set_prompt(pr);
696         rl_forced_update_display();
697     } else
698 #endif /* HAVE_LIBREADLINE */
699     {
700         printf("%s", pr);
701         fflush(stdout);
702     }
703     if (auxfp) {
704         fprintf(auxfp, "%s%s", teles, prompt);
705         fflush(auxfp);
706     }
707 }