diff options
Diffstat (limited to 'Modules/getpath.c')
| -rw-r--r-- | Modules/getpath.c | 565 |
1 files changed, 531 insertions, 34 deletions
diff --git a/Modules/getpath.c b/Modules/getpath.c index 8b08b6c..8dcf14e 100644 --- a/Modules/getpath.c +++ b/Modules/getpath.c @@ -34,9 +34,104 @@ PERFORMANCE OF THIS SOFTWARE. #include "Python.h" #include "osdefs.h" +#include <sys/types.h> +#include <sys/stat.h> +#include <strings.h> -#ifndef PYTHONPATH -#define PYTHONPATH "/usr/local/lib/python" +#if HAVE_UNISTD_H +#include <unistd.h> +#endif /* HAVE_UNISTD_H */ + +/* Search in some common locations for the associated Python libraries. + * + * Two directories must be found, the platform independent directory + * (prefix), containing the common .py and .pyc files, and the + * platform dependent directory (exec_prefix), containing the shared + * library modules. Note that prefix and exec_prefix can be the same + * directory, but for some installations, they are different. + * + * Py_GetPath() carries out separate searches for prefix and + * exec_prefix. Each search tries a number of different locations + * until a ``landmark'' file or directory is found. If no prefix or + * exec_prefix is found, a warning message is issued and the + * preprocessor defines PREFIX and EXEC_PREFIX are used (even though + * they will not work); python carries on as best as is possible, but + * most imports will fail. + * + * Before any searches are done, the location of the executable is + * determined. If argv[0] has a slash in it (or more), this is it; + * otherwise, it must have been invoked from the shell's path, so we + * search $PATH for the named executable and use that. If the + * executable was not found on $PATH (or there was no $PATH + * environment variable), the original argv[0] string is used. + * + * Next, either the executable location is examined to see if it is a + * symbolic link. If so, the link is chased (correctly interpreting a + * relative pathname if one is found) and the directory of the link + * target is used as instead. + * + * Finally, argv0_path is set to the directory containing the + * executable (i.e. the last component is stripped). + * + * With argv0_path in hand, we perform a number of steps. The same + * steps are performed for prefix and for exec_prefix, but with a + * different landmark. + * + * Step 1. Are we running python out of the build directory? This is + * checked by looking for a different kind of landmark relative to + * argv0_path. For prefix, the landmark's path is derived from the + * VPATH preprocessor variable (taking into account that its value is + * almost, but not quite, what we need). If the landmark is found, + * we're done. + * + * For the remaining steps, the prefix landmark will always be + * lib/python$VERSION/string.py and the exec_prefix will always be + * lib/python$VERSION/sharedmodules, where $VERSION is Python's + * version number as supplied by the Makefile. Note that this means + * that no more build directory checking is performed; if the first + * two steps did not find the landmarks, the assumption is that python + * is running from an installed setup. + * + * Step 2. See if the $PYTHONHOME environment variable points to the + * installed location of the Python libraries. If $PYTHONHOME is set, + * then it points to prefix and exec_prefix. $PYTHONHOME can be a + * single directory, which is used for both, or the prefix and + * exec_prefix directories separated by a colon. + * + * Step 3. Try to find prefix and exec_prefix relative to argv0_path, + * backtracking up the path until it is exhausted. This is the most + * common step to succeed. Note that if prefix and exec_prefix are + * different, exec_prefix is more likely to be found; however if + * exec_prefix is a subdirectory of prefix, both will be found. + * + * Step 4. Search the directories pointed to by the preprocessor + * variables PREFIX and EXEC_PREFIX. These are supplied by the + * Makefile but can be passed in as options to the configure script. + * + * Step 5. Search some `standard' directories, namely: /usr/local, + * /usr, then finally /. + * + * That's it! Well, almost. Once we have determined prefix and + * exec_prefix, the preprocesor variable PYTHONPATH is used to + * construct a path. Each relative path on PYTHONPATH is prefixed + * with prefix. Then the directory containing the shared library + * modules is appended. The environment variable $PYTHONPATH is + * inserted in front of it all. Finally, the prefix and exec_prefix + * globals are tweaked so the reflect the values expected by other + * code, by stripping the "lib/python$VERSION/..." stuff off. If + * either points to the build directory, the globals are reset to the + * corresponding preprocessor variables (so sys.prefix will reflect + * the installation location, even though sys.path points into the + * build directory). This seems to make more sense given that + * currently the only known use of sys.prefix and sys.exec_prefix is + * for the ILU installation process to find the installed Python tree. */ + +#ifndef VERSION +#define VERSION "1.5" +#endif + +#ifndef VPATH +#define VPATH "." #endif #ifndef PREFIX @@ -47,51 +142,453 @@ PERFORMANCE OF THIS SOFTWARE. #define EXEC_PREFIX PREFIX #endif +#ifndef PYTHONPATH +/* I know this isn't K&R C, but the Makefile specifies it anyway */ +#define PYTHONPATH PREFIX "/lib/python" VERSION ":" \ + PREFIX "/lib/python" VERSION "/test" ":" \ + EXEC_PREFIX "/lib/python" VERSION "/sharedmodules" +#endif -/* This is called once from pythonrun to initialize sys.path. The - environment variable PYTHONPATH is fetched and the default path - appended. The default path may be passed to the preprocessor; if - not, a hardcoded default is used, which only makes (some) sense on - Unix. */ +#ifndef LANDMARK +#define LANDMARK "string.py" +#endif -char * -Py_GetPath() +static char *std_dirs[] = {"/usr/local/", "/usr/", "/", NULL}; + +static char prefix[MAXPATHLEN+1]; +static char exec_prefix[MAXPATHLEN+1]; +static char *module_search_path = NULL; +static char lib_python[20]; /* Dynamically set to "lib/python" VERSION */ + +static void +reduce(dir) + char *dir; +{ + int i = strlen(dir); + while (i > 0 && dir[i] != SEP) + --i; + dir[i] = '\0'; +} + + +static int +exists(filename) + char *filename; +{ + struct stat buf; + return stat(filename, &buf) == 0; +} + + +static void +join(buffer, stuff) + char *buffer; + char *stuff; +{ + int n, k; + if (stuff[0] == SEP) + n = 0; + else { + n = strlen(buffer); + if (n > 0 && buffer[n-1] != SEP && n < MAXPATHLEN) + buffer[n++] = SEP; + } + k = strlen(stuff); + if (n + k > MAXPATHLEN) + k = MAXPATHLEN - n; + strncpy(buffer+n, stuff, k); + buffer[n+k] = '\0'; +} + + +/* Make sure path ends in a slash. + * Assume path is MAXPATHLEN+1 sized buffer. + */ +static void +string_addsep(path) + char *path; +{ + int len = strlen(path); + + if (path[len-1] != SEP) { + path[len] = SEP; + if (len < MAXPATHLEN) + len++; + path[len] = '\0'; + } +} + + +/* Append a source string onto the destination string, watching for + * buffer overruns. Assumes dest is MAXPATHLEN+1 sized buffer. + */ +static void +string_append(dest, source) + char *dest; + char *source; +{ + int dlen = strlen(dest); + int slen = strlen(source); + int len = dlen + slen; + + strncat(dest, source, MAXPATHLEN - dlen); + if (len < MAXPATHLEN) + len++; + dest[len] = '\0'; +} + + +static int +search_for_prefix(argv0_path, home) + char *argv0_path; + char *home; +{ + int i, n; + char *vpath; + + /* Check VPATH to see if argv0_path is in the build directory. + * Complication: the VPATH passed in is relative to the + * Modules build directory and points to the Modules source + * directory; we need it relative to the build tree and + * pointing to the source tree. Solution: chop off a leading + * ".." (but only if it's there -- it could be an absolute + * path) and chop off the final component (assuming it's + * "Modules"). + */ + vpath = VPATH; + if (vpath[0] == '.' && vpath[1] == '.' && vpath[2] == '/') + vpath += 3; + strcpy(prefix, argv0_path); + join(prefix, vpath); + reduce(prefix); + join(prefix, "Lib"); + join(prefix, LANDMARK); + if (exists(prefix)) + return -1; + + if (home) { + /* Check $PYTHONHOME */ + char *delim; + strcpy(prefix, home); + delim = strchr(prefix, DELIM); + if (delim) + *delim = '\0'; + join(prefix, lib_python); + join(prefix, LANDMARK); + if (exists(prefix)) + return 1; + } + + /* Search from argv0_path, until root is found */ + strcpy(prefix, argv0_path); + do { + n = strlen(prefix); + join(prefix, lib_python); + join(prefix, LANDMARK); + if (exists(prefix)) + return 1; + prefix[n] = '\0'; + reduce(prefix); + } while (prefix[0]); + + /* Look at configure's PREFIX */ + strcpy(prefix, PREFIX); + join(prefix, lib_python); + join(prefix, LANDMARK); + if (exists(prefix)) + return 1; + + /* Look at `standard' directories */ + for (i = 0; std_dirs[i]; i++) { + strcpy(prefix, std_dirs[i]); + join(prefix, lib_python); + join(prefix, LANDMARK); + if (exists(prefix)) + return 1; + } + return 0; +} + + +static int +search_for_exec_prefix(argv0_path, home) + char *argv0_path; + char *home; +{ + int i, n; + + /* Check to see if argv[0] is in the build directory */ + strcpy(exec_prefix, argv0_path); + join(exec_prefix, "Modules/Setup"); + if (exists(exec_prefix)) { + reduce(exec_prefix); + return -1; + } + + if (home) { + /* Check $PYTHONHOME */ + char *delim; + delim = strchr(home, DELIM); + if (delim) + strcpy(exec_prefix, delim+1); + else + strcpy(exec_prefix, home); + join(exec_prefix, lib_python); + join(exec_prefix, "sharedmodules"); + if (exists(exec_prefix)) + return 1; + } + + /* Search from argv0_path, until root is found */ + strcpy(exec_prefix, argv0_path); + do { + n = strlen(exec_prefix); + join(exec_prefix, lib_python); + join(exec_prefix, "sharedmodules"); + if (exists(exec_prefix)) + return 1; + exec_prefix[n] = '\0'; + reduce(exec_prefix); + } while (exec_prefix[0]); + + /* Look at configure's EXEC_PREFIX */ + strcpy(exec_prefix, EXEC_PREFIX); + join(exec_prefix, lib_python); + join(exec_prefix, "sharedmodules"); + if (exists(exec_prefix)) + return 1; + + /* Look at `standard' directories */ + for (i = 0; std_dirs[i]; i++) { + strcpy(exec_prefix, std_dirs[i]); + join(exec_prefix, lib_python); + join(exec_prefix, "sharedmodules"); + if (exists(exec_prefix)) + return 1; + } + return 0; +} + + +static void +calculate_path() { - char *path = getenv("PYTHONPATH"); - char *defpath = PYTHONPATH; - static char *buf = NULL; - char *p; - int n; - - if (path == NULL) - path = ""; - n = strlen(path) + strlen(defpath) + 2; - if (buf != NULL) { - free(buf); - buf = NULL; - } - buf = malloc(n); - if (buf == NULL) - Py_FatalError("not enough memory to copy module search path"); - strcpy(buf, path); - p = buf + strlen(buf); - if (p != buf) - *p++ = DELIM; - strcpy(p, defpath); - return buf; + extern char *Py_GetProgramName(); + + char delimiter[2] = {DELIM, '\0'}; + char separator[2] = {SEP, '\0'}; + char *pythonpath = PYTHONPATH; + char *rtpypath = getenv("PYTHONPATH"); + char *home = getenv("PYTHONHOME"); + char *path = getenv("PATH"); + char *prog = Py_GetProgramName(); + char argv0_path[MAXPATHLEN+1]; + char progpath[MAXPATHLEN+1]; + int pfound, efound; /* 1 if found; -1 if found build directory */ + char *buf; + int bufsz; + int prefixsz; + char *defpath = pythonpath; + + /* Initialize this dynamically for K&R C */ + sprintf(lib_python, "lib/python%s", VERSION); + + /* If there is no slash in the argv0 path, then we have to + * assume python is on the user's $PATH, since there's no + * other way to find a directory to start the search from. If + * $PATH isn't exported, you lose. + */ + if (strchr(prog, SEP)) + strcpy(progpath, prog); + else if (path) { + while (1) { + char *delim = strchr(path, DELIM); + + if (delim) { + int len = delim - path; + strncpy(progpath, path, len); + *(progpath + len) = '\0'; + } + else + strcpy(progpath, path); + + join(progpath, prog); + if (exists(progpath)) + break; + + if (!delim) { + progpath[0] = '\0'; + break; + } + path = delim + 1; + } + } + else + progpath[0] = '\0'; + + strcpy(argv0_path, progpath); + +#if HAVE_READLINK + { + char tmpbuffer[MAXPATHLEN+1]; + int linklen = readlink(progpath, tmpbuffer, MAXPATHLEN); + if (linklen != -1) { + /* It's not null terminated! */ + tmpbuffer[linklen] = '\0'; + if (tmpbuffer[0] == SEP) + strcpy(argv0_path, tmpbuffer); + else { + /* Interpret relative to progpath */ + reduce(argv0_path); + join(argv0_path, tmpbuffer); + } + } + } +#endif /* HAVE_READLINK */ + + reduce(argv0_path); + + if (!(pfound = search_for_prefix(argv0_path, home))) { + fprintf(stderr, + "Could not find platform independent libraries <prefix>\n"); + strcpy(prefix, PREFIX); + join(prefix, lib_python); + } + else + reduce(prefix); + + if (!(efound = search_for_exec_prefix(argv0_path, home))) { + fprintf(stderr, + "Could not find platform dependent libraries <exec_prefix>\n"); + strcpy(exec_prefix, EXEC_PREFIX); + join(exec_prefix, "lib/sharedmodules"); + } + /* If we found EXEC_PREFIX do *not* reduce it! (Yet.) */ + + if (!pfound || !efound) + fprintf(stderr, + "Consider setting $PYTHONHOME to <prefix>[:<exec_prefix>]\n"); + + /* Calculate size of return buffer. + */ + bufsz = 0; + + if (rtpypath) + bufsz += strlen(rtpypath) + 1; + + prefixsz = strlen(prefix) + 1; + + while (1) { + char *delim = strchr(defpath, DELIM); + + if (defpath[0] != SEP) + /* Paths are relative to prefix */ + bufsz += prefixsz; + + if (delim) + bufsz += delim - defpath + 1; + else { + bufsz += strlen(defpath) + 1; + break; + } + defpath = delim + 1; + } + + bufsz += strlen(exec_prefix) + 1; + + /* This is the only malloc call in this file */ + buf = malloc(bufsz); + + if (buf == NULL) { + /* We can't exit, so print a warning and limp along */ + fprintf(stderr, "Not enough memory for dynamic PYTHONPATH.\n"); + fprintf(stderr, "Using default static PYTHONPATH.\n"); + module_search_path = PYTHONPATH; + } + else { + /* Run-time value of $PYTHONPATH goes first */ + if (rtpypath) { + strcpy(buf, rtpypath); + strcat(buf, delimiter); + } + + /* Next goes merge of compile-time $PYTHONPATH with + * dynamically located prefix. + */ + defpath = pythonpath; + while (1) { + char *delim = strchr(defpath, DELIM); + + if (defpath[0] != SEP) { + strcat(buf, prefix); + strcat(buf, separator); + } + + if (delim) { + int len = delim - defpath + 1; + int end = strlen(buf) + len; + strncat(buf, defpath, len); + *(buf + end) = '\0'; + } + else { + strcat(buf, defpath); + break; + } + defpath = delim + 1; + } + strcat(buf, delimiter); + + /* Finally, on goes the directory for dynamic-load modules */ + strcat(buf, exec_prefix); + + /* And publish the results */ + module_search_path = buf; + } + + /* Reduce prefix and exec_prefix to their essence, + * e.g. /usr/local/lib/python1.5 is reduced to /usr/local. + * If we're loading relative to the build directory, + * return the compiled-in defaults instead. + */ + if (pfound > 0) { + reduce(prefix); + reduce(prefix); + } + else + strcpy(prefix, PREFIX); + + if (efound > 0) { + reduce(exec_prefix); + reduce(exec_prefix); + reduce(exec_prefix); + } + else + strcpy(exec_prefix, EXEC_PREFIX); } -/* Similar for Makefile variables $prefix and $exec_prefix */ +/* External interface */ + +char * +Py_GetPath() +{ + if (!module_search_path) + calculate_path(); + return module_search_path; +} char * Py_GetPrefix() { - return PREFIX; + if (!module_search_path) + calculate_path(); + return prefix; } char * Py_GetExecPrefix() { - return EXEC_PREFIX; + if (!module_search_path) + calculate_path(); + return exec_prefix; } |