void sploit_read_shell(int fd)
{
char buf[512];
size_t n;
if(io_list[fd].status.closed || io_list[fd].status.err)
{
log(sploit_log, L_status, "IRCD died!", buf);
sploit_shutdown();
}
while((n = io_gets(fd, buf, sizeof(buf))) > 0)
{
if(!sploit_success)
{
if(buf[0] != ':')
{
sploit_success = 1;
sploit_sock = fd;
io_register(STDIN_FILENO, IO_CB_READ, sploit_read_stdin);
}
else
{
log(sploit_log, L_status, "Exploitation failed.");
sploit_shutdown();
}
}
buf[n - 1] = '\0';
log(sploit_log, L_status, "%s", buf);
}
}
/*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*/
}
/* -------------------------------------------------------------------------- *
* control fd got readable, handle data *
* -------------------------------------------------------------------------- */
static void control_readable(int fd, void *ptr)
{
char buf[1024];
if(io_list[fd].status.closed || io_list[fd].status.err)
servauth_shutdown();
if(io_list[fd].recvq.lines)
{
while(io_gets(fd, buf, 1024) > 0)
{
if(control_parse(ptr, buf) == -1)
{
servauth_shutdown();
return;
}
}
}
return;
}
void sploit_read_irc(int fd)
{
char buf[512];
size_t n;
while(io_list[fd].recvq.lines)
{
if((n = io_gets(fd, buf, sizeof(buf))) > 0)
{
if(!str_ncmp(buf, "PING", 4))
{
buf[1] = 'O';
io_write(fd, buf, n);
}
else if(!str_ncmp(buf, ":sploit", 7))
{
log(sploit_log, L_status, "Logged in!", buf);
sploit_send(fd);
}
}
}
}
/*
* 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;
}
struct fsm *io_net_read(struct io_buf_handle *iobh, char **net_name) {
char buf[READ_BUF_SIZE];
struct fsm *net;
struct fsm_state *fsm;
char *new_symbol;
int i, items, new_symbol_number, laststate, lineint[5], *cm;
int extras;
char last_final = '1';
if (io_gets(iobh, buf) == 0) {
return NULL;
}
net = fsm_create("");
if (strcmp(buf, "##foma-net 1.0##") != 0) {
fsm_destroy(net);
perror("File format error foma!\n");
return NULL;
}
io_gets(iobh, buf);
if (strcmp(buf, "##props##") != 0) {
perror("File format error props!\n");
fsm_destroy(net);
return NULL;
}
/* Properties */
io_gets(iobh, buf);
extras = 0;
sscanf(buf, "%i %i %i %i %i %lld %i %i %i %i %i %i %s", &net->arity, &net->arccount, &net->statecount, &net->linecount, &net->finalcount, &net->pathcount, &net->is_deterministic, &net->is_pruned, &net->is_minimized, &net->is_epsilon_free, &net->is_loop_free, &extras, buf);
strcpy(net->name, buf);
*net_name = xxstrdup(buf);
io_gets(iobh, buf);
net->is_completed = (extras & 3);
net->arcs_sorted_in = (extras & 12) >> 2;
net->arcs_sorted_out = (extras & 48) >> 4;
/* Sigma */
while (strcmp(buf, "##sigma##") != 0) { /* Loop until we encounter ##sigma## */
if (buf[0] == '\0') {
printf("File format error at sigma definition!\n");
fsm_destroy(net);
return NULL;
}
io_gets(iobh, buf);
}
for (;;) {
io_gets(iobh, buf);
if (buf[0] == '#') break;
if (buf[0] == '\0') continue;
new_symbol = strstr(buf, " ");
new_symbol[0] = '\0';
new_symbol++;
if (new_symbol[0] == '\0') {
sscanf(buf,"%i", &new_symbol_number);
sigma_add_number(net->sigma, "\n", new_symbol_number);
} else {
sscanf(buf,"%i", &new_symbol_number);
sigma_add_number(net->sigma, new_symbol, new_symbol_number);
}
}
/* States */
if (strcmp(buf, "##states##") != 0) {
printf("File format error!\n");
return NULL;
}
net->states = xxmalloc(net->linecount*sizeof(struct fsm_state));
fsm = net->states;
laststate = -1;
for (i=0; ;i++) {
io_gets(iobh, buf);
if (buf[0] == '#') break;
/* scanf is just too slow here */
//items = sscanf(buf, "%i %i %i %i %i",&lineint[0], &lineint[1], &lineint[2], &lineint[3], &lineint[4]);
items = explode_line(buf, &lineint[0]);
switch (items) {
case 2:
(fsm+i)->state_no = laststate;
(fsm+i)->in = lineint[0];
(fsm+i)->out = lineint[0];
(fsm+i)->target = lineint[1];
(fsm+i)->final_state = last_final;
break;
case 3:
(fsm+i)->state_no = laststate;
(fsm+i)->in = lineint[0];
(fsm+i)->out = lineint[1];
(fsm+i)->target = lineint[2];
(fsm+i)->final_state = last_final;
break;
case 4:
(fsm+i)->state_no = lineint[0];
(fsm+i)->in = lineint[1];
(fsm+i)->out = lineint[1];
(fsm+i)->target = lineint[2];
(fsm+i)->final_state = lineint[3];
laststate = lineint[0];
last_final = lineint[3];
break;
case 5:
(fsm+i)->state_no = lineint[0];
(fsm+i)->in = lineint[1];
(fsm+i)->out = lineint[2];
(fsm+i)->target = lineint[3];
(fsm+i)->final_state = lineint[4];
laststate = lineint[0];
last_final = lineint[4];
break;
default:
printf("File format error\n");
return NULL;
}
if (laststate > 0) {
(fsm+i)->start_state = 0;
} else if (laststate == -1) {
(fsm+i)->start_state = -1;
} else {
(fsm+i)->start_state = 1;
}
}
if (strcmp(buf, "##cmatrix##") == 0) {
cmatrix_init(net);
cm = net->medlookup->confusion_matrix;
for (;;) {
io_gets(iobh, buf);
if (buf[0] == '#') break;
sscanf(buf,"%i", &i);
*cm = i;
cm++;
}
}
if (strcmp(buf, "##end##") != 0) {
printf("File format error!\n");
return NULL;
}
return(net);
}
