PC/getpathp.c

   1
   2 /* Return the initial module search path. */
   3 /* Used by DOS, OS/2, Windows 3.1, Windows 95/98, Windows NT. */
   4
   5 /* ----------------------------------------------------------------
   6    PATH RULES FOR WINDOWS:
   7    This describes how sys.path is formed on Windows.  It describes the
   8    functionality, not the implementation (ie, the order in which these
   9    are actually fetched is different)
  10
  11    * Python always adds an empty entry at the start, which corresponds
  12      to the current directory.
  13
  14    * If the PYTHONPATH env. var. exists, its entries are added next.
  15
  16    * We look in the registry for "application paths" - that is, sub-keys
  17      under the main PythonPath registry key.  These are added next (the
  18      order of sub-key processing is undefined).
  19      HKEY_CURRENT_USER is searched and added first.
  20      HKEY_LOCAL_MACHINE is searched and added next.
  21      (Note that all known installers only use HKLM, so HKCU is typically
  22      empty)
  23
  24    * We attempt to locate the "Python Home" - if the PYTHONHOME env var
  25      is set, we believe it.  Otherwise, we use the path of our host .EXE's
  26      to try and locate our "landmark" (lib\\os.py) and deduce our home.
  27      - If we DO have a Python Home: The relevant sub-directories (Lib,
  28        plat-win, lib-tk, etc) are based on the Python Home
  29      - If we DO NOT have a Python Home, the core Python Path is
  30        loaded from the registry.  This is the main PythonPath key,
  31        and both HKLM and HKCU are combined to form the path)
  32
  33    * Iff - we can not locate the Python Home, have not had a PYTHONPATH
  34      specified, and can't locate any Registry entries (ie, we have _nothing_
  35      we can assume is a good path), a default path with relative entries is
  36      used (eg. .\Lib;.\plat-win, etc)
  37
  38
  39   The end result of all this is:
  40   * When running python.exe, or any other .exe in the main Python directory
  41     (either an installed version, or directly from the PCbuild directory),
  42     the core path is deduced, and the core paths in the registry are
  43     ignored.  Other "application paths" in the registry are always read.
  44
  45   * When Python is hosted in another exe (different directory, embedded via
  46     COM, etc), the Python Home will not be deduced, so the core path from
  47     the registry is used.  Other "application paths" in the registry are
  48     always read.
  49
  50   * If Python can't find its home and there is no registry (eg, frozen
  51     exe, some very strange installation setup) you get a path with
  52     some default, but relative, paths.
  53
  54    ---------------------------------------------------------------- */
  55
  56
  57 #include "Python.h"
  58 #include "osdefs.h"
  59
  60 #ifdef MS_WINDOWS
  61 #include <windows.h>
  62 #include <tchar.h>
  63 #endif
  64
  65 #ifdef HAVE_SYS_TYPES_H
  66 #include <sys/types.h>
  67 #endif /* HAVE_SYS_TYPES_H */
  68
  69 #ifdef HAVE_SYS_STAT_H
  70 #include <sys/stat.h>
  71 #endif /* HAVE_SYS_STAT_H */
  72
  73 #include <string.h>
  74
  75 /* Search in some common locations for the associated Python libraries.
  76  *
  77  * Py_GetPath() tries to return a sensible Python module search path.
  78  *
  79  * The approach is an adaptation for Windows of the strategy used in
  80  * ../Modules/getpath.c; it uses the Windows Registry as one of its
  81  * information sources.
  82  */
  83
  84 #ifndef LANDMARK
  85 #define LANDMARK "lib\\os.py"
  86 #endif
  87
  88 static char prefix[MAXPATHLEN+1];
  89 static char progpath[MAXPATHLEN+1];
  90 static char dllpath[MAXPATHLEN+1];
  91 static char *module_search_path = NULL;
  92
  93
  94 static int
  95 is_sep(char ch) /* determine if "ch" is a separator character */
  96 {
  97 #ifdef ALTSEP
  98         return ch == SEP || ch == ALTSEP;
  99 #else
 100         return ch == SEP;
 101 #endif
 102 }
 103
 104 /* assumes 'dir' null terminated in bounds.  Never writes
 105    beyond existing terminator.
 106 */
 107 static void
 108 reduce(char *dir)
 109 {
 110         size_t i = strlen(dir);
 111         while (i > 0 && !is_sep(dir[i]))
 112                 --i;
 113         dir[i] = '\0';
 114 }
 115
 116
 117 static int
 118 exists(char *filename)
 119 {
 120         struct stat buf;
 121         return stat(filename, &buf) == 0;
 122 }
 123
 124 /* Assumes 'filename' MAXPATHLEN+1 bytes long -
 125    may extend 'filename' by one character.
 126 */
 127 static int
 128 ismodule(char *filename)        /* Is module -- check for .pyc/.pyo too */
 129 {
 130         if (exists(filename))
 131                 return 1;
 132
 133         /* Check for the compiled version of prefix. */
 134         if (strlen(filename) < MAXPATHLEN) {
 135                 strcat(filename, Py_OptimizeFlag ? "o" : "c");
 136                 if (exists(filename))
 137                         return 1;
 138         }
 139         return 0;
 140 }
 141
 142 /* Add a path component, by appending stuff to buffer.
 143    buffer must have at least MAXPATHLEN + 1 bytes allocated, and contain a
 144    NUL-terminated string with no more than MAXPATHLEN characters (not counting
 145    the trailing NUL).  It's a fatal error if it contains a string longer than
 146    that (callers must be careful!).  If these requirements are met, it's
 147    guaranteed that buffer will still be a NUL-terminated string with no more
 148    than MAXPATHLEN characters at exit.  If stuff is too long, only as much of
 149    stuff as fits will be appended.
 150 */
 151 static void
 152 join(char *buffer, char *stuff)
 153 {
 154         size_t n, k;
 155         if (is_sep(stuff[0]))
 156                 n = 0;
 157         else {
 158                 n = strlen(buffer);
 159                 if (n > 0 && !is_sep(buffer[n-1]) && n < MAXPATHLEN)
 160                         buffer[n++] = SEP;
 161         }
 162         if (n > MAXPATHLEN)
 163                 Py_FatalError("buffer overflow in getpathp.c's joinpath()");
 164         k = strlen(stuff);
 165         if (n + k > MAXPATHLEN)
 166                 k = MAXPATHLEN - n;
 167         strncpy(buffer+n, stuff, k);
 168         buffer[n+k] = '\0';
 169 }
 170
 171 /* gotlandmark only called by search_for_prefix, which ensures
 172    'prefix' is null terminated in bounds.  join() ensures
 173    'landmark' can not overflow prefix if too long.
 174 */
 175 static int
 176 gotlandmark(char *landmark)
 177 {
 178         int ok;
 179         Py_ssize_t n;
 180
 181         n = strlen(prefix);
 182         join(prefix, landmark);
 183         ok = ismodule(prefix);
 184         prefix[n] = '\0';
 185         return ok;
 186 }
 187
 188 /* assumes argv0_path is MAXPATHLEN+1 bytes long, already \0 term'd.
 189    assumption provided by only caller, calculate_path() */
 190 static int
 191 search_for_prefix(char *argv0_path, char *landmark)
 192 {
 193         /* Search from argv0_path, until landmark is found */
 194         strcpy(prefix, argv0_path);
 195         do {
 196                 if (gotlandmark(landmark))
 197                         return 1;
 198                 reduce(prefix);
 199         } while (prefix[0]);
 200         return 0;
 201 }
 202
 203 #ifdef MS_WINDOWS
 204
 205 /* a string loaded from the DLL at startup.*/
 206 extern const char *PyWin_DLLVersionString;
 207
 208
 209 /* Load a PYTHONPATH value from the registry.
 210    Load from either HKEY_LOCAL_MACHINE or HKEY_CURRENT_USER.
 211
 212    Works in both Unicode and 8bit environments.  Only uses the
 213    Ex family of functions so it also works with Windows CE.
 214
 215    Returns NULL, or a pointer that should be freed.
 216
 217    XXX - this code is pretty strange, as it used to also
 218    work on Win16, where the buffer sizes werent available
 219    in advance.  It could be simplied now Win16/Win32s is dead!
 220 */
 221
 222 static char *
 223 getpythonregpath(HKEY keyBase, int skipcore)
 224 {
 225         HKEY newKey = 0;
 226         DWORD dataSize = 0;
 227         DWORD numKeys = 0;
 228         LONG rc;
 229         char *retval = NULL;
 230         TCHAR *dataBuf = NULL;
 231         static const TCHAR keyPrefix[] = _T("Software\\Python\\PythonCore\\");
 232         static const TCHAR keySuffix[] = _T("\\PythonPath");
 233         size_t versionLen;
 234         DWORD index;
 235         TCHAR *keyBuf = NULL;
 236         TCHAR *keyBufPtr;
 237         TCHAR **ppPaths = NULL;
 238
 239         /* Tried to use sysget("winver") but here is too early :-( */
 240         versionLen = _tcslen(PyWin_DLLVersionString);
 241         /* Space for all the chars, plus one \0 */
 242         keyBuf = keyBufPtr = malloc(sizeof(keyPrefix) +
 243                                     sizeof(TCHAR)*(versionLen-1) +
 244                                     sizeof(keySuffix));
 245         if (keyBuf==NULL) goto done;
 246
 247         memcpy(keyBufPtr, keyPrefix, sizeof(keyPrefix)-sizeof(TCHAR));
 248         keyBufPtr += sizeof(keyPrefix)/sizeof(TCHAR) - 1;
 249         memcpy(keyBufPtr, PyWin_DLLVersionString, versionLen * sizeof(TCHAR));
 250         keyBufPtr += versionLen;
 251         /* NULL comes with this one! */
 252         memcpy(keyBufPtr, keySuffix, sizeof(keySuffix));
 253         /* Open the root Python key */
 254         rc=RegOpenKeyEx(keyBase,
 255                         keyBuf, /* subkey */
 256                         0, /* reserved */
 257                         KEY_READ,
 258                         &newKey);
 259         if (rc!=ERROR_SUCCESS) goto done;
 260         /* Find out how big our core buffer is, and how many subkeys we have */
 261         rc = RegQueryInfoKey(newKey, NULL, NULL, NULL, &numKeys, NULL, NULL,
 262                         NULL, NULL, &dataSize, NULL, NULL);
 263         if (rc!=ERROR_SUCCESS) goto done;
 264         if (skipcore) dataSize = 0; /* Only count core ones if we want them! */
 265         /* Allocate a temp array of char buffers, so we only need to loop
 266            reading the registry once
 267         */
 268         ppPaths = malloc( sizeof(TCHAR *) * numKeys );
 269         if (ppPaths==NULL) goto done;
 270         memset(ppPaths, 0, sizeof(TCHAR *) * numKeys);
 271         /* Loop over all subkeys, allocating a temp sub-buffer. */
 272         for(index=0;index<numKeys;index++) {
 273                 TCHAR keyBuf[MAX_PATH+1];
 274                 HKEY subKey = 0;
 275                 DWORD reqdSize = MAX_PATH+1;
 276                 /* Get the sub-key name */
 277                 DWORD rc = RegEnumKeyEx(newKey, index, keyBuf, &reqdSize,
 278                                         NULL, NULL, NULL, NULL );
 279                 if (rc!=ERROR_SUCCESS) goto done;
 280                 /* Open the sub-key */
 281                 rc=RegOpenKeyEx(newKey,
 282                                                 keyBuf, /* subkey */
 283                                                 0, /* reserved */
 284                                                 KEY_READ,
 285                                                 &subKey);
 286                 if (rc!=ERROR_SUCCESS) goto done;
 287                 /* Find the value of the buffer size, malloc, then read it */
 288                 RegQueryValueEx(subKey, NULL, 0, NULL, NULL, &reqdSize);
 289                 if (reqdSize) {
 290                         ppPaths[index] = malloc(reqdSize);
 291                         if (ppPaths[index]) {
 292                                 RegQueryValueEx(subKey, NULL, 0, NULL,
 293                                                 (LPBYTE)ppPaths[index],
 294                                                 &reqdSize);
 295                                 dataSize += reqdSize + 1; /* 1 for the ";" */
 296                         }
 297                 }
 298                 RegCloseKey(subKey);
 299         }
 300
 301         /* return null if no path to return */
 302         if (dataSize == 0) goto done;
 303
 304         /* original datasize from RegQueryInfo doesn't include the \0 */
 305         dataBuf = malloc((dataSize+1) * sizeof(TCHAR));
 306         if (dataBuf) {
 307                 TCHAR *szCur = dataBuf;
 308                 DWORD reqdSize = dataSize;
 309                 /* Copy our collected strings */
 310                 for (index=0;index<numKeys;index++) {
 311                         if (index > 0) {
 312                                 *(szCur++) = _T(';');
 313                                 dataSize--;
 314                         }
 315                         if (ppPaths[index]) {
 316                                 Py_ssize_t len = _tcslen(ppPaths[index]);
 317                                 _tcsncpy(szCur, ppPaths[index], len);
 318                                 szCur += len;
 319                                 assert(dataSize > (DWORD)len);
 320                                 dataSize -= (DWORD)len;
 321                         }
 322                 }
 323                 if (skipcore)
 324                         *szCur = '\0';
 325                 else {
 326                         /* If we have no values, we dont need a ';' */
 327                         if (numKeys) {
 328                                 *(szCur++) = _T(';');
 329                                 dataSize--;
 330                         }
 331                         /* Now append the core path entries -
 332                            this will include the NULL
 333                         */
 334                         rc = RegQueryValueEx(newKey, NULL, 0, NULL,
 335                                              (LPBYTE)szCur, &dataSize);
 336                 }
 337                 /* And set the result - caller must free
 338                    If MBCS, it is fine as is.  If Unicode, allocate new
 339                    buffer and convert.
 340                 */
 341 #ifdef UNICODE
 342                 retval = (char *)malloc(reqdSize+1);
 343                 if (retval)
 344                         WideCharToMultiByte(CP_ACP, 0,
 345                                         dataBuf, -1, /* source */
 346                                         retval, reqdSize+1, /* dest */
 347                                         NULL, NULL);
 348                 free(dataBuf);
 349 #else
 350                 retval = dataBuf;
 351 #endif
 352         }
 353 done:
 354         /* Loop freeing my temp buffers */
 355         if (ppPaths) {
 356                 for(index=0;index<numKeys;index++)
 357                         if (ppPaths[index]) free(ppPaths[index]);
 358                 free(ppPaths);
 359         }
 360         if (newKey)
 361                 RegCloseKey(newKey);
 362         if (keyBuf)
 363                 free(keyBuf);
 364         return retval;
 365 }
 366 #endif /* MS_WINDOWS */
 367
 368 static void
 369 get_progpath(void)
 370 {
 371         extern char *Py_GetProgramName(void);
 372         char *path = getenv("PATH");
 373         char *prog = Py_GetProgramName();
 374
 375 #ifdef MS_WINDOWS
 376         extern HANDLE PyWin_DLLhModule;
 377 #ifdef UNICODE
 378         WCHAR wprogpath[MAXPATHLEN+1];
 379         /* Windows documents that GetModuleFileName() will "truncate",
 380            but makes no mention of the null terminator.  Play it safe.
 381            PLUS Windows itself defines MAX_PATH as the same, but anyway...
 382         */
 383         wprogpath[MAXPATHLEN]=_T('\0');
 384         if (PyWin_DLLhModule &&
 385             GetModuleFileName(PyWin_DLLhModule, wprogpath, MAXPATHLEN)) {
 386                 WideCharToMultiByte(CP_ACP, 0,
 387                                     wprogpath, -1,
 388                                     dllpath, MAXPATHLEN+1,
 389                                     NULL, NULL);
 390         }
 391         wprogpath[MAXPATHLEN]=_T('\0');
 392         if (GetModuleFileName(NULL, wprogpath, MAXPATHLEN)) {
 393                 WideCharToMultiByte(CP_ACP, 0,
 394                                     wprogpath, -1,
 395                                     progpath, MAXPATHLEN+1,
 396                                     NULL, NULL);
 397                 return;
 398         }
 399 #else
 400         /* static init of progpath ensures final char remains \0 */
 401         if (PyWin_DLLhModule)
 402                 if (!GetModuleFileName(PyWin_DLLhModule, dllpath, MAXPATHLEN))
 403                         dllpath[0] = 0;
 404         if (GetModuleFileName(NULL, progpath, MAXPATHLEN))
 405                 return;
 406 #endif
 407 #endif
 408         if (prog == NULL || *prog == '\0')
 409                 prog = "python";
 410
 411         /* If there is no slash in the argv0 path, then we have to
 412          * assume python is on the user's $PATH, since there's no
 413          * other way to find a directory to start the search from.  If
 414          * $PATH isn't exported, you lose.
 415          */
 416 #ifdef ALTSEP
 417         if (strchr(prog, SEP) || strchr(prog, ALTSEP))
 418 #else
 419         if (strchr(prog, SEP))
 420 #endif
 421                 strncpy(progpath, prog, MAXPATHLEN);
 422         else if (path) {
 423                 while (1) {
 424                         char *delim = strchr(path, DELIM);
 425
 426                         if (delim) {
 427                                 size_t len = delim - path;
 428                                 /* ensure we can't overwrite buffer */
 429                                 len = min(MAXPATHLEN,len);
 430                                 strncpy(progpath, path, len);
 431                                 *(progpath + len) = '\0';
 432                         }
 433                         else
 434                                 strncpy(progpath, path, MAXPATHLEN);
 435
 436                         /* join() is safe for MAXPATHLEN+1 size buffer */
 437                         join(progpath, prog);
 438                         if (exists(progpath))
 439                                 break;
 440
 441                         if (!delim) {
 442                                 progpath[0] = '\0';
 443                                 break;
 444                         }
 445                         path = delim + 1;
 446                 }
 447         }
 448         else
 449                 progpath[0] = '\0';
 450 }
 451
 452 static void
 453 calculate_path(void)
 454 {
 455         char argv0_path[MAXPATHLEN+1];
 456         char *buf;
 457         size_t bufsz;
 458         char *pythonhome = Py_GetPythonHome();
 459         char *envpath = Py_GETENV("PYTHONPATH");
 460
 461 #ifdef MS_WINDOWS
 462         int skiphome, skipdefault;
 463         char *machinepath = NULL;
 464         char *userpath = NULL;
 465         char zip_path[MAXPATHLEN+1];
 466         size_t len;
 467 #endif
 468
 469         get_progpath();
 470         /* progpath guaranteed \0 terminated in MAXPATH+1 bytes. */
 471         strcpy(argv0_path, progpath);
 472         reduce(argv0_path);
 473         if (pythonhome == NULL || *pythonhome == '\0') {
 474                 if (search_for_prefix(argv0_path, LANDMARK))
 475                         pythonhome = prefix;
 476                 else
 477                         pythonhome = NULL;
 478         }
 479         else
 480                 strncpy(prefix, pythonhome, MAXPATHLEN);
 481
 482         if (envpath && *envpath == '\0')
 483                 envpath = NULL;
 484
 485
 486 #ifdef MS_WINDOWS
 487         /* Calculate zip archive path */
 488         if (dllpath[0])         /* use name of python DLL */
 489                 strncpy(zip_path, dllpath, MAXPATHLEN);
 490         else                    /* use name of executable program */
 491                 strncpy(zip_path, progpath, MAXPATHLEN);
 492         zip_path[MAXPATHLEN] = '\0';
 493         len = strlen(zip_path);
 494         if (len > 4) {
 495                 zip_path[len-3] = 'z';  /* change ending to "zip" */
 496                 zip_path[len-2] = 'i';
 497                 zip_path[len-1] = 'p';
 498         }
 499         else {
 500                 zip_path[0] = 0;
 501         }
 502
 503         skiphome = pythonhome==NULL ? 0 : 1;
 504         machinepath = getpythonregpath(HKEY_LOCAL_MACHINE, skiphome);
 505         userpath = getpythonregpath(HKEY_CURRENT_USER, skiphome);
 506         /* We only use the default relative PYTHONPATH if we havent
 507            anything better to use! */
 508         skipdefault = envpath!=NULL || pythonhome!=NULL || \
 509                       machinepath!=NULL || userpath!=NULL;
 510 #endif
 511
 512         /* We need to construct a path from the following parts.
 513            (1) the PYTHONPATH environment variable, if set;
 514            (2) for Win32, the zip archive file path;
 515            (3) for Win32, the machinepath and userpath, if set;
 516            (4) the PYTHONPATH config macro, with the leading "."
 517                of each component replaced with pythonhome, if set;
 518            (5) the directory containing the executable (argv0_path).
 519            The length calculation calculates #4 first.
 520            Extra rules:
 521            - If PYTHONHOME is set (in any way) item (3) is ignored.
 522            - If registry values are used, (4) and (5) are ignored.
 523         */
 524
 525         /* Calculate size of return buffer */
 526         if (pythonhome != NULL) {
 527                 char *p;
 528                 bufsz = 1;
 529                 for (p = PYTHONPATH; *p; p++) {
 530                         if (*p == DELIM)
 531                                 bufsz++; /* number of DELIM plus one */
 532                 }
 533                 bufsz *= strlen(pythonhome);
 534         }
 535         else
 536                 bufsz = 0;
 537         bufsz += strlen(PYTHONPATH) + 1;
 538         bufsz += strlen(argv0_path) + 1;
 539 #ifdef MS_WINDOWS
 540         if (userpath)
 541                 bufsz += strlen(userpath) + 1;
 542         if (machinepath)
 543                 bufsz += strlen(machinepath) + 1;
 544         bufsz += strlen(zip_path) + 1;
 545 #endif
 546         if (envpath != NULL)
 547                 bufsz += strlen(envpath) + 1;
 548
 549         module_search_path = buf = malloc(bufsz);
 550         if (buf == NULL) {
 551                 /* We can't exit, so print a warning and limp along */
 552                 fprintf(stderr, "Can't malloc dynamic PYTHONPATH.\n");
 553                 if (envpath) {
 554                         fprintf(stderr, "Using environment $PYTHONPATH.\n");
 555                         module_search_path = envpath;
 556                 }
 557                 else {
 558                         fprintf(stderr, "Using default static path.\n");
 559                         module_search_path = PYTHONPATH;
 560                 }
 561 #ifdef MS_WINDOWS
 562                 if (machinepath)
 563                         free(machinepath);
 564                 if (userpath)
 565                         free(userpath);
 566 #endif /* MS_WINDOWS */
 567                 return;
 568         }
 569
 570         if (envpath) {
 571                 strcpy(buf, envpath);
 572                 buf = strchr(buf, '\0');
 573                 *buf++ = DELIM;
 574         }
 575 #ifdef MS_WINDOWS
 576         if (zip_path[0]) {
 577                 strcpy(buf, zip_path);
 578                 buf = strchr(buf, '\0');
 579                 *buf++ = DELIM;
 580         }
 581         if (userpath) {
 582                 strcpy(buf, userpath);
 583                 buf = strchr(buf, '\0');
 584                 *buf++ = DELIM;
 585                 free(userpath);
 586         }
 587         if (machinepath) {
 588                 strcpy(buf, machinepath);
 589                 buf = strchr(buf, '\0');
 590                 *buf++ = DELIM;
 591                 free(machinepath);
 592         }
 593         if (pythonhome == NULL) {
 594                 if (!skipdefault) {
 595                         strcpy(buf, PYTHONPATH);
 596                         buf = strchr(buf, '\0');
 597                 }
 598         }
 599 #else
 600         if (pythonhome == NULL) {
 601                 strcpy(buf, PYTHONPATH);
 602                 buf = strchr(buf, '\0');
 603         }
 604 #endif /* MS_WINDOWS */
 605         else {
 606                 char *p = PYTHONPATH;
 607                 char *q;
 608                 size_t n;
 609                 for (;;) {
 610                         q = strchr(p, DELIM);
 611                         if (q == NULL)
 612                                 n = strlen(p);
 613                         else
 614                                 n = q-p;
 615                         if (p[0] == '.' && is_sep(p[1])) {
 616                                 strcpy(buf, pythonhome);
 617                                 buf = strchr(buf, '\0');
 618                                 p++;
 619                                 n--;
 620                         }
 621                         strncpy(buf, p, n);
 622                         buf += n;
 623                         if (q == NULL)
 624                                 break;
 625                         *buf++ = DELIM;
 626                         p = q+1;
 627                 }
 628         }
 629         if (argv0_path) {
 630                 *buf++ = DELIM;
 631                 strcpy(buf, argv0_path);
 632                 buf = strchr(buf, '\0');
 633         }
 634         *buf = '\0';
 635         /* Now to pull one last hack/trick.  If sys.prefix is
 636            empty, then try and find it somewhere on the paths
 637            we calculated.  We scan backwards, as our general policy
 638            is that Python core directories are at the *end* of
 639            sys.path.  We assume that our "lib" directory is
 640            on the path, and that our 'prefix' directory is
 641            the parent of that.
 642         */
 643         if (*prefix=='\0') {
 644                 char lookBuf[MAXPATHLEN+1];
 645                 char *look = buf - 1; /* 'buf' is at the end of the buffer */
 646                 while (1) {
 647                         Py_ssize_t nchars;
 648                         char *lookEnd = look;
 649                         /* 'look' will end up one character before the
 650                            start of the path in question - even if this
 651                            is one character before the start of the buffer
 652                         */
 653                         while (look >= module_search_path && *look != DELIM)
 654                                 look--;
 655                         nchars = lookEnd-look;
 656                         strncpy(lookBuf, look+1, nchars);
 657                         lookBuf[nchars] = '\0';
 658                         /* Up one level to the parent */
 659                         reduce(lookBuf);
 660                         if (search_for_prefix(lookBuf, LANDMARK)) {
 661                                 break;
 662                         }
 663                         /* If we are out of paths to search - give up */
 664                         if (look < module_search_path)
 665                                 break;
 666                         look--;
 667                 }
 668         }
 669 }
 670
 671
 672 /* External interface */
 673
 674 char *
 675 Py_GetPath(void)
 676 {
 677         if (!module_search_path)
 678                 calculate_path();
 679         return module_search_path;
 680 }
 681
 682 char *
 683 Py_GetPrefix(void)
 684 {
 685         if (!module_search_path)
 686                 calculate_path();
 687         return prefix;
 688 }
 689
 690 char *
 691 Py_GetExecPrefix(void)
 692 {
 693         return Py_GetPrefix();
 694 }
 695
 696 char *
 697 Py_GetProgramFullPath(void)
 698 {
 699         if (!module_search_path)
 700                 calculate_path();
 701         return progpath;
 702 }