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