Modules/getpath.c

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