2 * Empire - A multi-player, client/server Internet based war game.
3 * Copyright (C) 1986-2009, Dave Pare, Jeff Bailey, Thomas Ruschak,
4 * Ken Stevens, Steve McClure
6 * This program 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 2 of the License, or
9 * (at your option) any later version.
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.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 * See files README, COPYING and CREDITS in the root of the source
23 * tree for related information and legal notices. It is expected
24 * that future projects/authors will amend these files as needed.
28 * play.c: Playing the game
30 * Known contributors to this file:
31 * Markus Armbruster, 2007
32 * Ron Koenderink, 2007-2009
44 #include <sys/types.h>
56 static CRITICAL_SECTION signal_critical_section;
57 static LPCRITICAL_SECTION signal_critical_section_ptr = NULL;
59 static unsigned char bounce_buf[RING_SIZE];
61 * Set bounce_empty to indicate bounce_buf is available for the stdin thread
64 static HANDLE bounce_empty;
66 * Set bounce_full to indicate bounce_buf is contains data from the
67 * stdin thread and is available for recv_input
69 static HANDLE bounce_full;
70 /* Ctrl-C (SIGINT) was detected, generate EINTR for the w32_select() */
71 static HANDLE ctrl_c_event;
72 static int bounce_status, bounce_error;
75 static void (*ctrl_handler)(int sig) = { SIG_DFL };
78 * Ctrl-C handler for emulating the SIGINT in WIN32
81 w32_signal_handler(DWORD ctrl_type)
83 if (ctrl_type == CTRL_C_EVENT) {
84 EnterCriticalSection(signal_critical_section_ptr);
85 if (ctrl_handler != SIG_DFL) {
87 LeaveCriticalSection(signal_critical_section_ptr);
88 SetEvent(ctrl_c_event);
91 LeaveCriticalSection(signal_critical_section_ptr);
97 * WIN32 equivalent for sigaction supports the following:
98 * set handler for SIGINT using WIN32 Ctrl-C handler
99 * reset handler SIGINT to SIG_DFL
103 sigaction(int signal, struct sigaction *action, struct sigaction *oaction)
108 if (signal == SIGPIPE)
109 assert(action->sa_handler == SIG_IGN);
111 assert(signal == SIGINT && action->sa_handler != SIG_IGN);
112 if (ctrl_handler == action->sa_handler)
114 if (signal_critical_section_ptr == NULL) {
115 signal_critical_section_ptr = &signal_critical_section;
116 InitializeCriticalSection(signal_critical_section_ptr);
118 EnterCriticalSection(signal_critical_section_ptr);
119 if (!SetConsoleCtrlHandler(w32_signal_handler,
120 action->sa_handler != SIG_DFL)) {
121 errno = GetLastError();
122 LeaveCriticalSection(signal_critical_section_ptr);
125 ctrl_handler = action->sa_handler;
126 LeaveCriticalSection(signal_critical_section_ptr);
132 * Read the stdin in WIN32 environment
133 * WIN32 does not support select type function on console input
134 * so the client uses a separate thread to read input
137 stdin_read_thread(LPVOID lpParam)
140 if (WaitForSingleObject(bounce_empty, INFINITE) != WAIT_OBJECT_0)
142 bounce_status = _read(0, bounce_buf, sizeof(bounce_buf));
143 bounce_error = errno;
144 if (bounce_status == 0) {
146 SetEvent(bounce_empty);
151 SetEvent(bounce_full);
153 SetEvent(bounce_full);
158 * Initialize and start the stdin reading thread for WIN32
161 sysdep_stdin_init(void)
163 bounce_empty = CreateEvent(NULL, FALSE, TRUE, NULL);
164 bounce_full = CreateEvent(NULL, TRUE, FALSE, NULL);
165 ctrl_c_event = CreateEvent(NULL, FALSE, FALSE, NULL);
166 CreateThread(NULL, 0, stdin_read_thread, NULL, 0, NULL);
170 * This function uses to WaitForMultipleObjects to wait for both
171 * stdin and socket reading or writing.
172 * Stdin is treated special in WIN32. Waiting for stdin is done
173 * via a bounce_full event which is set in the stdin thread.
174 * Execute command file reading is done via handle. Execute
175 * command is read via CreateFile/ReadFile instead open/read
176 * because a file descriptor is not waitable.
177 * WaitForMultipleObjects will only respond with one object
178 * so an additonal select is also done to determine
179 * which individual events are active for the sock.
182 w32_select(int nfds, fd_set *rdfd, fd_set *wrfd, fd_set *errfd, struct timeval* time)
186 int result, s_result, num_handles = 0;
187 struct timeval tv_time = {0, 0};
190 if (rdfd->fd_count > 1) {
191 sock = rdfd->fd_array[1];
192 if (rdfd->fd_array[0])
193 handles[num_handles++] = (HANDLE)rdfd->fd_array[0];
195 handles[num_handles++] = ctrl_c_event;
196 handles[num_handles++] = bounce_full;
199 assert(rdfd->fd_count == 1);
200 sock = rdfd->fd_array[0];
202 assert(wrfd->fd_count == 0 ||
203 (wrfd->fd_count == 1 && wrfd->fd_array[0] == sock));
204 /* always wait on the socket */
205 handles[num_handles++] = WSACreateEvent();
207 if (wrfd->fd_count > 0)
208 WSAEventSelect(sock, handles[num_handles - 1],
209 FD_READ | FD_WRITE | FD_CLOSE);
211 WSAEventSelect(sock, handles[num_handles - 1],
214 result = WaitForMultipleObjects(num_handles, handles, 0, INFINITE);
216 errno = GetLastError();
217 WSACloseEvent(handles[num_handles - 1]);
220 WSACloseEvent(handles[num_handles - 1]);
222 if (num_handles == 3 && result == WAIT_OBJECT_0) {
228 FD_SET(sock, &rdfd2);
229 s_result = select(sock + 1, &rdfd2, wrfd, NULL, &tv_time);
232 errno = WSAGetLastError();
237 if (num_handles == 3 && result == WAIT_OBJECT_0 + 1) {
238 FD_SET((SOCKET)0, rdfd);
241 if (num_handles == 2 && result == WAIT_OBJECT_0) {
242 FD_SET((SOCKET)handles[0], rdfd);
249 * Read input from the user either stdin or from file.
250 * For stdin, read from bounce_buf which filled by the stdin thread
251 * otherwise use the regular ring_from_file.
254 w32_ring_from_file_or_bounce_buf(struct ring *r, int fd)
259 return ring_from_file(r, fd);
261 if (bounce_status < 0) {
262 errno = bounce_error;
265 for (i = 0; i < bounce_status; i++) {
266 if (ring_putc(r, bounce_buf[i]) == EOF) {
267 /* more work to do, hold on to bounce_buf */
268 memmove(bounce_buf, bounce_buf + i, bounce_status - i);
276 ResetEvent(bounce_full);
277 SetEvent(bounce_empty);
280 #define ring_from_file w32_ring_from_file_or_bounce_buf
281 #define close(fd) w32_close_handle((fd))
282 #define read(sock, buffer, buf_size) \
283 w32_recv((sock), (buffer), (buf_size), 0)
284 #define select(nfds, rd, wr, error, time) \
285 w32_select((nfds), (rd), (wr), (error), (time))
286 #define sigemptyset(mask) ((void)0)
288 #define sysdep_stdin_init() ((void)0)
291 #define EOF_COOKIE "ctld\n"
292 #define INTR_COOKIE "\naborted\n"
295 int send_eof; /* need to send EOF_COOKIE */
296 static volatile sig_atomic_t send_intr; /* need to send INTR_COOKIE */
299 * Receive and process server output from SOCK.
300 * Return number of characters received on success, -1 on error.
303 recv_output(int sock)
306 * Read a chunk of server output and feed its characters into a
307 * simple state machine.
308 * Initial state is SCANNING_ID.
309 * In state SCANNING_ID, buffer the character. If it's a space,
310 * decode the id that has been buffered, and enter state BUFFERING
311 * or COPYING depending on its value.
312 * In state BUFFERING, buffer the character. If it's newline,
313 * pass id and buffered text to servercmd(), then enter state
315 * In state COPYING, pass the character to outch(). If it's
316 * newline, enter state SCANNING_ID.
319 SCANNING_ID, BUFFERING, COPYING
320 } state = SCANNING_ID;
322 static struct lbuf lbuf;
328 n = read(sock, buf, sizeof(buf));
332 for (i = 0; i < n; i++) {
337 /* FIXME gripe unexpected! */
341 lbuf_putc(&lbuf, ch);
344 line = lbuf_line(&lbuf);
360 /* unknown or unexpected id, treat like C_DATA */
368 len = lbuf_putc(&lbuf, ch);
370 line = lbuf_line(&lbuf);
371 servercmd(id, line, len);
388 * Receive command input from FD into INBUF.
389 * Return 1 on receipt of input, zero on EOF, -1 on error.
392 recv_input(int fd, struct ring *inbuf)
394 static struct lbuf cmdbuf;
399 n = ring_from_file(inbuf, fd);
404 if (lbuf_len(&cmdbuf)) {
405 /* incomplete line */
406 ring_putc(inbuf, '\n');
410 * Can't put EOF cookie into INBUF here, it may not fit.
411 * Leave it to caller.
416 /* copy input to AUXFP etc. */
417 for (i = -n; i < 0; i++) {
418 ch = ring_peek(inbuf, i);
420 if (ch != '\r' && lbuf_putc(&cmdbuf, ch)) {
421 line = lbuf_line(&cmdbuf);
440 * The session must be in the playing phase.
441 * Return 0 when the session ended, -1 on error.
447 * Player input flows from INPUT_FD through recv_input() into ring
448 * buffer INBUF, which drains into SOCK. This must not block.
449 * Server output flows from SOCK into recv_output(). Reading SOCK
453 struct ring inbuf; /* input buffer, draining to SOCK */
454 int eof_fd0; /* read fd 0 hit EOF? */
459 sigemptyset(&sa.sa_mask);
460 sa.sa_handler = intr;
461 sigaction(SIGINT, &sa, NULL);
462 sa.sa_handler = SIG_IGN;
463 sigaction(SIGPIPE, &sa, NULL);
466 eof_fd0 = send_eof = send_intr = 0;
475 * Want to read player input only when we don't need to send
476 * cookies, and we haven't hit EOF on fd 0, and INBUF can
479 if (!send_intr && !send_eof && !eof_fd0 && ring_space(&inbuf))
480 FD_SET(input_fd, &rdfd);
481 /* Want to send player input only when we have something */
482 if (send_intr || send_eof || ring_len(&inbuf))
484 /* Always want to read server output */
487 n = select(MAX(input_fd, sock) + 1, &rdfd, &wrfd, NULL, NULL);
489 if (errno != EINTR) {
496 && ring_putm(&inbuf, EOF_COOKIE, sizeof(EOF_COOKIE) - 1) >= 0)
499 && ring_putm(&inbuf, INTR_COOKIE, sizeof(INTR_COOKIE) - 1) >= 0)
505 /* read player input */
506 if (FD_ISSET(input_fd, &rdfd)) {
507 n = recv_input(input_fd, &inbuf);
509 perror("read stdin"); /* FIXME stdin misleading, could be execing */
516 /* execute done, switch back to fd 0 */
520 /* stop reading input, drain socket ring buffers */
522 sa.sa_handler = SIG_DFL;
523 sigaction(SIGINT, &sa, NULL);
528 /* send it to the server */
529 if (FD_ISSET(sock, &wrfd)) {
530 n = ring_to_file(&inbuf, sock);
532 perror("write socket");
537 /* read server output and print it */
538 if (FD_ISSET(sock, &rdfd)) {
539 n = recv_output(sock);
541 perror("read socket");