lib/util/util_runcmd.c

   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 static void samba_runcmd_cleanup_fn(struct tevent_req *req,
  53                                     enum tevent_req_state req_state)
  54 {
  55         struct samba_runcmd_state *state = tevent_req_data(
  56                 req, struct samba_runcmd_state);
  57
  58         if (state->tfork != NULL) {
  59                 tfork_destroy(&state->tfork);
  60         }
  61         state->pid = -1;
  62
  63         if (state->fd_stdin != -1) {
  64                 close(state->fd_stdin);
  65                 state->fd_stdin = -1;
  66         }
  67 }
  68
  69 int samba_runcmd_export_stdin(struct tevent_req *req)
  70 {
  71         struct samba_runcmd_state *state = tevent_req_data(req,
  72                                            struct samba_runcmd_state);
  73         int ret = state->fd_stdin;
  74
  75         state->fd_stdin = -1;
  76
  77         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 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         if (argv0 == NULL) {
 105                 return NULL;
 106         }
 107
 108         req = tevent_req_create(mem_ctx, &state,
 109                                 struct samba_runcmd_state);
 110         if (req == NULL) {
 111                 return NULL;
 112         }
 113
 114         state->stdout_log_level = stdout_log_level;
 115         state->stderr_log_level = stderr_log_level;
 116         state->fd_stdin = -1;
 117
 118         state->arg0 = talloc_strdup(state, argv0[0]);
 119         if (tevent_req_nomem(state->arg0, req)) {
 120                 return tevent_req_post(req, ev);
 121         }
 122
 123         if (pipe(p1) != 0) {
 124                 tevent_req_error(req, errno);
 125                 return tevent_req_post(req, ev);
 126         }
 127         if (pipe(p2) != 0) {
 128                 close(p1[0]);
 129                 close(p1[1]);
 130                 tevent_req_error(req, errno);
 131                 return tevent_req_post(req, ev);
 132         }
 133         if (pipe(p3) != 0) {
 134                 close(p1[0]);
 135                 close(p1[1]);
 136                 close(p2[0]);
 137                 close(p2[1]);
 138                 tevent_req_error(req, errno);
 139                 return tevent_req_post(req, ev);
 140         }
 141
 142         state->tfork = tfork_create();
 143         if (state->tfork == NULL) {
 144                 close(p1[0]);
 145                 close(p1[1]);
 146                 close(p2[0]);
 147                 close(p2[1]);
 148                 close(p3[0]);
 149                 close(p3[1]);
 150                 tevent_req_error(req, errno);
 151                 return tevent_req_post(req, ev);
 152         }
 153         state->pid = tfork_child_pid(state->tfork);
 154         if (state->pid != 0) {
 155                 /* the parent */
 156                 close(p1[1]);
 157                 close(p2[1]);
 158                 close(p3[0]);
 159                 state->fd_stdout = p1[0];
 160                 state->fd_stderr = p2[0];
 161                 state->fd_stdin  = p3[1];
 162                 state->fd_status = tfork_event_fd(state->tfork);
 163
 164                 set_blocking(state->fd_stdout, false);
 165                 set_blocking(state->fd_stderr, false);
 166                 set_blocking(state->fd_stdin,  false);
 167                 set_blocking(state->fd_status, false);
 168
 169                 smb_set_close_on_exec(state->fd_stdin);
 170                 smb_set_close_on_exec(state->fd_stdout);
 171                 smb_set_close_on_exec(state->fd_stderr);
 172                 smb_set_close_on_exec(state->fd_status);
 173
 174                 tevent_req_set_cleanup_fn(req, samba_runcmd_cleanup_fn);
 175
 176                 state->fde_stdout = tevent_add_fd(ev, state,
 177                                                   state->fd_stdout,
 178                                                   TEVENT_FD_READ,
 179                                                   samba_runcmd_io_handler,
 180                                                   req);
 181                 if (tevent_req_nomem(state->fde_stdout, req)) {
 182                         close(state->fd_stdout);
 183                         close(state->fd_stderr);
 184                         close(state->fd_status);
 185                         return tevent_req_post(req, ev);
 186                 }
 187                 tevent_fd_set_auto_close(state->fde_stdout);
 188
 189                 state->fde_stderr = tevent_add_fd(ev, state,
 190                                                   state->fd_stderr,
 191                                                   TEVENT_FD_READ,
 192                                                   samba_runcmd_io_handler,
 193                                                   req);
 194                 if (tevent_req_nomem(state->fde_stdout, req)) {
 195                         close(state->fd_stdout);
 196                         close(state->fd_stderr);
 197                         close(state->fd_status);
 198                         return tevent_req_post(req, ev);
 199                 }
 200                 tevent_fd_set_auto_close(state->fde_stderr);
 201
 202                 state->fde_status = tevent_add_fd(ev, state,
 203                                                   state->fd_status,
 204                                                   TEVENT_FD_READ,
 205                                                   samba_runcmd_io_handler,
 206                                                   req);
 207                 if (tevent_req_nomem(state->fde_stdout, req)) {
 208                         close(state->fd_stdout);
 209                         close(state->fd_stderr);
 210                         close(state->fd_status);
 211                         return tevent_req_post(req, ev);
 212                 }
 213                 tevent_fd_set_auto_close(state->fde_status);
 214
 215                 if (!timeval_is_zero(&endtime)) {
 216                         tevent_req_set_endtime(req, ev, endtime);
 217                 }
 218
 219                 return req;
 220         }
 221
 222         /* the child */
 223         close(p1[0]);
 224         close(p2[0]);
 225         close(p3[1]);
 226         close(0);
 227         close(1);
 228         close(2);
 229
 230         /* we want to ensure that all of the network sockets we had
 231            open are closed */
 232         tevent_re_initialise(ev);
 233
 234         /* setup for logging to go to the parents debug log */
 235         dup2(p3[0], 0);
 236         dup2(p1[1], 1);
 237         dup2(p2[1], 2);
 238
 239         close(p1[1]);
 240         close(p2[1]);
 241         close(p3[0]);
 242
 243         argv = str_list_copy(state, discard_const_p(const char *, argv0));
 244         if (!argv) {
 245                 fprintf(stderr, "Out of memory in child\n");
 246                 _exit(255);
 247         }
 248
 249         va_start(ap, argv0);
 250         while (1) {
 251                 const char **l;
 252                 char *arg = va_arg(ap, char *);
 253                 if (arg == NULL) break;
 254                 l = discard_const_p(const char *, argv);
 255                 l = str_list_add(l, arg);
 256                 if (l == NULL) {
 257                         fprintf(stderr, "Out of memory in child\n");
 258                         _exit(255);
 259                 }
 260                 argv = discard_const_p(char *, l);
 261         }
 262         va_end(ap);
 263
 264         (void)execvp(state->arg0, argv);
 265         fprintf(stderr, "Failed to exec child - %s\n", strerror(errno));
 266         _exit(255);
 267         return NULL;
 268 }
 269
 270 /*
 271   handle stdout/stderr from the child
 272  */
 273 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         struct tevent_req *req = talloc_get_type_abort(private_data,
 279                                  struct tevent_req);
 280         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         if (!(flags & TEVENT_FD_READ)) {
 287                 return;
 288         }
 289
 290         if (fde == state->fde_stdout) {
 291                 level = state->stdout_log_level;
 292                 fd = state->fd_stdout;
 293         } else if (fde == state->fde_stderr) {
 294                 level = state->stderr_log_level;
 295                 fd = state->fd_stderr;
 296         } else {
 297                 int status;
 298
 299                 status = tfork_status(&state->tfork, false);
 300                 if (status == -1) {
 301                         if (errno == EAGAIN || errno == EWOULDBLOCK) {
 302                                 return;
 303                         }
 304                         DBG_ERR("Bad read on status pipe\n");
 305                         tevent_req_error(req, errno);
 306                         return;
 307                 }
 308                 state->pid = -1;
 309                 TALLOC_FREE(fde);
 310
 311                 if (WIFEXITED(status)) {
 312                         status = WEXITSTATUS(status);
 313                 } else if (WIFSIGNALED(status)) {
 314                         status = WTERMSIG(status);
 315                 } else {
 316                         status = ECHILD;
 317                 }
 318
 319                 DBG_NOTICE("Child %s exited %d\n", state->arg0, status);
 320                 if (status != 0) {
 321                         tevent_req_error(req, status);
 322                         return;
 323                 }
 324
 325                 tevent_req_done(req);
 326                 return;
 327         }
 328
 329         n = read(fd, &state->buf[state->buf_used],
 330                  sizeof(state->buf) - state->buf_used);
 331         if (n > 0) {
 332                 state->buf_used += n;
 333         } else if (n == 0) {
 334                 if (fde == state->fde_stdout) {
 335                         talloc_free(fde);
 336                         state->fde_stdout = NULL;
 337                         return;
 338                 }
 339                 if (fde == state->fde_stderr) {
 340                         talloc_free(fde);
 341                         state->fde_stderr = NULL;
 342                         return;
 343                 }
 344                 return;
 345         }
 346
 347         while (state->buf_used > 0 &&
 348                (p = (char *)memchr(state->buf, '\n', state->buf_used)) != NULL) {
 349                 int n1 = (p - state->buf)+1;
 350                 int n2 = n1 - 1;
 351                 /* swallow \r from child processes */
 352                 if (n2 > 0 && state->buf[n2-1] == '\r') {
 353                         n2--;
 354                 }
 355                 DEBUG(level,("%s: %*.*s\n", state->arg0, n2, n2, state->buf));
 356                 memmove(state->buf, p+1, sizeof(state->buf) - n1);
 357                 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         if (state->buf_used == sizeof(state->buf)) {
 363                 DEBUG(level,("%s: %*.*s\n",
 364                              state->arg0, state->buf_used,
 365                              state->buf_used, state->buf));
 366                 state->buf_used = 0;
 367         }
 368 }
 369
 370 int samba_runcmd_recv(struct tevent_req *req, int *perrno)
 371 {
 372         if (tevent_req_is_unix_error(req, perrno)) {
 373                 tevent_req_received(req);
 374                 return -1;
 375         }
 376
 377         tevent_req_received(req);
 378         return 0;
 379 }