2 * Copyright (C) 2013 Felix Fietkau <nbd@openwrt.org>
3 * Copyright (C) 2013 John Crispin <blogic@openwrt.org>
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
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.
16 #include <sys/socket.h>
17 #include <sys/types.h>
19 #include <linux/types.h>
20 #include <linux/netlink.h>
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>
36 struct list_head list;
46 struct blob_attr *rule;
47 struct blob_attr *data;
48 struct uloop_timeout delay;
50 struct json_script_ctx jctx;
56 void (*handler)(struct job *job, struct blob_attr *exec, struct blob_attr *env);
60 struct runqueue_process proc;
62 struct trigger *trigger;
63 struct blob_attr *exec;
64 struct blob_attr *env;
67 static LIST_HEAD(triggers);
68 static struct runqueue q;
70 static const char* rule_handle_var(struct json_script_ctx *ctx, const char *name, struct blob_attr *vars)
75 static struct json_script_file *
76 rule_load_script(struct json_script_ctx *ctx, const char *name)
78 struct trigger *t = container_of(ctx, struct trigger, jctx);
80 return json_script_file_from_blobmsg(t->type, t->rule, blob_pad_len(t->rule));
83 static void q_job_run(struct runqueue *q, struct runqueue_task *t)
85 struct job *j = container_of(t, struct job, proc.task);
87 DEBUG(4, "handle event %s\n", j->cmd->name);
88 j->cmd->handler(j, j->exec, j->env);
91 static void trigger_free(struct trigger *t)
98 static void q_job_complete(struct runqueue *q, struct runqueue_task *p)
100 struct job *j = container_of(p, struct job, proc.task);
102 if (j->trigger->remove) {
103 trigger_free(j->trigger);
105 j->trigger->pending = 0;
110 static void add_job(struct trigger *t, struct cmd *cmd, struct blob_attr *exec, struct blob_attr *data)
112 static const struct runqueue_task_type job_type = {
114 .cancel = runqueue_process_cancel_cb,
115 .kill = runqueue_process_kill_cb,
117 struct blob_attr *d, *e;
118 struct job *j = calloc_a(sizeof(*j), &e, blob_pad_len(exec), &d, blob_pad_len(data));
124 j->proc.task.type = &job_type;
125 j->proc.task.complete = q_job_complete;
128 memcpy(j->exec, exec, blob_pad_len(exec));
129 memcpy(j->env, data, blob_pad_len(data));
131 runqueue_task_add(&q, &j->proc.task, false);
134 static void _setenv(const char *key, const char *val)
138 snprintf(_key, sizeof(_key), "PARAM_%s", key);
139 setenv(_key, val, 1);
142 static void handle_run_script(struct job *j, struct blob_attr *exec, struct blob_attr *env)
145 struct blob_attr *cur;
155 runqueue_process_add(&q, &j->proc, pid);
161 close(STDOUT_FILENO);
162 close(STDERR_FILENO);
165 _setenv("type", j->trigger->type);
166 blobmsg_for_each_attr(cur, j->env, rem)
167 _setenv(blobmsg_name(cur), blobmsg_data(cur));
169 blobmsg_for_each_attr(cur, j->exec, rem) {
170 argv[i] = blobmsg_data(cur);
178 execvp(argv[0], &argv[0]);
184 static struct cmd handlers[] = {
186 .name = "run_script",
187 .handler = handle_run_script,
191 static void rule_handle_command(struct json_script_ctx *ctx, const char *name,
192 struct blob_attr *exec, struct blob_attr *vars)
194 struct trigger *t = container_of(ctx, struct trigger, jctx);
200 for (i = 0; i < ARRAY_SIZE(handlers); i++) {
201 if (!strcmp(handlers[i].name, name)) {
202 add_job(t, &handlers[i], exec, vars);
208 static void rule_handle_error(struct json_script_ctx *ctx, const char *msg,
209 struct blob_attr *context)
213 s = blobmsg_format_json(context, false);
214 ERROR("ERROR: %s in block: %s\n", msg, s);
218 static void q_empty(struct runqueue *q)
222 static void trigger_delay_cb(struct uloop_timeout *tout)
224 struct trigger *t = container_of(tout, struct trigger, delay);
226 json_script_run(&t->jctx, "foo", t->data);
231 static struct trigger* _trigger_add(char *type, struct blob_attr *rule, int timeout, void *id)
234 struct blob_attr *_r;
235 struct trigger *t = calloc_a(sizeof(*t), &_t, strlen(type) + 1, &_r, blob_pad_len(rule));
239 t->delay.cb = trigger_delay_cb;
240 t->timeout = timeout;
244 t->jctx.handle_var = rule_handle_var,
245 t->jctx.handle_error = rule_handle_error,
246 t->jctx.handle_command = rule_handle_command,
247 t->jctx.handle_file = rule_load_script,
249 strcpy(t->type, type);
250 memcpy(t->rule, rule, blob_pad_len(rule));
252 list_add(&t->list, &triggers);
253 json_script_init(&t->jctx);
258 void trigger_add(struct blob_attr *rule, void *id)
260 struct blob_attr *cur;
263 blobmsg_for_each_attr(cur, rule, rem) {
264 struct blob_attr *_cur, *type = NULL, *script = NULL, *timeout = NULL;
268 if (blobmsg_type(cur) != BLOBMSG_TYPE_ARRAY)
271 blobmsg_for_each_attr(_cur, cur, _rem) {
274 if (blobmsg_type(_cur) == BLOBMSG_TYPE_STRING)
279 if (blobmsg_type(_cur) == BLOBMSG_TYPE_ARRAY)
284 if (blobmsg_type(_cur) == BLOBMSG_TYPE_INT32)
290 if (type && script) {
294 t = blobmsg_get_u32(timeout);
295 _trigger_add(blobmsg_get_string(type), script, t, id);
300 void trigger_del(void *id)
302 struct trigger *t, *n;
304 list_for_each_entry_safe(t, n, &triggers, list) {
317 void trigger_init(void)
320 q.empty_cb = q_empty;
321 q.max_running_tasks = 1;
324 void trigger_event(char *type, struct blob_attr *data)
328 list_for_each_entry(t, &triggers, list) {
329 if (t->pending || t->remove)
331 if (!strcmp(t->type, type)) {
334 t->data = blob_memdup(data);
335 uloop_timeout_set(&t->delay, t->timeout);
337 json_script_run(&t->jctx, "foo", data);