Overhaul dhcpcd for chrome os use

eloop.c

 /* 
  * dhcpcd - DHCP client daemon
  * Copyright (c) 2006-2008 Roy Marples <roy@marples.name>
  * All rights reserved
 
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
@@ skipping 23 matching lines @@
 #include <stdlib.h>
 #include <syslog.h>
 
 #include "common.h"
 #include "eloop.h"
 
 static struct timeval now;
 
 static struct event {
         int fd;
+        int flags;
         void (*callback)(void *);
+        void (*callback_f)(int, void *);
         void *arg;
         struct event *next;
 } *events;
 static struct event *free_events;
 
 static struct timeout {
         struct timeval when;
         void (*callback)(void *);
         void *arg;
         struct timeout *next;
 } *timeouts;
 static struct timeout *free_timeouts;
 
 static struct pollfd *fds;
 static size_t fds_len;
 
-void
-add_event(int fd, void (*callback)(void *), void *arg)
+static int
+_add_event_flags(int fd,
+    int flags,
+    void (*callback)(void *),
+    void (*callback_f)(int, void *),
+    void *arg)
 {
         struct event *e, *last = NULL;
 
         /* We should only have one callback monitoring the fd */
         for (e = events; e; e = e->next) {
                 if (e->fd == fd) {
+                        e->flags = flags;
                         e->callback = callback;
+                        e->callback_f = callback_f;
                         e->arg = arg;
-                        return;
+                        return 0;
                 }
                 last = e;
         }
 
         /* Allocate a new event if no free ones already allocated */
         if (free_events) {
                 e = free_events;
                 free_events = e->next;
-        } else
-                e = xmalloc(sizeof(*e));
+        } else {
+                e = malloc(sizeof(*e));
+                if (e == NULL)
+                        return -1;
+        }
         e->fd = fd;
+        e->flags = flags;
         e->callback = callback;
+        e->callback_f = callback_f;
         e->arg = arg;
         e->next = NULL;
         if (last)
                 last->next = e;
         else
                 events = e;
+        return 0;
+}
+
+int
+add_event(int fd, void (*callback)(void *), void *arg)
+{
+        return _add_event_flags(fd, 0, callback, NULL, arg);
+}
+
+int
+add_event_flags(int fd, int flags, void (*callback)(int, void *), void *arg)
+{
+        return _add_event_flags(fd, flags, NULL, callback, arg);
 }
 
 void
 delete_event(int fd)
 {
         struct event *e, *last = NULL;
 
         for (e = events; e; e = e->next) {
                 if (e->fd == fd) {
                         if (last)
@@ skipping 189 matching lines @@
                                 free_timeouts = t;
                                 continue;
                         }
                         timersub(&timeouts->when, &now, &tv);
                         if (tv.tv_sec > INT_MAX / 1000 ||
                             (tv.tv_sec == INT_MAX / 1000 &&
                                 (tv.tv_usec + 999) / 1000 > INT_MAX % 1000))
                                 msecs = INT_MAX;
                         else
                                 msecs = tv.tv_sec * 1000 +
-                                    (tv.tv_usec + 999) / 1000;
+                                        (tv.tv_usec + 999) / 1000;
                 } else
                         /* No timeouts, so wait forever. */
                         msecs = -1;
 
                 /* Allocate memory for our pollfds as and when needed.
                  * We don't bother shrinking it. */
                 nfds = 0;
                 for (e = events; e; e = e->next)
                         nfds++;
                 if (msecs == -1 && nfds == 0) {
                         syslog(LOG_ERR, "nothing to do");
                         exit(EXIT_FAILURE);
                 }
                 if (nfds > fds_len) {
                         free(fds);
-                        /* Allocate 5 more than we need for future use */
-                        fds_len = nfds + 5;
-                        fds = xmalloc(sizeof(*fds) * fds_len);
+                        fds = malloc(sizeof(*fds) * nfds);
+                        if (fds == NULL) {
+                                syslog(LOG_ERR, "malloc: %m");
+                                exit(EXIT_FAILURE);
+                        }
+                        fds_len = nfds;
                 }
                 nfds = 0;
                 for (e = events; e; e = e->next) {
                         fds[nfds].fd = e->fd;
-                        fds[nfds].events = POLLIN;
+                        if (e->flags == 0)
+                                fds[nfds].events = POLLIN;
+                        else
+                                fds[nfds].events = e->flags;
                         fds[nfds].revents = 0;
                         nfds++;
                 }
                 n = poll(fds, nfds, msecs);
                 if (n == -1) {
                         if (errno == EAGAIN || errno == EINTR) {
                                 get_monotonic(&now);
                                 continue;
                         }
                         syslog(LOG_ERR, "poll: %m");
                         exit(EXIT_FAILURE);
                 }
 
                 /* Get the now time and process any triggered events. */
                 get_monotonic(&now);
                 if (n == 0)
                         continue;
                 for (i = 0; i < nfds; i++) {
-                        if (!(fds[i].revents & (POLLIN | POLLHUP)))
+                        if (fds[i].revents == 0)
                                 continue;
                         for (e = events; e; e = e->next) {
-                                if (e->fd == fds[i].fd) {
-                                        e->callback(e->arg);
+                                if (e->fd != fds[i].fd)
+                                        continue;
+                                if (e->flags) {
+                                        e->callback_f(fds[i].revents, e->arg);
                                         break;
                                 }
+                                if (fds[i].revents & (POLLIN | POLLHUP))
+                                        e->callback(e->arg);
+                                break;
                         }
                 }
         }
 }