2 Unix SMB/CIFS implementation.
6 Copyright (C) Andrew Tridgell 2010
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.
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.
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/>.
24 this runs a child command with stdout and stderr going to the Samba
29 #include "system/filesys.h"
31 #include "../lib/util/tevent_unix.h"
32 #include "../lib/util/tfork.h"
33 #include "../lib/util/sys_rw.h"
35 struct samba_runcmd_state
{
38 struct tevent_fd
*fde_stdout
;
39 struct tevent_fd
*fde_stderr
;
40 struct tevent_fd
*fde_status
;
41 int fd_stdin
, fd_stdout
, fd_stderr
, fd_status
;
49 static void samba_runcmd_cleanup_fn(struct tevent_req
*req
,
50 enum tevent_req_state req_state
)
52 struct samba_runcmd_state
*state
= tevent_req_data(
53 req
, struct samba_runcmd_state
);
55 if (state
->tfork
!= NULL
) {
56 tfork_destroy(&state
->tfork
);
60 if (state
->fd_stdin
!= -1) {
61 close(state
->fd_stdin
);
66 int samba_runcmd_export_stdin(struct tevent_req
*req
)
68 struct samba_runcmd_state
*state
= tevent_req_data(req
,
69 struct samba_runcmd_state
);
70 int ret
= state
->fd_stdin
;
77 static void samba_runcmd_io_handler(struct tevent_context
*ev
,
78 struct tevent_fd
*fde
,
83 run a command as a child process, with a timeout.
85 any stdout/stderr from the child will appear in the Samba logs with
86 the specified log levels
88 struct tevent_req
*samba_runcmd_send(TALLOC_CTX
*mem_ctx
,
89 struct tevent_context
*ev
,
90 struct timeval endtime
,
93 const char * const *argv0
, ...)
95 struct tevent_req
*req
;
96 struct samba_runcmd_state
*state
;
97 int p1
[2], p2
[2], p3
[2];
105 req
= tevent_req_create(mem_ctx
, &state
,
106 struct samba_runcmd_state
);
111 state
->stdout_log_level
= stdout_log_level
;
112 state
->stderr_log_level
= stderr_log_level
;
113 state
->fd_stdin
= -1;
115 state
->arg0
= talloc_strdup(state
, argv0
[0]);
116 if (tevent_req_nomem(state
->arg0
, req
)) {
117 return tevent_req_post(req
, ev
);
121 tevent_req_error(req
, errno
);
122 return tevent_req_post(req
, ev
);
127 tevent_req_error(req
, errno
);
128 return tevent_req_post(req
, ev
);
135 tevent_req_error(req
, errno
);
136 return tevent_req_post(req
, ev
);
139 state
->tfork
= tfork_create();
140 if (state
->tfork
== NULL
) {
147 tevent_req_error(req
, errno
);
148 return tevent_req_post(req
, ev
);
150 state
->pid
= tfork_child_pid(state
->tfork
);
151 if (state
->pid
!= 0) {
156 state
->fd_stdout
= p1
[0];
157 state
->fd_stderr
= p2
[0];
158 state
->fd_stdin
= p3
[1];
159 state
->fd_status
= tfork_event_fd(state
->tfork
);
161 set_blocking(state
->fd_stdout
, false);
162 set_blocking(state
->fd_stderr
, false);
163 set_blocking(state
->fd_stdin
, false);
164 set_blocking(state
->fd_status
, false);
166 smb_set_close_on_exec(state
->fd_stdin
);
167 smb_set_close_on_exec(state
->fd_stdout
);
168 smb_set_close_on_exec(state
->fd_stderr
);
169 smb_set_close_on_exec(state
->fd_status
);
171 tevent_req_set_cleanup_fn(req
, samba_runcmd_cleanup_fn
);
173 state
->fde_stdout
= tevent_add_fd(ev
, state
,
176 samba_runcmd_io_handler
,
178 if (tevent_req_nomem(state
->fde_stdout
, req
)) {
179 close(state
->fd_stdout
);
180 close(state
->fd_stderr
);
181 close(state
->fd_status
);
182 return tevent_req_post(req
, ev
);
184 tevent_fd_set_auto_close(state
->fde_stdout
);
186 state
->fde_stderr
= tevent_add_fd(ev
, state
,
189 samba_runcmd_io_handler
,
191 if (tevent_req_nomem(state
->fde_stdout
, req
)) {
192 close(state
->fd_stdout
);
193 close(state
->fd_stderr
);
194 close(state
->fd_status
);
195 return tevent_req_post(req
, ev
);
197 tevent_fd_set_auto_close(state
->fde_stderr
);
199 state
->fde_status
= tevent_add_fd(ev
, state
,
202 samba_runcmd_io_handler
,
204 if (tevent_req_nomem(state
->fde_stdout
, req
)) {
205 close(state
->fd_stdout
);
206 close(state
->fd_stderr
);
207 close(state
->fd_status
);
208 return tevent_req_post(req
, ev
);
210 tevent_fd_set_auto_close(state
->fde_status
);
212 if (!timeval_is_zero(&endtime
)) {
213 tevent_req_set_endtime(req
, ev
, endtime
);
227 /* we want to ensure that all of the network sockets we had
229 tevent_re_initialise(ev
);
231 /* setup for logging to go to the parents debug log */
240 argv
= str_list_copy(state
, discard_const_p(const char *, argv0
));
242 fprintf(stderr
, "Out of memory in child\n");
249 char *arg
= va_arg(ap
, char *);
250 if (arg
== NULL
) break;
251 l
= discard_const_p(const char *, argv
);
252 l
= str_list_add(l
, arg
);
254 fprintf(stderr
, "Out of memory in child\n");
257 argv
= discard_const_p(char *, l
);
261 (void)execvp(state
->arg0
, argv
);
262 fprintf(stderr
, "Failed to exec child - %s\n", strerror(errno
));
268 handle stdout/stderr from the child
270 static void samba_runcmd_io_handler(struct tevent_context
*ev
,
271 struct tevent_fd
*fde
,
275 struct tevent_req
*req
= talloc_get_type_abort(private_data
,
277 struct samba_runcmd_state
*state
= tevent_req_data(req
,
278 struct samba_runcmd_state
);
283 if (!(flags
& TEVENT_FD_READ
)) {
287 if (fde
== state
->fde_stdout
) {
288 level
= state
->stdout_log_level
;
289 fd
= state
->fd_stdout
;
290 } else if (fde
== state
->fde_stderr
) {
291 level
= state
->stderr_log_level
;
292 fd
= state
->fd_stderr
;
296 status
= tfork_status(&state
->tfork
, false);
298 if (errno
== EAGAIN
|| errno
== EWOULDBLOCK
) {
301 DBG_ERR("Bad read on status pipe\n");
302 tevent_req_error(req
, errno
);
308 if (WIFEXITED(status
)) {
309 status
= WEXITSTATUS(status
);
310 } else if (WIFSIGNALED(status
)) {
311 status
= WTERMSIG(status
);
316 DBG_NOTICE("Child %s exited %d\n", state
->arg0
, status
);
318 tevent_req_error(req
, status
);
322 tevent_req_done(req
);
326 n
= read(fd
, &state
->buf
[state
->buf_used
],
327 sizeof(state
->buf
) - state
->buf_used
);
329 state
->buf_used
+= n
;
331 if (fde
== state
->fde_stdout
) {
333 state
->fde_stdout
= NULL
;
336 if (fde
== state
->fde_stderr
) {
338 state
->fde_stderr
= NULL
;
344 while (state
->buf_used
> 0 &&
345 (p
= (char *)memchr(state
->buf
, '\n', state
->buf_used
)) != NULL
) {
346 int n1
= (p
- state
->buf
)+1;
348 /* swallow \r from child processes */
349 if (n2
> 0 && state
->buf
[n2
-1] == '\r') {
352 DEBUG(level
,("%s: %*.*s\n", state
->arg0
, n2
, n2
, state
->buf
));
353 memmove(state
->buf
, p
+1, sizeof(state
->buf
) - n1
);
354 state
->buf_used
-= n1
;
357 /* the buffer could have completely filled - unfortunately we have
358 no choice but to dump it out straight away */
359 if (state
->buf_used
== sizeof(state
->buf
)) {
360 DEBUG(level
,("%s: %*.*s\n",
361 state
->arg0
, state
->buf_used
,
362 state
->buf_used
, state
->buf
));
367 int samba_runcmd_recv(struct tevent_req
*req
, int *perrno
)
369 if (tevent_req_is_unix_error(req
, perrno
)) {
370 tevent_req_received(req
);
374 tevent_req_received(req
);