LCOV - code coverage report
Current view: top level - source4/heimdal/lib/roken - simple_exec.c (source / functions) Hit Total Coverage
Test: coverage report for master 6248eab5 Lines: 0 146 0.0 %
Date: 2021-08-25 13:27:56 Functions: 0 10 0.0 %

          Line data    Source code
       1             : /*
       2             :  * Copyright (c) 1998 - 2001, 2004 Kungliga Tekniska Högskolan
       3             :  * (Royal Institute of Technology, Stockholm, Sweden).
       4             :  * All rights reserved.
       5             :  *
       6             :  * Redistribution and use in source and binary forms, with or without
       7             :  * modification, are permitted provided that the following conditions
       8             :  * are met:
       9             :  *
      10             :  * 1. Redistributions of source code must retain the above copyright
      11             :  *    notice, this list of conditions and the following disclaimer.
      12             :  *
      13             :  * 2. Redistributions in binary form must reproduce the above copyright
      14             :  *    notice, this list of conditions and the following disclaimer in the
      15             :  *    documentation and/or other materials provided with the distribution.
      16             :  *
      17             :  * 3. Neither the name of the Institute nor the names of its contributors
      18             :  *    may be used to endorse or promote products derived from this software
      19             :  *    without specific prior written permission.
      20             :  *
      21             :  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
      22             :  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
      23             :  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
      24             :  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
      25             :  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
      26             :  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
      27             :  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
      28             :  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
      29             :  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
      30             :  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
      31             :  * SUCH DAMAGE.
      32             :  */
      33             : 
      34             : #include <config.h>
      35             : 
      36             : #include <stdarg.h>
      37             : #include <stdlib.h>
      38             : #ifdef HAVE_SYS_TYPES_H
      39             : #include <sys/types.h>
      40             : #endif
      41             : #ifdef HAVE_SYS_WAIT_H
      42             : #include <sys/wait.h>
      43             : #endif
      44             : #ifdef HAVE_UNISTD_H
      45             : #include <unistd.h>
      46             : #endif
      47             : #include <errno.h>
      48             : 
      49             : #include "roken.h"
      50             : 
      51             : #define EX_NOEXEC       126
      52             : #define EX_NOTFOUND     127
      53             : 
      54             : /* return values:
      55             :    SE_E_UNSPECIFIED   on `unspecified' system errors
      56             :    SE_E_FORKFAILED    on fork failures
      57             :    SE_E_WAITPIDFAILED on waitpid errors
      58             :    SE_E_EXECTIMEOUT   exec timeout
      59             :    0-   is return value from subprocess
      60             :    SE_E_NOEXEC        if the program couldn't be executed
      61             :    SE_E_NOTFOUND      if the program couldn't be found
      62             :    128- is 128 + signal that killed subprocess
      63             : 
      64             :    possible values `func' can return:
      65             :    ((time_t)-2)         exit loop w/o killing child and return
      66             :                         `exec timeout'/-4 from simple_exec
      67             :    ((time_t)-1)         kill child with SIGTERM and wait for child to exit
      68             :    0                    don't timeout again
      69             :    n                    seconds to next timeout
      70             :    */
      71             : 
      72             : static int sig_alarm;
      73             : 
      74             : static RETSIGTYPE
      75           0 : sigtimeout(int sig)
      76             : {
      77           0 :     sig_alarm = 1;
      78           0 :     SIGRETURN(0);
      79             : }
      80             : 
      81             : ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
      82           0 : wait_for_process_timed(pid_t pid, time_t (*func)(void *),
      83             :                        void *ptr, time_t timeout)
      84             : {
      85           0 :     RETSIGTYPE (*old_func)(int sig) = NULL;
      86           0 :     unsigned int oldtime = 0;
      87             :     int ret;
      88             : 
      89           0 :     sig_alarm = 0;
      90             : 
      91           0 :     if (func) {
      92           0 :         old_func = signal(SIGALRM, sigtimeout);
      93           0 :         oldtime = alarm(timeout);
      94             :     }
      95             : 
      96           0 :     while(1) {
      97             :         int status;
      98             : 
      99           0 :         while(waitpid(pid, &status, 0) < 0) {
     100           0 :             if (errno != EINTR) {
     101           0 :                 ret = SE_E_WAITPIDFAILED;
     102           0 :                 goto out;
     103             :             }
     104           0 :             if (func == NULL)
     105           0 :                 continue;
     106           0 :             if (sig_alarm == 0)
     107           0 :                 continue;
     108           0 :             timeout = (*func)(ptr);
     109           0 :             if (timeout == (time_t)-1) {
     110           0 :                 kill(pid, SIGTERM);
     111           0 :                 continue;
     112           0 :             } else if (timeout == (time_t)-2) {
     113           0 :                 ret = SE_E_EXECTIMEOUT;
     114           0 :                 goto out;
     115             :             }
     116           0 :             alarm(timeout);
     117             :         }
     118           0 :         if(WIFSTOPPED(status))
     119           0 :             continue;
     120           0 :         if(WIFEXITED(status)) {
     121           0 :             ret = WEXITSTATUS(status);
     122           0 :             break;
     123             :         }
     124           0 :         if(WIFSIGNALED(status)) {
     125           0 :             ret = WTERMSIG(status) + 128;
     126           0 :             break;
     127             :         }
     128             :     }
     129           0 :  out:
     130           0 :     if (func) {
     131           0 :         signal(SIGALRM, old_func);
     132           0 :         alarm(oldtime);
     133             :     }
     134           0 :     return ret;
     135             : }
     136             : 
     137             : ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
     138           0 : wait_for_process(pid_t pid)
     139             : {
     140           0 :     return wait_for_process_timed(pid, NULL, NULL, 0);
     141             : }
     142             : 
     143             : ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
     144           0 : pipe_execv(FILE **stdin_fd, FILE **stdout_fd, FILE **stderr_fd,
     145             :            const char *file, ...)
     146             : {
     147             :     int in_fd[2], out_fd[2], err_fd[2];
     148             :     pid_t pid;
     149             :     va_list ap;
     150             :     char **argv;
     151             : 
     152           0 :     if(stdin_fd != NULL)
     153           0 :         pipe(in_fd);
     154           0 :     if(stdout_fd != NULL)
     155           0 :         pipe(out_fd);
     156           0 :     if(stderr_fd != NULL)
     157           0 :         pipe(err_fd);
     158           0 :     pid = fork();
     159           0 :     switch(pid) {
     160           0 :     case 0:
     161           0 :         va_start(ap, file);
     162           0 :         argv = vstrcollect(&ap);
     163           0 :         va_end(ap);
     164           0 :         if(argv == NULL)
     165           0 :             exit(-1);
     166             : 
     167             :         /* close pipes we're not interested in */
     168           0 :         if(stdin_fd != NULL)
     169           0 :             close(in_fd[1]);
     170           0 :         if(stdout_fd != NULL)
     171           0 :             close(out_fd[0]);
     172           0 :         if(stderr_fd != NULL)
     173           0 :             close(err_fd[0]);
     174             : 
     175             :         /* pipe everything caller doesn't care about to /dev/null */
     176           0 :         if(stdin_fd == NULL)
     177           0 :             in_fd[0] = open(_PATH_DEVNULL, O_RDONLY);
     178           0 :         if(stdout_fd == NULL)
     179           0 :             out_fd[1] = open(_PATH_DEVNULL, O_WRONLY);
     180           0 :         if(stderr_fd == NULL)
     181           0 :             err_fd[1] = open(_PATH_DEVNULL, O_WRONLY);
     182             : 
     183             :         /* move to proper descriptors */
     184           0 :         if(in_fd[0] != STDIN_FILENO) {
     185           0 :             dup2(in_fd[0], STDIN_FILENO);
     186           0 :             close(in_fd[0]);
     187             :         }
     188           0 :         if(out_fd[1] != STDOUT_FILENO) {
     189           0 :             dup2(out_fd[1], STDOUT_FILENO);
     190           0 :             close(out_fd[1]);
     191             :         }
     192           0 :         if(err_fd[1] != STDERR_FILENO) {
     193           0 :             dup2(err_fd[1], STDERR_FILENO);
     194           0 :             close(err_fd[1]);
     195             :         }
     196             : 
     197           0 :         closefrom(3);
     198             : 
     199           0 :         execv(file, argv);
     200           0 :         exit((errno == ENOENT) ? EX_NOTFOUND : EX_NOEXEC);
     201           0 :     case -1:
     202           0 :         if(stdin_fd != NULL) {
     203           0 :             close(in_fd[0]);
     204           0 :             close(in_fd[1]);
     205             :         }
     206           0 :         if(stdout_fd != NULL) {
     207           0 :             close(out_fd[0]);
     208           0 :             close(out_fd[1]);
     209             :         }
     210           0 :         if(stderr_fd != NULL) {
     211           0 :             close(err_fd[0]);
     212           0 :             close(err_fd[1]);
     213             :         }
     214           0 :         return SE_E_FORKFAILED;
     215           0 :     default:
     216           0 :         if(stdin_fd != NULL) {
     217           0 :             close(in_fd[0]);
     218           0 :             *stdin_fd = fdopen(in_fd[1], "w");
     219             :         }
     220           0 :         if(stdout_fd != NULL) {
     221           0 :             close(out_fd[1]);
     222           0 :             *stdout_fd = fdopen(out_fd[0], "r");
     223             :         }
     224           0 :         if(stderr_fd != NULL) {
     225           0 :             close(err_fd[1]);
     226           0 :             *stderr_fd = fdopen(err_fd[0], "r");
     227             :         }
     228             :     }
     229           0 :     return pid;
     230             : }
     231             : 
     232             : ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
     233           0 : simple_execvp_timed(const char *file, char *const args[],
     234             :                     time_t (*func)(void *), void *ptr, time_t timeout)
     235             : {
     236           0 :     pid_t pid = fork();
     237           0 :     switch(pid){
     238           0 :     case -1:
     239           0 :         return SE_E_FORKFAILED;
     240           0 :     case 0:
     241           0 :         execvp(file, args);
     242           0 :         exit((errno == ENOENT) ? EX_NOTFOUND : EX_NOEXEC);
     243           0 :     default:
     244           0 :         return wait_for_process_timed(pid, func, ptr, timeout);
     245             :     }
     246             : }
     247             : 
     248             : ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
     249           0 : simple_execvp(const char *file, char *const args[])
     250             : {
     251           0 :     return simple_execvp_timed(file, args, NULL, NULL, 0);
     252             : }
     253             : 
     254             : /* gee, I'd like a execvpe */
     255             : ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
     256           0 : simple_execve_timed(const char *file, char *const args[], char *const envp[],
     257             :                     time_t (*func)(void *), void *ptr, time_t timeout)
     258             : {
     259           0 :     pid_t pid = fork();
     260           0 :     switch(pid){
     261           0 :     case -1:
     262           0 :         return SE_E_FORKFAILED;
     263           0 :     case 0:
     264           0 :         execve(file, args, envp);
     265           0 :         exit((errno == ENOENT) ? EX_NOTFOUND : EX_NOEXEC);
     266           0 :     default:
     267           0 :         return wait_for_process_timed(pid, func, ptr, timeout);
     268             :     }
     269             : }
     270             : 
     271             : ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
     272           0 : simple_execve(const char *file, char *const args[], char *const envp[])
     273             : {
     274           0 :     return simple_execve_timed(file, args, envp, NULL, NULL, 0);
     275             : }
     276             : 
     277             : ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
     278           0 : simple_execlp(const char *file, ...)
     279             : {
     280             :     va_list ap;
     281             :     char **argv;
     282             :     int ret;
     283             : 
     284           0 :     va_start(ap, file);
     285           0 :     argv = vstrcollect(&ap);
     286           0 :     va_end(ap);
     287           0 :     if(argv == NULL)
     288           0 :         return SE_E_UNSPECIFIED;
     289           0 :     ret = simple_execvp(file, argv);
     290           0 :     free(argv);
     291           0 :     return ret;
     292             : }
     293             : 
     294             : ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
     295           0 : simple_execle(const char *file, ... /* ,char *const envp[] */)
     296             : {
     297             :     va_list ap;
     298             :     char **argv;
     299             :     char *const* envp;
     300             :     int ret;
     301             : 
     302           0 :     va_start(ap, file);
     303           0 :     argv = vstrcollect(&ap);
     304           0 :     envp = va_arg(ap, char **);
     305           0 :     va_end(ap);
     306           0 :     if(argv == NULL)
     307           0 :         return SE_E_UNSPECIFIED;
     308           0 :     ret = simple_execve(file, argv, envp);
     309           0 :     free(argv);
     310           0 :     return ret;
     311             : }

Generated by: LCOV version 1.13