/*
* Empire - A multi-player, client/server Internet based war game.
- * Copyright (C) 1986-2007, Dave Pare, Jeff Bailey, Thomas Ruschak,
+ * Copyright (C) 1986-2010, Dave Pare, Jeff Bailey, Thomas Ruschak,
* Ken Stevens, Steve McClure
*
* This program is free software; you can redistribute it and/or modify
* ---
*
* play.c: Playing the game
- *
+ *
* Known contributors to this file:
- * Markus Armbruster, 2007
+ * Markus Armbruster, 2007-2009
+ * Ron Koenderink, 2007-2009
*/
#include <config.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
-#include <sys/time.h>
-#include <sys/types.h>
+#ifdef _WIN32
+#include <process.h>
+#include <sys/socket.h>
+#else
+#include <sys/select.h>
+#endif
#include <unistd.h>
#include "linebuf.h"
#include "misc.h"
#include "ringbuf.h"
#include "secure.h"
+#ifdef _WIN32
+static CRITICAL_SECTION signal_critical_section;
+static LPCRITICAL_SECTION signal_critical_section_ptr = NULL;
+
+static unsigned char bounce_buf[RING_SIZE];
+/*
+ * Set bounce_empty to indicate bounce_buf is available for the stdin thread
+ * to use.
+ */
+static HANDLE bounce_empty;
+/*
+ * Set bounce_full to indicate bounce_buf is contains data from the
+ * stdin thread and is available for recv_input
+ */
+static HANDLE bounce_full;
+/* Ctrl-C (SIGINT) was detected, generate EINTR for the w32_select() */
+static HANDLE ctrl_c_event;
+static int bounce_status, bounce_error;
+
+struct sigaction {
+ int sa_flags;
+ void (*sa_handler)(int sig);
+};
+
+#define SIGPIPE -1
+static void (*ctrl_handler)(int sig) = { SIG_DFL };
+
+/*
+ * Ctrl-C handler for emulating the SIGINT in WIN32
+ */
+static BOOL WINAPI
+w32_signal_handler(DWORD ctrl_type)
+{
+ if (ctrl_type == CTRL_C_EVENT) {
+ EnterCriticalSection(signal_critical_section_ptr);
+ if (ctrl_handler != SIG_DFL) {
+ ctrl_handler(SIGINT);
+ LeaveCriticalSection(signal_critical_section_ptr);
+ SetEvent(ctrl_c_event);
+ return TRUE;
+ } else
+ LeaveCriticalSection(signal_critical_section_ptr);
+ }
+ return FALSE;
+}
+
+/*
+ * WIN32 equivalent for sigaction supports the following:
+ * set handler for SIGINT using WIN32 Ctrl-C handler
+ * reset handler SIGINT to SIG_DFL
+ * ignore SIGPIPE
+ */
+static int
+sigaction(int signal, struct sigaction *action, struct sigaction *oaction)
+{
+ assert(!oaction);
+ assert(action);
+
+ if (signal == SIGPIPE)
+ assert(action->sa_handler == SIG_IGN);
+ else {
+ assert(signal == SIGINT && action->sa_handler != SIG_IGN);
+ if (ctrl_handler == action->sa_handler)
+ return 0;
+ if (signal_critical_section_ptr == NULL) {
+ signal_critical_section_ptr = &signal_critical_section;
+ InitializeCriticalSection(signal_critical_section_ptr);
+ }
+ EnterCriticalSection(signal_critical_section_ptr);
+ if (!SetConsoleCtrlHandler(w32_signal_handler,
+ action->sa_handler != SIG_DFL)) {
+ errno = GetLastError();
+ LeaveCriticalSection(signal_critical_section_ptr);
+ return -1;
+ }
+ ctrl_handler = action->sa_handler;
+ LeaveCriticalSection(signal_critical_section_ptr);
+ }
+ return 0;
+}
+
+/*
+ * Read the stdin in WIN32 environment
+ * WIN32 does not support select type function on console input
+ * so the client uses a separate thread to read input
+ */
+static void
+stdin_read_thread(void *dummy)
+{
+ for (;;) {
+ switch (WaitForSingleObject(bounce_empty, INFINITE)) {
+ case WAIT_FAILED:
+ bounce_status = -1;
+ bounce_error = GetLastError();
+ break;
+ case WAIT_OBJECT_0:
+ bounce_status = _read(0, bounce_buf, sizeof(bounce_buf));
+ bounce_error = errno;
+ break;
+ case WAIT_ABANDONED:
+ return;
+ default:
+ assert(0);
+ }
+ SetEvent(bounce_full);
+ }
+}
+
+/*
+ * Initialize and start the stdin reading thread for WIN32
+ */
+static void
+sysdep_stdin_init(void)
+{
+ bounce_empty = CreateEvent(NULL, FALSE, TRUE, NULL);
+ bounce_full = CreateEvent(NULL, TRUE, FALSE, NULL);
+ ctrl_c_event = CreateEvent(NULL, FALSE, FALSE, NULL);
+ _beginthread(stdin_read_thread, 0, NULL);
+}
+
+/*
+ * This function uses to WaitForMultipleObjects to wait for both
+ * stdin and socket reading or writing.
+ * Stdin is treated special in WIN32. Waiting for stdin is done
+ * via a bounce_full event which is set in the stdin thread.
+ * Execute command file reading is done via handle.
+ * WaitForMultipleObjects will only respond with one object,
+ * so an additonal select is also done to determine
+ * which individual events are active.
+ */
+static int
+w32_select(int nfds, fd_set *rdfd, fd_set *wrfd, fd_set *errfd, struct timeval* time)
+{
+ HANDLE handles[3];
+ SOCKET sock;
+ int inp, sockfd, result, s_result, num_handles;
+ struct timeval tv_time = {0, 0};
+ fd_set rdsock, wrsock;
+
+ switch (rdfd->fd_count) {
+ case 1:
+ inp = -1;
+ sockfd = rdfd->fd_array[0];
+ break;
+ case 2:
+ inp = rdfd->fd_array[0];
+ sockfd = rdfd->fd_array[1];
+ break;
+ default:
+ assert(0);
+ }
+ sock = w32_fd2socket(sockfd);
+
+ assert(wrfd->fd_count == 0
+ || (wrfd->fd_count == 1 && wrfd->fd_array[0] == (SOCKET)sockfd));
+ assert(inp < 0 || inp == input_fd);
+
+ num_handles = 0;
+ handles[num_handles++] = ctrl_c_event;
+ if (inp >= 0)
+ handles[num_handles++]
+ = inp ? (HANDLE)_get_osfhandle(inp) : bounce_full;
+ /* always wait on the socket */
+ handles[num_handles++] = WSACreateEvent();
+
+ if (wrfd->fd_count > 0)
+ WSAEventSelect(sock, handles[num_handles - 1],
+ FD_READ | FD_WRITE | FD_CLOSE);
+ else
+ WSAEventSelect(sock, handles[num_handles - 1],
+ FD_READ | FD_CLOSE);
+
+ result = WaitForMultipleObjects(num_handles, handles, 0, INFINITE);
+ if (result < 0) {
+ errno = GetLastError();
+ WSACloseEvent(handles[num_handles - 1]);
+ return -1;
+ }
+ WSACloseEvent(handles[num_handles - 1]);
+
+ if (result == WAIT_OBJECT_0) {
+ errno = EINTR;
+ return -1;
+ }
+
+ FD_ZERO(&rdsock);
+ FD_ZERO(&wrsock);
+ FD_SET(sock, &rdsock);
+ if (wrfd->fd_count)
+ FD_SET(sock, &wrsock);
+ s_result = select(sock + 1, &rdsock, &wrsock, NULL, &tv_time);
+
+ if (s_result < 0) {
+ w32_set_winsock_errno();
+ return s_result;
+ }
+
+ if (!FD_ISSET(sock, &rdsock))
+ FD_CLR((SOCKET)sockfd, rdfd);
+ if (!FD_ISSET(sock, &wrsock))
+ FD_CLR((SOCKET)sockfd, wrfd);
+ if (inp >= 0 && result == WAIT_OBJECT_0 + 1)
+ s_result++;
+ else
+ FD_CLR((SOCKET)inp, rdfd);
+
+ return s_result;
+}
+
+/*
+ * Read input from the user either stdin or from file.
+ * For stdin, read from bounce_buf which filled by the stdin thread
+ * otherwise use the regular ring_from_file.
+ */
+static int
+w32_ring_from_file_or_bounce_buf(struct ring *r, int fd)
+{
+ int i, res;
+
+ if (fd)
+ return ring_from_file(r, fd);
+
+ if (bounce_status < 0) {
+ errno = bounce_error;
+ res = bounce_status;
+ } else {
+ for (i = 0; i < bounce_status; i++) {
+ if (ring_putc(r, bounce_buf[i]) == EOF) {
+ /* more work to do, hold on to bounce_buf */
+ memmove(bounce_buf, bounce_buf + i, bounce_status - i);
+ bounce_status -= i;
+ return i;
+ }
+ }
+ res = i;
+ }
+
+ ResetEvent(bounce_full);
+ SetEvent(bounce_empty);
+ return res;
+}
+#define ring_from_file w32_ring_from_file_or_bounce_buf
+#define select(nfds, rd, wr, error, time) \
+ w32_select((nfds), (rd), (wr), (error), (time))
+#define sigemptyset(mask) ((void)0)
+#else
+#define sysdep_stdin_init() ((void)0)
+#endif
+
#define EOF_COOKIE "ctld\n"
-#define INTR_COOKIE "\naborted\n"
+#define INTR_COOKIE "aborted\n"
int input_fd;
int send_eof; /* need to send EOF_COOKIE */
char buf[4096];
ssize_t n;
int i, ch, len;
- char *line, *end;
+ char *line;
n = read(sock, buf, sizeof(buf));
if (n < 0)
lbuf_init(&lbuf);
break;
}
- if (ch != ' ') {
- lbuf_putc(&lbuf, ch);
+ lbuf_putc(&lbuf, ch);
+ if (ch != ' ')
break;
- }
line = lbuf_line(&lbuf);
- id = strtol(line, &end, 16);
- if (end == line || *end) {
- /* FIXME gripe bad id */
- id = -1;
- }
+ id = parseid(line);
lbuf_init(&lbuf);
switch (id) {
for (i = -n; i < 0; i++) {
ch = ring_peek(inbuf, i);
assert(ch != EOF);
- if (lbuf_putc(&cmdbuf, ch)) {
+ if (ch != '\r' && lbuf_putc(&cmdbuf, ch)) {
line = lbuf_line(&cmdbuf);
if (auxfp)
fputs(line, auxfp);
intr(int sig)
{
send_intr = 1;
-#ifdef _WIN32
- signal(SIGINT, intr);
-#endif
}
/*
struct sigaction sa;
struct ring inbuf; /* input buffer, draining to SOCK */
int eof_fd0; /* read fd 0 hit EOF? */
+ int input_eol; /* input ends with '\n'? */
fd_set rdfd, wrfd;
int n;
sa.sa_flags = 0;
+ sigemptyset(&sa.sa_mask);
sa.sa_handler = intr;
sigaction(SIGINT, &sa, NULL);
sa.sa_handler = SIG_IGN;
sigaction(SIGPIPE, &sa, NULL);
ring_init(&inbuf);
- eof_fd0 = send_eof = send_intr = 0;
+ eof_fd0 = input_eol = send_eof = send_intr = 0;
input_fd = 0;
+ sysdep_stdin_init();
for (;;) {
FD_ZERO(&rdfd);
/*
* Want to read player input only when we don't need to send
- * cookies, and we haven't hit EOF on fd 0, and INBUF can
- * accept some.
+ * cookies, and INPUT_FD is still open, and INBUF can accept
+ * some.
*/
- if (!send_intr && !send_eof && !eof_fd0 && ring_space(&inbuf))
+ if (!send_intr && !send_eof && input_fd >= 0 && ring_space(&inbuf))
FD_SET(input_fd, &rdfd);
/* Want to send player input only when we have something */
if (send_intr || send_eof || ring_len(&inbuf))
}
}
- if (send_eof
+ if ((send_eof || send_intr) && !input_eol
+ && ring_putc(&inbuf, '\n') != EOF)
+ input_eol = 1;
+ if (send_eof && input_eol
&& ring_putm(&inbuf, EOF_COOKIE, sizeof(EOF_COOKIE) - 1) >= 0)
send_eof--;
- if (send_intr
- && ring_putm(&inbuf, INTR_COOKIE, sizeof(INTR_COOKIE) - 1) >= 0)
+ if (send_intr && input_eol
+ && ring_putm(&inbuf, INTR_COOKIE, sizeof(INTR_COOKIE) - 1) >= 0) {
send_intr = 0;
+ if (input_fd) {
+ /* execute aborted, switch back to fd 0 */
+ close(input_fd);
+ input_fd = eof_fd0 ? -1 : 0;
+ }
+ }
if (n < 0)
continue;
/* read player input */
- if (FD_ISSET(input_fd, &rdfd)) {
+ if (input_fd >= 0 && FD_ISSET(input_fd, &rdfd)) {
n = recv_input(input_fd, &inbuf);
if (n < 0) {
perror("read stdin"); /* FIXME stdin misleading, could be execing */
if (input_fd) {
/* execute done, switch back to fd 0 */
close(input_fd);
- input_fd = 0;
+ input_fd = eof_fd0 ? -1 : 0;
} else {
/* stop reading input, drain socket ring buffers */
eof_fd0 = 1;
+ input_fd = -1;
sa.sa_handler = SIG_DFL;
sigaction(SIGINT, &sa, NULL);
}
- }
+ } else
+ input_eol = ring_peek(&inbuf, -1) == '\n';
}
/* send it to the server */
projects / empserver / blobdiff