source: python/trunk/Modules/getpath.c@ 388

Last change on this file since 388 was 383, checked in by dmik, 11 years ago

Restore original dynamic 'sys.prefix' detection.

This in particular reverts r20 and parts of r10. These hacks are not
necessary after properly defining 'sys.path' entries in 'site.py'.

  • Property svn:eol-style set to native
File size: 20.6 KB
Line 
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 && !IS_SEP(dir[i]))
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 (IS_ABSPATH(stuff))
212 n = 0;
213 else {
214 n = strlen(buffer);
215 if (n > 0 && !IS_SEP(buffer[n-1]) && 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 (IS_ABSPATH(p)) {
233 strcpy(path, p);
234#ifdef ALTSEP
235 p = path;
236 while ((p = strchr(p, ALTSEP)))
237 *p++ = SEP;
238#endif
239 }
240 else {
241 getcwd(path, MAXPATHLEN);
242 if (p[0] == '.' && IS_SEP(p[1]))
243 p += 2;
244 joinpath(path, p);
245 }
246}
247
248/* absolutize() requires that path be allocated at least MAXPATHLEN+1 bytes. */
249static void
250absolutize(char *path)
251{
252 char buffer[MAXPATHLEN + 1];
253
254 if (IS_ABSPATH(path)) {
255#ifdef ALTSEP
256 while ((path = strchr(path, ALTSEP)))
257 *path++ = SEP;
258#endif
259 return;
260 }
261 copy_absolute(buffer, path);
262 strcpy(path, buffer);
263}
264
265/* search_for_prefix requires that argv0_path be no more than MAXPATHLEN
266 bytes long.
267*/
268static int
269search_for_prefix(char *argv0_path, char *home)
270{
271 size_t n;
272 char *vpath;
273
274 /* If PYTHONHOME is set, we believe it unconditionally */
275 if (home) {
276 char *delim;
277 strncpy(prefix, home, MAXPATHLEN);
278 delim = strchr(prefix, DELIM);
279 if (delim)
280 *delim = '\0';
281 joinpath(prefix, lib_python);
282 joinpath(prefix, LANDMARK);
283 return 1;
284 }
285
286 /* Check to see if argv[0] is in the build directory */
287 strcpy(prefix, argv0_path);
288 joinpath(prefix, "Modules/Setup");
289 if (isfile(prefix)) {
290 /* Check VPATH to see if argv0_path is in the build directory. */
291 vpath = VPATH;
292 strcpy(prefix, argv0_path);
293 joinpath(prefix, vpath);
294 joinpath(prefix, "Lib");
295 joinpath(prefix, LANDMARK);
296 if (ismodule(prefix))
297 return -1;
298 }
299
300 /* Search from argv0_path, until root is found */
301 copy_absolute(prefix, argv0_path);
302 do {
303 n = strlen(prefix);
304 joinpath(prefix, lib_python);
305 joinpath(prefix, LANDMARK);
306 if (ismodule(prefix))
307 return 1;
308 prefix[n] = '\0';
309 reduce(prefix);
310 } while (prefix[0]);
311
312 /* Look at configure's PREFIX */
313 strncpy(prefix, PREFIX, MAXPATHLEN);
314 joinpath(prefix, lib_python);
315 joinpath(prefix, LANDMARK);
316 if (ismodule(prefix))
317 return 1;
318
319 /* Fail */
320 return 0;
321}
322
323
324/* search_for_exec_prefix requires that argv0_path be no more than
325 MAXPATHLEN bytes long.
326*/
327static int
328search_for_exec_prefix(char *argv0_path, char *home)
329{
330 size_t n;
331
332 /* If PYTHONHOME is set, we believe it unconditionally */
333 if (home) {
334 char *delim;
335 delim = strchr(home, DELIM);
336 if (delim)
337 strncpy(exec_prefix, delim+1, MAXPATHLEN);
338 else
339 strncpy(exec_prefix, home, MAXPATHLEN);
340 joinpath(exec_prefix, lib_python);
341 joinpath(exec_prefix, "lib-dynload");
342 return 1;
343 }
344
345 /* Check to see if argv[0] is in the build directory */
346 strcpy(exec_prefix, argv0_path);
347 joinpath(exec_prefix, "Modules/Setup");
348 if (isfile(exec_prefix)) {
349 reduce(exec_prefix);
350 return -1;
351 }
352
353 /* Search from argv0_path, until root is found */
354 copy_absolute(exec_prefix, argv0_path);
355 do {
356 n = strlen(exec_prefix);
357 joinpath(exec_prefix, lib_python);
358 joinpath(exec_prefix, "lib-dynload");
359 if (isdir(exec_prefix))
360 return 1;
361 exec_prefix[n] = '\0';
362 reduce(exec_prefix);
363 } while (exec_prefix[0]);
364
365 /* Look at configure's EXEC_PREFIX */
366 strncpy(exec_prefix, EXEC_PREFIX, MAXPATHLEN);
367 joinpath(exec_prefix, lib_python);
368 joinpath(exec_prefix, "lib-dynload");
369 if (isdir(exec_prefix))
370 return 1;
371
372 /* Fail */
373 return 0;
374}
375
376
377static void
378calculate_path(void)
379{
380 extern char *Py_GetProgramName(void);
381
382 static char delimiter[2] = {DELIM, '\0'};
383 static char separator[2] = {SEP, '\0'};
384 char *pythonpath = PYTHONPATH;
385 char *rtpypath = Py_GETENV("PYTHONPATH");
386 char *home = Py_GetPythonHome();
387 char *path = getenv("PATH");
388 char *prog = Py_GetProgramName();
389 char argv0_path[MAXPATHLEN+1];
390 char zip_path[MAXPATHLEN+1];
391 int pfound, efound; /* 1 if found; -1 if found build directory */
392 char *buf;
393 size_t bufsz;
394 size_t prefixsz;
395 char *defpath = pythonpath;
396#ifdef WITH_NEXT_FRAMEWORK
397 NSModule pythonModule;
398#endif
399#ifdef __APPLE__
400#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4
401 uint32_t nsexeclength = MAXPATHLEN;
402#else
403 unsigned long nsexeclength = MAXPATHLEN;
404#endif
405#endif
406
407 /* If there is no slash in the argv0 path, then we have to
408 * assume python is on the user's $PATH, since there's no
409 * other way to find a directory to start the search from. If
410 * $PATH isn't exported, you lose.
411 */
412 if (HAS_ANYSEP(prog))
413 strncpy(progpath, prog, MAXPATHLEN);
414#ifdef __APPLE__
415 /* On Mac OS X, if a script uses an interpreter of the form
416 * "#!/opt/python2.3/bin/python", the kernel only passes "python"
417 * as argv[0], which falls through to the $PATH search below.
418 * If /opt/python2.3/bin isn't in your path, or is near the end,
419 * this algorithm may incorrectly find /usr/bin/python. To work
420 * around this, we can use _NSGetExecutablePath to get a better
421 * hint of what the intended interpreter was, although this
422 * will fail if a relative path was used. but in that case,
423 * absolutize() should help us out below
424 */
425 else if(0 == _NSGetExecutablePath(progpath, &nsexeclength) && progpath[0] == SEP)
426 ;
427#endif /* __APPLE__ */
428 else if (path) {
429 while (1) {
430 char *delim = strchr(path, DELIM);
431
432 if (delim) {
433 size_t len = delim - path;
434 if (len > MAXPATHLEN)
435 len = MAXPATHLEN;
436 strncpy(progpath, path, len);
437 *(progpath + len) = '\0';
438 }
439 else
440 strncpy(progpath, path, MAXPATHLEN);
441
442 joinpath(progpath, prog);
443 if (isxfile(progpath))
444 break;
445
446 if (!delim) {
447 progpath[0] = '\0';
448 break;
449 }
450 path = delim + 1;
451 }
452 }
453 else
454 progpath[0] = '\0';
455#ifndef ALTSEP
456 if (!IS_ABSPATH(progpath))
457#endif
458 absolutize(progpath);
459 strncpy(argv0_path, progpath, MAXPATHLEN);
460 argv0_path[MAXPATHLEN] = '\0';
461
462#ifdef WITH_NEXT_FRAMEWORK
463 /* On Mac OS X we have a special case if we're running from a framework.
464 ** This is because the python home should be set relative to the library,
465 ** which is in the framework, not relative to the executable, which may
466 ** be outside of the framework. Except when we're in the build directory...
467 */
468 pythonModule = NSModuleForSymbol(NSLookupAndBindSymbol("_Py_Initialize"));
469 /* Use dylib functions to find out where the framework was loaded from */
470 buf = (char *)NSLibraryNameForModule(pythonModule);
471 if (buf != NULL) {
472 /* We're in a framework. */
473 /* See if we might be in the build directory. The framework in the
474 ** build directory is incomplete, it only has the .dylib and a few
475 ** needed symlinks, it doesn't have the Lib directories and such.
476 ** If we're running with the framework from the build directory we must
477 ** be running the interpreter in the build directory, so we use the
478 ** build-directory-specific logic to find Lib and such.
479 */
480 strncpy(argv0_path, buf, MAXPATHLEN);
481 reduce(argv0_path);
482 joinpath(argv0_path, lib_python);
483 joinpath(argv0_path, LANDMARK);
484 if (!ismodule(argv0_path)) {
485 /* We are in the build directory so use the name of the
486 executable - we know that the absolute path is passed */
487 strncpy(argv0_path, prog, MAXPATHLEN);
488 }
489 else {
490 /* Use the location of the library as the progpath */
491 strncpy(argv0_path, buf, MAXPATHLEN);
492 }
493 }
494#endif
495
496#if HAVE_READLINK
497 {
498 char tmpbuffer[MAXPATHLEN+1];
499 int linklen = readlink(progpath, tmpbuffer, MAXPATHLEN);
500 while (linklen != -1) {
501 /* It's not null terminated! */
502 tmpbuffer[linklen] = '\0';
503 if (IS_ABSPATH(tmpbuffer))
504 /* tmpbuffer should never be longer than MAXPATHLEN,
505 but extra check does not hurt */
506 strncpy(argv0_path, tmpbuffer, MAXPATHLEN);
507 else {
508 /* Interpret relative to progpath */
509 reduce(argv0_path);
510 joinpath(argv0_path, tmpbuffer);
511 }
512 linklen = readlink(argv0_path, tmpbuffer, MAXPATHLEN);
513 }
514 }
515#endif /* HAVE_READLINK */
516
517 reduce(argv0_path);
518 /* At this point, argv0_path is guaranteed to be less than
519 MAXPATHLEN bytes long.
520 */
521
522 if (!(pfound = search_for_prefix(argv0_path, home))) {
523 if (!Py_FrozenFlag)
524 fprintf(stderr,
525 "Could not find platform independent libraries <prefix>\n");
526 strncpy(prefix, PREFIX, MAXPATHLEN);
527 joinpath(prefix, lib_python);
528 }
529 else
530 reduce(prefix);
531
532 strncpy(zip_path, prefix, MAXPATHLEN);
533 zip_path[MAXPATHLEN] = '\0';
534 if (pfound > 0) { /* Use the reduced prefix returned by Py_GetPrefix() */
535 reduce(zip_path);
536 reduce(zip_path);
537 }
538 else
539 strncpy(zip_path, PREFIX, MAXPATHLEN);
540 joinpath(zip_path, "lib/python00.zip");
541 bufsz = strlen(zip_path); /* Replace "00" with version */
542 zip_path[bufsz - 6] = VERSION[0];
543 zip_path[bufsz - 5] = VERSION[2];
544
545 if (!(efound = search_for_exec_prefix(argv0_path, home))) {
546 if (!Py_FrozenFlag)
547 fprintf(stderr,
548 "Could not find platform dependent libraries <exec_prefix>\n");
549 strncpy(exec_prefix, EXEC_PREFIX, MAXPATHLEN);
550 joinpath(exec_prefix, "lib/lib-dynload");
551 }
552 /* If we found EXEC_PREFIX do *not* reduce it! (Yet.) */
553
554 if ((!pfound || !efound) && !Py_FrozenFlag)
555 fprintf(stderr,
556 "Consider setting $PYTHONHOME to <prefix>[:<exec_prefix>]\n");
557
558 /* Calculate size of return buffer.
559 */
560 bufsz = 0;
561
562 if (rtpypath)
563 bufsz += strlen(rtpypath) + 1;
564
565 prefixsz = strlen(prefix) + 1;
566
567 while (1) {
568 char *delim = strchr(defpath, ':'); /* bird: hardcoded DELIM in default path. */
569
570 if (!IS_ABSPATH(defpath))
571 /* Paths are relative to prefix */
572 bufsz += prefixsz;
573
574 if (delim)
575 bufsz += delim - defpath + 1;
576 else {
577 bufsz += strlen(defpath) + 1;
578 break;
579 }
580 defpath = delim + 1;
581 }
582
583 bufsz += strlen(zip_path) + 1;
584 bufsz += strlen(exec_prefix) + 1;
585
586 /* This is the only malloc call in this file */
587 buf = (char *)PyMem_Malloc(bufsz);
588
589 if (buf == NULL) {
590 /* We can't exit, so print a warning and limp along */
591 fprintf(stderr, "Not enough memory for dynamic PYTHONPATH.\n");
592 fprintf(stderr, "Using default static PYTHONPATH.\n");
593 module_search_path = PYTHONPATH;
594 }
595 else {
596 /* Run-time value of $PYTHONPATH goes first */
597 if (rtpypath) {
598 strcpy(buf, rtpypath);
599 strcat(buf, delimiter);
600 }
601 else
602 buf[0] = '\0';
603
604 /* Next is the default zip path */
605 strcat(buf, zip_path);
606 strcat(buf, delimiter);
607
608 /* Next goes merge of compile-time $PYTHONPATH with
609 * dynamically located prefix.
610 */
611 defpath = pythonpath;
612 while (1) {
613 char *delim = strchr(defpath, ':'); /* bird: hardcoded DELIM in default path. */
614
615 if (!IS_ABSPATH(defpath)) {
616 strcat(buf, prefix);
617 strcat(buf, separator);
618 }
619
620 if (delim) {
621 size_t len = delim - defpath;
622 size_t end = strlen(buf) + len;
623 strncat(buf, defpath, len);
624 *(buf + end) = DELIM; /* bird: correct the DELIM char. */
625 *(buf + end + 1) = '\0';
626 }
627 else {
628 strcat(buf, defpath);
629 break;
630 }
631 defpath = delim + 1;
632 }
633 strcat(buf, delimiter);
634
635 /* Finally, on goes the directory for dynamic-load modules */
636 strcat(buf, exec_prefix);
637
638 /* And publish the results */
639 module_search_path = buf;
640 }
641
642 /* Reduce prefix and exec_prefix to their essence,
643 * e.g. /usr/local/lib/python1.5 is reduced to /usr/local.
644 * If we're loading relative to the build directory,
645 * return the compiled-in defaults instead.
646 */
647 if (pfound > 0) {
648 reduce(prefix);
649 reduce(prefix);
650 /* The prefix is the root directory, but reduce() chopped
651 * off the "/". */
652 if (!prefix[0])
653 strcpy(prefix, separator);
654 }
655 else
656 strncpy(prefix, PREFIX, MAXPATHLEN);
657
658 if (efound > 0) {
659 reduce(exec_prefix);
660 reduce(exec_prefix);
661 reduce(exec_prefix);
662 if (!exec_prefix[0])
663 strcpy(exec_prefix, separator);
664 }
665 else
666 strncpy(exec_prefix, EXEC_PREFIX, MAXPATHLEN);
667}
668
669
670/* External interface */
671
672char *
673Py_GetPath(void)
674{
675 if (!module_search_path)
676 calculate_path();
677 return module_search_path;
678}
679
680char *
681Py_GetPrefix(void)
682{
683 if (!module_search_path)
684 calculate_path();
685 return prefix;
686}
687
688char *
689Py_GetExecPrefix(void)
690{
691 if (!module_search_path)
692 calculate_path();
693 return exec_prefix;
694}
695
696char *
697Py_GetProgramFullPath(void)
698{
699 if (!module_search_path)
700 calculate_path();
701 return progpath;
702}
703
704
705#ifdef __cplusplus
706}
707#endif
708
Note: See TracBrowser for help on using the repository browser.