execve(file, argv, env)参数argv获取字符串个数

 /* Copyright (C) 1999, 2000, 2002, 2003 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 <errno.h>
 #include <unistd.h>

 #include <sysdep.h>
 #include <alloca.h>
 #include <sys/syscall.h>
 #include <bp-checks.h>
 #include <stdio.h>

 int
 __execve (file, argv, envp)
      const char *file;
      char *const argv[];
      char *const envp[];
 {
 #if __BOUNDED_POINTERS__
   {
     printf("__BOUNDED_POINTERS__,-powered by elliot4718");
     char *const *v;
     int i;
     char *__unbounded *__unbounded ubp_argv;
     char *__unbounded *__unbounded ubp_envp;
     char *__unbounded *__unbounded ubp_v;

     for (v = argv; *v; v++)
       ;
     i = v - argv + ;
     ubp_argv = (char *__unbounded *__unbounded) alloca (sizeof (*ubp_argv) * i);
     for (v = argv, ubp_v = ubp_argv; --i; v++, ubp_v++)
       *ubp_v = CHECK_STRING (*v);
     *ubp_v = ;

     for (v = envp; *v; v++)
       ;
     i = v - envp + ;
     ubp_envp = (char *__unbounded *__unbounded) alloca (sizeof (*ubp_envp) * i);
     for (v = envp, ubp_v = ubp_envp; --i; v++, ubp_v++)
       *ubp_v = CHECK_STRING (*v);
     *ubp_v = ;

     return INLINE_SYSCALL (execve, , CHECK_STRING (file), ubp_argv, ubp_envp);
   }
 #else
   printf("__NONONONONONONO__,-powered by elliot4718");

   return INLINE_SYSCALL (execve, , file, argv, envp);
 #endif
 }
 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[] = (char *) _PATH_BSHELL;
  new_argv[] = (char *) file;
  while (argc > )
    {
      new_argv[argc] = argv[argc - ];
      --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 == '\0')
    {
      /* We check the simple case first. */
      __set_errno (ENOENT);
      return -;
    }

  if (strchr (file, '/') != NULL)
    {
      /* Don't search when it contains a slash.  */
      __execve (file, argv, envp);

      if (errno == ENOEXEC)
    {
      /* Count the arguments.  */
      int argc = ;
      while (argv[argc++])
        ;
      size_t len = (argc + ) * 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[], script_argv, envp);

          free (ptr);
        }
    }
    }
  else
    {
      size_t pathlen;
      size_t alloclen = ;
      char *path = getenv ("PATH");
      if (path == NULL)
    {
      pathlen = confstr (_CS_PATH, (char *) NULL, );
      alloclen = pathlen + ;
    }
      else
    pathlen = strlen (path);

      size_t len = strlen (file) + ;
      alloclen += pathlen + len + ;

      char *name;
      char *path_malloc = NULL;
      if (__libc_use_alloca (alloclen))
    name = alloca (alloclen);
      else
    {
      path_malloc = name = malloc (alloclen);
      if (name == NULL)
        return -;
    }

      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 + ;
      path[] = ':';
      (void) confstr (_CS_PATH, path + , pathlen);
    }

      /* Copy the file name at the top.  */
      name = (char *) memcpy (name + pathlen + , 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 + ;
      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 = ;
          while (argv[argc++])
            ;
          size_t arglen = (argc + ) * 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[], 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 -;
        }
    }
      while (*p++ != '\0');

      /* 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 -;
}
weak_alias (__execvpe, execvpe)

在execve中为了寻找argv对字符串的解析，直接不给力。最后找到了execvp的代码，原来就是这么简单。。。。