int main(int argc, char **argv)
{
int fd;
char ch;
ssize_t ret_n;
if (argc != 4) {
while ((ch = getchar()) != EOF)
putchar(toupper(ch));
return 0;
}
if ((fd = open(argv[2], atoi(argv[3]))) < 0) {
perror("open file");
exit(EXIT_FAILURE);
}
if ((ret_n = send_back(atoi(argv[1]), "", 1, fd)) < 0) {
perror("send_back");
exit(EXIT_FAILURE);
}
return 0;
}
/** SIGCHLD handler **/
void handler(int signum, siginfo_t *info, void *context) {
int cpid, status;
cpid = info->si_pid; // sending pid
//printf("Got a SIGCHLD from %d!\n", cpid);
// loop to catch simultaneous SIGCHLDs
while( (cpid = waitpid(-1, &status, WNOHANG | WUNTRACED | WCONTINUED)) > 0 ) {
//printf("HANDLER Got %d from waitpid\n", cpid);
job *j = get_job(job_list, cpid);
if(j == NULL) {
printf("Error: get_job returned null\n");
_exit(EXIT_FAILURE);
}
if(WIFEXITED(status)) { // completed
if( set_complete(j, cpid) == -1 ) {
printf("HANDLER set_complete went awry!\n");
_exit(EXIT_FAILURE);
}
}
else if(WIFSIGNALED(status)) { // terminated
set_complete(j, cpid);
printf("\n");
//printf("TERMINATED: %d\n", WTERMSIG(status));
}
else if(WIFSTOPPED(status)) { // stopped
j->running = 0;
if(j->fg) {
send_back(job_list, j->pgid);
printf("\nStopped: %s\n", j->rawcmd);
} else {
// queue stopped message
message *m = malloc(sizeof(message));
copy_to_buf(j->rawcmd, m->msg);
m->status = 0;
push(msg_q, PROCESS, (void *)m);
}
}
else if(WIFCONTINUED(status)) { // continued
j->running = 1;
//printf("CONTINUED\n");
}
if(j->complete) {
j->running = 0;
if(!j->fg) {
// queue finished message
message *m = malloc(sizeof(message));
copy_to_buf(j->rawcmd, m->msg);
m->status = 1;
push(msg_q, PROCESS, (void *)m);
free_job(del_job(job_list, j->pgid));
}
}
}
//printf("HANDLER Done with waitpid loop\n");
}
machine_t::machine_t(const Timed *daemon) : timed(daemon)
{
log_debug() ;
// T = transition state
// IO = waiting for i/o state
// G = gate state
// C = concentrating gate state
// F = filtering state
// A = actions allowed
// -->NEW loaded as new
// -->DUE loaded as due
abstract_state_t *S[] =
{
state_start = new state_start_t(this), // T
state_epoch = new state_epoch_t(this), // T
state_waiting = new state_waiting_t(this), // IO G
state_new = new state_new_t(this), // T
state_scheduler = new state_scheduler_t(this), // T
state_qentry = new state_qentry_t(this), // T
state_flt_conn = new state_flt_conn_t(this), // IO G F -->NEW
state_flt_alrm = new state_flt_alrm_t(this), // IO G F -->NEW
state_flt_user = new state_flt_user_t(this), // IO G F -->NEW
state_queued = new state_queued_t(this), // IO A -->NEW
state_due = new state_due_t(this), // T
state_missed = new state_missed_t(this), // T A
state_skipped = new state_skipped_t(this), // T
state_armed = new state_armed_t(this), // IO G
state_triggered = new state_triggered_t(this), // T A
state_dlg_wait = new state_dlg_wait_t(this), // IO G -->DUE
state_dlg_cntr = new state_dlg_cntr_t(this), // IO C -->DUE
state_dlg_requ = new state_dlg_requ_t(this), // IO G -->DUE
state_dlg_user = new state_dlg_user_t(this), // IO G -->DUE
state_dlg_resp = new state_dlg_resp_t(this), // T
/* state_buttons: below */ // T A
state_snoozed = new state_snoozed_t(this), // T
state_recurred = new state_recurred_t(this), // T
state_served = new state_served_t(this), // T
state_tranquil = new state_tranquil_t(this), // IO A -->DUE
state_removed = new state_removed_t(this), // T
state_aborted = new state_aborted_t(this), // T
state_finalized = new state_finalized_t(this), // T A
NULL
} ;
log_debug() ;
for(int i=0; S[i]; ++i)
states.insert(S[i]) ;
log_debug() ;
for(int i=0; i<=Maemo::Timed::Number_of_Sys_Buttons; ++i)
states.insert(buttons[-i] = new state_button_t(this, -i)) ;
log_debug() ;
for(int i=1; i<=Maemo::Timed::Max_Number_of_App_Buttons; ++i)
states.insert(buttons[i] = new state_button_t(this, i)) ;
for (set<abstract_state_t*>::iterator it=states.begin(); it!=states.end(); ++it)
(*it)->resolve_names() ;
log_debug() ;
state_triggered->set_action_mask(ActionFlags::State_Triggered) ;
state_queued->set_action_mask(ActionFlags::State_Queued) ;
state_missed->set_action_mask(ActionFlags::State_Missed) ;
state_tranquil->set_action_mask(ActionFlags::State_Tranquil) ;
state_finalized->set_action_mask(ActionFlags::State_Finalized) ;
state_due->set_action_mask(ActionFlags::State_Due) ;
state_snoozed->set_action_mask(ActionFlags::State_Snoozed) ;
state_served->set_action_mask(ActionFlags::State_Served) ;
state_aborted->set_action_mask(ActionFlags::State_Aborted) ;
// states_failed->set_action_mask(ActionFlags::State_Failed) ;
#if 0
log_debug() ;
io_state *queued = dynamic_cast<io_state*> (states["QUEUED"]) ;
log_assert(queued!=NULL) ;
gate_state *armed = dynamic_cast<gate_state*> (states["ARMED"]) ;
log_assert(armed!=NULL) ;
armed->open() ; // will be closed in some very special situations
log_debug() ;
gate_state *dlg_wait = dynamic_cast<gate_state*> (states["DLG_WAIT"]) ;
gate_state *dlg_requ = dynamic_cast<gate_state*> (states["DLG_REQU"]) ;
gate_state *dlg_user = dynamic_cast<gate_state*> (states["DLG_USER"]) ;
gate_state *dlg_cntr = dynamic_cast<gate_state*> (states["DLG_CNTR"]) ;
log_assert(dlg_wait!=NULL) ;
log_assert(dlg_requ!=NULL) ;
log_assert(dlg_user!=NULL) ;
log_assert(dlg_cntr!=NULL) ;
#endif
state_armed->open() ;
QObject::connect(state_dlg_wait, SIGNAL(voland_needed()), this, SIGNAL(voland_needed())) ;
QObject::connect(state_dlg_wait, SIGNAL(closed()), state_dlg_requ, SLOT(open())) ;
QObject::connect(state_dlg_wait, SIGNAL(closed()), state_dlg_user, SLOT(open())) ;
QObject::connect(state_dlg_requ, SIGNAL(closed()), state_dlg_wait, SLOT(open())) ;
QObject::connect(this, SIGNAL(voland_registered()), state_dlg_requ, SLOT(close())) ;
QObject::connect(this, SIGNAL(voland_registered()), state_dlg_user, SLOT(close())) ;
QObject::connect(this, SIGNAL(voland_unregistered()), state_dlg_wait, SLOT(close())) ;
QObject::connect(this, SIGNAL(voland_unregistered()), state_dlg_cntr, SLOT(send_back())) ;
QObject::connect(state_queued, SIGNAL(sleep()), state_dlg_cntr, SLOT(open()), Qt::QueuedConnection) ;
QObject::connect(state_dlg_wait, SIGNAL(opened()), state_dlg_cntr, SLOT(open()), Qt::QueuedConnection) ;
#if 0
log_debug() ;
filter_state *flt_conn = dynamic_cast<filter_state*> (states["FLT_CONN"]) ;
filter_state *flt_alrm = dynamic_cast<filter_state*> (states["FLT_ALRM"]) ;
filter_state *flt_user = dynamic_cast<filter_state*> (states["FLT_USER"]) ;
log_assert(flt_conn) ;
log_assert(flt_alrm) ;
log_assert(flt_user) ;
#endif
QObject::connect(state_flt_conn, SIGNAL(closed(abstract_filter_state_t*)), state_queued, SLOT(filter_closed(abstract_filter_state_t*))) ;
QObject::connect(state_flt_alrm, SIGNAL(closed(abstract_filter_state_t*)), state_queued, SLOT(filter_closed(abstract_filter_state_t*))) ;
QObject::connect(state_flt_user, SIGNAL(closed(abstract_filter_state_t*)), state_queued, SLOT(filter_closed(abstract_filter_state_t*))) ;
log_debug() ;
QObject::connect(this, SIGNAL(engine_pause(int)), state_queued, SLOT(engine_pause(int))) ;
log_debug() ;
initial_pause = new pause_t(this) ;
log_debug() ;
cluster_queue = new cluster_queue_t(this) ;
log_debug() ;
clusters[cluster_queue->bit] = cluster_queue ;
log_debug() ;
cluster_dialog = new cluster_dialog_t(this) ;
log_debug() ;
clusters[cluster_dialog->bit] = cluster_dialog ;
log_debug() ;
signalled_bootup = -1 ; // no signal sent yet
signalled_non_boot_event = -1;
log_debug() ;
log_debug("machine->settings->alarms_are_enabled=%d", timed->settings->alarms_are_enabled) ;
log_debug() ;
alarm_gate(timed->settings->alarms_are_enabled) ;
log_debug() ;
transition_start_time = ticker_t(0) ;
transition_time_adjustment.set(0) ;
log_debug() ;
next_cookie = 1 ;
log_debug() ;
context_changed = false ;
log_debug("last line") ;
}
int main()
{
struct pollfd fds[3];
fds[0].fd = -1;
fds[1].fd = -1;
fds[2].fd = -1;
int srv_sock = Socket(AF_INET, SOCK_STREAM, 0);
fds[0].fd = srv_sock;
fds[0].events = POLLIN;
struct sockaddr_in srv_addr;
mkaddr(&srv_addr, "127.0.0.1", "2345");
Bind(srv_sock, (struct sockaddr *)&srv_addr, sizeof(srv_addr));
Listen(srv_sock, 5);
int ret = 0;
char buf[128];
int i = 1;
while (1) {
printf("debug: going to poll().... ");
fflush(stdout);
ret = Poll(fds, 3, -1);
printf("%d\n", ret);
int j = 0;
for (j = 0; j < 3; j++)
{
if (fds[j].fd == -1)
continue;
if ((fds[j].fd == srv_sock) && ((fds[j].revents & POLLIN) == POLLIN)) {
int cli_sock = Accept(srv_sock, NULL, NULL);
fds[i].fd = cli_sock;
fds[i].events = POLLIN;
i++;
printf("debug: create a new connection\n");
if (--ret == 0)
break;
}
if ((fds[j].revents & POLLIN) == POLLIN) {
printf("debug: is on the cli_sock %d\n", fds[j].fd);
int len = recv_all(fds[j].fd, buf);
if (len == -1) {
close(fds[j].fd);
fds[j].fd == -1;
bzero(&fds[j], sizeof(struct pollfd));
printf("here\n");
break;
}
send_back(fds[j].fd, buf, len);
printf("debug: send back %s\n", buf);
}
if ((fds[j].revents & POLLHUP) == POLLHUP) {
close(fds[j].fd);
printf("debug POLLUP\n");
}
}
}
close(srv_sock);
return 0;
}
