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 #ifdef Py_ENABLE_SHARED
 205
 206 /* a string loaded from the DLL at startup.*/
 207 extern const char *PyWin_DLLVersionString;
 208
 209
 210 /* Load a PYTHONPATH value from the registry.
 211    Load from either HKEY_LOCAL_MACHINE or HKEY_CURRENT_USER.
 212
 213    Works in both Unicode and 8bit environments.  Only uses the
 214    Ex family of functions so it also works with Windows CE.
 215
 216    Returns NULL, or a pointer that should be freed.
 217
 218    XXX - this code is pretty strange, as it used to also
 219    work on Win16, where the buffer sizes werent available
 220    in advance.  It could be simplied now Win16/Win32s is dead!
 221 */
 222
 223 static char *
 224 getpythonregpath(HKEY keyBase, int skipcore)
 225 {
 226         HKEY newKey = 0;
 227         DWORD dataSize = 0;
 228         DWORD numKeys = 0;
 229         LONG rc;
 230         char *retval = NULL;
 231         TCHAR *dataBuf = NULL;
 232         static const TCHAR keyPrefix[] = _T("Software\\Python\\PythonCore\\");
 233         static const TCHAR keySuffix[] = _T("\\PythonPath");
 234         size_t versionLen;
 235         DWORD index;
 236         TCHAR *keyBuf = NULL;
 237         TCHAR *keyBufPtr;
 238         TCHAR **ppPaths = NULL;
 239
 240         /* Tried to use sysget("winver") but here is too early :-( */
 241         versionLen = _tcslen(PyWin_DLLVersionString);
 242         /* Space for all the chars, plus one \0 */
 243         keyBuf = keyBufPtr = malloc(sizeof(keyPrefix) +
 244                                     sizeof(TCHAR)*(versionLen-1) +
 245                                     sizeof(keySuffix));
 246         if (keyBuf==NULL) goto done;
 247
 248         memcpy(keyBufPtr, keyPrefix, sizeof(keyPrefix)-sizeof(TCHAR));
 249         keyBufPtr += sizeof(keyPrefix)/sizeof(TCHAR) - 1;
 250         memcpy(keyBufPtr, PyWin_DLLVersionString, versionLen * sizeof(TCHAR));
 251         keyBufPtr += versionLen;
 252         /* NULL comes with this one! */
 253         memcpy(keyBufPtr, keySuffix, sizeof(keySuffix));
 254         /* Open the root Python key */
 255         rc=RegOpenKeyEx(keyBase,
 256                         keyBuf, /* subkey */
 257                         0, /* reserved */
 258                         KEY_READ,
 259                         &newKey);
 260         if (rc!=ERROR_SUCCESS) goto done;
 261         /* Find out how big our core buffer is, and how many subkeys we have */
 262         rc = RegQueryInfoKey(newKey, NULL, NULL, NULL, &numKeys, NULL, NULL,
 263                         NULL, NULL, &dataSize, NULL, NULL);
 264         if (rc!=ERROR_SUCCESS) goto done;
 265         if (skipcore) dataSize = 0; /* Only count core ones if we want them! */
 266         /* Allocate a temp array of char buffers, so we only need to loop
 267            reading the registry once
 268         */
 269         ppPaths = malloc( sizeof(TCHAR *) * numKeys );
 270         if (ppPaths==NULL) goto done;
 271         memset(ppPaths, 0, sizeof(TCHAR *) * numKeys);
 272         /* Loop over all subkeys, allocating a temp sub-buffer. */
 273         for(index=0;index<numKeys;index++) {
 274                 TCHAR keyBuf[MAX_PATH+1];
 275                 HKEY subKey = 0;
 276                 DWORD reqdSize = MAX_PATH+1;
 277                 /* Get the sub-key name */
 278                 DWORD rc = RegEnumKeyEx(newKey, index, keyBuf, &reqdSize,
 279                                         NULL, NULL, NULL, NULL );
 280                 if (rc!=ERROR_SUCCESS) goto done;
 281                 /* Open the sub-key */
 282                 rc=RegOpenKeyEx(newKey,
 283                                                 keyBuf, /* subkey */
 284                                                 0, /* reserved */
 285                                                 KEY_READ,
 286                                                 &subKey);
 287                 if (rc!=ERROR_SUCCESS) goto done;
 288                 /* Find the value of the buffer size, malloc, then read it */
 289                 RegQueryValueEx(subKey, NULL, 0, NULL, NULL, &reqdSize);
 290                 if (reqdSize) {
 291                         ppPaths[index] = malloc(reqdSize);
 292                         if (ppPaths[index]) {
 293                                 RegQueryValueEx(subKey, NULL, 0, NULL,
 294                                                 (LPBYTE)ppPaths[index],
 295                                                 &reqdSize);
 296                                 dataSize += reqdSize + 1; /* 1 for the ";" */
 297                         }
 298                 }
 299                 RegCloseKey(subKey);
 300         }
 301
 302         /* return null if no path to return */
 303         if (dataSize == 0) goto done;
 304
 305         /* original datasize from RegQueryInfo doesn't include the \0 */
 306         dataBuf = malloc((dataSize+1) * sizeof(TCHAR));
 307         if (dataBuf) {
 308                 TCHAR *szCur = dataBuf;
 309                 DWORD reqdSize = dataSize;
 310                 /* Copy our collected strings */
 311                 for (index=0;index<numKeys;index++) {
 312                         if (index > 0) {
 313                                 *(szCur++) = _T(';');
 314                                 dataSize--;
 315                         }
 316                         if (ppPaths[index]) {
 317                                 Py_ssize_t len = _tcslen(ppPaths[index]);
 318                                 _tcsncpy(szCur, ppPaths[index], len);
 319                                 szCur += len;
 320                                 assert(dataSize > (DWORD)len);
 321                                 dataSize -= (DWORD)len;
 322                         }
 323                 }
 324                 if (skipcore)
 325                         *szCur = '\0';
 326                 else {
 327                         /* If we have no values, we dont need a ';' */
 328                         if (numKeys) {
 329                                 *(szCur++) = _T(';');
 330                                 dataSize--;
 331                         }
 332                         /* Now append the core path entries -
 333                            this will include the NULL
 334                         */
 335                         rc = RegQueryValueEx(newKey, NULL, 0, NULL,
 336                                              (LPBYTE)szCur, &dataSize);
 337                 }
 338                 /* And set the result - caller must free
 339                    If MBCS, it is fine as is.  If Unicode, allocate new
 340                    buffer and convert.
 341                 */
 342 #ifdef UNICODE
 343                 retval = (char *)malloc(reqdSize+1);
 344                 if (retval)
 345                         WideCharToMultiByte(CP_ACP, 0,
 346                                         dataBuf, -1, /* source */
 347                                         retval, reqdSize+1, /* dest */
 348                                         NULL, NULL);
 349                 free(dataBuf);
 350 #else
 351                 retval = dataBuf;
 352 #endif
 353         }
 354 done:
 355         /* Loop freeing my temp buffers */
 356         if (ppPaths) {
 357                 for(index=0;index<numKeys;index++)
 358                         if (ppPaths[index]) free(ppPaths[index]);
 359                 free(ppPaths);
 360         }
 361         if (newKey)
 362                 RegCloseKey(newKey);
 363         if (keyBuf)
 364                 free(keyBuf);
 365         return retval;
 366 }
 367 #endif /* Py_ENABLE_SHARED */
 368 #endif /* MS_WINDOWS */
 369
 370 static void
 371 get_progpath(void)
 372 {
 373         extern char *Py_GetProgramName(void);
 374         char *path = getenv("PATH");
 375         char *prog = Py_GetProgramName();
 376
 377 #ifdef MS_WINDOWS
 378         extern HANDLE PyWin_DLLhModule;
 379 #ifdef UNICODE
 380         WCHAR wprogpath[MAXPATHLEN+1];
 381         /* Windows documents that GetModuleFileName() will "truncate",
 382            but makes no mention of the null terminator.  Play it safe.
 383            PLUS Windows itself defines MAX_PATH as the same, but anyway...
 384         */
 385 #ifdef Py_ENABLE_SHARED
 386         wprogpath[MAXPATHLEN]=_T('\0');
 387         if (PyWin_DLLhModule &&
 388             GetModuleFileName(PyWin_DLLhModule, wprogpath, MAXPATHLEN)) {
 389                 WideCharToMultiByte(CP_ACP, 0,
 390                                     wprogpath, -1,
 391                                     dllpath, MAXPATHLEN+1,
 392                                     NULL, NULL);
 393         }
 394 #else
 395         dllpath[0] = 0;
 396 #endif
 397         wprogpath[MAXPATHLEN]=_T('\0');
 398         if (GetModuleFileName(NULL, wprogpath, MAXPATHLEN)) {
 399                 WideCharToMultiByte(CP_ACP, 0,
 400                                     wprogpath, -1,
 401                                     progpath, MAXPATHLEN+1,
 402                                     NULL, NULL);
 403                 return;
 404         }
 405 #else
 406         /* static init of progpath ensures final char remains \0 */
 407 #ifdef Py_ENABLE_SHARED
 408         if (PyWin_DLLhModule)
 409                 if (!GetModuleFileName(PyWin_DLLhModule, dllpath, MAXPATHLEN))
 410                         dllpath[0] = 0;
 411 #else
 412         dllpath[0] = 0;
 413 #endif
 414         if (GetModuleFileName(NULL, progpath, MAXPATHLEN))
 415                 return;
 416 #endif
 417 #endif
 418         if (prog == NULL || *prog == '\0')
 419                 prog = "python";
 420
 421         /* If there is no slash in the argv0 path, then we have to
 422          * assume python is on the user's $PATH, since there's no
 423          * other way to find a directory to start the search from.  If
 424          * $PATH isn't exported, you lose.
 425          */
 426 #ifdef ALTSEP
 427         if (strchr(prog, SEP) || strchr(prog, ALTSEP))
 428 #else
 429         if (strchr(prog, SEP))
 430 #endif
 431                 strncpy(progpath, prog, MAXPATHLEN);
 432         else if (path) {
 433                 while (1) {
 434                         char *delim = strchr(path, DELIM);
 435
 436                         if (delim) {
 437                                 size_t len = delim - path;
 438                                 /* ensure we can't overwrite buffer */
 439                                 len = min(MAXPATHLEN,len);
 440                                 strncpy(progpath, path, len);
 441                                 *(progpath + len) = '\0';
 442                         }
 443                         else
 444                                 strncpy(progpath, path, MAXPATHLEN);
 445
 446                         /* join() is safe for MAXPATHLEN+1 size buffer */
 447                         join(progpath, prog);
 448                         if (exists(progpath))
 449                                 break;
 450
 451                         if (!delim) {
 452                                 progpath[0] = '\0';
 453                                 break;
 454                         }
 455                         path = delim + 1;
 456                 }
 457         }
 458         else
 459                 progpath[0] = '\0';
 460 }
 461
 462 static void
 463 calculate_path(void)
 464 {
 465         char argv0_path[MAXPATHLEN+1];
 466         char *buf;
 467         size_t bufsz;
 468         char *pythonhome = Py_GetPythonHome();
 469         char *envpath = Py_GETENV("PYTHONPATH");
 470
 471 #ifdef MS_WINDOWS
 472         int skiphome, skipdefault;
 473         char *machinepath = NULL;
 474         char *userpath = NULL;
 475         char zip_path[MAXPATHLEN+1];
 476         size_t len;
 477 #endif
 478
 479         get_progpath();
 480         /* progpath guaranteed \0 terminated in MAXPATH+1 bytes. */
 481         strcpy(argv0_path, progpath);
 482         reduce(argv0_path);
 483         if (pythonhome == NULL || *pythonhome == '\0') {
 484                 if (search_for_prefix(argv0_path, LANDMARK))
 485                         pythonhome = prefix;
 486                 else
 487                         pythonhome = NULL;
 488         }
 489         else
 490                 strncpy(prefix, pythonhome, MAXPATHLEN);
 491
 492         if (envpath && *envpath == '\0')
 493                 envpath = NULL;
 494
 495
 496 #ifdef MS_WINDOWS
 497         /* Calculate zip archive path */
 498         if (dllpath[0])         /* use name of python DLL */
 499                 strncpy(zip_path, dllpath, MAXPATHLEN);
 500         else                    /* use name of executable program */
 501                 strncpy(zip_path, progpath, MAXPATHLEN);
 502         zip_path[MAXPATHLEN] = '\0';
 503         len = strlen(zip_path);
 504         if (len > 4) {
 505                 zip_path[len-3] = 'z';  /* change ending to "zip" */
 506                 zip_path[len-2] = 'i';
 507                 zip_path[len-1] = 'p';
 508         }
 509         else {
 510                 zip_path[0] = 0;
 511         }
 512
 513         skiphome = pythonhome==NULL ? 0 : 1;
 514 #ifdef Py_ENABLE_SHARED
 515         machinepath = getpythonregpath(HKEY_LOCAL_MACHINE, skiphome);
 516         userpath = getpythonregpath(HKEY_CURRENT_USER, skiphome);
 517 #endif
 518         /* We only use the default relative PYTHONPATH if we havent
 519            anything better to use! */
 520         skipdefault = envpath!=NULL || pythonhome!=NULL || \
 521                       machinepath!=NULL || userpath!=NULL;
 522 #endif
 523
 524         /* We need to construct a path from the following parts.
 525            (1) the PYTHONPATH environment variable, if set;
 526            (2) for Win32, the zip archive file path;
 527            (3) for Win32, the machinepath and userpath, if set;
 528            (4) the PYTHONPATH config macro, with the leading "."
 529                of each component replaced with pythonhome, if set;
 530            (5) the directory containing the executable (argv0_path).
 531            The length calculation calculates #4 first.
 532            Extra rules:
 533            - If PYTHONHOME is set (in any way) item (3) is ignored.
 534            - If registry values are used, (4) and (5) are ignored.
 535         */
 536
 537         /* Calculate size of return buffer */
 538         if (pythonhome != NULL) {
 539                 char *p;
 540                 bufsz = 1;
 541                 for (p = PYTHONPATH; *p; p++) {
 542                         if (*p == DELIM)
 543                                 bufsz++; /* number of DELIM plus one */
 544                 }
 545                 bufsz *= strlen(pythonhome);
 546         }
 547         else
 548                 bufsz = 0;
 549         bufsz += strlen(PYTHONPATH) + 1;
 550         bufsz += strlen(argv0_path) + 1;
 551 #ifdef MS_WINDOWS
 552         if (userpath)
 553                 bufsz += strlen(userpath) + 1;
 554         if (machinepath)
 555                 bufsz += strlen(machinepath) + 1;
 556         bufsz += strlen(zip_path) + 1;
 557 #endif
 558         if (envpath != NULL)
 559                 bufsz += strlen(envpath) + 1;
 560
 561         module_search_path = buf = malloc(bufsz);
 562         if (buf == NULL) {
 563                 /* We can't exit, so print a warning and limp along */
 564                 fprintf(stderr, "Can't malloc dynamic PYTHONPATH.\n");
 565                 if (envpath) {
 566                         fprintf(stderr, "Using environment $PYTHONPATH.\n");
 567                         module_search_path = envpath;
 568                 }
 569                 else {
 570                         fprintf(stderr, "Using default static path.\n");
 571                         module_search_path = PYTHONPATH;
 572                 }
 573 #ifdef MS_WINDOWS
 574                 if (machinepath)
 575                         free(machinepath);
 576                 if (userpath)
 577                         free(userpath);
 578 #endif /* MS_WINDOWS */
 579                 return;
 580         }
 581
 582         if (envpath) {
 583                 strcpy(buf, envpath);
 584                 buf = strchr(buf, '\0');
 585                 *buf++ = DELIM;
 586         }
 587 #ifdef MS_WINDOWS
 588         if (zip_path[0]) {
 589                 strcpy(buf, zip_path);
 590                 buf = strchr(buf, '\0');
 591                 *buf++ = DELIM;
 592         }
 593         if (userpath) {
 594                 strcpy(buf, userpath);
 595                 buf = strchr(buf, '\0');
 596                 *buf++ = DELIM;
 597                 free(userpath);
 598         }
 599         if (machinepath) {
 600                 strcpy(buf, machinepath);
 601                 buf = strchr(buf, '\0');
 602                 *buf++ = DELIM;
 603                 free(machinepath);
 604         }
 605         if (pythonhome == NULL) {
 606                 if (!skipdefault) {
 607                         strcpy(buf, PYTHONPATH);
 608                         buf = strchr(buf, '\0');
 609                 }
 610         }
 611 #else
 612         if (pythonhome == NULL) {
 613                 strcpy(buf, PYTHONPATH);
 614                 buf = strchr(buf, '\0');
 615         }
 616 #endif /* MS_WINDOWS */
 617         else {
 618                 char *p = PYTHONPATH;
 619                 char *q;
 620                 size_t n;
 621                 for (;;) {
 622                         q = strchr(p, DELIM);
 623                         if (q == NULL)
 624                                 n = strlen(p);
 625                         else
 626                                 n = q-p;
 627                         if (p[0] == '.' && is_sep(p[1])) {
 628                                 strcpy(buf, pythonhome);
 629                                 buf = strchr(buf, '\0');
 630                                 p++;
 631                                 n--;
 632                         }
 633                         strncpy(buf, p, n);
 634                         buf += n;
 635                         if (q == NULL)
 636                                 break;
 637                         *buf++ = DELIM;
 638                         p = q+1;
 639                 }
 640         }
 641         if (argv0_path) {
 642                 *buf++ = DELIM;
 643                 strcpy(buf, argv0_path);
 644                 buf = strchr(buf, '\0');
 645         }
 646         *buf = '\0';
 647         /* Now to pull one last hack/trick.  If sys.prefix is
 648            empty, then try and find it somewhere on the paths
 649            we calculated.  We scan backwards, as our general policy
 650            is that Python core directories are at the *end* of
 651            sys.path.  We assume that our "lib" directory is
 652            on the path, and that our 'prefix' directory is
 653            the parent of that.
 654         */
 655         if (*prefix=='\0') {
 656                 char lookBuf[MAXPATHLEN+1];
 657                 char *look = buf - 1; /* 'buf' is at the end of the buffer */
 658                 while (1) {
 659                         Py_ssize_t nchars;
 660                         char *lookEnd = look;
 661                         /* 'look' will end up one character before the
 662                            start of the path in question - even if this
 663                            is one character before the start of the buffer
 664                         */
 665                         while (look >= module_search_path && *look != DELIM)
 666                                 look--;
 667                         nchars = lookEnd-look;
 668                         strncpy(lookBuf, look+1, nchars);
 669                         lookBuf[nchars] = '\0';
 670                         /* Up one level to the parent */
 671                         reduce(lookBuf);
 672                         if (search_for_prefix(lookBuf, LANDMARK)) {
 673                                 break;
 674                         }
 675                         /* If we are out of paths to search - give up */
 676                         if (look < module_search_path)
 677                                 break;
 678                         look--;
 679                 }
 680         }
 681 }
 682
 683
 684 /* External interface */
 685
 686 char *
 687 Py_GetPath(void)
 688 {
 689         if (!module_search_path)
 690                 calculate_path();
 691         return module_search_path;
 692 }
 693
 694 char *
 695 Py_GetPrefix(void)
 696 {
 697         if (!module_search_path)
 698                 calculate_path();
 699         return prefix;
 700 }
 701
 702 char *
 703 Py_GetExecPrefix(void)
 704 {
 705         return Py_GetPrefix();
 706 }
 707
 708 char *
 709 Py_GetProgramFullPath(void)
 710 {
 711         if (!module_search_path)
 712                 calculate_path();
 713         return progpath;
 714 }