Adjust for changes to getaddrinfo.c.
[kopensolaris-gnu/glibc.git] / posix / execvp.c
1 /* Copyright (C) 1991,92,1995-99,2002,2004,2005 Free Software Foundation, Inc.
2    This file is part of the GNU C Library.
3
4    The GNU C Library is free software; you can redistribute it and/or
5    modify it under the terms of the GNU Lesser General Public
6    License as published by the Free Software Foundation; either
7    version 2.1 of the License, or (at your option) any later version.
8
9    The GNU C Library is distributed in the hope that it will be useful,
10    but WITHOUT ANY WARRANTY; without even the implied warranty of
11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12    Lesser General Public License for more details.
13
14    You should have received a copy of the GNU Lesser General Public
15    License along with the GNU C Library; if not, write to the Free
16    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
17    02111-1307 USA.  */
18
19 #include <unistd.h>
20 #include <stdarg.h>
21 #include <stdbool.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <errno.h>
25 #include <paths.h>
26
27
28 /* The file is accessible but it is not an executable file.  Invoke
29    the shell to interpret it as a script.  */
30 static char **
31 internal_function
32 allocate_scripts_argv (const char *file, char *const argv[])
33 {
34   /* Count the arguments.  */
35   int argc = 0;
36   while (argv[argc++])
37     ;
38
39   /* Construct an argument list for the shell.  */
40   char **new_argv = (char **) malloc ((argc + 1) * sizeof (char *));
41   if (new_argv != NULL)
42     {
43       new_argv[0] = (char *) _PATH_BSHELL;
44       new_argv[1] = (char *) file;
45       while (argc > 1)
46         {
47           new_argv[argc] = argv[argc - 1];
48           --argc;
49         }
50     }
51
52   return new_argv;
53 }
54
55
56 /* Execute FILE, searching in the `PATH' environment variable if it contains
57    no slashes, with arguments ARGV and environment from `environ'.  */
58 int
59 execvp (file, argv)
60      const char *file;
61      char *const argv[];
62 {
63   if (*file == '\0')
64     {
65       /* We check the simple case first. */
66       __set_errno (ENOENT);
67       return -1;
68     }
69
70   char **script_argv = NULL;
71
72   if (strchr (file, '/') != NULL)
73     {
74       /* Don't search when it contains a slash.  */
75       __execve (file, argv, __environ);
76
77       if (errno == ENOEXEC)
78         {
79           script_argv = allocate_scripts_argv (file, argv);
80           if (script_argv != NULL)
81             {
82               __execve (script_argv[0], script_argv, __environ);
83
84               free (script_argv);
85             }
86         }
87     }
88   else
89     {
90       char *path = getenv ("PATH");
91       char *path_malloc = NULL;
92       if (path == NULL)
93         {
94           /* There is no `PATH' in the environment.
95              The default search path is the current directory
96              followed by the path `confstr' returns for `_CS_PATH'.  */
97           size_t len = confstr (_CS_PATH, (char *) NULL, 0);
98           path = (char *) malloc (1 + len);
99           if (path == NULL)
100             return -1;
101           path[0] = ':';
102           (void) confstr (_CS_PATH, path + 1, len);
103           path_malloc = path;
104         }
105
106       size_t len = strlen (file) + 1;
107       size_t pathlen = strlen (path);
108       char *name = malloc (pathlen + len + 1);
109       if (name == NULL)
110         {
111           free (path_malloc);
112           return -1;
113         }
114       /* Copy the file name at the top.  */
115       name = (char *) memcpy (name + pathlen + 1, file, len);
116       /* And add the slash.  */
117       *--name = '/';
118
119       bool got_eacces = false;
120       char *p = path;
121       do
122         {
123           char *startp;
124
125           path = p;
126           p = __strchrnul (path, ':');
127
128           if (p == path)
129             /* Two adjacent colons, or a colon at the beginning or the end
130                of `PATH' means to search the current directory.  */
131             startp = name + 1;
132           else
133             startp = (char *) memcpy (name - (p - path), path, p - path);
134
135           /* Try to execute this name.  If it works, execve will not return. */
136           __execve (startp, argv, __environ);
137
138           if (errno == ENOEXEC)
139             {
140               if (script_argv == NULL)
141                 {
142                   script_argv = allocate_scripts_argv (startp, argv);
143                   if (script_argv == NULL)
144                     {
145                       /* A possible EACCES error is not as important as
146                          the ENOMEM.  */
147                       got_eacces = false;
148                       break;
149                     }
150                 }
151
152               __execve (script_argv[0], script_argv, __environ);
153             }
154
155           switch (errno)
156             {
157             case EACCES:
158               /* Record the we got a `Permission denied' error.  If we end
159                  up finding no executable we can use, we want to diagnose
160                  that we did find one but were denied access.  */
161               got_eacces = true;
162             case ENOENT:
163             case ESTALE:
164             case ENOTDIR:
165               /* Those errors indicate the file is missing or not executable
166                  by us, in which case we want to just try the next path
167                  directory.  */
168             case ENODEV:
169             case ETIMEDOUT:
170               /* Some strange filesystems like AFS return even
171                  stranger error numbers.  They cannot reasonably mean
172                  anything else so ignore those, too.  */
173               break;
174
175             default:
176               /* Some other error means we found an executable file, but
177                  something went wrong executing it; return the error to our
178                  caller.  */
179               return -1;
180             }
181         }
182       while (*p++ != '\0');
183
184       /* We tried every element and none of them worked.  */
185       if (got_eacces)
186         /* At least one failure was due to permissions, so report that
187            error.  */
188         __set_errno (EACCES);
189
190       free (script_argv);
191       free (name - pathlen);
192       free (path_malloc);
193     }
194
195   /* Return the error from the last attempt (probably ENOENT).  */
196   return -1;
197 }
198 libc_hidden_def (execvp)