src/main/exec.c

   1 /*
   2  * exec.c       Execute external programs.
   3  *
   4  * Version:     $Id$
   5  *
   6  *   This program is free software; you can redistribute it and/or modify
   7  *   it under the terms of the GNU General Public License as published by
   8  *   the Free Software Foundation; either version 2 of the License, or
   9  *   (at your option) any later version.
  10  *
  11  *   This program is distributed in the hope that it will be useful,
  12  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *   GNU General Public License for more details.
  15  *
  16  *   You should have received a copy of the GNU General Public License
  17  *   along with this program; if not, write to the Free Software
  18  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  * Copyright 2000  The FreeRADIUS server project
  21  * Copyright 2000  Michael J. Hartwick <hartwick@hartwick.com>
  22  */
  23 static const char rcsid[] = "$Id$";
  24
  25 #include "autoconf.h"
  26
  27 #include <sys/file.h>
  28
  29 #include <stdlib.h>
  30 #include <string.h>
  31 #include <fcntl.h>
  32 #include <ctype.h>
  33 #include <signal.h>
  34
  35 #if HAVE_SYS_WAIT_H
  36 #       include <sys/wait.h>
  37 #endif
  38 #ifndef WEXITSTATUS
  39 #       define WEXITSTATUS(stat_val) ((unsigned)(stat_val) >> 8)
  40 #endif
  41 #ifndef WIFEXITED
  42 #       define WIFEXITED(stat_val) (((stat_val) & 255) == 0)
  43 #endif
  44
  45 #include "radiusd.h"
  46 #include "rad_assert.h"
  47
  48 #ifndef HAVE_PTHREAD_H
  49 #define rad_fork(n) fork()
  50 #define rad_waitpid waitpid
  51 #endif
  52
  53 /*
  54  *      Execute a program on successful authentication.
  55  *      Return 0 if exec_wait == 0.
  56  *      Return the exit code of the called program if exec_wait != 0.
  57  *      Return -1 on fork/other errors in the parent process.
  58  */
  59 int radius_exec_program(const char *cmd, REQUEST *request,
  60                         int exec_wait, const char **user_msg)
  61 {
  62         VALUE_PAIR *vp;
  63         static char message[256];
  64         char answer[4096];
  65         char *argv[256];
  66         char *buf, *p;
  67         int pd[2];
  68         pid_t pid, child_pid;
  69         int argc = -1;
  70         int comma = 0;
  71         int status;
  72         int n, left, done;
  73
  74         /*
  75          *      Open a pipe for child/parent communication, if
  76          *      necessary.
  77          */
  78         if (exec_wait) {
  79                 if (pipe(pd) != 0) {
  80                         radlog(L_ERR|L_CONS, "Couldn't open pipe: %s",
  81                                strerror(errno));
  82                         return -1;
  83                 }
  84         }
  85
  86         /*
  87          *      Do the translation (as the parent) of the command to
  88          *      execute.  This MAY involve calling other modules, so
  89          *      we want to do it in the parent.
  90          */
  91         radius_xlat(answer, sizeof(answer), cmd, request, NULL);
  92         buf = answer;
  93
  94         /*
  95          *      Log the command if we are debugging something
  96          */
  97         DEBUG("Exec-Program: %s", buf);
  98
  99         /*
 100          *      Build vector list of arguments and execute.
 101          */
 102         p = strtok(buf, " \t");
 103         if (p) do {
 104                 argv[++argc] = p;
 105                 p = strtok(NULL, " \t");
 106         } while(p != NULL);
 107
 108         argv[++argc] = p;
 109         if (argc == 0) {
 110                 radlog(L_ERR, "Exec-Program: empty command line.");
 111                 return -1;
 112         }
 113
 114         if ((pid = rad_fork(exec_wait)) == 0) {
 115 #define MAX_ENVP 1024
 116                 int i, devnull;
 117                 char *envp[MAX_ENVP];
 118                 int envlen;
 119                 char buffer[1024];
 120
 121                 /*
 122                  *      Child process.
 123                  *
 124                  *      We try to be fail-safe here.  So if ANYTHING
 125                  *      goes wrong, we exit with status 1.
 126                  */
 127
 128                 /*
 129                  *      Open STDIN to /dev/null
 130                  */
 131                 devnull = open("/dev/null", O_RDWR);
 132                 if (devnull < 0) {
 133                         radlog(L_ERR|L_CONS, "Failed opening /dev/null: %s\n",
 134                                strerror(errno));
 135                         exit(1);
 136                 }
 137                 dup2(devnull, STDIN_FILENO);
 138
 139                 /*
 140                  *      Only massage the pipe handles if the parent
 141                  *      has created them.
 142                  */
 143                 if (exec_wait) {
 144                         /*
 145                          *      pd[0] is the FD the child will read from,
 146                          *      which we don't want.
 147                          */
 148                         if (close(pd[0]) != 0) {
 149                                 radlog(L_ERR|L_CONS, "Can't close pipe: %s",
 150                                        strerror(errno));
 151                                 exit(1);
 152                         }
 153
 154                         /*
 155                          *      pd[1] is the FD that the child will write to,
 156                          *      so we make it STDOUT.
 157                          */
 158                         if (dup2(pd[1], STDOUT_FILENO) != 1) {
 159                                 radlog(L_ERR|L_CONS, "Can't dup stdout: %s",
 160                                        strerror(errno));
 161                                 exit(1);
 162                         }
 163
 164                 } else {        /* no pipe, STDOUT should be /dev/null */
 165                         dup2(devnull, STDOUT_FILENO);
 166                 }
 167
 168                 /*
 169                  *      If we're not debugging, then we can't do
 170                  *      anything with the error messages, so we throw
 171                  *      them away.
 172                  *
 173                  *      If we are debugging, then we want the error
 174                  *      messages to go to the STDERR of the server.
 175                  */
 176                 if (debug_flag == 0) {
 177                         dup2(devnull, STDERR_FILENO);
 178                 }
 179                 close(devnull);
 180
 181                 /*
 182                  *      The server may have MANY FD's open.  We don't
 183                  *      want to leave dangling FD's for the child process
 184                  *      to play funky games with, so we close them.
 185                  */
 186                 for (i = 3; i < 256; i++) {
 187                         close(i);
 188                 }
 189
 190                 /*
 191                  *      Set up the environment variables.
 192                  *      We're in the child, and it will exit in 4 lines
 193                  *      anyhow, so memory allocation isn't an issue.
 194                  */
 195                 envlen = 0;
 196
 197                 for (vp = request->packet->vps; vp->next; vp = vp->next) {
 198                         /*
 199                          *      Hmm... maybe we shouldn't pass the
 200                          *      user's password in an environment
 201                          *      variable...
 202                          */
 203                         snprintf(buffer, sizeof(buffer), "%s=", vp->name);
 204                         for (p = buffer; *p != '='; p++) {
 205                                 if (*p == '-') {
 206                                         *p = '_';
 207                                 } else if (isalpha(*p)) {
 208                                         *p = toupper(*p);
 209                                 }
 210                         }
 211
 212                         n = strlen(buffer);
 213                         vp_prints_value(buffer+n, sizeof(buffer) - n, vp, 1);
 214
 215                         envp[envlen++] = strdup(buffer);
 216                 }
 217                 envp[envlen] = NULL;
 218
 219                 execve(argv[0], argv, envp);
 220
 221                 radlog(L_ERR, "Exec-Program: FAILED to execute %s: %s",
 222                        argv[0], strerror(errno));
 223                 exit(1);
 224         }
 225
 226         /*
 227          *      Parent process.
 228          */
 229         if (pid < 0) {
 230                 radlog(L_ERR|L_CONS, "Couldn't fork %s: %s",
 231                        argv[0], strerror(errno));
 232                 return -1;
 233         }
 234
 235         /*
 236          *      We're not waiting, exit, and ignore any child's
 237          *      status.
 238          */
 239         if (!exec_wait) {
 240                 return 0;
 241         }
 242
 243         /*
 244          *      Close the FD to which the child writes it's data.
 245          *
 246          *      If we can't close it, then we close pd[0], and return an
 247          *      error.
 248          */
 249         if (close(pd[1]) != 0) {
 250                 radlog(L_ERR|L_CONS, "Can't close pipe: %s", strerror(errno));
 251                 close(pd[0]);
 252                 return -1;
 253         }
 254
 255         /*
 256          *      Read from the pipe until we doesn't get any more or
 257          *      until the message is full.
 258          */
 259         done = 0;
 260         left = sizeof(answer) - 1;
 261         while (1) {
 262                 status = read(pd[0], answer + done, left);
 263                 /*
 264                  *      Nothing more to read: stop.
 265                  */
 266                 if (status == 0) {
 267                         break;
 268                 }
 269
 270                 /*
 271                  *      Error: See if we have to continue.
 272                  */
 273                 if (status < 0) {
 274                         /*
 275                          *      We were interrupted: continue reading.
 276                          */
 277                         if (errno == EINTR) {
 278                                 continue;
 279                         }
 280
 281                         /*
 282                          *      There was another error.  Most likely
 283                          *      The child process has finished, and
 284                          *      exited.
 285                          */
 286                         break;
 287                 }
 288
 289                 done += status;
 290                 left -= status;
 291                 if (left <= 0) break;
 292         }
 293         answer[done] = 0;
 294
 295         /*
 296          *      Make sure that the writer can't block while writing to
 297          *      a pipe that no one is reading from anymore.
 298          */
 299         close(pd[0]);
 300
 301         /*
 302          *      Parse the output, if any.
 303          */
 304         if (done) {
 305                 /*
 306                  *      For backwards compatibility, first check
 307                  *      for plain text (user_msg).
 308                  */
 309                 vp = NULL;
 310                 n = userparse(answer, &vp);
 311                 if (vp) {
 312                         pairfree(&vp);
 313                 }
 314
 315                 if (n < 0) {
 316                         radlog(L_DBG, "Exec-Program-Wait: plaintext: %s", answer);
 317                         if (user_msg) {
 318                                 strncpy(message, answer, sizeof(message));
 319                                 message[sizeof(message) - 1] = 0;
 320                                 *user_msg = message;
 321                         }
 322                 } else {
 323                         /*
 324                          *      HACK: Replace '\n' with ',' so that
 325                          *      userparse() can parse the buffer in
 326                          *      one go (the proper way would be to
 327                          *      fix userparse(), but oh well).
 328                          */
 329                         for (p = answer; *p; p++) {
 330                                 if (*p == '\n') {
 331                                         *p = comma ? ' ' : ',';
 332                                         p++;
 333                                         comma = 0;
 334                                 }
 335                                 if (*p == ',') comma++;
 336                         }
 337
 338                         /*
 339                          *  Replace any trailing comma by a NUL.
 340                          */
 341                         if (answer[strlen(answer) - 1] == ',') {
 342                                 answer[strlen(answer) - 1] = '\0';
 343                         }
 344
 345                         radlog(L_DBG,"Exec-Program-Wait: value-pairs: %s", answer);
 346                         if (userparse(answer, &vp) < 0) {
 347                                 radlog(L_ERR, "Exec-Program-Wait: %s: unparsable reply", cmd);
 348
 349                         } else {
 350                                 /*
 351                                  *      Add the attributes to the reply.
 352                                  */
 353                                 pairmove(&request->reply->vps, &vp);
 354                                 pairfree(&vp);
 355                         }
 356                 } /* else the answer was a set of VP's, not a text message */
 357         } /* else we didn't read anything from the child. */
 358
 359         /*
 360          *      Call rad_waitpid (should map to waitpid on non-threaded
 361          *      or single-server systems).
 362          */
 363         child_pid = rad_waitpid(pid, &status, 0);
 364         rad_assert(child_pid == pid);
 365
 366         if (WIFEXITED(status)) {
 367                 status = WEXITSTATUS(status);
 368                 radlog(L_DBG, "Exec-Program: returned: %d", status);
 369                 return status;
 370         }
 371         radlog(L_ERR|L_CONS, "Exec-Program: Abnormal child exit (killed or coredump)");
 372
 373         return 1;
 374 }