/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License, Version 1.0 only * (the "License"). You may not use this file except in compliance * with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2005 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ #include <stdlib.h> #include <errno.h> #include <sys/types.h> #include <sys/stropts.h> /* INFTIM */ #include <libinetutil.h> #include "libinetutil_impl.h" static int grow_fds(iu_eh_t *, int); /* * signal_to_eh[] is pretty much useless, since the event handler is * really a singleton (we pass iu_eh_t *'s around to maintain an * abstraction, not to allow multiple event handlers to exist). we * need some way to get back our event handler in post_signal(), * and since the signal model is too lame to provide opaque pointers, * we have to resort to global variables. */ static iu_eh_t *signal_to_eh[NSIG]; /* * iu_eh_create(): creates, initializes, and returns an event handler for use * * input: void * output: iu_eh_t *: the new event handler */ iu_eh_t * iu_eh_create(void) { iu_eh_t *eh = malloc(sizeof (iu_eh_t)); int sig; if (eh == NULL) return (NULL); eh->iueh_pollfds = NULL; eh->iueh_events = NULL; eh->iueh_shutdown = NULL; eh->iueh_num_fds = 0; eh->iueh_stop = B_FALSE; eh->iueh_reason = 0; eh->iueh_shutdown_arg = NULL; (void) sigemptyset(&eh->iueh_sig_regset); for (sig = 0; sig < NSIG; sig++) { eh->iueh_sig_info[sig].iues_pending = B_FALSE; eh->iueh_sig_info[sig].iues_handler = NULL; eh->iueh_sig_info[sig].iues_data = NULL; } return (eh); } /* * iu_eh_destroy(): destroys an existing event handler * * input: iu_eh_t *: the event handler to destroy * output: void * notes: it is assumed all events related to this eh have been unregistered * prior to calling iu_eh_destroy() */ void iu_eh_destroy(iu_eh_t *eh) { int sig; for (sig = 0; sig < NSIG; sig++) if (signal_to_eh[sig] == eh) (void) iu_eh_unregister_signal(eh, sig, NULL); free(eh->iueh_pollfds); free(eh->iueh_events); free(eh); } /* * iu_stop_handling_events(): informs the event handler to stop handling events * * input: iu_eh_t *: the event handler to stop. * unsigned int: the (user-defined) reason why * iu_eh_shutdown_t *: the shutdown callback. if it is NULL, * the event handler will stop right away; * otherwise, the event handler will not * stop until the callback returns B_TRUE * void *: data for the shutdown callback. it may be NULL * output: void * notes: the event handler in question must be in iu_handle_events() */ void iu_stop_handling_events(iu_eh_t *eh, unsigned int reason, iu_eh_shutdown_t *shutdown, void *arg) { eh->iueh_stop = B_TRUE; eh->iueh_reason = reason; eh->iueh_shutdown = shutdown; eh->iueh_shutdown_arg = arg; } /* * grow_fds(): grows the internal file descriptor set used by the event * handler * * input: iu_eh_t *: the event handler whose descriptor set needs to be grown * int: the new total number of descriptors needed in the set * output: int: zero on failure, success otherwise */ static int grow_fds(iu_eh_t *eh, int total_fds) { unsigned int i; struct pollfd *new_pollfds; iu_event_node_t *new_events; if (total_fds <= eh->iueh_num_fds) return (1); new_pollfds = realloc(eh->iueh_pollfds, total_fds * sizeof (struct pollfd)); if (new_pollfds == NULL) return (0); eh->iueh_pollfds = new_pollfds; new_events = realloc(eh->iueh_events, total_fds * sizeof (iu_event_node_t)); if (new_events == NULL) { /* * yow. one realloc failed, but the other succeeded. * we will just leave the descriptor size at the * original size. if the caller tries again, then the * first realloc() will do nothing since the requested * number of descriptors is already allocated. */ return (0); } for (i = eh->iueh_num_fds; i < total_fds; i++) eh->iueh_pollfds[i].fd = -1; eh->iueh_events = new_events; eh->iueh_num_fds = total_fds; return (1); } /* * when increasing the file descriptor set size, how much to increase by: */ #define EH_FD_SLACK 10 /* * iu_register_event(): adds an event to the set managed by an event handler * * input: iu_eh_t *: the event handler to add the event to * int: the descriptor on which to listen for events. must be * a descriptor which has not yet been registered. * short: the events to listen for on that descriptor * iu_eh_callback_t: the callback to execute when the event happens * void *: the argument to pass to the callback function * output: iu_event_id_t: -1 on failure, the new event id otherwise */ iu_event_id_t iu_register_event(iu_eh_t *eh, int fd, short events, iu_eh_callback_t *callback, void *arg) { if (eh->iueh_num_fds <= fd) if (grow_fds(eh, fd + EH_FD_SLACK) == 0) return (-1); /* * the current implementation uses the file descriptor itself * as the iu_event_id_t, since we know the kernel's gonna be * pretty smart about managing file descriptors and we know * that they're per-process unique. however, it does mean * that the same descriptor cannot be registered multiple * times for different callbacks depending on its events. if * this behavior is desired, either use dup(2) to get a unique * descriptor, or demultiplex in the callback function based * on `events'. */ if (eh->iueh_pollfds[fd].fd != -1) return (-1); eh->iueh_pollfds[fd].fd = fd; eh->iueh_pollfds[fd].events = events; eh->iueh_events[fd].iuen_callback = callback; eh->iueh_events[fd].iuen_arg = arg; return (fd); } /* * iu_unregister_event(): removes an event from the set managed by an event * handler * * input: iu_eh_t *: the event handler to remove the event from * iu_event_id_t: the event to remove (from iu_register_event()) * void **: if non-NULL, will be set to point to the argument passed * into iu_register_event() * output: int: zero on failure, success otherwise */ int iu_unregister_event(iu_eh_t *eh, iu_event_id_t event_id, void **arg) { if (event_id < 0 || event_id >= eh->iueh_num_fds || eh->iueh_pollfds[event_id].fd == -1) return (0); /* * fringe condition: in case this event was about to be called * back in iu_handle_events(), zero revents to prevent it. * (having an unregistered event get called back could be * disastrous depending on if `arg' is reference counted). */ eh->iueh_pollfds[event_id].revents = 0; eh->iueh_pollfds[event_id].fd = -1; if (arg != NULL) *arg = eh->iueh_events[event_id].iuen_arg; return (1); } /* * iu_handle_events(): begins handling events on an event handler * * input: iu_eh_t *: the event handler to begin event handling on * tq_t *: a timer queue of timers to process while handling events * (see timer_queue.h for details) * output: int: the reason why we stopped, -1 if due to internal failure */ int iu_handle_events(iu_eh_t *eh, iu_tq_t *tq) { int n_lit, timeout, sig, saved_errno; unsigned int i; sigset_t oset; eh->iueh_stop = B_FALSE; do { timeout = tq ? iu_earliest_timer(tq) : INFTIM; /* * we only unblock registered signals around poll(); this * way other parts of the code don't have to worry about * restarting "non-restartable" system calls and so forth. */ (void) sigprocmask(SIG_UNBLOCK, &eh->iueh_sig_regset, &oset); n_lit = poll(eh->iueh_pollfds, eh->iueh_num_fds, timeout); saved_errno = errno; (void) sigprocmask(SIG_SETMASK, &oset, NULL); switch (n_lit) { case -1: if (saved_errno != EINTR) return (-1); for (sig = 0; sig < NSIG; sig++) { if (eh->iueh_sig_info[sig].iues_pending) { eh->iueh_sig_info[sig].iues_pending = B_FALSE; eh->iueh_sig_info[sig].iues_handler(eh, sig, eh->iueh_sig_info[sig].iues_data); } } if (eh->iueh_shutdown != NULL) break; continue; case 0: /* * timeout occurred. we must have a valid tq pointer * since that's the only way a timeout can happen. */ (void) iu_expire_timers(tq); continue; default: break; } /* file descriptors are lit; call 'em back */ for (i = 0; i < eh->iueh_num_fds && n_lit > 0; i++) { if (eh->iueh_pollfds[i].revents == 0) continue; n_lit--; /* * turn off any descriptors that have gone * bad. shouldn't happen, but... */ if (eh->iueh_pollfds[i].revents & (POLLNVAL|POLLERR)) { /* TODO: issue a warning here - but how? */ (void) iu_unregister_event(eh, i, NULL); continue; } eh->iueh_events[i].iuen_callback(eh, i, eh->iueh_pollfds[i].revents, i, eh->iueh_events[i].iuen_arg); } } while (eh->iueh_stop == B_FALSE || (eh->iueh_shutdown != NULL && eh->iueh_shutdown(eh, eh->iueh_shutdown_arg) == B_FALSE)); return (eh->iueh_reason); } /* * post_signal(): posts a signal for later consumption in iu_handle_events() * * input: int: the signal that's been received * output: void */ static void post_signal(int sig) { if (signal_to_eh[sig] != NULL) signal_to_eh[sig]->iueh_sig_info[sig].iues_pending = B_TRUE; } /* * iu_eh_register_signal(): registers a signal handler with an event handler * * input: iu_eh_t *: the event handler to register the signal handler with * int: the signal to register * iu_eh_sighandler_t *: the signal handler to call back * void *: the argument to pass to the signal handler function * output: int: zero on failure, success otherwise */ int iu_eh_register_signal(iu_eh_t *eh, int sig, iu_eh_sighandler_t *handler, void *data) { struct sigaction act; if (sig < 0 || sig >= NSIG || signal_to_eh[sig] != NULL) return (0); act.sa_flags = 0; act.sa_handler = &post_signal; (void) sigemptyset(&act.sa_mask); (void) sigaddset(&act.sa_mask, sig); /* used for sigprocmask() */ if (sigaction(sig, &act, NULL) == -1) return (0); (void) sigprocmask(SIG_BLOCK, &act.sa_mask, NULL); eh->iueh_sig_info[sig].iues_data = data; eh->iueh_sig_info[sig].iues_handler = handler; signal_to_eh[sig] = eh; (void) sigaddset(&eh->iueh_sig_regset, sig); return (0); } /* * iu_eh_unregister_signal(): unregisters a signal handler from an event handler * * input: iu_eh_t *: the event handler to unregister the signal handler from * int: the signal to unregister * void **: if non-NULL, will be set to point to the argument passed * into iu_eh_register_signal() * output: int: zero on failure, success otherwise */ int iu_eh_unregister_signal(iu_eh_t *eh, int sig, void **datap) { sigset_t set; if (sig < 0 || sig >= NSIG || signal_to_eh[sig] != eh) return (0); if (signal(sig, SIG_DFL) == SIG_ERR) return (0); if (datap != NULL) *datap = eh->iueh_sig_info[sig].iues_data; (void) sigemptyset(&set); (void) sigaddset(&set, sig); (void) sigprocmask(SIG_UNBLOCK, &set, NULL); eh->iueh_sig_info[sig].iues_data = NULL; eh->iueh_sig_info[sig].iues_handler = NULL; eh->iueh_sig_info[sig].iues_pending = B_FALSE; signal_to_eh[sig] = NULL; (void) sigdelset(&eh->iueh_sig_regset, sig); return (1); }
