PageRenderTime 81ms CodeModel.GetById 40ms app.highlight 34ms RepoModel.GetById 1ms app.codeStats 0ms

/Modules/getpath.c

http://unladen-swallow.googlecode.com/
C | 694 lines | 442 code | 81 blank | 171 comment | 103 complexity | 5a8e01a89a7bbebd1bf15e24fcd77cd0 MD5 | raw file
  1/* Return the initial module search path. */
  2
  3#include "Python.h"
  4#include "osdefs.h"
  5
  6#include <sys/types.h>
  7#include <string.h>
  8
  9#ifdef __APPLE__
 10#include <mach-o/dyld.h>
 11#endif
 12
 13/* Search in some common locations for the associated Python libraries.
 14 *
 15 * Two directories must be found, the platform independent directory
 16 * (prefix), containing the common .py and .pyc files, and the platform
 17 * dependent directory (exec_prefix), containing the shared library
 18 * modules.  Note that prefix and exec_prefix can be the same directory,
 19 * but for some installations, they are different.
 20 *
 21 * Py_GetPath() carries out separate searches for prefix and exec_prefix.
 22 * Each search tries a number of different locations until a ``landmark''
 23 * file or directory is found.  If no prefix or exec_prefix is found, a
 24 * warning message is issued and the preprocessor defined PREFIX and
 25 * EXEC_PREFIX are used (even though they will not work); python carries on
 26 * as best as is possible, but most imports will fail.
 27 *
 28 * Before any searches are done, the location of the executable is
 29 * determined.  If argv[0] has one or more slashes in it, it is used
 30 * unchanged.  Otherwise, it must have been invoked from the shell's path,
 31 * so we search $PATH for the named executable and use that.  If the
 32 * executable was not found on $PATH (or there was no $PATH environment
 33 * variable), the original argv[0] string is used.
 34 *
 35 * Next, the executable location is examined to see if it is a symbolic
 36 * link.  If so, the link is chased (correctly interpreting a relative
 37 * pathname if one is found) and the directory of the link target is used.
 38 *
 39 * Finally, argv0_path is set to the directory containing the executable
 40 * (i.e. the last component is stripped).
 41 *
 42 * With argv0_path in hand, we perform a number of steps.  The same steps
 43 * are performed for prefix and for exec_prefix, but with a different
 44 * landmark.
 45 *
 46 * Step 1. Are we running python out of the build directory?  This is
 47 * checked by looking for a different kind of landmark relative to
 48 * argv0_path.  For prefix, the landmark's path is derived from the VPATH
 49 * preprocessor variable (taking into account that its value is almost, but
 50 * not quite, what we need).  For exec_prefix, the landmark is
 51 * Modules/Setup.  If the landmark is found, we're done.
 52 *
 53 * For the remaining steps, the prefix landmark will always be
 54 * lib/python$VERSION/os.py and the exec_prefix will always be
 55 * lib/python$VERSION/lib-dynload, where $VERSION is Python's version
 56 * number as supplied by the Makefile.  Note that this means that no more
 57 * build directory checking is performed; if the first step did not find
 58 * the landmarks, the assumption is that python is running from an
 59 * installed setup.
 60 *
 61 * Step 2. See if the $PYTHONHOME environment variable points to the
 62 * installed location of the Python libraries.  If $PYTHONHOME is set, then
 63 * it points to prefix and exec_prefix.  $PYTHONHOME can be a single
 64 * directory, which is used for both, or the prefix and exec_prefix
 65 * directories separated by a colon.
 66 *
 67 * Step 3. Try to find prefix and exec_prefix relative to argv0_path,
 68 * backtracking up the path until it is exhausted.  This is the most common
 69 * step to succeed.  Note that if prefix and exec_prefix are different,
 70 * exec_prefix is more likely to be found; however if exec_prefix is a
 71 * subdirectory of prefix, both will be found.
 72 *
 73 * Step 4. Search the directories pointed to by the preprocessor variables
 74 * PREFIX and EXEC_PREFIX.  These are supplied by the Makefile but can be
 75 * passed in as options to the configure script.
 76 *
 77 * That's it!
 78 *
 79 * Well, almost.  Once we have determined prefix and exec_prefix, the
 80 * preprocessor variable PYTHONPATH is used to construct a path.  Each
 81 * relative path on PYTHONPATH is prefixed with prefix.  Then the directory
 82 * containing the shared library modules is appended.  The environment
 83 * variable $PYTHONPATH is inserted in front of it all.  Finally, the
 84 * prefix and exec_prefix globals are tweaked so they reflect the values
 85 * expected by other code, by stripping the "lib/python$VERSION/..." stuff
 86 * off.  If either points to the build directory, the globals are reset to
 87 * the corresponding preprocessor variables (so sys.prefix will reflect the
 88 * installation location, even though sys.path points into the build
 89 * directory).  This seems to make more sense given that currently the only
 90 * known use of sys.prefix and sys.exec_prefix is for the ILU installation
 91 * process to find the installed Python tree.
 92 */
 93
 94#ifdef __cplusplus
 95 extern "C" {
 96#endif
 97
 98
 99#ifndef VERSION
100#define VERSION "2.1"
101#endif
102
103#ifndef VPATH
104#define VPATH "."
105#endif
106
107#ifndef PREFIX
108#  ifdef __VMS
109#    define PREFIX ""
110#  else
111#    define PREFIX "/usr/local"
112#  endif
113#endif
114
115#ifndef EXEC_PREFIX
116#define EXEC_PREFIX PREFIX
117#endif
118
119#ifndef PYTHONPATH
120#define PYTHONPATH PREFIX "/lib/python" VERSION ":" \
121              EXEC_PREFIX "/lib/python" VERSION "/lib-dynload"
122#endif
123
124#ifndef LANDMARK
125#define LANDMARK "os.py"
126#endif
127
128static char prefix[MAXPATHLEN+1];
129static char exec_prefix[MAXPATHLEN+1];
130static char progpath[MAXPATHLEN+1];
131static char *module_search_path = NULL;
132static char lib_python[] = "lib/python" VERSION;
133
134static void
135reduce(char *dir)
136{
137    size_t i = strlen(dir);
138    while (i > 0 && dir[i] != SEP)
139        --i;
140    dir[i] = '\0';
141}
142
143
144static int
145isfile(char *filename)          /* Is file, not directory */
146{
147    struct stat buf;
148    if (stat(filename, &buf) != 0)
149        return 0;
150    if (!S_ISREG(buf.st_mode))
151        return 0;
152    return 1;
153}
154
155
156static int
157ismodule(char *filename)        /* Is module -- check for .pyc/.pyo too */
158{
159    if (isfile(filename))
160        return 1;
161
162    /* Check for the compiled version of prefix. */
163    if (strlen(filename) < MAXPATHLEN) {
164        strcat(filename, Py_OptimizeFlag ? "o" : "c");
165        if (isfile(filename))
166            return 1;
167    }
168    return 0;
169}
170
171
172static int
173isxfile(char *filename)         /* Is executable file */
174{
175    struct stat buf;
176    if (stat(filename, &buf) != 0)
177        return 0;
178    if (!S_ISREG(buf.st_mode))
179        return 0;
180    if ((buf.st_mode & 0111) == 0)
181        return 0;
182    return 1;
183}
184
185
186static int
187isdir(char *filename)                   /* Is directory */
188{
189    struct stat buf;
190    if (stat(filename, &buf) != 0)
191        return 0;
192    if (!S_ISDIR(buf.st_mode))
193        return 0;
194    return 1;
195}
196
197
198/* Add a path component, by appending stuff to buffer.
199   buffer must have at least MAXPATHLEN + 1 bytes allocated, and contain a
200   NUL-terminated string with no more than MAXPATHLEN characters (not counting
201   the trailing NUL).  It's a fatal error if it contains a string longer than
202   that (callers must be careful!).  If these requirements are met, it's
203   guaranteed that buffer will still be a NUL-terminated string with no more
204   than MAXPATHLEN characters at exit.  If stuff is too long, only as much of
205   stuff as fits will be appended.
206*/
207static void
208joinpath(char *buffer, char *stuff)
209{
210    size_t n, k;
211    if (stuff[0] == SEP)
212        n = 0;
213    else {
214        n = strlen(buffer);
215        if (n > 0 && buffer[n-1] != SEP && n < MAXPATHLEN)
216            buffer[n++] = SEP;
217    }
218    if (n > MAXPATHLEN)
219    	Py_FatalError("buffer overflow in getpath.c's joinpath()");
220    k = strlen(stuff);
221    if (n + k > MAXPATHLEN)
222        k = MAXPATHLEN - n;
223    strncpy(buffer+n, stuff, k);
224    buffer[n+k] = '\0';
225}
226
227/* copy_absolute requires that path be allocated at least
228   MAXPATHLEN + 1 bytes and that p be no more than MAXPATHLEN bytes. */
229static void
230copy_absolute(char *path, char *p)
231{
232    if (p[0] == SEP)
233        strcpy(path, p);
234    else {
235        getcwd(path, MAXPATHLEN);
236        if (p[0] == '.' && p[1] == SEP)
237            p += 2;
238        joinpath(path, p);
239    }
240}
241
242/* absolutize() requires that path be allocated at least MAXPATHLEN+1 bytes. */
243static void
244absolutize(char *path)
245{
246    char buffer[MAXPATHLEN + 1];
247
248    if (path[0] == SEP)
249        return;
250    copy_absolute(buffer, path);
251    strcpy(path, buffer);
252}
253
254/* search_for_prefix requires that argv0_path be no more than MAXPATHLEN
255   bytes long.
256*/
257static int
258search_for_prefix(char *argv0_path, char *home)
259{
260    size_t n;
261    char *vpath;
262
263    /* If PYTHONHOME is set, we believe it unconditionally */
264    if (home) {
265        char *delim;
266        strncpy(prefix, home, MAXPATHLEN);
267        delim = strchr(prefix, DELIM);
268        if (delim)
269            *delim = '\0';
270        joinpath(prefix, lib_python);
271        joinpath(prefix, LANDMARK);
272        return 1;
273    }
274
275    /* Check to see if argv[0] is in the build directory */
276    strcpy(prefix, argv0_path);
277    joinpath(prefix, "Modules/Setup");
278    if (isfile(prefix)) {
279        /* Check VPATH to see if argv0_path is in the build directory. */
280        vpath = VPATH;
281        strcpy(prefix, argv0_path);
282        joinpath(prefix, vpath);
283        joinpath(prefix, "Lib");
284        joinpath(prefix, LANDMARK);
285        if (ismodule(prefix))
286            return -1;
287    }
288
289    /* Search from argv0_path, until root is found */
290    copy_absolute(prefix, argv0_path);
291    do {
292        n = strlen(prefix);
293        joinpath(prefix, lib_python);
294        joinpath(prefix, LANDMARK);
295        if (ismodule(prefix))
296            return 1;
297        prefix[n] = '\0';
298        reduce(prefix);
299    } while (prefix[0]);
300
301    /* Look at configure's PREFIX */
302    strncpy(prefix, PREFIX, MAXPATHLEN);
303    joinpath(prefix, lib_python);
304    joinpath(prefix, LANDMARK);
305    if (ismodule(prefix))
306        return 1;
307
308    /* Fail */
309    return 0;
310}
311
312
313/* search_for_exec_prefix requires that argv0_path be no more than
314   MAXPATHLEN bytes long.
315*/
316static int
317search_for_exec_prefix(char *argv0_path, char *home)
318{
319    size_t n;
320
321    /* If PYTHONHOME is set, we believe it unconditionally */
322    if (home) {
323        char *delim;
324        delim = strchr(home, DELIM);
325        if (delim)
326            strncpy(exec_prefix, delim+1, MAXPATHLEN);
327        else
328            strncpy(exec_prefix, home, MAXPATHLEN);
329        joinpath(exec_prefix, lib_python);
330        joinpath(exec_prefix, "lib-dynload");
331        return 1;
332    }
333
334    /* Check to see if argv[0] is in the build directory */
335    strcpy(exec_prefix, argv0_path);
336    joinpath(exec_prefix, "Modules/Setup");
337    if (isfile(exec_prefix)) {
338        reduce(exec_prefix);
339        return -1;
340    }
341
342    /* Search from argv0_path, until root is found */
343    copy_absolute(exec_prefix, argv0_path);
344    do {
345        n = strlen(exec_prefix);
346        joinpath(exec_prefix, lib_python);
347        joinpath(exec_prefix, "lib-dynload");
348        if (isdir(exec_prefix))
349            return 1;
350        exec_prefix[n] = '\0';
351        reduce(exec_prefix);
352    } while (exec_prefix[0]);
353
354    /* Look at configure's EXEC_PREFIX */
355    strncpy(exec_prefix, EXEC_PREFIX, MAXPATHLEN);
356    joinpath(exec_prefix, lib_python);
357    joinpath(exec_prefix, "lib-dynload");
358    if (isdir(exec_prefix))
359        return 1;
360
361    /* Fail */
362    return 0;
363}
364
365
366static void
367calculate_path(void)
368{
369    extern char *Py_GetProgramName(void);
370
371    static char delimiter[2] = {DELIM, '\0'};
372    static char separator[2] = {SEP, '\0'};
373    char *pythonpath = PYTHONPATH;
374    char *rtpypath = Py_GETENV("PYTHONPATH");
375    char *home = Py_GetPythonHome();
376    char *path = getenv("PATH");
377    char *prog = Py_GetProgramName();
378    char argv0_path[MAXPATHLEN+1];
379    char zip_path[MAXPATHLEN+1];
380    int pfound, efound; /* 1 if found; -1 if found build directory */
381    char *buf;
382    size_t bufsz;
383    size_t prefixsz;
384    char *defpath = pythonpath;
385#ifdef WITH_NEXT_FRAMEWORK
386    NSModule pythonModule;
387#endif
388#ifdef __APPLE__
389#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4
390    uint32_t nsexeclength = MAXPATHLEN;
391#else
392    unsigned long nsexeclength = MAXPATHLEN;
393#endif
394#endif
395
396	/* If there is no slash in the argv0 path, then we have to
397	 * assume python is on the user's $PATH, since there's no
398	 * other way to find a directory to start the search from.  If
399	 * $PATH isn't exported, you lose.
400	 */
401	if (strchr(prog, SEP))
402		strncpy(progpath, prog, MAXPATHLEN);
403#ifdef __APPLE__
404     /* On Mac OS X, if a script uses an interpreter of the form
405      * "#!/opt/python2.3/bin/python", the kernel only passes "python"
406      * as argv[0], which falls through to the $PATH search below.
407      * If /opt/python2.3/bin isn't in your path, or is near the end,
408      * this algorithm may incorrectly find /usr/bin/python. To work
409      * around this, we can use _NSGetExecutablePath to get a better
410      * hint of what the intended interpreter was, although this
411      * will fail if a relative path was used. but in that case,
412      * absolutize() should help us out below
413      */
414     else if(0 == _NSGetExecutablePath(progpath, &nsexeclength) && progpath[0] == SEP)
415       ;
416#endif /* __APPLE__ */
417	else if (path) {
418		while (1) {
419			char *delim = strchr(path, DELIM);
420
421			if (delim) {
422				size_t len = delim - path;
423				if (len > MAXPATHLEN)
424					len = MAXPATHLEN;
425				strncpy(progpath, path, len);
426				*(progpath + len) = '\0';
427			}
428			else
429				strncpy(progpath, path, MAXPATHLEN);
430
431			joinpath(progpath, prog);
432			if (isxfile(progpath))
433				break;
434
435			if (!delim) {
436				progpath[0] = '\0';
437				break;
438			}
439			path = delim + 1;
440		}
441	}
442	else
443		progpath[0] = '\0';
444	if (progpath[0] != SEP)
445		absolutize(progpath);
446	strncpy(argv0_path, progpath, MAXPATHLEN);
447	argv0_path[MAXPATHLEN] = '\0';
448
449#ifdef WITH_NEXT_FRAMEWORK
450	/* On Mac OS X we have a special case if we're running from a framework.
451	** This is because the python home should be set relative to the library,
452	** which is in the framework, not relative to the executable, which may
453	** be outside of the framework. Except when we're in the build directory...
454	*/
455    pythonModule = NSModuleForSymbol(NSLookupAndBindSymbol("_Py_Initialize"));
456    /* Use dylib functions to find out where the framework was loaded from */
457    buf = (char *)NSLibraryNameForModule(pythonModule);
458    if (buf != NULL) {
459        /* We're in a framework. */
460        /* See if we might be in the build directory. The framework in the
461        ** build directory is incomplete, it only has the .dylib and a few
462        ** needed symlinks, it doesn't have the Lib directories and such.
463        ** If we're running with the framework from the build directory we must
464        ** be running the interpreter in the build directory, so we use the
465        ** build-directory-specific logic to find Lib and such.
466        */
467        strncpy(argv0_path, buf, MAXPATHLEN);
468        reduce(argv0_path);
469        joinpath(argv0_path, lib_python);
470        joinpath(argv0_path, LANDMARK);
471        if (!ismodule(argv0_path)) {
472                /* We are in the build directory so use the name of the
473                   executable - we know that the absolute path is passed */
474                strncpy(argv0_path, prog, MAXPATHLEN);
475        }
476        else {
477                /* Use the location of the library as the progpath */
478                strncpy(argv0_path, buf, MAXPATHLEN);
479        }
480    }
481#endif
482
483#if HAVE_READLINK
484    {
485        char tmpbuffer[MAXPATHLEN+1];
486        int linklen = readlink(progpath, tmpbuffer, MAXPATHLEN);
487        while (linklen != -1) {
488            /* It's not null terminated! */
489            tmpbuffer[linklen] = '\0';
490            if (tmpbuffer[0] == SEP)
491                /* tmpbuffer should never be longer than MAXPATHLEN,
492                   but extra check does not hurt */
493                strncpy(argv0_path, tmpbuffer, MAXPATHLEN);
494            else {
495                /* Interpret relative to progpath */
496                reduce(argv0_path);
497                joinpath(argv0_path, tmpbuffer);
498            }
499            linklen = readlink(argv0_path, tmpbuffer, MAXPATHLEN);
500        }
501    }
502#endif /* HAVE_READLINK */
503
504    reduce(argv0_path);
505    /* At this point, argv0_path is guaranteed to be less than
506       MAXPATHLEN bytes long.
507    */
508
509    if (!(pfound = search_for_prefix(argv0_path, home))) {
510        if (!Py_FrozenFlag)
511            fprintf(stderr,
512                "Could not find platform independent libraries <prefix>\n");
513        strncpy(prefix, PREFIX, MAXPATHLEN);
514        joinpath(prefix, lib_python);
515    }
516    else
517        reduce(prefix);
518
519    strncpy(zip_path, prefix, MAXPATHLEN);
520    zip_path[MAXPATHLEN] = '\0';
521    if (pfound > 0) { /* Use the reduced prefix returned by Py_GetPrefix() */
522        reduce(zip_path);
523        reduce(zip_path);
524    }
525    else
526        strncpy(zip_path, PREFIX, MAXPATHLEN);
527    joinpath(zip_path, "lib/python00.zip");
528    bufsz = strlen(zip_path);	/* Replace "00" with version */
529    zip_path[bufsz - 6] = VERSION[0];
530    zip_path[bufsz - 5] = VERSION[2];
531
532    if (!(efound = search_for_exec_prefix(argv0_path, home))) {
533        if (!Py_FrozenFlag)
534            fprintf(stderr,
535                "Could not find platform dependent libraries <exec_prefix>\n");
536        strncpy(exec_prefix, EXEC_PREFIX, MAXPATHLEN);
537        joinpath(exec_prefix, "lib/lib-dynload");
538    }
539    /* If we found EXEC_PREFIX do *not* reduce it!  (Yet.) */
540
541    if ((!pfound || !efound) && !Py_FrozenFlag)
542        fprintf(stderr,
543                "Consider setting $PYTHONHOME to <prefix>[:<exec_prefix>]\n");
544
545    /* Calculate size of return buffer.
546     */
547    bufsz = 0;
548
549    if (rtpypath)
550        bufsz += strlen(rtpypath) + 1;
551
552    prefixsz = strlen(prefix) + 1;
553
554    while (1) {
555        char *delim = strchr(defpath, DELIM);
556
557        if (defpath[0] != SEP)
558            /* Paths are relative to prefix */
559            bufsz += prefixsz;
560
561        if (delim)
562            bufsz += delim - defpath + 1;
563        else {
564            bufsz += strlen(defpath) + 1;
565            break;
566        }
567        defpath = delim + 1;
568    }
569
570    bufsz += strlen(zip_path) + 1;
571    bufsz += strlen(exec_prefix) + 1;
572
573    /* This is the only malloc call in this file */
574    buf = (char *)PyMem_Malloc(bufsz);
575
576    if (buf == NULL) {
577        /* We can't exit, so print a warning and limp along */
578        fprintf(stderr, "Not enough memory for dynamic PYTHONPATH.\n");
579        fprintf(stderr, "Using default static PYTHONPATH.\n");
580        module_search_path = PYTHONPATH;
581    }
582    else {
583        /* Run-time value of $PYTHONPATH goes first */
584        if (rtpypath) {
585            strcpy(buf, rtpypath);
586            strcat(buf, delimiter);
587        }
588        else
589            buf[0] = '\0';
590
591        /* Next is the default zip path */
592        strcat(buf, zip_path);
593        strcat(buf, delimiter);
594
595        /* Next goes merge of compile-time $PYTHONPATH with
596         * dynamically located prefix.
597         */
598        defpath = pythonpath;
599        while (1) {
600            char *delim = strchr(defpath, DELIM);
601
602            if (defpath[0] != SEP) {
603                strcat(buf, prefix);
604                strcat(buf, separator);
605            }
606
607            if (delim) {
608                size_t len = delim - defpath + 1;
609                size_t end = strlen(buf) + len;
610                strncat(buf, defpath, len);
611                *(buf + end) = '\0';
612            }
613            else {
614                strcat(buf, defpath);
615                break;
616            }
617            defpath = delim + 1;
618        }
619        strcat(buf, delimiter);
620
621        /* Finally, on goes the directory for dynamic-load modules */
622        strcat(buf, exec_prefix);
623
624        /* And publish the results */
625        module_search_path = buf;
626    }
627
628    /* Reduce prefix and exec_prefix to their essence,
629     * e.g. /usr/local/lib/python1.5 is reduced to /usr/local.
630     * If we're loading relative to the build directory,
631     * return the compiled-in defaults instead.
632     */
633    if (pfound > 0) {
634        reduce(prefix);
635        reduce(prefix);
636	/* The prefix is the root directory, but reduce() chopped
637	 * off the "/". */
638	if (!prefix[0])
639		strcpy(prefix, separator);
640    }
641    else
642        strncpy(prefix, PREFIX, MAXPATHLEN);
643
644    if (efound > 0) {
645        reduce(exec_prefix);
646        reduce(exec_prefix);
647        reduce(exec_prefix);
648	if (!exec_prefix[0])
649		strcpy(exec_prefix, separator);
650    }
651    else
652        strncpy(exec_prefix, EXEC_PREFIX, MAXPATHLEN);
653}
654
655
656/* External interface */
657
658char *
659Py_GetPath(void)
660{
661    if (!module_search_path)
662        calculate_path();
663    return module_search_path;
664}
665
666char *
667Py_GetPrefix(void)
668{
669    if (!module_search_path)
670        calculate_path();
671    return prefix;
672}
673
674char *
675Py_GetExecPrefix(void)
676{
677    if (!module_search_path)
678        calculate_path();
679    return exec_prefix;
680}
681
682char *
683Py_GetProgramFullPath(void)
684{
685    if (!module_search_path)
686        calculate_path();
687    return progpath;
688}
689
690
691#ifdef __cplusplus
692}
693#endif
694