/*
* Send C_FLASH text to everyone.
* Format text to send using printf-style @format and optional
* arguments. It is assumed to be plain ASCII.
* Prefix text it with a header suitable for broadcast from deity.
* Initiate an output queue flush, but do not wait for it to complete.
*/
void
pr_wall(char *format, ...)
{
time_t now;
struct tm *tm;
char buf[4096]; /* UTF-8 */
int n;
struct player *p;
va_list ap;
time(&now);
tm = localtime(&now);
n = sprintf(buf, "BROADCAST from %s @ %02d:%02d: ",
getnatp(0)->nat_cnam, tm->tm_hour, tm->tm_min);
va_start(ap, format);
(void)vsprintf(buf + n, format, ap);
va_end(ap);
for (p = player_next(NULL); p; p = player_next(p)) {
if (p->state != PS_PLAYING)
continue;
pr_player(p, C_FLASH, buf);
io_output(p->iop, 0);
}
}
/*ARGSUSED*/
void
player_login(void *ud)
{
time_t deadline;
char buf[128];
char space[128];
int res, ac, cmd, prev_state;
player->proc = empth_self();
pr_id(player, C_INIT, "Empire server ready\n");
for (;;) {
deadline = player_io_deadline(player, 0);
if (io_outputwaiting(player->iop)) {
if (io_output(player->iop, deadline) <= 0)
break;
continue;
}
if (io_gets(player->iop, buf, sizeof(buf)) < 0) {
res = io_input(player->iop, deadline);
if (res <= 0)
break;
continue;
}
journal_input(buf);
ac = parse(buf, space, player->argp, NULL, NULL, NULL);
if (ac <= 0) {
pr_id(player, C_BADCMD, "Can't parse command\n");
continue;
}
cmd = comtch(player->argp[0], login_coms, 0);
if (cmd < 0) {
pr_id(player, C_BADCMD, "Command %s not found\n", player->argp[0]);
continue;
}
switch (login_coms[cmd].c_addr()) {
case RET_OK:
break;
case RET_FAIL:
break;
case RET_SYN:
pr_id(player, C_BADCMD, "Usage %s\n", login_coms[cmd].c_form);
break;
default:
break;
}
}
prev_state = player->state;
player->state = PS_SHUTDOWN;
if (prev_state == PS_PLAYING)
empth_rwlock_unlock(shutdown_lock);
pr_id(player, C_EXIT, "so long...\n");
player_delete(player);
empth_exit();
/*NOTREACHED*/
}
void io_test(void * arg) {
AsyncData* d = (AsyncData*) arg;
pthread_t main_thread = pthread_self();
printf("the main_thread2222222 === %p \n", &main_thread);
printf("the key : %d", d->key);
io_output(&d->key);
free(d);
sleep(2);
}
int io (
struct chip8 *chip8
) {
io_input (chip8);
io_output(chip8);
//Pause
SDL_Delay(1000/FREQ);
return 0;
}
/*
* Send C_INFORM text to @pl.
* Format text to send using printf-style @format and optional
* arguments. It is assumed to be plain ASCII.
* Initiate an output queue flush, but do not wait for it to complete.
*/
void
pr_inform(struct player *pl, char *format, ...)
{
char buf[4096];
va_list ap;
if (pl->state != PS_PLAYING)
return;
va_start(ap, format);
(void)vsprintf(buf, format, ap);
va_end(ap);
pr_player(pl, C_INFORM, buf);
io_output(pl->iop, 0);
}
/*
* Send C_FLASH text to @pl.
* Format text to send using printf-style @format and optional
* arguments. It is assumed to be UTF-8.
* Initiate an output queue flush, but do not wait for it to complete.
*/
void
pr_flash(struct player *pl, char *format, ...)
{
char buf[4096]; /* UTF-8 */
va_list ap;
if (pl->state != PS_PLAYING)
return;
va_start(ap, format);
(void)vsprintf(buf, format, ap);
va_end(ap);
if (!(pl->flags & PF_UTF8))
copy_utf8_to_ascii_no_funny(buf, buf);
pr_player(pl, C_FLASH, buf);
io_output(pl->iop, 0);
}
static int tcp_server_client_output(object_t parent, const char *buffer, int size)
{
return io_output(parent, buffer, size);
}
/*
* 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;
}
