file: use blob_buf_free()
[project/rpcd.git] / exec.c
1 /*
2  * rpcd - UBUS RPC server
3  *
4  *   Copyright (C) 2013-2014 Jo-Philipp Wich <jow@openwrt.org>
5  *
6  * Permission to use, copy, modify, and/or distribute this software for any
7  * purpose with or without fee is hereby granted, provided that the above
8  * copyright notice and this permission notice appear in all copies.
9  *
10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17  */
18
19 #include <fcntl.h>
20 #include <errno.h>
21 #include <unistd.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <limits.h>
25 #include <dirent.h>
26 #include <sys/stat.h>
27 #include <sys/wait.h>
28
29 #include <rpcd/exec.h>
30
31 static int
32 rpc_errno_status(void)
33 {
34         switch (errno)
35         {
36         case EACCES:
37                 return UBUS_STATUS_PERMISSION_DENIED;
38
39         case ENOTDIR:
40                 return UBUS_STATUS_INVALID_ARGUMENT;
41
42         case ENOENT:
43                 return UBUS_STATUS_NOT_FOUND;
44
45         case EINVAL:
46                 return UBUS_STATUS_INVALID_ARGUMENT;
47
48         default:
49                 return UBUS_STATUS_UNKNOWN_ERROR;
50         }
51 }
52
53 const char *
54 rpc_exec_lookup(const char *cmd)
55 {
56         struct stat s;
57         int plen = 0, clen = strlen(cmd) + 1;
58         char *search, *p;
59         static char path[PATH_MAX];
60
61         if (!stat(cmd, &s) && S_ISREG(s.st_mode))
62                 return cmd;
63
64         search = getenv("PATH");
65
66         if (!search)
67                 search = "/bin:/usr/bin:/sbin:/usr/sbin";
68
69         p = search;
70
71         do
72         {
73                 if (*p != ':' && *p != '\0')
74                         continue;
75
76                 plen = p - search;
77
78                 if ((plen + clen) >= sizeof(path))
79                         continue;
80
81                 strncpy(path, search, plen);
82                 sprintf(path + plen, "/%s", cmd);
83
84                 if (!stat(path, &s) && S_ISREG(s.st_mode))
85                         return path;
86
87                 search = p + 1;
88         }
89         while (*p++);
90
91         return NULL;
92 }
93
94
95 static void
96 rpc_ustream_to_blobmsg(struct blob_buf *blob, struct ustream *s,
97                        const char *name)
98 {
99         int len;
100         char *rbuf, *wbuf;
101
102         if ((len = ustream_pending_data(s, false)) > 0)
103         {
104                 wbuf = blobmsg_alloc_string_buffer(blob, name, len + 1);
105
106                 if (!wbuf)
107                         return;
108
109                 ustream_for_each_read_buffer(s, rbuf, len)
110                 {
111                         memcpy(wbuf, rbuf, len);
112                         wbuf += len;
113                 }
114
115                 *wbuf = 0;
116                 blobmsg_add_string_buffer(blob);
117         }
118 }
119
120 static void
121 rpc_exec_reply(struct rpc_exec_context *c, int rv)
122 {
123         uloop_timeout_cancel(&c->timeout);
124         uloop_process_delete(&c->process);
125
126         if (rv == UBUS_STATUS_OK)
127         {
128                 if (!c->stdout_cb && !c->stderr_cb && !c->finish_cb)
129                 {
130                         blobmsg_add_u32(&c->blob, "code", WEXITSTATUS(c->stat));
131                         rpc_ustream_to_blobmsg(&c->blob, &c->opipe.stream, "stdout");
132                         rpc_ustream_to_blobmsg(&c->blob, &c->epipe.stream, "stderr");
133                 }
134
135                 if (c->finish_cb)
136                         rv = c->finish_cb(&c->blob, c->stat, c->priv);
137
138                 if (rv == UBUS_STATUS_OK)
139                         ubus_send_reply(c->context, &c->request, c->blob.head);
140         }
141
142         ubus_complete_deferred_request(c->context, &c->request, rv);
143
144         blob_buf_free(&c->blob);
145
146         ustream_free(&c->opipe.stream);
147         ustream_free(&c->epipe.stream);
148
149         close(c->opipe.fd.fd);
150         close(c->epipe.fd.fd);
151
152         if (c->priv)
153                 free(c->priv);
154
155         free(c);
156 }
157
158 static void
159 rpc_exec_timeout_cb(struct uloop_timeout *t)
160 {
161         struct rpc_exec_context *c =
162                 container_of(t, struct rpc_exec_context, timeout);
163
164         kill(c->process.pid, SIGKILL);
165         rpc_exec_reply(c, UBUS_STATUS_TIMEOUT);
166 }
167
168 static void
169 rpc_exec_process_cb(struct uloop_process *p, int stat)
170 {
171         struct rpc_exec_context *c =
172                 container_of(p, struct rpc_exec_context, process);
173
174         c->stat = stat;
175
176         ustream_poll(&c->opipe.stream);
177         ustream_poll(&c->epipe.stream);
178 }
179
180 static void
181 rpc_exec_ipipe_write_cb(struct ustream *s, int bytes)
182 {
183         struct rpc_exec_context *c =
184                 container_of(s, struct rpc_exec_context, ipipe.stream);
185
186         if (c->stdin_cb(s, c->priv) <= 0)
187         {
188                 ustream_free(&c->ipipe.stream);
189                 close(c->ipipe.fd.fd);
190         }
191 }
192
193 static void
194 rpc_exec_opipe_read_cb(struct ustream *s, int bytes)
195 {
196         int len, rv;
197         char *buf;
198         struct rpc_exec_context *c =
199                 container_of(s, struct rpc_exec_context, opipe.stream);
200
201         if (c->stdout_cb)
202         {
203                 do {
204                         buf = ustream_get_read_buf(s, &len);
205
206                         if (!buf || !len)
207                                 break;
208
209                         rv = c->stdout_cb(&c->blob, buf, len, c->priv);
210
211                         if (rv <= 0)
212                                 break;
213
214                         ustream_consume(s, rv);
215                 } while(1);
216         }
217         else if (ustream_read_buf_full(s))
218         {
219                 rpc_exec_reply(c, UBUS_STATUS_NOT_SUPPORTED);
220         }
221 }
222
223 static void
224 rpc_exec_epipe_read_cb(struct ustream *s, int bytes)
225 {
226         int len, rv;
227         char *buf;
228         struct rpc_exec_context *c =
229                 container_of(s, struct rpc_exec_context, epipe.stream);
230
231         if (c->stderr_cb)
232         {
233                 do {
234                         buf = ustream_get_read_buf(s, &len);
235
236                         if (!buf || !len)
237                                 break;
238
239                         rv = c->stderr_cb(&c->blob, buf, len, c->priv);
240
241                         if (rv <= 0)
242                                 break;
243
244                         ustream_consume(s, rv);
245                 } while(1);
246         }
247         else if (ustream_read_buf_full(s))
248         {
249                 rpc_exec_reply(c, UBUS_STATUS_NOT_SUPPORTED);
250         }
251 }
252
253 static void
254 rpc_exec_opipe_state_cb(struct ustream *s)
255 {
256         struct rpc_exec_context *c =
257                 container_of(s, struct rpc_exec_context, opipe.stream);
258
259         if (c->opipe.stream.eof && c->epipe.stream.eof)
260                 rpc_exec_reply(c, UBUS_STATUS_OK);
261 }
262
263 static void
264 rpc_exec_epipe_state_cb(struct ustream *s)
265 {
266         struct rpc_exec_context *c =
267                 container_of(s, struct rpc_exec_context, epipe.stream);
268
269         if (c->opipe.stream.eof && c->epipe.stream.eof)
270                 rpc_exec_reply(c, UBUS_STATUS_OK);
271 }
272
273 int
274 rpc_exec(const char **args, rpc_exec_write_cb_t in,
275          rpc_exec_read_cb_t out, rpc_exec_read_cb_t err,
276          rpc_exec_done_cb_t end, void *priv, struct ubus_context *ctx,
277          struct ubus_request_data *req)
278 {
279         pid_t pid;
280
281         int ipipe[2];
282         int opipe[2];
283         int epipe[2];
284
285         const char *cmd;
286         struct rpc_exec_context *c;
287
288         cmd = rpc_exec_lookup(args[0]);
289
290         if (!cmd)
291                 return UBUS_STATUS_NOT_FOUND;
292
293         c = malloc(sizeof(*c));
294
295         if (!c)
296                 return UBUS_STATUS_UNKNOWN_ERROR;
297
298         if (pipe(ipipe))
299                 goto fail_ipipe;
300
301         if (pipe(opipe))
302                 goto fail_opipe;
303
304         if (pipe(epipe))
305                 goto fail_epipe;
306
307         switch ((pid = fork()))
308         {
309         case -1:
310                 return rpc_errno_status();
311
312         case 0:
313                 uloop_done();
314
315                 dup2(ipipe[0], 0);
316                 dup2(opipe[1], 1);
317                 dup2(epipe[1], 2);
318
319                 close(ipipe[0]);
320                 close(ipipe[1]);
321                 close(opipe[0]);
322                 close(opipe[1]);
323                 close(epipe[0]);
324                 close(epipe[1]);
325
326                 if (execv(cmd, (char * const *)args))
327                         return rpc_errno_status();
328
329         default:
330                 memset(c, 0, sizeof(*c));
331                 blob_buf_init(&c->blob, 0);
332
333                 c->stdin_cb  = in;
334                 c->stdout_cb = out;
335                 c->stderr_cb = err;
336                 c->finish_cb = end;
337                 c->priv      = priv;
338
339                 ustream_declare_read(c->opipe, opipe[0], opipe);
340                 ustream_declare_read(c->epipe, epipe[0], epipe);
341
342                 c->process.pid = pid;
343                 c->process.cb = rpc_exec_process_cb;
344                 uloop_process_add(&c->process);
345
346                 c->timeout.cb = rpc_exec_timeout_cb;
347                 uloop_timeout_set(&c->timeout, RPC_EXEC_MAX_RUNTIME);
348
349                 if (c->stdin_cb)
350                 {
351                         ustream_declare_write(c->ipipe, ipipe[1], ipipe);
352                         rpc_exec_ipipe_write_cb(&c->ipipe.stream, 0);
353                 }
354                 else
355                 {
356                         close(ipipe[1]);
357                 }
358
359                 close(ipipe[0]);
360                 close(opipe[1]);
361                 close(epipe[1]);
362
363                 c->context = ctx;
364                 ubus_defer_request(ctx, req, &c->request);
365         }
366
367         return UBUS_STATUS_OK;
368
369 fail_epipe:
370         close(opipe[0]);
371         close(opipe[1]);
372
373 fail_opipe:
374         close(ipipe[0]);
375         close(ipipe[1]);
376
377 fail_ipipe:
378         return rpc_errno_status();
379 }