Return to fdevent_solaris_port.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / lighttpd / src

lighttpd 1.4.41

    1: #include "first.h"
    2: 
    3: #include "fdevent.h"
    4: #include "buffer.h"
    5: #include "log.h"
    6: 
    7: #include <sys/types.h>
    8: 
    9: #include <unistd.h>
   10: #include <stdlib.h>
   11: #include <stdio.h>
   12: #include <string.h>
   13: #include <errno.h>
   14: #include <signal.h>
   15: #include <fcntl.h>
   16: 
   17: #ifdef USE_SOLARIS_PORT
   18: 
   19: static const int SOLARIS_PORT_POLL_READ       = POLLIN;
   20: static const int SOLARIS_PORT_POLL_WRITE      = POLLOUT;
   21: static const int SOLARIS_PORT_POLL_READ_WRITE = POLLIN & POLLOUT;
   22: 
   23: static int fdevent_solaris_port_event_del(fdevents *ev, int fde_ndx, int fd) {
   24: 	if (fde_ndx < 0) return -1;
   25: 
   26: 	if (0 != port_dissociate(ev->port_fd, PORT_SOURCE_FD, fd)) {
   27: 		log_error_write(ev->srv, __FILE__, __LINE__, "SSS",
   28: 			"port_dissociate failed: ", strerror(errno), ", dying");
   29: 
   30: 		SEGFAULT();
   31: 
   32: 		return 0;
   33: 	}
   34: 
   35: 	return -1;
   36: }
   37: 
   38: static int fdevent_solaris_port_event_set(fdevents *ev, int fde_ndx, int fd, int events) {
   39: 	const int* user_data = NULL;
   40: 
   41: 	if ((events & FDEVENT_IN) && (events & FDEVENT_OUT)) {
   42: 		user_data = &SOLARIS_PORT_POLL_READ_WRITE;
   43: 	} else if (events & FDEVENT_IN) {
   44: 		user_data = &SOLARIS_PORT_POLL_READ;
   45: 	} else if (events & FDEVENT_OUT) {
   46: 		user_data = &SOLARIS_PORT_POLL_WRITE;
   47: 	}
   48: 
   49: 	if (0 != port_associate(ev->port_fd, PORT_SOURCE_FD, fd, *user_data, (void*) user_data)) {
   50: 		log_error_write(ev->srv, __FILE__, __LINE__, "SSS",
   51: 			"port_associate failed: ", strerror(errno), ", dying");
   52: 
   53: 		SEGFAULT();
   54: 
   55: 		return 0;
   56: 	}
   57: 
   58: 	return fd;
   59: }
   60: 
   61: static int fdevent_solaris_port_event_get_revent(fdevents *ev, size_t ndx) {
   62: 	int events = 0, e;
   63: 
   64: 	e = ev->port_events[ndx].portev_events;
   65: 	if (e & POLLIN) events |= FDEVENT_IN;
   66: 	if (e & POLLOUT) events |= FDEVENT_OUT;
   67: 	if (e & POLLERR) events |= FDEVENT_ERR;
   68: 	if (e & POLLHUP) events |= FDEVENT_HUP;
   69: 	if (e & POLLPRI) events |= FDEVENT_PRI;
   70: 	if (e & POLLNVAL) events |= FDEVENT_NVAL;
   71: 
   72: 	return e;
   73: }
   74: 
   75: static int fdevent_solaris_port_event_get_fd(fdevents *ev, size_t ndx) {
   76: 	return ev->port_events[ndx].portev_object;
   77: }
   78: 
   79: static int fdevent_solaris_port_event_next_fdndx(fdevents *ev, int ndx) {
   80: 	size_t i;
   81: 
   82: 	UNUSED(ev);
   83: 
   84: 	i = (ndx < 0) ? 0 : ndx + 1;
   85: 
   86: 	return i;
   87: }
   88: 
   89: static void fdevent_solaris_port_free(fdevents *ev) {
   90: 	close(ev->port_fd);
   91: 	free(ev->port_events);
   92: }
   93: 
   94: /* if there is any error it will return the return values of port_getn, otherwise it will return number of events **/
   95: static int fdevent_solaris_port_poll(fdevents *ev, int timeout_ms) {
   96: 	int i = 0;
   97: 	int ret;
   98: 	unsigned int available_events, wait_for_events = 0;
   99: 	const int *user_data;
  100: 
  101: 	struct timespec  timeout;
  102: 
  103: 	timeout.tv_sec  = timeout_ms/1000L;
  104: 	timeout.tv_nsec = (timeout_ms % 1000L) * 1000000L;
  105: 
  106: 	/* get the number of file descriptors with events */
  107: 	if ((ret = port_getn(ev->port_fd, ev->port_events, 0, &wait_for_events, &timeout)) < 0) return ret;
  108: 
  109: 	/* wait for at least one event */
  110: 	if (0 == wait_for_events) wait_for_events = 1;
  111: 
  112: 	available_events = wait_for_events;
  113: 
  114: 	/* get the events of the file descriptors */
  115: 	if ((ret = port_getn(ev->port_fd, ev->port_events, ev->maxfds, &available_events, &timeout)) < 0) {
  116: 		/* if errno == ETIME and available_event == wait_for_events we didn't get any events */
  117: 		/* for other errors we didn't get any events either */
  118: 		if (!(errno == ETIME && wait_for_events != available_events)) return ret;
  119: 	}
  120: 
  121: 	for (i = 0; i < available_events; ++i) {
  122: 		user_data = (const int *) ev->port_events[i].portev_user;
  123: 
  124: 		if ((ret = port_associate(ev->port_fd, PORT_SOURCE_FD, ev->port_events[i].portev_object,
  125: 			*user_data, (void*) user_data)) < 0) {
  126: 			log_error_write(ev->srv, __FILE__, __LINE__, "SSS",
  127: 				"port_associate failed: ", strerror(errno), ", dying");
  128: 
  129: 			SEGFAULT();
  130: 
  131: 			return 0;
  132: 		}
  133: 	}
  134: 
  135: 	return available_events;
  136: }
  137: 
  138: int fdevent_solaris_port_init(fdevents *ev) {
  139: 	ev->type = FDEVENT_HANDLER_SOLARIS_PORT;
  140: #define SET(x) \
  141: 	ev->x = fdevent_solaris_port_##x;
  142: 
  143: 	SET(free);
  144: 	SET(poll);
  145: 
  146: 	SET(event_del);
  147: 	SET(event_set);
  148: 
  149: 	SET(event_next_fdndx);
  150: 	SET(event_get_fd);
  151: 	SET(event_get_revent);
  152: 
  153: 	if ((ev->port_fd = port_create()) < 0) {
  154: 		log_error_write(ev->srv, __FILE__, __LINE__, "SSS",
  155: 			"port_create() failed (", strerror(errno), "), try to set server.event-handler = \"poll\" or \"select\"");
  156: 
  157: 		return -1;
  158: 	}
  159: 
  160: 	ev->port_events = malloc(ev->maxfds * sizeof(*ev->port_events));
  161: 	force_assert(NULL != ev->port_events);
  162: 
  163: 	return 0;
  164: }
  165: 
  166: #else
  167: int fdevent_solaris_port_init(fdevents *ev) {
  168: 	UNUSED(ev);
  169: 
  170: 	log_error_write(ev->srv, __FILE__, __LINE__, "S",
  171: 		"solaris-eventports not supported, try to set server.event-handler = \"poll\" or \"select\"");
  172: 
  173: 	return -1;
  174: }
  175: #endif