Fix procd not handling rapid reboot signals very well
[project/procd.git] / service / trigger.c
1 /*
2  * Copyright (C) 2013 Felix Fietkau <nbd@openwrt.org>
3  * Copyright (C) 2013 John Crispin <blogic@openwrt.org>
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU Lesser General Public License version 2.1
7  * as published by the Free Software Foundation
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  */
14
15 #include <sys/stat.h>
16 #include <sys/socket.h>
17 #include <sys/types.h>
18
19 #include <linux/types.h>
20 #include <linux/netlink.h>
21
22 #include <libubox/blobmsg_json.h>
23 #include <libubox/json_script.h>
24 #include <libubox/runqueue.h>
25 #include <libubox/ustream.h>
26 #include <libubox/uloop.h>
27
28 #include <fcntl.h>
29 #include <unistd.h>
30 #include <stdlib.h>
31 #include <libgen.h>
32
33 #include "../procd.h"
34
35 struct trigger {
36         struct list_head list;
37
38         char *type;
39
40         int pending;
41         int remove;
42         int timeout;
43
44         void *id;
45
46         struct blob_attr *rule;
47         struct blob_attr *data;
48         struct uloop_timeout delay;
49
50         struct json_script_ctx jctx;
51 };
52
53 struct job;
54 struct cmd {
55         char *name;
56         void (*handler)(struct job *job, struct blob_attr *exec, struct blob_attr *env);
57 };
58
59 struct job {
60         struct runqueue_process proc;
61         struct cmd *cmd;
62         struct trigger *trigger;
63         struct blob_attr *exec;
64         struct blob_attr *env;
65 };
66
67 static LIST_HEAD(triggers);
68 static struct runqueue q;
69
70 static const char* rule_handle_var(struct json_script_ctx *ctx, const char *name, struct blob_attr *vars)
71 {
72         return NULL;
73 }
74
75 static struct json_script_file *
76 rule_load_script(struct json_script_ctx *ctx, const char *name)
77 {
78         struct trigger *t = container_of(ctx, struct trigger, jctx);
79
80         return json_script_file_from_blobmsg(t->type, t->rule, blob_pad_len(t->rule));
81 }
82
83 static void q_job_run(struct runqueue *q, struct runqueue_task *t)
84 {
85         struct job *j = container_of(t, struct job, proc.task);
86
87         DEBUG(4, "handle event %s\n", j->cmd->name);
88         j->cmd->handler(j, j->exec, j->env);
89 }
90
91 static void trigger_free(struct trigger *t)
92 {
93         json_script_free(&t->jctx);
94         uloop_timeout_cancel(&t->delay);
95         free(t->data);
96         list_del(&t->list);
97         free(t);
98 }
99
100 static void q_job_complete(struct runqueue *q, struct runqueue_task *p)
101 {
102         struct job *j = container_of(p, struct job, proc.task);
103
104         if (j->trigger->remove) {
105                 trigger_free(j->trigger);
106         } else {
107                 j->trigger->pending = 0;
108         }
109         free(j);
110 }
111
112 static void add_job(struct trigger *t, struct cmd *cmd, struct blob_attr *exec, struct blob_attr *data)
113 {
114         static const struct runqueue_task_type job_type = {
115                 .run = q_job_run,
116                 .cancel = runqueue_process_cancel_cb,
117                 .kill = runqueue_process_kill_cb,
118         };
119         struct blob_attr *d, *e;
120         struct job *j = calloc_a(sizeof(*j), &e, blob_pad_len(exec), &d, blob_pad_len(data));
121
122         j->env = d;
123         j->exec = e;
124         j->cmd = cmd;
125         j->trigger = t;
126         j->proc.task.type = &job_type;
127         j->proc.task.complete = q_job_complete;
128         t->pending = 1;
129
130         memcpy(j->exec, exec, blob_pad_len(exec));
131         memcpy(j->env, data, blob_pad_len(data));
132
133         runqueue_task_add(&q, &j->proc.task, false);
134 }
135
136 static void _setenv(const char *key, const char *val)
137 {
138         char _key[32];
139
140         snprintf(_key, sizeof(_key), "PARAM_%s", key);
141         setenv(_key, val, 1);
142 }
143
144 static void handle_run_script(struct job *j, struct blob_attr *exec, struct blob_attr *env)
145 {
146         char *argv[8];
147         struct blob_attr *cur;
148         int rem;
149         int i = 0;
150         pid_t pid;
151
152         pid = fork();
153         if (pid < 0)
154                 return;
155
156         if (pid) {
157                 runqueue_process_add(&q, &j->proc, pid);
158                 return;
159         }
160
161         if (debug < 3) {
162                 close(STDIN_FILENO);
163                 close(STDOUT_FILENO);
164                 close(STDERR_FILENO);
165         }
166
167         _setenv("type", j->trigger->type);
168         blobmsg_for_each_attr(cur, j->env, rem)
169                 _setenv(blobmsg_name(cur), blobmsg_data(cur));
170
171         blobmsg_for_each_attr(cur, j->exec, rem) {
172                 argv[i] = blobmsg_data(cur);
173                 i++;
174                 if (i == 7)
175                         break;
176         }
177
178         if (i > 0) {
179                 argv[i] = NULL;
180                 execvp(argv[0], &argv[0]);
181         }
182
183         exit(1);
184 }
185
186 static struct cmd handlers[] = {
187         {
188                 .name = "run_script",
189                 .handler = handle_run_script,
190         },
191 };
192
193 static void rule_handle_command(struct json_script_ctx *ctx, const char *name,
194                                 struct blob_attr *exec, struct blob_attr *vars)
195 {
196         struct trigger *t = container_of(ctx, struct trigger, jctx);
197         int i;
198
199         if (t->pending)
200                 return;
201
202         for (i = 0; i < ARRAY_SIZE(handlers); i++) {
203                 if (!strcmp(handlers[i].name, name)) {
204                         add_job(t, &handlers[i], exec, vars);
205                         break;
206                 }
207         }
208 }
209
210 static void rule_handle_error(struct json_script_ctx *ctx, const char *msg,
211                                 struct blob_attr *context)
212 {
213         char *s;
214
215         s = blobmsg_format_json(context, false);
216         ERROR("ERROR: %s in block: %s\n", msg, s);
217         free(s);
218 }
219
220 static void q_empty(struct runqueue *q)
221 {
222 }
223
224 static void trigger_delay_cb(struct uloop_timeout *tout)
225 {
226         struct trigger *t = container_of(tout, struct trigger, delay);
227
228         json_script_run(&t->jctx, "foo", t->data);
229         free(t->data);
230         t->data = NULL;
231 }
232
233 static struct trigger* _trigger_add(char *type, struct blob_attr *rule, int timeout, void *id)
234 {
235         char *_t;
236         struct blob_attr *_r;
237         struct trigger *t = calloc_a(sizeof(*t), &_t, strlen(type) + 1, &_r, blob_pad_len(rule));
238
239         t->type = _t;
240         t->rule = _r;
241         t->delay.cb = trigger_delay_cb;
242         t->timeout = timeout;
243         t->pending = 0;
244         t->remove = 0;
245         t->id = id;
246         t->jctx.handle_var = rule_handle_var,
247         t->jctx.handle_error = rule_handle_error,
248         t->jctx.handle_command = rule_handle_command,
249         t->jctx.handle_file = rule_load_script,
250
251         strcpy(t->type, type);
252         memcpy(t->rule, rule, blob_pad_len(rule));
253
254         list_add(&t->list, &triggers);
255         json_script_init(&t->jctx);
256
257         return t;
258 }
259
260 void trigger_add(struct blob_attr *rule, void *id)
261 {
262         struct blob_attr *cur;
263         int rem;
264
265         blobmsg_for_each_attr(cur, rule, rem) {
266                 struct blob_attr *_cur, *type = NULL, *script = NULL, *timeout = NULL;
267                 int _rem;
268                 int i = 0;
269
270                 if (blobmsg_type(cur) != BLOBMSG_TYPE_ARRAY)
271                         continue;
272
273                 blobmsg_for_each_attr(_cur, cur, _rem) {
274                         switch (i++) {
275                         case 0:
276                                 if (blobmsg_type(_cur) == BLOBMSG_TYPE_STRING)
277                                         type = _cur;
278                                 break;
279
280                         case 1:
281                                 if (blobmsg_type(_cur) == BLOBMSG_TYPE_ARRAY)
282                                         script = _cur;
283                                 break;
284
285                         case 2:
286                                 if (blobmsg_type(_cur) == BLOBMSG_TYPE_INT32)
287                                         timeout = _cur;
288                                 break;
289                         }
290                 }
291
292                 if (type && script) {
293                         int t = 0;
294
295                         if (timeout)
296                                 t = blobmsg_get_u32(timeout);
297                         _trigger_add(blobmsg_get_string(type), script, t, id);
298                 }
299         }
300 }
301
302 void trigger_del(void *id)
303 {
304         struct trigger *t, *n;
305
306         list_for_each_entry_safe(t, n, &triggers, list) {
307                 if (t->id != id)
308                         continue;
309
310                 if (t->pending) {
311                         t->remove = 1;
312                         continue;
313                 }
314
315                 trigger_free(t);
316         }
317 }
318
319 void trigger_init(void)
320 {
321         runqueue_init(&q);
322         q.empty_cb = q_empty;
323         q.max_running_tasks = 1;
324 }
325
326 static int trigger_match(const char *event, const char *match)
327 {
328         char *wildcard = strstr(match, ".*");
329         if (wildcard)
330                 return strncmp(event, match, wildcard - match);
331         return strcmp(event, match);
332 }
333
334 void trigger_event(const char *type, struct blob_attr *data)
335 {
336         struct trigger *t;
337
338         list_for_each_entry(t, &triggers, list) {
339                 if (t->pending || t->remove)
340                         continue;
341                 if (!trigger_match(type, t->type)) {
342                         if (t->timeout) {
343                                 free(t->data);
344                                 t->data = blob_memdup(data);
345                                 uloop_timeout_set(&t->delay, t->timeout);
346                         } else {
347                                 json_script_run(&t->jctx, "foo", data);
348                         }
349                 }
350         }
351 }