spawn-pipe.c

   1 #include "git-compat-util.h"
   2 #include "spawn-pipe.h"
   3
   4 extern char **environ;
   5
   6 #ifdef __MINGW32__
   7 static char *lookup_prog(const char *dir, const char *cmd, int tryexe)
   8 {
   9         char path[MAX_PATH];
  10         snprintf(path, sizeof(path), "%s/%s.exe", dir, cmd);
  11
  12         if (tryexe && access(path, 0) == 0)
  13                 return xstrdup(path);
  14         path[strlen(path)-4] = '\0';
  15         if (access(path, 0) == 0)
  16                 return xstrdup(path);
  17         return NULL;
  18 }
  19
  20 /*
  21  * Splits the PATH into parts.
  22  */
  23 char **get_path_split()
  24 {
  25         char *p, **path, *envpath = getenv("PATH");
  26         int i, n = 0;
  27
  28         if (!envpath || !*envpath)
  29                 return NULL;
  30
  31         envpath = xstrdup(envpath);
  32         p = envpath;
  33         while (p) {
  34                 char *dir = p;
  35                 p = strchr(p, ';');
  36                 if (p) *p++ = '\0';
  37                 if (*dir) {     /* not earlier, catches series of ; */
  38                         ++n;
  39                 }
  40         }
  41         if (!n)
  42                 return NULL;
  43
  44         path = xmalloc((n+1)*sizeof(char*));
  45         p = envpath;
  46         i = 0;
  47         do {
  48                 if (*p)
  49                         path[i++] = xstrdup(p);
  50                 p = p+strlen(p)+1;
  51         } while (i < n);
  52         path[i] = NULL;
  53
  54         free(envpath);
  55
  56         return path;
  57 }
  58
  59 void free_path_split(char **path)
  60 {
  61         if (!path)
  62                 return;
  63
  64         char **p = path;
  65         while (*p)
  66                 free(*p++);
  67         free(path);
  68 }
  69
  70 /*
  71  * Determines the absolute path of cmd using the the split path in path.
  72  * If cmd contains a slash or backslash, no lookup is performed.
  73  */
  74 static char *path_lookup(const char *cmd, char **path)
  75 {
  76         char **p = path;
  77         char *prog = NULL;
  78         int len = strlen(cmd);
  79         int tryexe = len < 4 || strcasecmp(cmd+len-4, ".exe");
  80
  81         if (strchr(cmd, '/') || strchr(cmd, '\\'))
  82                 prog = xstrdup(cmd);
  83
  84         while (!prog && *p) {
  85                 prog = lookup_prog(*p++, cmd, tryexe);
  86         }
  87         if (!prog) {
  88                 prog = lookup_prog(".", cmd, tryexe);
  89                 if (!prog)
  90                         prog = xstrdup(cmd);
  91         }
  92         return prog;
  93 }
  94 #endif
  95
  96 /* cmd specifies the command to invoke.
  97  * argv specifies its arguments; argv[0] will be replaced by the basename of cmd.
  98  * env specifies the environment.
  99  * pin and pout specify pipes; the read end of pin is made the standard input
 100  * of the spawned process, and the write end of pout is mad the standard output.
 101  * The respective unused ends of the pipes are closed both in the parent
 102  * process as well as in the child process.
 103  * Anyone of pin or pout can be NULL, or any one of the ends can be -1 to
 104  * indicate that no processing shall occur.
 105  */
 106 int spawnvpe_pipe(const char *cmd, const char **argv, const char **env,
 107                   int pin[], int pout[])
 108 {
 109 #ifdef __MINGW32__
 110         char **path = get_path_split();
 111
 112         pid_t pid = spawnvppe_pipe(cmd, argv, env, path, pin, pout);
 113
 114         free_path_split(path);
 115 #else
 116         pid_t pid = spawnvppe_pipe(cmd, argv, env, NULL, pin, pout);
 117 #endif
 118         return pid;
 119 }
 120
 121 int spawnvppe_pipe(const char *cmd, const char **argv, const char **env,
 122                   char **path,
 123                   int pin[], int pout[])
 124 {
 125         const char *cmd_basename = strrchr(cmd, '/');
 126         pid_t pid;
 127
 128 #ifdef __MINGW32__
 129         int s0 = -1, s1 = -1, argc;
 130         char *prog;
 131         const char **qargv, *interpr;
 132
 133         if (!cmd_basename)
 134                 cmd_basename = strrchr(cmd, '\\');
 135 #endif
 136
 137         if (!cmd_basename)
 138                 cmd_basename = cmd;
 139         else
 140                 cmd_basename++;
 141         argv[0] = cmd_basename;
 142
 143 #ifndef __MINGW32__
 144         pid = fork();
 145         if (pid < 0)
 146                 die("unable to fork");
 147         if (!pid) {
 148                 if (pin) {
 149                         if (pin[0] >= 0) {
 150                                 dup2(pin[0], 0);
 151                                 close(pin[0]);
 152                         }
 153                         if (pin[1] >= 0)
 154                                 close(pin[1]);
 155                 }
 156                 if (pout) {
 157                         if (pout[1] >= 0) {
 158                                 dup2(pout[1], 1);
 159                                 close(pout[1]);
 160                         }
 161                         if (pout[0] >= 0)
 162                                 close(pout[0]);
 163                 }
 164                 environ = env;
 165                 execvp(cmd, argv);
 166                 die("exec failed");
 167         }
 168
 169         if (pin && pin[0] >= 0)
 170                 close(pin[0]);
 171         if (pout && pout[1] >= 1)
 172                 close(pout[1]);
 173 #else
 174         if (pin) {
 175                 if (pin[0] >= 0) {
 176                         s0 = dup(0);
 177                         dup2(pin[0], 0);
 178                         close(pin[0]);
 179                 }
 180         }
 181         if (pout) {
 182                 if (pout[1] >= 0) {
 183                         s1 = dup(1);
 184                         dup2(pout[1], 1);
 185                         close(pout[1]);
 186                 }
 187         }
 188
 189         prog = path_lookup(cmd, path);
 190         interpr = parse_interpreter(prog);
 191
 192         for (argc = 0; argv[argc];) argc++;
 193         qargv = xmalloc((argc+2)*sizeof(char*));
 194         if (!interpr) {
 195                 quote_argv(qargv, argv);
 196                 pid = spawnve(_P_NOWAIT, prog, qargv, env);
 197         } else {
 198                 qargv[0] = interpr;
 199                 argv[0] = prog;
 200                 quote_argv(&qargv[1], argv);
 201                 pid = spawnvpe(_P_NOWAIT, interpr, qargv, env);
 202         }
 203
 204         free(qargv);            /* TODO: quoted args should be freed, too */
 205         free(prog);
 206
 207         if (s0 >= 0) {
 208                 dup2(s0, 0);
 209                 close(s0);
 210         }
 211         if (s1 >= 0) {
 212                 dup2(s1, 1);
 213                 close(s1);
 214         }
 215 #endif
 216
 217         return pid;
 218 }
 219
 220 const char **copy_environ()
 221 {
 222         return copy_env(environ);
 223 }
 224
 225 const char **copy_env(const char **env)
 226 {
 227         const char **s;
 228         int n = 1;
 229         for (s = env; *s; s++)
 230                 n++;
 231         s = xmalloc(n*sizeof(const char *));
 232         memcpy(s, env, n*sizeof(const char *));
 233         return s;
 234 }
 235
 236 void env_unsetenv(const char **env, const char *name)
 237 {
 238         int src, dst;
 239         size_t nmln;
 240
 241         nmln = strlen(name);
 242
 243         for (src = dst = 0; env[src]; ++src) {
 244                 size_t enln;
 245                 enln = strlen(env[src]);
 246                 if (enln > nmln) {
 247                         /* might match, and can test for '=' safely */
 248                         if (0 == strncmp (env[src], name, nmln)
 249                             && '=' == env[src][nmln])
 250                                 /* matches, so skip */
 251                                 continue;
 252                 }
 253                 env[dst] = env[src];
 254                 ++dst;
 255         }
 256         env[dst] = NULL;
 257 }