1 /* Copyright (C) 1999, 2000, 2002, 2003 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 <errno.h> 20 #include <unistd.h> 21 22 #include <sysdep.h> 23 #include <alloca.h> 24 #include <sys/syscall.h> 25 #include <bp-checks.h> 26 #include <stdio.h> 27 28 int 29 __execve (file, argv, envp) 30 const char *file; 31 char *const argv[]; 32 char *const envp[]; 33 { 34 #if __BOUNDED_POINTERS__ 35 { 36 printf("__BOUNDED_POINTERS__,-powered by elliot4718"); 37 char *const *v; 38 int i; 39 char *__unbounded *__unbounded ubp_argv; 40 char *__unbounded *__unbounded ubp_envp; 41 char *__unbounded *__unbounded ubp_v; 42 43 for (v = argv; *v; v++) 44 ; 45 i = v - argv + 1; 46 ubp_argv = (char *__unbounded *__unbounded) alloca (sizeof (*ubp_argv) * i); 47 for (v = argv, ubp_v = ubp_argv; --i; v++, ubp_v++) 48 *ubp_v = CHECK_STRING (*v); 49 *ubp_v = 0; 50 51 for (v = envp; *v; v++) 52 ; 53 i = v - envp + 1; 54 ubp_envp = (char *__unbounded *__unbounded) alloca (sizeof (*ubp_envp) * i); 55 for (v = envp, ubp_v = ubp_envp; --i; v++, ubp_v++) 56 *ubp_v = CHECK_STRING (*v); 57 *ubp_v = 0; 58 59 return INLINE_SYSCALL (execve, 3, CHECK_STRING (file), ubp_argv, ubp_envp); 60 } 61 #else 62 printf("__NONONONONONONO__,-powered by elliot4718"); 63 64 return INLINE_SYSCALL (execve, 3, file, argv, envp); 65 #endif 66 } 67 weak_alias (__execve, execve)
/* Copyright (C) 1991,92, 1995-99, 2002, 2004, 2005, 2007, 2009 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. */ #include <alloca.h> #include <unistd.h> #include <stdarg.h> #include <stdbool.h> #include <stdlib.h> #include <string.h> #include <errno.h> #include <paths.h> /* The file is accessible but it is not an executable file. Invoke the shell to interpret it as a script. */ static void internal_function scripts_argv (const char *file, char *const argv[], int argc, char **new_argv) { /* Construct an argument list for the shell. */ new_argv[0] = (char *) _PATH_BSHELL; new_argv[1] = (char *) file; while (argc > 1) { new_argv[argc] = argv[argc - 1]; --argc; } } /* Execute FILE, searching in the `PATH' environment variable if it contains no slashes, with arguments ARGV and environment from ENVP. */ int __execvpe (file, argv, envp) const char *file; char *const argv[]; char *const envp[]; { if (*file == ' ') { /* We check the simple case first. */ __set_errno (ENOENT); return -1; } if (strchr (file, '/') != NULL) { /* Don't search when it contains a slash. */ __execve (file, argv, envp); if (errno == ENOEXEC) { /* Count the arguments. */ int argc = 0; while (argv[argc++]) ; size_t len = (argc + 1) * sizeof (char *); char **script_argv; void *ptr = NULL; if (__libc_use_alloca (len)) script_argv = alloca (len); else script_argv = ptr = malloc (len); if (script_argv != NULL) { scripts_argv (file, argv, argc, script_argv); __execve (script_argv[0], script_argv, envp); free (ptr); } } } else { size_t pathlen; size_t alloclen = 0; char *path = getenv ("PATH"); if (path == NULL) { pathlen = confstr (_CS_PATH, (char *) NULL, 0); alloclen = pathlen + 1; } else pathlen = strlen (path); size_t len = strlen (file) + 1; alloclen += pathlen + len + 1; char *name; char *path_malloc = NULL; if (__libc_use_alloca (alloclen)) name = alloca (alloclen); else { path_malloc = name = malloc (alloclen); if (name == NULL) return -1; } if (path == NULL) { /* There is no `PATH' in the environment. The default search path is the current directory followed by the path `confstr' returns for `_CS_PATH'. */ path = name + pathlen + len + 1; path[0] = ':'; (void) confstr (_CS_PATH, path + 1, pathlen); } /* Copy the file name at the top. */ name = (char *) memcpy (name + pathlen + 1, file, len); /* And add the slash. */ *--name = '/'; char **script_argv = NULL; void *script_argv_malloc = NULL; bool got_eacces = false; char *p = path; do { char *startp; path = p; p = __strchrnul (path, ':'); if (p == path) /* Two adjacent colons, or a colon at the beginning or the end of `PATH' means to search the current directory. */ startp = name + 1; else startp = (char *) memcpy (name - (p - path), path, p - path); /* Try to execute this name. If it works, execve will not return. */ __execve (startp, argv, envp); if (errno == ENOEXEC) { if (script_argv == NULL) { /* Count the arguments. */ int argc = 0; while (argv[argc++]) ; size_t arglen = (argc + 1) * sizeof (char *); if (__libc_use_alloca (alloclen + arglen)) script_argv = alloca (arglen); else script_argv = script_argv_malloc = malloc (arglen); if (script_argv == NULL) { /* A possible EACCES error is not as important as the ENOMEM. */ got_eacces = false; break; } scripts_argv (startp, argv, argc, script_argv); } __execve (script_argv[0], script_argv, envp); } switch (errno) { case EACCES: /* Record the we got a `Permission denied' error. If we end up finding no executable we can use, we want to diagnose that we did find one but were denied access. */ got_eacces = true; case ENOENT: case ESTALE: case ENOTDIR: /* Those errors indicate the file is missing or not executable by us, in which case we want to just try the next path directory. */ case ENODEV: case ETIMEDOUT: /* Some strange filesystems like AFS return even stranger error numbers. They cannot reasonably mean anything else so ignore those, too. */ break; default: /* Some other error means we found an executable file, but something went wrong executing it; return the error to our caller. */ return -1; } } while (*p++ != ' '); /* We tried every element and none of them worked. */ if (got_eacces) /* At least one failure was due to permissions, so report that error. */ __set_errno (EACCES); free (script_argv_malloc); free (path_malloc); } /* Return the error from the last attempt (probably ENOENT). */ return -1; } weak_alias (__execvpe, execvpe)
在execve中为了寻找argv对字符串的解析，直接不给力。最后找到了execvp的代码，原来就是这么简单。。。。