void signal_handler(void)
{
DEBUG_MSG("signal_handler activated");
#ifdef SIGSEGV
signal_handle(SIGSEGV, signal_SEGV, 0);
#endif
#ifdef SIGBUS
signal_handle(SIGBUS, signal_SEGV, 0);
#endif
#ifdef SIGINT
signal_handle(SIGINT, signal_TERM, 0);
#endif
#ifdef SIGTERM
signal_handle(SIGTERM, signal_TERM, 0);
#endif
#ifdef SIGCHLD
signal_handle(SIGCHLD, signal_CHLD, 0);
#endif
#ifdef SIGPIPE
/* needed by sslwrap */
signal_handle(SIGPIPE, SIG_IGN, 0);
#endif
#ifdef SIGALRM
/* needed by solaris */
signal_handle(SIGALRM, SIG_IGN, 0);
#endif
#ifdef SIGTTOU
/* allow the user to type "ettercap .. &" */
signal_handle(SIGTTOU, SIG_IGN, 0);
#endif
#ifdef SIGTTIN
signal_handle(SIGTTIN, SIG_IGN, 0);
#endif
}
void event_remove(const event_t &criterion) {
event_list_t new_list;
if (debug_level >= 3) {
wcstring desc = event_desc_compact(criterion);
debug(3, "unregister: %ls\n", desc.c_str());
}
// Because of concurrency issues (env_remove could remove an event that is currently being
// executed), env_remove does not actually free any events - instead it simply moves all events
// that should be removed from the event list to the killme list, and the ones that shouldn't be
// killed to new_list, and then drops the empty events-list.
if (s_event_handlers.empty()) return;
for (size_t i = 0; i < s_event_handlers.size(); i++) {
event_t *n = s_event_handlers.at(i);
if (event_match(criterion, *n)) {
killme.push_back(n);
// If this event was a signal handler and no other handler handles the specified signal
// type, do not handle that type of signal any more.
if (n->type == EVENT_SIGNAL) {
event_t e = event_t::signal_event(n->param1.signal);
if (event_get(e, 0) == 1) {
signal_handle(e.param1.signal, 0);
set_signal_observed(e.param1.signal, 0);
}
}
} else {
new_list.push_back(n);
}
}
s_event_handlers.swap(new_list);
}
void event_remove(event_t *criterion)
{
size_t i;
event_list_t new_list;
CHECK(criterion,);
/*
Because of concurrency issues (env_remove could remove an event
that is currently being executed), env_remove does not actually
free any events - instead it simply moves all events that should
be removed from the event list to the killme list, and the ones
that shouldn't be killed to new_list, and then drops the empty
events-list.
*/
if (events.empty())
return;
for (i=0; i<events.size(); i++)
{
event_t *n = events.at(i);
if (event_match(criterion, n))
{
killme.push_back(n);
/*
If this event was a signal handler and no other handler handles
the specified signal type, do not handle that type of signal any
more.
*/
if (n->type == EVENT_SIGNAL)
{
event_t e = event_t::signal_event(n->param1.signal);
if (event_get(&e, 0) == 1)
{
signal_handle(e.param1.signal, 0);
}
}
}
else
{
new_list.push_back(n);
}
}
signal_block();
events.swap(new_list);
signal_unblock();
}
void event_add_handler(const event_t &event) {
event_t *e;
if (debug_level >= 3) {
wcstring desc = event_desc_compact(event);
debug(3, "register: %ls\n", desc.c_str());
}
e = new event_t(event);
if (e->type == EVENT_SIGNAL) {
signal_handle(e->param1.signal, 1);
set_signal_observed(e->param1.signal, true);
}
s_event_handlers.push_back(e);
}
// Runs the appropriate action for each queued event
void event_process()
{
Event event;
while (kl_shift(Event, event_queue, &event) == 0) {
switch (event.type) {
case kEventSignal:
signal_handle(event);
break;
case kEventJobActivity:
job_handle(event);
break;
default:
abort();
}
}
}
void event_add_handler(const event_t *event)
{
event_t *e;
CHECK(event,);
e = event_copy(event, 0);
if (e->type == EVENT_SIGNAL)
{
signal_handle(e->param1.signal, 1);
}
// Block around updating the events vector
signal_block();
events.push_back(e);
signal_unblock();
}
// Runs the appropriate action for each queued event
void event_process(bool deferred)
{
Event event;
while (kl_shift(Event, get_queue(deferred), &event) == 0) {
switch (event.type) {
case kEventSignal:
signal_handle(event);
break;
case kEventRStreamData:
rstream_read_event(event);
break;
case kEventJobExit:
job_exit_event(event);
break;
default:
abort();
}
}
}
// Runs the appropriate action for each queued event
static void process_all_events()
{
EventNode *next;
Event *event;
while (has_pending_events()) {
next = head->next;
event = head->event;
free(head);
head = next;
switch (event->type) {
case kEventSignal:
signal_handle(event);
break;
default:
abort();
}
}
}
void event_add_handler(const event_t &event)
{
event_t *e;
if (debug_level >= 3)
{
wcstring desc = event_desc_compact(event);
debug(3, "register: %ls\n", desc.c_str());
}
e = new event_t(event);
if (e->type == EVENT_SIGNAL)
{
signal_handle(e->param1.signal, 1);
}
// Block around updating the events vector
signal_block();
events.push_back(e);
signal_unblock();
}
void
ISR_syscall(interrupt_frame frame)
{
UPDATE(&frame);
va_list ap;
syscall_result_t result;
thread_t *thisthr = curthread;
irq_enable();
mem_zero(&result, sizeof(result));
ap = (va_list) (frame.f_esp + 16);
thisthr->thr_flags |= THREAD_SYSCALL;
syscall(thisthr, frame.f_eax, &result, ap);
thisthr->thr_flags &= ~THREAD_SYSCALL;
signal_handle(thisthr);
// result
frame.f_eax = result.result;
frame.f_ecx = result.errno;
}
// Runs the appropriate action for each queued event
bool event_process(bool deferred)
{
bool processed_events = false;
Event event;
while (kl_shift(Event, get_queue(deferred), &event) == 0) {
processed_events = true;
switch (event.type) {
case kEventSignal:
signal_handle(event);
break;
case kEventRStreamData:
rstream_read_event(event);
break;
case kEventJobExit:
job_exit_event(event);
break;
default:
abort();
}
}
return processed_events;
}
static void
sigpipe_ignore()
{
signal_handle(SIGPIPE, SIG_IGN);
}
static void
sigchld_trampoline()
{
signal_handle(SIGCHLD, _trampoline);
}
