Changeset 5807

Timestamp:

03/13/10 14:58:03 (3 years ago)

Author:

Cyrus

Message:

upsd: Add extension hooks, Implement builtin start-stop-daemon utility,
Make runlevel API more straight-forward, Add a lock for interactive processes

Location:

luci2/upsd

Files:

• action.c (modified) (8 diffs)
• cbi2/datatypes.h (modified) (1 diff)
• cbi2/hmap.c (modified) (6 diffs)
• cbi2/hmap.h (modified) (3 diffs)
• cbi2/hmap_config.h (modified) (1 diff)
• core.h (modified) (5 diffs)
• hook.c (added)
• hook.h (added)
• libupsd.c (modified) (5 diffs)
• service.c (modified) (8 diffs)
• service.h (modified) (1 diff)
• ups-cli/ups.c (modified) (3 diffs)
• upsd.h (modified) (11 diffs)
• upsd_config.h (modified) (1 diff)
• worker.c (modified) (2 diffs)
• worker.h (deleted)

luci2/upsd/action.c

@@ -25 +25 @@
 #include "service.h"
 #include "action.h"
+#include "hook.h"
 
 /* Create a list wrapper */
-static upsd_initlist_t* _libupsd_action_enlist
+UPSD_MALLOC static upsd_initlist_t* _libupsd_action_enlist
 (upsd_init_t *init, upsd_initlist_t *next) {
     upsd_initlist_t *list = malloc(sizeof(upsd_initlist_t));
@@ -141 +142 @@
     upsd_report_t *report;
     int status;
-    int legacy = 1;
+    int legacy = 1, interactive = 1;
     int done = 0;
     int waiting = 0;
@@ -156 +157 @@
             continue;   /* Don't process legacy elements in parallel */
         }
+        if (!interactive && (init->flags & UPSD_INIT_INTERACTIVE)) {
+            prev = &list->next;
+            continue;   /* Don't process interacitve elements in parallel */
+        }
         if (inst->flags & UPSD_FLAG_SIMULATE) {
             UPSD_LOG_WARN("Simulating action %u on '%s'", (unsigned)action,
                     init->provides[0]);
         }
+        if (init->hndl.status != UPSD_EAGAIN) {
+            _libupsd_hook_call(state, init, action, UPSD_HOOK_BEFORE);
+        }
 
         status = ((inst->flags & UPSD_FLAG_SIMULATE) || (!init->worker)) ?
@@ -165 +173 @@
 
         if (status == UPSD_EAGAIN) {
-            if (!init->hndl.timeout) {
-                init->hndl.timeout = inst->time + UPSD_INIT_TIMEOUT;
-            } else if (inst->time > init->hndl.timeout) {
-                status = UPSD_ETIMEDOUT;
+            if (!(init->flags & UPSD_INIT_INTERACTIVE)) {
+                if (!init->hndl.timeout) {
+                    init->hndl.timeout = inst->time + UPSD_INIT_TIMEOUT;
+                } else if (inst->time > init->hndl.timeout) {
+                    status = UPSD_ETIMEDOUT;
+                }
             }
             if (init->flags & UPSD_INIT_LEGACY) {
                 legacy = 0; /* Stop processing legacy elements for this turn */
             }
-        }
-
+            if (init->flags & UPSD_INIT_INTERACTIVE) {
+                interactive = 0;/* Stop processing interactives for this turn */
+            }
+        }
+
+        init->hndl.status = status;
         if (status != UPSD_EAGAIN) {
-            init->hndl.status = status;
             if (init->worker) {
                 init->worker(init, UPSD_ACTION_INTERNAL_CLEAN);
@@ -198 +211 @@
                         (!status || (inst->flags & UPSD_FLAG_SKIPFAILED)));
             }
+            _libupsd_hook_call(state, init, action, UPSD_HOOK_AFTER);
 
             inst->lasterror = (status) ? status : inst->lasterror;
@@ -339 +353 @@
 
     if (flags & UPSD_FLAG_REPORT) {
-        if (!(state->report = calloc(count + 1, sizeof(upsd_report_t)))) {
+        if (!(state->report = malloc((count + 1) * sizeof(upsd_report_t)))) {
             return UPSD_ENOMEM;
         }
@@ -383 +397 @@
 
     if (flags & UPSD_FLAG_REPORT) {
-        if (!(state->report = calloc(count + 1, sizeof(upsd_report_t)))) {
+        if (!(state->report = malloc((count + 1) * sizeof(upsd_report_t)))) {
             return UPSD_ENOMEM;
         }
@@ -419 +433 @@
 
     if (flags & UPSD_FLAG_REPORT) {
-        if (!(state->report = calloc(count + 1, sizeof(upsd_report_t)))) {
+        if (!(state->report = malloc((count + 1) * sizeof(upsd_report_t)))) {
             return UPSD_ENOMEM;
         }

luci2/upsd/cbi2/datatypes.h

@@ -8 +8 @@
 #if __GNUC__ >= 4
     #define CBI2_LOCAL  __attribute__ ((visibility("hidden")))
+    #define CBI2_MALLOC __attribute__ ((malloc))
 #else
     #define CBI2_LOCAL
+    #define CBI2_MALLOC
 #endif
 

luci2/upsd/cbi2/hmap.c

@@ -36 +36 @@
 
 
-CBI2_LOCAL cbi2_hmap_t* cbi2_hmap_create(cbi2_size_t hint) {
+CBI2_MALLOC CBI2_LOCAL cbi2_hmap_t* cbi2_hmap_create(cbi2_size_t hint) {
     cbi2_hmap_t* map = calloc(1, sizeof(cbi2_hmap_t));
     if (!map) {
@@ -125 +125 @@
 }
 
+#ifdef CBI2_HMAP_UNSET
 CBI2_LOCAL int cbi2_hmap_unset
 (cbi2_hmap_t *map, const void *key, uint16_t len) {
@@ -162 +163 @@
     return CBI2_OK;
 }
+#endif
 
 CBI2_LOCAL cbi2_hmap_bucket_t* cbi2_hmap_next
@@ -194 +196 @@
 }
 
+#ifdef CBI2_HMAP_REFCOUNT
 CBI2_LOCAL void cbi2_hmap_reference(cbi2_hmap_t *map) {
     map->refcount++;
@@ -205 +208 @@
     }
 }
+#endif
 
 
@@ -307 +311 @@
             break;
         case CBI2_TYPE_HASHMAP:
+#ifdef CBI2_HMAP_REFCOUNT
             cbi2_hmap_unreference(bucket->data.buffer.pointer);
-            break;
+#else
+            cbi2_hmap_destroy(bucket->data.buffer.pointer);
 #endif
-    }
-}
+            break;
+#endif
+    }
+}

luci2/upsd/cbi2/hmap.h

@@ -38 +38 @@
 
 
-CBI2_LOCAL cbi2_hmap_t* cbi2_hmap_create(cbi2_size_t hint);
+CBI2_MALLOC CBI2_LOCAL cbi2_hmap_t* cbi2_hmap_create(cbi2_size_t hint);
 CBI2_LOCAL int cbi2_hmap_resize(cbi2_hmap_t *map, cbi2_size_t payload);
 CBI2_LOCAL cbi2_hmap_bucket_t* cbi2_hmap_rawget(cbi2_hmap_t *map,
@@ -44 +44 @@
 CBI2_LOCAL int cbi2_hmap_get (cbi2_hmap_t *map, const void *key, uint16_t len,
 cbi2_hmap_data_t **value);
+
+#ifdef CBI2_HMAP_UNSET
 CBI2_LOCAL int cbi2_hmap_unset(cbi2_hmap_t *map, const void *key, uint16_t len);
+#endif
+
 CBI2_LOCAL cbi2_hmap_bucket_t* cbi2_hmap_next
 (cbi2_hmap_t *map, cbi2_hmap_iter_t *iter);
@@ -51 +55 @@
 CBI2_LOCAL void cbi2_hmap_clear(cbi2_hmap_t *map);
 CBI2_LOCAL void cbi2_hmap_destroy(cbi2_hmap_t *map);
+
+#ifdef CBI2_HMAP_REFCOUNT
 CBI2_LOCAL void cbi2_hmap_reference(cbi2_hmap_t *map);
 CBI2_LOCAL void cbi2_hmap_unreference(cbi2_hmap_t *map);
+#endif
 
 #endif /* CBI2_HMAP_H_ */

luci2/upsd/cbi2/hmap_config.h

@@ -26 +26 @@
 #define CBI2_HMAP_CAPACITY_MIN  16
 
+/*
+ * Enable unset function
+ */
+/* #define CBI2_HMAP_UNSET */
+
+/*
+ * Enable refcounting
+ */
+/* #define CBI2_HMAP_REFCOUNT */
+
+/*
+ * Enable managed buffer datatype
+ */
+/* #define CBI2_HMAP_MANAGED */
+
 
 typedef cbi2_blob_t cbi2_hmap_blob_t;

luci2/upsd/core.h

@@ -25 +25 @@
 typedef struct upsd_initlist upsd_initlist_t;
 typedef struct upsd_handler upsd_handler_t;
+typedef struct upsd_extension upsd_extension_t;
 typedef union upsd_handle upsd_handle_t;
 
@@ -51 +52 @@
     char **options;
     char **provides;
-    upsd_worker_t worker;
+    upsd_worker_t *worker;
     upsd_handler_t hndl;
 };
@@ -88 +89 @@
 };
 
+struct upsd_extension {
+    upsd_extension_t *next;
+    uint16_t flags;
+    upsd_action_t action;
+    upsd_hook_t *hook;
+    void *context;
+};
+
 
 #include "cbi2/hmap.h"
@@ -93 +102 @@
 struct upsd_state {
     cbi2_hmap_t *events;
+    upsd_extension_t *extensions;
     upsd_report_t *report;
     size_t reportidx;
@@ -98 +108 @@
 };
 
-
 #define UPSD_INIT_LEGACY            0x01
 #define UPSD_INIT_INTERNAL          0x02
+#define UPSD_INIT_INTERACTIVE       0x04
+
 
 #if UPSD_LOGGING >= 4

luci2/upsd/libupsd.c

@@ -26 +26 @@
 #include "service.h"
 #include "action.h"
+#include "hook.h"
 
 upsd_state_t* libupsd_create() {
@@ -46 +47 @@
 }
 
+int libupsd_hook_register(upsd_state_t *state, upsd_hook_t *hook,
+void *context, upsd_action_t action, uint16_t flags) {
+    return _libupsd_hook_register(state, hook, context, action, flags);
+}
+
 int libupsd_dependency_add(upsd_state_t *state, const char *issuer,
 const char *receiver, upsd_action_t action, uint16_t flags) {
@@ -51 +57 @@
 }
 
-int libupsd_options_add(upsd_state_t *state, const char *service,
-const char **options) {
-    return _libupsd_service_option_add(state, service, options);
-}
-
 int libupsd_service_register(upsd_state_t *state,
-const char **facilities, upsd_worker_t worker, void *identifier) {
-    return _libupsd_service_register(state, facilities,
+const char **services, upsd_worker_t worker, void *identifier) {
+    return _libupsd_service_register(state, services,
             worker, identifier, 0, NULL);
 }
@@ -102 +103 @@
 }
 
-int libupsd_runlevel_control
-(upsd_state_t *state, char runlevel, upsd_action_t action, uint16_t flags) {
-    int ret = _libupsd_action_by_runlevel(state, runlevel, action, flags);
-    if (!ret) {
-        ret = _libupsd_action_perform(state, action);
+int libupsd_runlevel_enter(upsd_state_t *state, char runlevel, uint16_t flags) {
+    int ret1 = _libupsd_action_by_runlevel
+            (state, runlevel, UPSD_ACTION_STOP, flags);
+    if (!ret1) {
+        ret1 = _libupsd_action_perform(state, UPSD_ACTION_STOP);
     }
-    return ret;
+    int ret2 = _libupsd_action_by_runlevel
+            (state, runlevel, UPSD_ACTION_START, flags);
+    if (!ret2) {
+        ret2 = _libupsd_action_perform(state, UPSD_ACTION_START);
+    }
+    return (ret1 && !ret2) ? ret1 : ret2;
 }
 
@@ -121 +127 @@
     _libupsd_action_cleanup(state);
     _libupsd_service_clear(state);
-    cbi2_hmap_unreference(state->events);
+    _libupsd_hook_clear(state);
+    cbi2_hmap_destroy(state->events);
     free(state);
 }

luci2/upsd/service.c

@@ -31 +31 @@
 
 #include "service.h"
-#include "worker.h"
 
 /* Get the init object designated for the specified service entry, if any */
@@ -88 +87 @@
 
     if (!(emitter_e->emitting++ % UPSD_SYS_EVENT_STEP)) {
-        emitter_e->emitters = realloc(emitter_e->emitters, sizeof
+        upsd_listener_t **tmp = realloc(emitter_e->emitters, sizeof
             (upsd_listener_t*) * (emitter_e->emitting + UPSD_SYS_EVENT_STEP - 1));
-        if (!emitter_e->emitters) {
+        if (!tmp) {
             return UPSD_ENOMEM;
         }
+        emitter_e->emitters = tmp;
     }
     emitter_e->emitters[emitter_e->emitting - 1] = listener;
@@ -102 +102 @@
 
     if (!(receiver_e->receiving++ % UPSD_SYS_EVENT_STEP)) {
-        receiver_e->receivers = realloc(receiver_e->receivers, sizeof
+        upsd_listener_t **tmp = realloc(receiver_e->receivers, sizeof
         (upsd_listener_t*) * (receiver_e->receiving + UPSD_SYS_EVENT_STEP - 1));
-        if (!receiver_e->receivers) {
+        if (!tmp) {
             return UPSD_ENOMEM;
         }
+        receiver_e->receivers = tmp;
     }
     receiver_e->receivers[receiver_e->receiving - 1] = listener;
@@ -177 +178 @@
     for (char **c = init->options; *c; c++, i++);
     for (const char **c = options; *c; c++, j++);
-    init->options = realloc(init->options, (i + j + 1) * sizeof(char*));
-    if (!init->options) {
+    char **tmp = realloc(init->options, (i + j + 1) * sizeof(char*));
+    if (!tmp) {
         return UPSD_ENOMEM;
     }
+    init->options = tmp;
     for (const char **c = options; *c; c++, j++) {
         init->options[i++] = strdup(*c);
@@ -221 +223 @@
     }
     init->identifier = rpath;
-    init->worker = _libupsd_worker_exec;
+    init->worker = libupsd_worker_exec;
     if (_libupsd_service_designate(state, name, init)) {
         UPSD_LOG_INFO("Designated name %s is occupied.", name);
@@ -329 +331 @@
                 }
             }
+        } else if (!memcmp(buffer, UPSD_LITERAL_PTRSIZE("# X-Interactive:"))) {
+            init->flags |= UPSD_INIT_INTERACTIVE;
         } else if (!memcmp(buffer, UPSD_LITERAL_PTRSIZE("# X-"))) {
+            if (!memcmp(buffer, UPSD_LITERAL_PTRSIZE("# X-Daemon-Command:"))) {
+                init->worker = libupsd_worker_daemon;
+            }
+            char *c = buffer + strlen(buffer) - 1;
+            while (isspace(*c)) {
+                *c-- = 0;
+            }
             if (++options == opts) {
                 opts += 4;
-                if (!(init->options = realloc(init->options,
+                if (!(entries = realloc(init->options,
                         (opts + 1)  * sizeof(char*)))) {
                     break;
                 }
+                init->options = entries;
             }
             init->options[options] = strdup(buffer + 2);
@@ -350 +362 @@
 /* Create a dummy services that is treated as provided */
 UPSD_LOCAL int _libupsd_service_register
-(upsd_state_t *state, const char **services, upsd_worker_t worker,
+(upsd_state_t *state, const char **services, upsd_worker_t *worker,
 void *identifier, uint16_t flags, upsd_init_t **handle) {
     upsd_init_t *init = calloc(1, sizeof(upsd_init_t));
@@ -456 +468 @@
         size_t baselen = strlen(entry->d_name);
         ((char*)memcpy(cpath + cpathlen, entry->d_name, baselen))[baselen] = 0;
-        if (!memcmp(".lua", cpath - 4 + cpathlen + baselen, 4)) {
-            UPSD_LOG_ERROR("Lua support not implemented!");
-            /** SCAN LUA */
-            _libupsd_service_parse(state, cpath, NULL);
-        } else if (!access(cpath, X_OK)) {
+        if (!access(cpath, X_OK)) {
             _libupsd_service_parse(state, cpath, NULL);
         }

luci2/upsd/service.h

@@ -11 +11 @@
 UPSD_LOCAL int _libupsd_service_init(upsd_state_t *state);
 UPSD_LOCAL int _libupsd_service_register
-(upsd_state_t *state, const char **services, upsd_worker_t worker,
+(upsd_state_t *state, const char **services, upsd_worker_t *worker,
 void *identifier, uint16_t flags, upsd_init_t **handle);
 UPSD_LOCAL upsd_init_t* _libupsd_service_next

luci2/upsd/ups-cli/ups.c

@@ -68 +68 @@
         "   status          Returns the status of a service\n\n"
         "   enter           Enter a runlevel\n"
-        "   leave           Leave a runlevel\n"
         "\n\nOptions:\n"
         "   -a fac1[,fac2,...]  Automatically provide facilities\n"
@@ -153 +152 @@
         action = UPSD_ACTION_STATUS;
     } else if (!strcmp(cmd, "enter")) {
-        action = UPSD_ACTION_ENTER;
-        func = UPS_FUNC_RUNLEVEL;
-    } else if (!strcmp(cmd, "leave")) {
-        action = UPSD_ACTION_LEAVE;
+        action = UPSD_ACTION_START;
         func = UPS_FUNC_RUNLEVEL;
     } else {
@@ -182 +178 @@
     } else if (func == UPS_FUNC_RUNLEVEL) {
         char runlvl = (argc > optind) ? argv[optind][0] : UPSD_RUNLEVEL_DEFAULT;
-        stat = libupsd_runlevel_control(state, runlvl, action, flags);
+        stat = libupsd_runlevel_enter(state, runlvl, flags);
     }
 

luci2/upsd/upsd.h

@@ -22 +22 @@
 #ifndef UPSD_H_
 #define UPSD_H_
+
+#if __GNUC__ >= 4
+    #define UPSD_MALLOC __attribute__ ((malloc))
+#else
+    #define UPSD_MALLOC
+#endif
 
 #include <stdint.h>
@@ -67 +73 @@
 #define UPSD_ACTION_STATUS          6
 
-/* Known runlevel actions */
-#define UPSD_ACTION_ENTER           UPSD_ACTION_START
-#define UPSD_ACTION_LEAVE           UPSD_ACTION_STOP
-
 /* Known rc actions */
 #define UPSD_RC_INSTALL             1
@@ -86 +88 @@
 
 /* Worker */
-#define UPSD_WORKER_PROVIDE         ((upsd_worker_t)NULL)
+#define UPSD_WORKER_PROVIDE         ((upsd_worker_t*)NULL)
+
+/* Hook flags */
+#define UPSD_HOOK_BEFORE            0x01
+#define UPSD_HOOK_AFTER             0x02
+
 
 
@@ -93 +100 @@
 typedef struct upsd_state upsd_state_t;
 typedef struct upsd_init upsd_init_t;
-typedef int(*upsd_worker_t)(upsd_init_t *init, upsd_action_t action);
+typedef int(upsd_worker_t)(upsd_init_t *init, upsd_action_t action);
+typedef int(upsd_hook_t)
+(void *context, upsd_init_t *init, upsd_action_t action, uint16_t flags);
 typedef struct upsd_report {
     upsd_action_t action;
@@ -100 +109 @@
 } upsd_report_t;
 
+
+/* Builtin workers */
+int libupsd_worker_exec(upsd_init_t *init, upsd_action_t action);
+int libupsd_worker_daemon(upsd_init_t *init, upsd_action_t action);
+
+
 /**
  * libupsd_create() - Create a new ups.d state.
@@ -144 +159 @@
  */
 int libupsd_scan_initdir(upsd_state_t *state, const char *initdir);
+
+/**
+ * libupsd_hook_register() - Register an extension hook.
+ * @state:      ups.d state
+ * @hook:       Hook callback function
+ * @context:    Hook context (optional)
+ * @action:     Action to hook (optional)
+ * @flags:      Hooking flags
+ *
+ * Registers an extension hook callback that will be called whenever an action
+ * on a service will be performed.
+ *
+ * Context is a pointer passed to the hook-function as a first argument.
+ * Action is the specific action to hook or 0 to hook all.
+ * Flags can be UPSD_HOOK_BEFORE, UPSD_HOOK_AFTER or 0 for hooking before or
+ * after the action is performed or both.
+ *
+ * Returns an ups.d status code.
+ */
+int libupsd_hook_register(upsd_state_t *state, upsd_hook_t *hook,
+void *context, upsd_action_t action, uint16_t flags);
 
 /**
@@ -168 +204 @@
 
 /**
- * libupsd_options_add() - Add user-defined options to a service.
- * @state:      ups.d state
- * @service:    Target service
- * @options:    Options added to the service
- *
- * Adds user-defined options to a given service. Options to be added should
- * begin with an X- marking them as custom. Standardized LSB-Options
- * (like Required-Start) are silently ignored.
- *
- * Options is a NULL-terminated list of strings containing the options.
- * Each option string is in LSB-format: KEYWORD: VALUE1 VALUE2 VALUE3.
- *
- * Returns an ups.d status code.
- */
-int libupsd_options_add(upsd_state_t *state, const char *service,
-const char **options);
-
-/**
  * libupsd_service_register() - Register a user-defined service.
  * @state:      ups.d state
- * @facilities: Facilities provided by the new service
+ * @services:   Facilities provided by the new service
  * @worker:     Associated worker for performing tasks (optional)
  * @identifier: Service-specific identifier, e.g. pathname (optional)
@@ -208 +226 @@
  * Returns an ups.d status code.
  */
-int libupsd_service_register(upsd_state_t *state, const char **facilities,
+int libupsd_service_register(upsd_state_t *state, const char **services,
         upsd_worker_t worker, void *identifier);
 
@@ -261 +279 @@
 
 /**
- * libupsd_runlevel_control() - Perform an action on a runlevel.
+ * libupsd_runlevel_enter() - Enter a runlevel.
  * @state:      ups.d state
  * @runlevel:   ASCII-Char describing the runlevel
- * @action:     Runlevel action to perform
  * @flags:      Flags controlling the action
  *
@@ -276 +293 @@
  * values (usually a runlevel of 'X' translates to /etc/rcX.d).
  *
- * Action can be any runlevel action, for now only UPSD_ACTION_ENTER and
- * UPSD_ACTION_LEAVE are defined which will start / stop associated services.
  *
  * NOTE: Legacy init scripts (without LSB-style dependency comments) are also
@@ -285 +300 @@
  * failed or UPSD_OK if all actions could be completed successfully.
  */
-int libupsd_runlevel_control(upsd_state_t *state, char runlevel,
-        upsd_action_t action, uint16_t flags);
+int libupsd_runlevel_enter(upsd_state_t *state, char runlevel, uint16_t flags);
 
 /**

luci2/upsd/upsd_config.h

@@ -15 +15 @@
  */
 #ifndef UPSD_SYS_EVENT_STEP
-#define UPSD_SYS_EVENT_STEP 8
+#define UPSD_SYS_EVENT_STEP 7
 #endif
 

luci2/upsd/worker.c

@@ -22 +22 @@
 #include <sys/types.h>
 #include <sys/wait.h>
+#include <sys/stat.h>
 #include <unistd.h>
 #include <signal.h>
-#include "worker.h"
+#include <string.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <ctype.h>
+#include <pwd.h>
+#include <grp.h>
+#include "core.h"
 
 static char* const _libupsd_worker_cmds[] = {"start", "stop", "restart",
         "force-reload", "reload", "status"};
 
-UPSD_LOCAL int _libupsd_worker_exec(upsd_init_t *init, upsd_action_t action) {
+int libupsd_worker_exec(upsd_init_t *init, upsd_action_t action) {
     pid_t pid = init->hndl.handle.pid;
     if (action == UPSD_ACTION_INTERNAL_CLEAN) {
@@ -66 +74 @@
 }
 
+int libupsd_worker_daemon(upsd_init_t *init, upsd_action_t action) {
+    const char *pidfile = NULL, *command = NULL, *options = NULL;
+    int background = 0, user = 0, group = 0, reloadsig = 0;
+    char name[256], buffer[1024];
+    FILE *fp;
+    pid_t pid = init->hndl.handle.pid;
+
+    if (pid) {  /* Waiting for launcher process to complete */
+        if (action == UPSD_ACTION_INTERNAL_CLEAN) {
+            if (pid) {
+                UPSD_LOG_WARN("Service '%s' seems to hang, killing...",
+                        init->provides[0]);
+                kill(pid, SIGKILL);
+            }
+            return UPSD_OK;
+        }
+        int status;
+        if ((pid = waitpid(pid, &status, WNOHANG)) == init->hndl.handle.pid) {
+            init->hndl.handle.pid = (pid_t)0;
+            return (WIFEXITED(status)) ? WEXITSTATUS(status) : UPSD_EEXEC;
+        } else {
+            return (!pid) ? UPSD_EAGAIN : UPSD_EEXEC;
+        }
+    }
+
+    for (char **c = init->options; *c; c++) {   /* Parsing daemon options */
+        if (!strncmp(*c, "X-Daemon-Pidfile:", 17)) {
+            pidfile = *c + 17;
+            while (isspace(*pidfile)) {
+                pidfile++;
+            }
+        } else if (!strncmp(*c, "X-Daemon-Command:", 17)) {
+            command = *c + 17;
+            while (isspace(*command)) {
+                command++;
+            }
+        } else if (!strncmp(*c, "X-Daemon-Options:", 17)) {
+            options = *c + 17;
+            while (isspace(*options)) {
+                options++;
+            }
+        }
+    }
+    if (options) {
+        if (strstr(options, "reload=sighup")) {
+            reloadsig = SIGHUP;
+        }
+        background = !!strstr(options, "background");
+    }
+    if (!command || !pidfile || strlen(command) >= sizeof(buffer)) {
+        UPSD_LOG_ERROR("'%s' has invalid command or pidfile", *init->provides);
+        return UPSD_EIO;
+    }
+    if (!reloadsig) {   /* If reload is not defined, use fallback if possible */
+        if (action == UPSD_ACTION_RELOAD) {
+            return UPSD_COMMAND_UNSUPPORTED;
+        } else if (action == UPSD_ACTION_FORCERELOAD) {
+            action = UPSD_ACTION_RESTART;
+        }
+    } else if (action == UPSD_ACTION_FORCERELOAD) {
+        action = UPSD_ACTION_RELOAD;
+    }
+
+    if ((fp = fopen(pidfile, "r"))) {   /* Get PID from pidfile */
+        buffer[0] = 0;
+        fgets(buffer, sizeof(buffer), fp);
+        fclose(fp);
+        pid = atoi(buffer);
+    }
+
+    if (!pid || kill(pid, 0) == -1) {   /* Process not active */
+        if (action == UPSD_ACTION_STATUS) {
+            return (!fp) ? UPSD_STATUS_STOPPED : UPSD_STATUS_DEAD_RUN;
+        } else if (action == UPSD_ACTION_STOP) {
+            unlink(pidfile);
+            return UPSD_OK;
+        }
+    } else {    /* Process still active */
+        if (action == UPSD_ACTION_STATUS || action == UPSD_ACTION_START) {
+            return UPSD_STATUS_OK;
+        }
+        kill(pid, (action == UPSD_ACTION_RELOAD) ? reloadsig : SIGTERM);
+        if (action != UPSD_ACTION_RELOAD) {
+            unlink(pidfile);
+        }
+        if (action == UPSD_ACTION_RELOAD || action == UPSD_ACTION_STOP) {
+            return UPSD_OK;
+        }
+    }
+
+    pid = fork();
+    if (pid == -1) {
+        return UPSD_COMMAND_EXECFAILED;
+    } else if (pid > 0) {
+        if (!background) {
+            init->hndl.handle.pid = pid;
+            return UPSD_EAGAIN;
+        } else {
+            if (!(fp = fopen(pidfile, "w"))) {
+                UPSD_LOG_WARN("Unable to write pidfile '%s'", pidfile);
+            } else {
+                fprintf(fp, "%i\n", (int)pid);
+                fclose(fp);
+            }
+            return UPSD_OK;
+        }
+    }
+
+    /* Execute service */
+
+    if (options) {
+        struct passwd pwd, *pwdp;
+        struct group grp, *grpp;
+        const char *lname;
+        int i;
+
+        if ((lname = strstr(options, "user="))) {
+            lname += 5;
+            for (i = 0; isgraph(*lname); lname++) {
+                name[i++] = *lname;
+            }
+            name[i] = 0;
+            getpwnam_r(name, &pwd, buffer, sizeof(buffer), &pwdp);
+            if (!pwdp) {
+                UPSD_LOG_ERROR("Unable to resolve user '%s'", name);
+                return UPSD_COMMAND_ERROR;
+            }
+            user = pwd.pw_uid;
+        }
+
+        if ((lname = strstr(options, "group="))) {
+            lname += 6;
+            for (i = 0; isgraph(*lname); lname++) {
+                name[i++] = *lname;
+            }
+            name[i] = 0;
+            getgrnam_r(name, &grp, buffer, sizeof(buffer), &grpp);
+            if (!grpp) {
+                UPSD_LOG_ERROR("Unable to resolve group '%s'", name);
+                return UPSD_COMMAND_ERROR;
+            }
+            group = grp.gr_gid;
+        }
+    }
+
+
+    char *p = buffer, **argv;
+    int args = 0;
+    strcpy(buffer, command);
+    for (;;) {
+        for (; isblank(*p); p++) {
+            *p = 0;
+        }
+        if (isgraph(*p)) {
+            args++;
+            for (; isgraph(*p); p++);
+            *p = 0;
+        } else {
+            break;
+        }
+    }
+    argv = malloc((args + 1) * sizeof(char*));
+
+    p = buffer;
+    for (int i = 0; i < args; i++) {
+        for (; !(*p); p++);
+        argv[i] = p;
+        for (; *p; p++);
+    }
+    argv[args] = NULL;
+
+    if (background) {
+        setsid();
+        chdir("/");
+        int devnull = open("/dev/null", O_RDWR);
+        dup2(devnull, STDIN_FILENO);
+        dup2(devnull, STDOUT_FILENO);
+        dup2(devnull, STDERR_FILENO);
+        close(devnull);
+    }
+
+    if (group) {
+        setgid(group);
+    }
+
+    if (user) {
+        setuid(user);
+    }
+
+    execv(argv[0], argv);
+    free(argv);
+    _exit(UPSD_COMMAND_EXECFAILED);
+}