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