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