Decouple safe.c from knowing anything about libhttpd

Author: acv

src/gateway.c

@@ -391,6 +391,7 @@ main_loop(void)
         debug(LOG_ERR, "Could not create web server: %s", strerror(errno));
         exit(1);
     }
+    register_fd_cleanup_on_fork(webserver->serverSock);
 
     debug(LOG_DEBUG, "Assigning callbacks to web server");
     httpdAddCContent(webserver, "/", "wifidog", 0, NULL, http_callback_wifidog);

src/safe.c

@@ -35,11 +35,52 @@
 #include <errno.h>
 #include <syslog.h>
 
-#include "httpd.h"
-#include "gateway.h"
 #include "safe.h"
 #include "debug.h"
 
+/** @brief Clean up all the registered fds. */
+static void cleanup_fds(void);
+
+/** List of fd's to close on fork. */
+typedef struct _fd_list {
+    int fd;                 /**< @brief file descriptor */
+    struct _fd_list *next;  /**< @brief linked list pointer */
+} fd_list_t;
+
+static fd_list_t *fd_list = NULL;
+
+/** Clean up all the registered fds. Frees the list as it goes.
+ * XXX This should only be run by CHILD processes.
+ */
+static void
+cleanup_fds(void)
+{
+    fd_list_t *entry;
+
+    while (NULL != (entry = fd_list)) {
+        close(entry->fd);
+        fd_list = entry->next;
+        free(entry);
+    }
+}
+
+/** Register an fd for auto-cleanup on fork()
+ * @param fd A file descriptor.
+ */
+void
+register_fd_cleanup_on_fork(const int fd)
+{
+    fd_list_t *entry = safe_malloc(sizeof(fd_list_t));
+
+    entry->fd = fd;
+    entry->next = fd_list;
+    fd_list = entry;
+}
+
+/** Allocate zero-filled ram or die.
+ * @param size Number of bytes to allocate
+ * @return void * pointer to the zero'd bytes.
+ */
 void *
 safe_malloc(size_t size)
 {
@@ -53,6 +94,14 @@ safe_malloc(size_t size)
     return (retval);
 }
 
+/** Re-allocates memory to a new larger allocation.
+ * DOES NOT ZERO the added RAM
+ * Original pointer is INVALID after call
+ * Dies on allocation failures.
+ * @param ptr A pointer to a current allocation from safe_malloc()
+ * @param newsize What size it should now be in bytes
+ * @return pointer to newly allocation ram
+ */
 void *
 safe_realloc(void *ptr, size_t newsize)
 {
@@ -65,6 +114,10 @@ safe_realloc(void *ptr, size_t newsize)
     return retval;
 }
 
+/** Duplicates a string or die if memory cannot be allocated
+ * @param s String to duplicate
+ * @return A string in a newly allocated chunk of heap.
+ */
 char *
 safe_strdup(const char *s)
 {
@@ -81,6 +134,13 @@ safe_strdup(const char *s)
     return (retval);
 }
 
+/** Sprintf into a newly allocated buffer
+ * Memory MUST be freed. Dies if memory cannot be allocated.
+ * @param strp Pointer to a pointer that will be set to the newly allocated string
+ * @param fmt Format string like sprintf
+ * @param ... Variable number of arguments for format string
+ * @return int Size of allocated string.
+ */
 int
 safe_asprintf(char **strp, const char *fmt, ...)
 {
@@ -94,6 +154,13 @@ safe_asprintf(char **strp, const char *fmt, ...)
     return (retval);
 }
 
+/** Sprintf into a newly allocated buffer
+ * Memory MUST be freed. Dies if memory cannot be allocted.
+ * @param strp Pointer to a pointer that will be set to the newly allocated string
+ * @param fmt Format string like sprintf
+ * @param ap pre-digested va_list of arguments.
+ * @return int Size of allocated string.
+ */
 int
 safe_vasprintf(char **strp, const char *fmt, va_list ap)
 {
@@ -108,6 +175,10 @@ safe_vasprintf(char **strp, const char *fmt, va_list ap)
     return (retval);
 }
 
+/** Fork and then close any registered fille descriptors.
+ * If fork() fails, we die.
+ * @return pid_t 0 for child, pid of child for parent
+ */
 pid_t
 safe_fork(void)
 {
@@ -119,10 +190,7 @@ safe_fork(void)
         exit(1);
     } else if (result == 0) {
         /* I'm the child - do some cleanup */
-        if (webserver) {
-            close(webserver->serverSock);
-            webserver = NULL;
-        }
+        cleanup_fds();
     }
 
     return result;

src/safe.h

@@ -32,28 +32,25 @@
 #include <sys/types.h>          /* For fork */
 #include <unistd.h>             /* For fork */
 
-/** @brief Safe version of malloc
- */
+/** Register an fd for auto-cleanup on fork() */
+void register_fd_cleanup_on_fork(const int);
+
+/** @brief Safe version of malloc */
 void *safe_malloc(size_t);
 
 /** @brief Safe version of realloc */
 void *safe_realloc(void *, size_t);
 
-/* @brief Safe version of strdup
- */
+/* @brief Safe version of strdup */
 char *safe_strdup(const char *);
 
-/* @brief Safe version of asprintf
- */
+/* @brief Safe version of asprintf */
 int safe_asprintf(char **, const char *, ...);
 
-/* @brief Safe version of vasprintf
- */
+/* @brief Safe version of vasprintf */
 int safe_vasprintf(char **, const char *, va_list);
 
-/* @brief Safe version of fork
- */
-
+/* @brief Safe version of fork */
 pid_t safe_fork(void);
 
 #endif                          /* _SAFE_H_ */