static int play_cmd(void) { struct player *other; natid cnum; struct natstr *natp; char **ap; char buf[128]; ap = player->argp; if (*++ap) { strncpy(player->userid, *ap, sizeof(player->userid) - 1); player->userid[sizeof(player->userid) - 1] = '\0'; player->authenticated = 0; } if (*++ap) { if (natbyname(*ap, &cnum) < 0) { pr_id(player, C_CMDERR, "country %s does not exist\n", *ap); return RET_FAIL; } } if (*++ap) { if (!natpass(cnum, *ap)) { pr_id(player, C_CMDERR, "password bad, logging entry\n"); logerror("%s tried country #%d with %s", praddr(player), cnum, *ap); return RET_FAIL; } player->cnum = cnum; player->authenticated = 1; } if (!may_play()) return RET_FAIL; other = getplayer(player->cnum); if (other) { natp = getnatp(player->cnum); if (natp->nat_stat != STAT_VIS) { pr_id(player, C_EXIT, "country in use by %s\n", praddr(other)); } else { pr_id(player, C_EXIT, "country in use\n"); } return RET_FAIL; } snprintf(buf, sizeof(buf), "Play#%d", player->cnum); logerror("%s logged in as country #%d", praddr(player), player->cnum); journal_login(); empth_set_name(empth_self(), buf); pr_id(player, C_INIT, "%d\n", CLIENTPROTO); empth_rwlock_rdlock(shutdown_lock); player->state = PS_PLAYING; player_main(player); journal_logout(); logerror("%s logged out, country #%d", praddr(player), player->cnum); if (!io_eof(player->iop) && !io_error(player->iop)) io_set_eof(player->iop); return RET_OK; }
static int kill_cmd(void) { struct player *other; if (!may_play()) return RET_FAIL; other = getplayer(player->cnum); if (!other) { pr_id(player, C_EXIT, "country not in use\n"); return RET_FAIL; } logerror("%s killed country #%d", praddr(player), player->cnum); pr_flash(other, "Disconnected by %s\n", praddr(player)); io_set_eof(other->iop); other->aborted = 1; other->may_sleep = PLAYER_SLEEP_NEVER; empth_wakeup(other->proc); pr_id(player, C_EXIT, "terminated %s's connection\n", praddr(other)); return RET_OK; }
/* * Receive a line of input from the current player. * If the player's aborted flag is set, return -1 without receiving * input. * Else receive one line and store it in CMD[SIZE]. * This may block for input, yielding the processor. Flush buffered * output when blocking, to make sure player sees the prompt. * If the player's connection has the I/O error or EOF indicator set, * or the line is "aborted", set the player's aborted flag and return * -1. * If we block and time out, set the EOF indicator on the player's * connection, set the player's aborted flag, and return -1. * If the line is "ctld", set the player's eof and aborted flag and * return -1. * Else return the length of the line. * Design bug: there is no way to indicate truncation of a long line. */ int recvclient(char *cmd, int size) { int count, res; time_t deadline; count = -1; while (!player->aborted) { /* Try to get a line of input */ count = io_gets(player->iop, cmd, size); if (count >= 0) { /* got it */ if (strcmp(cmd, "ctld") == 0) player->aborted = player->got_ctld = 1; if (strcmp(cmd, "aborted") == 0) player->aborted = 1; journal_input(cmd); break; } /* * Flush all queued output before potentially sleeping in * io_input(), to make sure player sees the prompt. */ deadline = player_io_deadline(player, 0); while (io_output(player->iop, deadline) > 0) ; /* * Try to receive some input. Need to recompute deadline; * command abortion during io_output() might have changed it. */ deadline = player_io_deadline(player, 0); res = io_input(player->iop, deadline); if (res > 0) ; else if (res < 0) player->aborted = 1; else if (io_eof(player->iop)) player->aborted = 1; else if (!player->aborted) { pr_flash(player, "idle connection terminated\n"); io_set_eof(player->iop); player->aborted = 1; } } if (player->aborted) { player->recvfail++; if (player->recvfail > 255) { /* * Looks like the thread is stuck in a loop that fails to * check errors; oops once, then slow it down drastically. */ CANT_HAPPEN(player->recvfail == 256); empth_sleep(time(NULL) + 60); } return -1; } player->recvfail = 0; return count; }
static int quit_cmd(void) { io_set_eof(player->iop); return RET_OK; }