/* Find the original arg buffer, return 0 if found, else -1.
*
* If found, set argc to the number of arguments, argv to an array
* of pointers to the single arguments. The array is allocated via malloc.
*
* If the function fails in a way that shouldn't be ignored, also set
* a Python exception.
*
* The function overcomes three Py_GetArgcArgv shortcomings:
* - some python parameters mess up with the original argv, e.g. -m
* (see issue #8)
* - with Python 3, argv is a decoded copy and doesn't point to
* the original area.
* - If python is embedded, the function doesn't return anything.
*/
static int
get_argc_argv(int *argc_o, char ***argv_o)
{
int argc = 0;
argv_t **argv_py = NULL;
char **argv = NULL;
char *arg0 = NULL;
int rv = -1;
#ifndef IS_PYPY
spt_debug("reading argc/argv from Python main");
Py_GetArgcArgv(&argc, &argv_py);
#endif
if (argc > 0) {
spt_debug("found %d arguments", argc);
#ifdef IS_PY3K
if (!(arg0 = get_encoded_arg0(argv_py[0]))) {
spt_debug("couldn't get a copy of argv[0]");
goto exit;
}
#else
if (!(argv = fix_argv(argc, (char **)argv_py))) {
spt_debug("failed to fix argv");
goto exit;
}
#endif
/* we got argv: on py2 it points to the right place in memory; on py3
* we only got a copy of argv[0]: we will use it to look from environ
*/
}
else {
spt_debug("no good news from Py_GetArgcArgv");
/* get a copy of argv[0] from /proc, so we get back in the same
* situation of Py3 */
if (0 > get_args_from_proc(&argc, &arg0)) {
spt_debug("failed to get args from proc fs");
goto exit;
}
}
/* If we don't know argv but we know the content of argv[0], we can walk
* backwards from environ and see if we get it. */
if (arg0 && !argv) {
if (!(argv = find_argv_from_env(argc, arg0))) {
spt_debug("couldn't find argv from environ");
goto exit;
}
}
/* success */
*argc_o = argc;
*argv_o = argv;
argv = NULL;
rv = 0;
exit:
if (arg0) { free(arg0); }
if (argv) { free(argv); }
return rv;
}
/* Find the original arg buffer starting from the env position.
*
* Return nonzero if found.
*
* Required on Python 3 as Py_GetArgcArgv doesn't return pointers to the
* original area.
*/
static int
find_argv_from_env(int *argc_o, char ***argv_o)
{
int rv = 0;
int argc;
wchar_t **argv;
char **buf = NULL;
char *arg0 = NULL;
/* Find the number of parameters. */
Py_GetArgcArgv(&argc, &argv);
buf = (char **)malloc((argc + 1) * sizeof(char *));
buf[argc] = NULL;
/* Walk back from environ until you find argc-1 null-terminated strings.
* Don't look for argv[0] as it's probably not preceded by 0. */
int i;
char *ptr = environ[0];
char *limit = ptr - 8192; /* TODO: empiric limit: should use MAX_ARG */
--ptr;
for (i = argc - 1; i >= 1; --i) {
if (*ptr) {
spt_debug("zero %d not found", i);
goto error;
}
--ptr;
while (*ptr && ptr > limit) { --ptr; }
if (ptr <= limit) {
spt_debug("failed to found arg %d start", i);
goto error;
}
buf[i] = (ptr + 1);
}
/* The first arg has not a zero in front. But what we have is reliable
* enough (modulo its encoding). Check if it is exactly what found.
*
* The check is known to fail on OS X with locale C if there are
* non-ascii characters in the executable path. See Python issue #9167
*/
arg0 = get_encoded_arg0(argv[0]);
if (!arg0) { goto error; }
ptr -= strlen(arg0);
if (ptr <= limit) {
spt_debug("failed to found argv[0] start");
goto error;
}
if (strcmp(ptr, arg0)) {
spt_debug("failed to recognize argv[0]");
goto error;
}
/* We have all the pieces of the jigsaw. */
buf[0] = ptr;
*argc_o = argc;
*argv_o = buf;
rv = 1;
goto exit;
error:
if (buf) { free(buf); }
exit:
if (arg0) { free(arg0); }
return rv;
}
