source: vendor/3.6.0/lib/util/util_runcmd.c

Last change on this file was 740, checked in by Silvan Scherrer, 13 years ago

Samba Server: update vendor to 3.6.0
File size: 7.6 KB
Line 
1/*
2 Unix SMB/CIFS mplementation.
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 "includes.h"
29#include "system/filesys.h"
30#include <tevent.h>
31#include "../lib/util/tevent_unix.h"
32
33struct samba_runcmd_state {
34 int stdout_log_level;
35 int stderr_log_level;
36 struct tevent_fd *fde_stdout;
37 struct tevent_fd *fde_stderr;
38 int fd_stdout, fd_stderr;
39 char *arg0;
40 pid_t pid;
41 char buf[1024];
42 uint16_t buf_used;
43};
44
45static int samba_runcmd_state_destructor(struct samba_runcmd_state *state)
46{
47 if (state->pid > 0) {
48 kill(state->pid, SIGKILL);
49 waitpid(state->pid, NULL, 0);
50 state->pid = -1;
51 }
52 return 0;
53}
54
55static void samba_runcmd_io_handler(struct tevent_context *ev,
56 struct tevent_fd *fde,
57 uint16_t flags,
58 void *private_data);
59
60/*
61 run a command as a child process, with a timeout.
62
63 any stdout/stderr from the child will appear in the Samba logs with
64 the specified log levels
65 */
66struct tevent_req *samba_runcmd_send(TALLOC_CTX *mem_ctx,
67 struct tevent_context *ev,
68 struct timeval endtime,
69 int stdout_log_level,
70 int stderr_log_level,
71 const char * const *argv0, ...)
72{
73 struct tevent_req *req;
74 struct samba_runcmd_state *state;
75 int p1[2], p2[2];
76 char **argv;
77 int ret;
78 va_list ap;
79
80 req = tevent_req_create(mem_ctx, &state,
81 struct samba_runcmd_state);
82 if (req == NULL) {
83 return NULL;
84 }
85
86 state->stdout_log_level = stdout_log_level;
87 state->stderr_log_level = stderr_log_level;
88
89 state->arg0 = talloc_strdup(state, argv0[0]);
90 if (tevent_req_nomem(state->arg0, req)) {
91 return tevent_req_post(req, ev);
92 }
93
94 if (pipe(p1) != 0) {
95 tevent_req_error(req, errno);
96 return tevent_req_post(req, ev);
97 }
98 if (pipe(p2) != 0) {
99 close(p1[0]);
100 close(p1[1]);
101 tevent_req_error(req, errno);
102 return tevent_req_post(req, ev);
103 }
104
105 state->pid = fork();
106 if (state->pid == (pid_t)-1) {
107 close(p1[0]);
108 close(p1[1]);
109 close(p2[0]);
110 close(p2[1]);
111 tevent_req_error(req, errno);
112 return tevent_req_post(req, ev);
113 }
114
115 if (state->pid != 0) {
116 /* the parent */
117 close(p1[1]);
118 close(p2[1]);
119 state->fd_stdout = p1[0];
120 state->fd_stderr = p2[0];
121 set_blocking(state->fd_stdout, false);
122 set_blocking(state->fd_stderr, false);
123
124 talloc_set_destructor(state, samba_runcmd_state_destructor);
125
126 state->fde_stdout = tevent_add_fd(ev, state,
127 state->fd_stdout,
128 TEVENT_FD_READ,
129 samba_runcmd_io_handler,
130 req);
131 if (tevent_req_nomem(state->fde_stdout, req)) {
132 close(p1[0]);
133 close(p2[0]);
134 return tevent_req_post(req, ev);
135 }
136 tevent_fd_set_auto_close(state->fde_stdout);
137
138 state->fde_stderr = tevent_add_fd(ev, state,
139 state->fd_stderr,
140 TEVENT_FD_READ,
141 samba_runcmd_io_handler,
142 req);
143 if (tevent_req_nomem(state->fde_stdout, req)) {
144 close(p2[0]);
145 return tevent_req_post(req, ev);
146 }
147 tevent_fd_set_auto_close(state->fde_stderr);
148
149 if (!timeval_is_zero(&endtime)) {
150 tevent_req_set_endtime(req, ev, endtime);
151 }
152
153 return req;
154 }
155
156 /* the child */
157 close(p1[0]);
158 close(p2[0]);
159 close(0);
160 close(1);
161 close(2);
162
163 /* we want to ensure that all of the network sockets we had
164 open are closed */
165 tevent_re_initialise(ev);
166
167 /* setup for logging to go to the parents debug log */
168 open("/dev/null", O_RDONLY); /* for stdin */
169 dup2(p1[1], 1);
170 dup2(p2[1], 2);
171
172 argv = str_list_copy(state, discard_const_p(const char *, argv0));
173 if (!argv) {
174 fprintf(stderr, "Out of memory in child\n");
175 _exit(255);
176 }
177
178 va_start(ap, argv0);
179 while (1) {
180 char *arg = va_arg(ap, char *);
181 if (arg == NULL) break;
182 argv = discard_const_p(char *, str_list_add((const char **)argv, arg));
183 if (!argv) {
184 fprintf(stderr, "Out of memory in child\n");
185 _exit(255);
186 }
187 }
188 va_end(ap);
189
190 ret = execvp(state->arg0, argv);
191 fprintf(stderr, "Failed to exec child - %s\n", strerror(errno));
192 _exit(255);
193 return NULL;
194}
195
196/*
197 handle stdout/stderr from the child
198 */
199static void samba_runcmd_io_handler(struct tevent_context *ev,
200 struct tevent_fd *fde,
201 uint16_t flags,
202 void *private_data)
203{
204 struct tevent_req *req = talloc_get_type_abort(private_data,
205 struct tevent_req);
206 struct samba_runcmd_state *state = tevent_req_data(req,
207 struct samba_runcmd_state);
208 int level;
209 char *p;
210 int n, fd;
211
212 if (fde == state->fde_stdout) {
213 level = state->stdout_log_level;
214 fd = state->fd_stdout;
215 } else {
216 level = state->stderr_log_level;
217 fd = state->fd_stderr;
218 }
219
220 if (!(flags & TEVENT_FD_READ)) {
221 return;
222 }
223
224 n = read(fd, &state->buf[state->buf_used],
225 sizeof(state->buf) - state->buf_used);
226 if (n > 0) {
227 state->buf_used += n;
228 } else if (n == 0) {
229 if (fde == state->fde_stdout) {
230 talloc_free(fde);
231 state->fde_stdout = NULL;
232 }
233 if (fde == state->fde_stderr) {
234 talloc_free(fde);
235 state->fde_stderr = NULL;
236 }
237 if (state->fde_stdout == NULL &&
238 state->fde_stderr == NULL) {
239 int status;
240 /* the child has closed both stdout and
241 * stderr, assume its dead */
242 pid_t pid = waitpid(state->pid, &status, 0);
243 if (pid != state->pid) {
244 if (errno == ECHILD) {
245 /* this happens when the
246 parent has set SIGCHLD to
247 SIG_IGN. In that case we
248 can only get error
249 information for the child
250 via its logging. We should
251 stop using SIG_IGN on
252 SIGCHLD in the standard
253 process model.
254 */
255 tevent_req_done(req);
256 return;
257 }
258 DEBUG(0,("Error in waitpid() for child %s - %s \n",
259 state->arg0, strerror(errno)));
260 if (errno == 0) {
261 errno = ECHILD;
262 }
263 tevent_req_error(req, errno);
264 return;
265 }
266 status = WEXITSTATUS(status);
267 DEBUG(3,("Child %s exited with status %d - %s\n",
268 state->arg0, status, strerror(status)));
269 if (status != 0) {
270 tevent_req_error(req, status);
271 return;
272 }
273
274 tevent_req_done(req);
275 return;
276 }
277 return;
278 }
279
280 while (state->buf_used > 0 &&
281 (p = (char *)memchr(state->buf, '\n', state->buf_used)) != NULL) {
282 int n1 = (p - state->buf)+1;
283 int n2 = n1 - 1;
284 /* swallow \r from child processes */
285 if (n2 > 0 && state->buf[n2-1] == '\r') {
286 n2--;
287 }
288 DEBUG(level,("%s: %*.*s\n", state->arg0, n2, n2, state->buf));
289 memmove(state->buf, p+1, sizeof(state->buf) - n1);
290 state->buf_used -= n1;
291 }
292
293 /* the buffer could have completely filled - unfortunately we have
294 no choice but to dump it out straight away */
295 if (state->buf_used == sizeof(state->buf)) {
296 DEBUG(level,("%s: %*.*s\n",
297 state->arg0, state->buf_used,
298 state->buf_used, state->buf));
299 state->buf_used = 0;
300 }
301}
302
303int samba_runcmd_recv(struct tevent_req *req, int *perrno)
304{
305 if (tevent_req_is_unix_error(req, perrno)) {
306 tevent_req_received(req);
307 return -1;
308 }
309
310 tevent_req_received(req);
311 return 0;
312}
Note: See TracBrowser for help on using the repository browser.