Line data Source code
1 : /*
2 : Unix SMB/CIFS implementation.
3 :
4 : run a child command
5 :
6 : Copyright (C) Andrew Tridgell 2010
7 :
8 : This program is free software; you can redistribute it and/or modify
9 : it under the terms of the GNU General Public License as published by
10 : the Free Software Foundation; either version 3 of the License, or
11 : (at your option) any later version.
12 :
13 : This program is distributed in the hope that it will be useful,
14 : but WITHOUT ANY WARRANTY; without even the implied warranty of
15 : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 : GNU General Public License for more details.
17 :
18 : You should have received a copy of the GNU General Public License
19 : along with this program. If not, see <http://www.gnu.org/licenses/>.
20 :
21 : */
22 :
23 : /*
24 : this runs a child command with stdout and stderr going to the Samba
25 : log
26 : */
27 :
28 : #include "replace.h"
29 : #include "system/filesys.h"
30 : #include "system/wait.h"
31 : #include <tevent.h>
32 : #include "lib/util/samba_util.h"
33 : #include "lib/util/debug.h"
34 : #include "../lib/util/tevent_unix.h"
35 : #include "../lib/util/tfork.h"
36 : #include "../lib/util/sys_rw.h"
37 :
38 : struct samba_runcmd_state {
39 : int stdout_log_level;
40 : int stderr_log_level;
41 : struct tevent_fd *fde_stdout;
42 : struct tevent_fd *fde_stderr;
43 : struct tevent_fd *fde_status;
44 : int fd_stdin, fd_stdout, fd_stderr, fd_status;
45 : char *arg0;
46 : pid_t pid;
47 : struct tfork *tfork;
48 : char buf[1024];
49 : uint16_t buf_used;
50 : };
51 :
52 1448 : static void samba_runcmd_cleanup_fn(struct tevent_req *req,
53 : enum tevent_req_state req_state)
54 : {
55 1448 : struct samba_runcmd_state *state = tevent_req_data(
56 : req, struct samba_runcmd_state);
57 :
58 1448 : if (state->tfork != NULL) {
59 131 : tfork_destroy(&state->tfork);
60 : }
61 1448 : state->pid = -1;
62 :
63 1448 : if (state->fd_stdin != -1) {
64 765 : close(state->fd_stdin);
65 765 : state->fd_stdin = -1;
66 : }
67 1448 : }
68 :
69 23 : int samba_runcmd_export_stdin(struct tevent_req *req)
70 : {
71 23 : struct samba_runcmd_state *state = tevent_req_data(req,
72 : struct samba_runcmd_state);
73 23 : int ret = state->fd_stdin;
74 :
75 23 : state->fd_stdin = -1;
76 :
77 23 : return ret;
78 : }
79 :
80 : static void samba_runcmd_io_handler(struct tevent_context *ev,
81 : struct tevent_fd *fde,
82 : uint16_t flags,
83 : void *private_data);
84 :
85 : /*
86 : run a command as a child process, with a timeout.
87 :
88 : any stdout/stderr from the child will appear in the Samba logs with
89 : the specified log levels
90 : */
91 788 : struct tevent_req *samba_runcmd_send(TALLOC_CTX *mem_ctx,
92 : struct tevent_context *ev,
93 : struct timeval endtime,
94 : int stdout_log_level,
95 : int stderr_log_level,
96 : const char * const *argv0, ...)
97 : {
98 : struct tevent_req *req;
99 : struct samba_runcmd_state *state;
100 : int p1[2], p2[2], p3[2];
101 : char **argv;
102 : va_list ap;
103 :
104 788 : if (argv0 == NULL) {
105 0 : return NULL;
106 : }
107 :
108 788 : req = tevent_req_create(mem_ctx, &state,
109 : struct samba_runcmd_state);
110 788 : if (req == NULL) {
111 0 : return NULL;
112 : }
113 :
114 788 : state->stdout_log_level = stdout_log_level;
115 788 : state->stderr_log_level = stderr_log_level;
116 788 : state->fd_stdin = -1;
117 :
118 788 : state->arg0 = talloc_strdup(state, argv0[0]);
119 788 : if (tevent_req_nomem(state->arg0, req)) {
120 0 : return tevent_req_post(req, ev);
121 : }
122 :
123 788 : if (pipe(p1) != 0) {
124 0 : tevent_req_error(req, errno);
125 0 : return tevent_req_post(req, ev);
126 : }
127 788 : if (pipe(p2) != 0) {
128 0 : close(p1[0]);
129 0 : close(p1[1]);
130 0 : tevent_req_error(req, errno);
131 0 : return tevent_req_post(req, ev);
132 : }
133 788 : if (pipe(p3) != 0) {
134 0 : close(p1[0]);
135 0 : close(p1[1]);
136 0 : close(p2[0]);
137 0 : close(p2[1]);
138 0 : tevent_req_error(req, errno);
139 0 : return tevent_req_post(req, ev);
140 : }
141 :
142 788 : state->tfork = tfork_create();
143 1576 : if (state->tfork == NULL) {
144 0 : close(p1[0]);
145 0 : close(p1[1]);
146 0 : close(p2[0]);
147 0 : close(p2[1]);
148 0 : close(p3[0]);
149 0 : close(p3[1]);
150 0 : tevent_req_error(req, errno);
151 0 : return tevent_req_post(req, ev);
152 : }
153 1576 : state->pid = tfork_child_pid(state->tfork);
154 1576 : if (state->pid != 0) {
155 : /* the parent */
156 788 : close(p1[1]);
157 788 : close(p2[1]);
158 788 : close(p3[0]);
159 788 : state->fd_stdout = p1[0];
160 788 : state->fd_stderr = p2[0];
161 788 : state->fd_stdin = p3[1];
162 788 : state->fd_status = tfork_event_fd(state->tfork);
163 :
164 788 : set_blocking(state->fd_stdout, false);
165 788 : set_blocking(state->fd_stderr, false);
166 788 : set_blocking(state->fd_stdin, false);
167 788 : set_blocking(state->fd_status, false);
168 :
169 788 : smb_set_close_on_exec(state->fd_stdin);
170 788 : smb_set_close_on_exec(state->fd_stdout);
171 788 : smb_set_close_on_exec(state->fd_stderr);
172 788 : smb_set_close_on_exec(state->fd_status);
173 :
174 788 : tevent_req_set_cleanup_fn(req, samba_runcmd_cleanup_fn);
175 :
176 788 : state->fde_stdout = tevent_add_fd(ev, state,
177 : state->fd_stdout,
178 : TEVENT_FD_READ,
179 : samba_runcmd_io_handler,
180 : req);
181 788 : if (tevent_req_nomem(state->fde_stdout, req)) {
182 0 : close(state->fd_stdout);
183 0 : close(state->fd_stderr);
184 0 : close(state->fd_status);
185 0 : return tevent_req_post(req, ev);
186 : }
187 788 : tevent_fd_set_auto_close(state->fde_stdout);
188 :
189 788 : state->fde_stderr = tevent_add_fd(ev, state,
190 : state->fd_stderr,
191 : TEVENT_FD_READ,
192 : samba_runcmd_io_handler,
193 : req);
194 788 : if (tevent_req_nomem(state->fde_stdout, req)) {
195 0 : close(state->fd_stdout);
196 0 : close(state->fd_stderr);
197 0 : close(state->fd_status);
198 0 : return tevent_req_post(req, ev);
199 : }
200 788 : tevent_fd_set_auto_close(state->fde_stderr);
201 :
202 788 : state->fde_status = tevent_add_fd(ev, state,
203 : state->fd_status,
204 : TEVENT_FD_READ,
205 : samba_runcmd_io_handler,
206 : req);
207 788 : if (tevent_req_nomem(state->fde_stdout, req)) {
208 0 : close(state->fd_stdout);
209 0 : close(state->fd_stderr);
210 0 : close(state->fd_status);
211 0 : return tevent_req_post(req, ev);
212 : }
213 788 : tevent_fd_set_auto_close(state->fde_status);
214 :
215 788 : if (!timeval_is_zero(&endtime)) {
216 660 : tevent_req_set_endtime(req, ev, endtime);
217 : }
218 :
219 776 : return req;
220 : }
221 :
222 : /* the child */
223 788 : close(p1[0]);
224 788 : close(p2[0]);
225 788 : close(p3[1]);
226 788 : close(0);
227 788 : close(1);
228 788 : close(2);
229 :
230 : /* we want to ensure that all of the network sockets we had
231 : open are closed */
232 788 : tevent_re_initialise(ev);
233 :
234 : /* setup for logging to go to the parents debug log */
235 788 : dup2(p3[0], 0);
236 788 : dup2(p1[1], 1);
237 788 : dup2(p2[1], 2);
238 :
239 788 : close(p1[1]);
240 788 : close(p2[1]);
241 788 : close(p3[0]);
242 :
243 788 : argv = str_list_copy(state, discard_const_p(const char *, argv0));
244 788 : if (!argv) {
245 0 : fprintf(stderr, "Out of memory in child\n");
246 0 : _exit(255);
247 : }
248 :
249 788 : va_start(ap, argv0);
250 472 : while (1) {
251 : const char **l;
252 1277 : char *arg = va_arg(ap, char *);
253 1277 : if (arg == NULL) break;
254 489 : l = discard_const_p(const char *, argv);
255 489 : l = str_list_add(l, arg);
256 489 : if (l == NULL) {
257 0 : fprintf(stderr, "Out of memory in child\n");
258 0 : _exit(255);
259 : }
260 472 : argv = discard_const_p(char *, l);
261 : }
262 788 : va_end(ap);
263 :
264 788 : (void)execvp(state->arg0, argv);
265 788 : fprintf(stderr, "Failed to exec child - %s\n", strerror(errno));
266 0 : _exit(255);
267 : return NULL;
268 : }
269 :
270 : /*
271 : handle stdout/stderr from the child
272 : */
273 4071 : static void samba_runcmd_io_handler(struct tevent_context *ev,
274 : struct tevent_fd *fde,
275 : uint16_t flags,
276 : void *private_data)
277 : {
278 4071 : struct tevent_req *req = talloc_get_type_abort(private_data,
279 : struct tevent_req);
280 4071 : struct samba_runcmd_state *state = tevent_req_data(req,
281 : struct samba_runcmd_state);
282 : int level;
283 : char *p;
284 : int n, fd;
285 :
286 4071 : if (!(flags & TEVENT_FD_READ)) {
287 0 : return;
288 : }
289 :
290 4071 : if (fde == state->fde_stdout) {
291 1079 : level = state->stdout_log_level;
292 1079 : fd = state->fd_stdout;
293 2992 : } else if (fde == state->fde_stderr) {
294 2335 : level = state->stderr_log_level;
295 2335 : fd = state->fd_stderr;
296 : } else {
297 : int status;
298 :
299 657 : status = tfork_status(&state->tfork, false);
300 657 : if (status == -1) {
301 0 : if (errno == EAGAIN || errno == EWOULDBLOCK) {
302 0 : return;
303 : }
304 0 : DBG_ERR("Bad read on status pipe\n");
305 0 : tevent_req_error(req, errno);
306 0 : return;
307 : }
308 657 : state->pid = -1;
309 657 : TALLOC_FREE(fde);
310 :
311 657 : if (WIFEXITED(status)) {
312 657 : status = WEXITSTATUS(status);
313 0 : } else if (WIFSIGNALED(status)) {
314 0 : status = WTERMSIG(status);
315 : } else {
316 0 : status = ECHILD;
317 : }
318 :
319 657 : DBG_NOTICE("Child %s exited %d\n", state->arg0, status);
320 657 : if (status != 0) {
321 20 : tevent_req_error(req, status);
322 20 : return;
323 : }
324 :
325 637 : tevent_req_done(req);
326 637 : return;
327 : }
328 :
329 4306 : n = read(fd, &state->buf[state->buf_used],
330 3414 : sizeof(state->buf) - state->buf_used);
331 3414 : if (n > 0) {
332 1881 : state->buf_used += n;
333 1533 : } else if (n == 0) {
334 1533 : if (fde == state->fde_stdout) {
335 765 : talloc_free(fde);
336 765 : state->fde_stdout = NULL;
337 765 : return;
338 : }
339 768 : if (fde == state->fde_stderr) {
340 768 : talloc_free(fde);
341 768 : state->fde_stderr = NULL;
342 768 : return;
343 : }
344 0 : return;
345 : }
346 :
347 6863 : while (state->buf_used > 0 &&
348 2008 : (p = (char *)memchr(state->buf, '\n', state->buf_used)) != NULL) {
349 1994 : int n1 = (p - state->buf)+1;
350 1994 : int n2 = n1 - 1;
351 : /* swallow \r from child processes */
352 1994 : if (n2 > 0 && state->buf[n2-1] == '\r') {
353 0 : n2--;
354 : }
355 1994 : DEBUG(level,("%s: %*.*s\n", state->arg0, n2, n2, state->buf));
356 2033 : memmove(state->buf, p+1, sizeof(state->buf) - n1);
357 1994 : state->buf_used -= n1;
358 : }
359 :
360 : /* the buffer could have completely filled - unfortunately we have
361 : no choice but to dump it out straight away */
362 1881 : if (state->buf_used == sizeof(state->buf)) {
363 0 : DEBUG(level,("%s: %*.*s\n",
364 : state->arg0, state->buf_used,
365 : state->buf_used, state->buf));
366 0 : state->buf_used = 0;
367 : }
368 : }
369 :
370 659 : int samba_runcmd_recv(struct tevent_req *req, int *perrno)
371 : {
372 659 : if (tevent_req_is_unix_error(req, perrno)) {
373 23 : tevent_req_received(req);
374 23 : return -1;
375 : }
376 :
377 636 : tevent_req_received(req);
378 636 : return 0;
379 : }
|
