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, it's 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_WIN32
  61 #include <windows.h>
  62 #include <tchar.h>
  63 #endif
  64
  65 #include <sys/types.h>
  66 #include <sys/stat.h>
  67 #include <string.h>
  68
  69 #if HAVE_UNISTD_H
  70 #include <unistd.h>
  71 #endif /* HAVE_UNISTD_H */
  72
  73 /* Search in some common locations for the associated Python libraries.
  74  *
  75  * Py_GetPath() tries to return a sensible Python module search path.
  76  *
  77  * The approach is an adaptation for Windows of the strategy used in
  78  * ../Modules/getpath.c; it uses the Windows Registry as one of its
  79  * information sources.
  80  */
  81
  82 #ifndef LANDMARK
  83 #define LANDMARK "lib\\os.py"
  84 #endif
  85
  86 static char prefix[MAXPATHLEN+1];
  87 static char progpath[MAXPATHLEN+1];
  88 static char *module_search_path = NULL;
  89
  90
  91 static int
  92 is_sep(char ch) /* determine if "ch" is a separator character */
  93 {
  94 #ifdef ALTSEP
  95         return ch == SEP || ch == ALTSEP;
  96 #else
  97         return ch == SEP;
  98 #endif
  99 }
 100
 101 /* assumes 'dir' null terminated in bounds.  Never writes
 102    beyond existing terminator.
 103 */
 104 static void
 105 reduce(char *dir)
 106 {
 107         size_t i = strlen(dir);
 108         while (i > 0 && !is_sep(dir[i]))
 109                 --i;
 110         dir[i] = '\0';
 111 }
 112
 113
 114 static int
 115 exists(char *filename)
 116 {
 117         struct stat buf;
 118         return stat(filename, &buf) == 0;
 119 }
 120
 121 /* Assumes 'filename' MAXPATHLEN+1 bytes long -
 122    may extend 'filename' by one character.
 123 */
 124 static int
 125 ismodule(char *filename)        /* Is module -- check for .pyc/.pyo too */
 126 {
 127         if (exists(filename))
 128                 return 1;
 129
 130         /* Check for the compiled version of prefix. */
 131         if (strlen(filename) < MAXPATHLEN) {
 132                 strcat(filename, Py_OptimizeFlag ? "o" : "c");
 133                 if (exists(filename))
 134                         return 1;
 135         }
 136         return 0;
 137 }
 138
 139 /* guarantees buffer will never overflow MAXPATHLEN+1 bytes */
 140 static void
 141 join(char *buffer, char *stuff)
 142 {
 143         size_t n, k;
 144         if (is_sep(stuff[0]))
 145                 n = 0;
 146         else {
 147                 n = strlen(buffer);
 148                 if (n > 0 && !is_sep(buffer[n-1]) && n < MAXPATHLEN)
 149                         buffer[n++] = SEP;
 150         }
 151         k = strlen(stuff);
 152         if (n + k > MAXPATHLEN)
 153                 k = MAXPATHLEN - n;
 154         strncpy(buffer+n, stuff, k);
 155         buffer[n+k] = '\0';
 156 }
 157
 158 /* gotlandmark only called by search_for_prefix, which ensures
 159    'prefix' is null terminated in bounds.  join() ensures
 160    'landmark' can not overflow prefix if too long.
 161 */
 162 static int
 163 gotlandmark(char *landmark)
 164 {
 165         int n, ok;
 166
 167         n = strlen(prefix);
 168         join(prefix, landmark);
 169         ok = ismodule(prefix);
 170         prefix[n] = '\0';
 171         return ok;
 172 }
 173
 174 /* assumes argv0_path is MAXPATHLEN+1 bytes long, already \0 term'd.
 175    assumption provided by only caller, calculate_path() */
 176 static int
 177 search_for_prefix(char *argv0_path, char *landmark)
 178 {
 179         /* Search from argv0_path, until landmark is found */
 180         strcpy(prefix, argv0_path);
 181         do {
 182                 if (gotlandmark(landmark))
 183                         return 1;
 184                 reduce(prefix);
 185         } while (prefix[0]);
 186         return 0;
 187 }
 188
 189 #ifdef MS_WIN32
 190
 191 /* a string loaded from the DLL at startup.*/
 192 extern const char *PyWin_DLLVersionString;
 193
 194
 195 /* Load a PYTHONPATH value from the registry.
 196    Load from either HKEY_LOCAL_MACHINE or HKEY_CURRENT_USER.
 197
 198    Works in both Unicode and 8bit environments.  Only uses the
 199    Ex family of functions so it also works with Windows CE.
 200
 201    Returns NULL, or a pointer that should be freed.
 202 */
 203
 204 static char *
 205 getpythonregpath(HKEY keyBase, int skipcore)
 206 {
 207         HKEY newKey = 0;
 208         DWORD dataSize = 0;
 209         DWORD numKeys = 0;
 210         LONG rc;
 211         char *retval = NULL;
 212         TCHAR *dataBuf = NULL;
 213         static const TCHAR keyPrefix[] = _T("Software\\Python\\PythonCore\\");
 214         static const TCHAR keySuffix[] = _T("\\PythonPath");
 215         size_t versionLen;
 216         DWORD index;
 217         TCHAR *keyBuf = NULL;
 218         TCHAR *keyBufPtr;
 219         TCHAR **ppPaths = NULL;
 220
 221         /* Tried to use sysget("winver") but here is too early :-( */
 222         versionLen = _tcslen(PyWin_DLLVersionString);
 223         /* Space for all the chars, plus one \0 */
 224         keyBuf = keyBufPtr = malloc(sizeof(keyPrefix) +
 225                                     sizeof(TCHAR)*(versionLen-1) +
 226                                     sizeof(keySuffix));
 227         if (keyBuf==NULL) goto done;
 228
 229         memcpy(keyBufPtr, keyPrefix, sizeof(keyPrefix)-sizeof(TCHAR));
 230         keyBufPtr += sizeof(keyPrefix)/sizeof(TCHAR) - 1;
 231         memcpy(keyBufPtr, PyWin_DLLVersionString, versionLen * sizeof(TCHAR));
 232         keyBufPtr += versionLen;
 233         /* NULL comes with this one! */
 234         memcpy(keyBufPtr, keySuffix, sizeof(keySuffix));
 235         /* Open the root Python key */
 236         rc=RegOpenKeyEx(keyBase,
 237                         keyBuf, /* subkey */
 238                         0, /* reserved */
 239                         KEY_READ,
 240                         &newKey);
 241         if (rc!=ERROR_SUCCESS) goto done;
 242         /* Find out how big our core buffer is, and how many subkeys we have */
 243         rc = RegQueryInfoKey(newKey, NULL, NULL, NULL, &numKeys, NULL, NULL,
 244                         NULL, NULL, &dataSize, NULL, NULL);
 245         if (rc!=ERROR_SUCCESS) goto done;
 246         if (skipcore) dataSize = 0; /* Only count core ones if we want them! */
 247         /* Allocate a temp array of char buffers, so we only need to loop
 248            reading the registry once
 249         */
 250         ppPaths = malloc( sizeof(TCHAR *) * numKeys );
 251         if (ppPaths==NULL) goto done;
 252         memset(ppPaths, 0, sizeof(TCHAR *) * numKeys);
 253         /* Loop over all subkeys, allocating a temp sub-buffer. */
 254         for(index=0;index<numKeys;index++) {
 255                 TCHAR keyBuf[MAX_PATH+1];
 256                 HKEY subKey = 0;
 257                 DWORD reqdSize = MAX_PATH+1;
 258                 /* Get the sub-key name */
 259                 DWORD rc = RegEnumKeyEx(newKey, index, keyBuf, &reqdSize,
 260                                         NULL, NULL, NULL, NULL );
 261                 if (rc!=ERROR_SUCCESS) goto done;
 262                 /* Open the sub-key */
 263                 rc=RegOpenKeyEx(newKey,
 264                                                 keyBuf, /* subkey */
 265                                                 0, /* reserved */
 266                                                 KEY_READ,
 267                                                 &subKey);
 268                 if (rc!=ERROR_SUCCESS) goto done;
 269                 /* Find the value of the buffer size, malloc, then read it */
 270                 RegQueryValueEx(subKey, NULL, 0, NULL, NULL, &reqdSize);
 271                 if (reqdSize) {
 272                         ppPaths[index] = malloc(reqdSize);
 273                         if (ppPaths[index]) {
 274                                 RegQueryValueEx(subKey, NULL, 0, NULL,
 275                                                 (LPBYTE)ppPaths[index],
 276                                                 &reqdSize);
 277                                 dataSize += reqdSize + 1; /* 1 for the ";" */
 278                         }
 279                 }
 280                 RegCloseKey(subKey);
 281         }
 282         dataBuf = malloc((dataSize+1) * sizeof(TCHAR));
 283         if (dataBuf) {
 284                 TCHAR *szCur = dataBuf;
 285                 DWORD reqdSize = dataSize;
 286                 /* Copy our collected strings */
 287                 for (index=0;index<numKeys;index++) {
 288                         if (index > 0) {
 289                                 *(szCur++) = _T(';');
 290                                 dataSize--;
 291                         }
 292                         if (ppPaths[index]) {
 293                                 int len = _tcslen(ppPaths[index]);
 294                                 _tcsncpy(szCur, ppPaths[index], len);
 295                                 szCur += len;
 296                                 dataSize -= len;
 297                         }
 298                 }
 299                 if (skipcore)
 300                         *szCur = '\0';
 301                 else {
 302                         *(szCur++) = _T(';');
 303                         dataSize--;
 304                         /* Now append the core path entries -
 305                            this will include the NULL
 306                         */
 307                         rc = RegQueryValueEx(newKey, NULL, 0, NULL,
 308                                              (LPBYTE)szCur, &dataSize);
 309                 }
 310                 /* And set the result - caller must free
 311                    If MBCS, it is fine as is.  If Unicode, allocate new
 312                    buffer and convert.
 313                 */
 314 #ifdef UNICODE
 315                 retval = (char *)malloc(reqdSize+1);
 316                 if (retval)
 317                         WideCharToMultiByte(CP_ACP, 0,
 318                                         dataBuf, -1, /* source */
 319                                         retval, dataSize+1, /* dest */
 320                                         NULL, NULL);
 321                 free(dataBuf);
 322 #else
 323                 retval = dataBuf;
 324 #endif
 325         }
 326 done:
 327         /* Loop freeing my temp buffers */
 328         if (ppPaths) {
 329                 for(index=0;index<numKeys;index++)
 330                         if (ppPaths[index]) free(ppPaths[index]);
 331                 free(ppPaths);
 332         }
 333         if (newKey)
 334                 RegCloseKey(newKey);
 335         if (keyBuf)
 336                 free(keyBuf);
 337         return retval;
 338 }
 339 #endif /* MS_WIN32 */
 340
 341 static void
 342 get_progpath(void)
 343 {
 344         extern char *Py_GetProgramName(void);
 345         char *path = getenv("PATH");
 346         char *prog = Py_GetProgramName();
 347
 348 #ifdef MS_WIN32
 349 #ifdef UNICODE
 350         WCHAR wprogpath[MAXPATHLEN+1];
 351         /* Windows documents that GetModuleFileName() will "truncate",
 352            but makes no mention of the null terminator.  Play it safe.
 353            PLUS Windows itself defines MAX_PATH as the same, but anyway...
 354         */
 355         wprogpath[MAXPATHLEN]=_T('\0')';
 356         if (GetModuleFileName(NULL, wprogpath, MAXPATHLEN)) {
 357                 WideCharToMultiByte(CP_ACP, 0,
 358                                     wprogpath, -1,
 359                                     progpath, MAXPATHLEN+1,
 360                                     NULL, NULL);
 361                 return;
 362         }
 363 #else
 364         /* static init of progpath ensures final char remains \0 */
 365         if (GetModuleFileName(NULL, progpath, MAXPATHLEN))
 366                 return;
 367 #endif
 368 #endif
 369         if (prog == NULL || *prog == '\0')
 370                 prog = "python";
 371
 372         /* If there is no slash in the argv0 path, then we have to
 373          * assume python is on the user's $PATH, since there's no
 374          * other way to find a directory to start the search from.  If
 375          * $PATH isn't exported, you lose.
 376          */
 377 #ifdef ALTSEP
 378         if (strchr(prog, SEP) || strchr(prog, ALTSEP))
 379 #else
 380         if (strchr(prog, SEP))
 381 #endif
 382                 strncpy(progpath, prog, MAXPATHLEN);
 383         else if (path) {
 384                 while (1) {
 385                         char *delim = strchr(path, DELIM);
 386
 387                         if (delim) {
 388                                 size_t len = delim - path;
 389                                 /* ensure we can't overwrite buffer */
 390                                 len = min(MAXPATHLEN,len);
 391                                 strncpy(progpath, path, len);
 392                                 *(progpath + len) = '\0';
 393                         }
 394                         else
 395                                 strncpy(progpath, path, MAXPATHLEN);
 396
 397                         /* join() is safe for MAXPATHLEN+1 size buffer */
 398                         join(progpath, prog);
 399                         if (exists(progpath))
 400                                 break;
 401
 402                         if (!delim) {
 403                                 progpath[0] = '\0';
 404                                 break;
 405                         }
 406                         path = delim + 1;
 407                 }
 408         }
 409         else
 410                 progpath[0] = '\0';
 411 }
 412
 413 static void
 414 calculate_path(void)
 415 {
 416         char argv0_path[MAXPATHLEN+1];
 417         char *buf;
 418         size_t bufsz;
 419         char *pythonhome = Py_GetPythonHome();
 420         char *envpath = getenv("PYTHONPATH");
 421
 422 #ifdef MS_WIN32
 423         int skiphome, skipdefault;
 424         char *machinepath = NULL;
 425         char *userpath = NULL;
 426 #endif
 427
 428         get_progpath();
 429         /* progpath guaranteed \0 terminated in MAXPATH+1 bytes. */
 430         strcpy(argv0_path, progpath);
 431         reduce(argv0_path);
 432         if (pythonhome == NULL || *pythonhome == '\0') {
 433                 if (search_for_prefix(argv0_path, LANDMARK))
 434                         pythonhome = prefix;
 435                 else
 436                         pythonhome = NULL;
 437         }
 438         else
 439                 strncpy(prefix, pythonhome, MAXPATHLEN);
 440
 441         if (envpath && *envpath == '\0')
 442                 envpath = NULL;
 443
 444
 445 #ifdef MS_WIN32
 446         skiphome = pythonhome==NULL ? 0 : 1;
 447         machinepath = getpythonregpath(HKEY_LOCAL_MACHINE, skiphome);
 448         userpath = getpythonregpath(HKEY_CURRENT_USER, skiphome);
 449         /* We only use the default relative PYTHONPATH if we havent
 450            anything better to use! */
 451         skipdefault = envpath!=NULL || pythonhome!=NULL || \
 452                       machinepath!=NULL || userpath!=NULL;
 453 #endif
 454
 455         /* We need to construct a path from the following parts.
 456            (1) the PYTHONPATH environment variable, if set;
 457            (2) for Win32, the machinepath and userpath, if set;
 458            (3) the PYTHONPATH config macro, with the leading "."
 459                of each component replaced with pythonhome, if set;
 460            (4) the directory containing the executable (argv0_path).
 461            The length calculation calculates #3 first.
 462            Extra rules:
 463            - If PYTHONHOME is set (in any way) item (2) is ignored.
 464            - If registry values are used, (3) and (4) are ignored.
 465         */
 466
 467         /* Calculate size of return buffer */
 468         if (pythonhome != NULL) {
 469                 char *p;
 470                 bufsz = 1;
 471                 for (p = PYTHONPATH; *p; p++) {
 472                         if (*p == DELIM)
 473                                 bufsz++; /* number of DELIM plus one */
 474                 }
 475                 bufsz *= strlen(pythonhome);
 476         }
 477         else
 478                 bufsz = 0;
 479         bufsz += strlen(PYTHONPATH) + 1;
 480         bufsz += strlen(argv0_path) + 1;
 481 #ifdef MS_WIN32
 482         if (userpath)
 483                 bufsz += strlen(userpath) + 1;
 484         if (machinepath)
 485                 bufsz += strlen(machinepath) + 1;
 486 #endif
 487         if (envpath != NULL)
 488                 bufsz += strlen(envpath) + 1;
 489
 490         module_search_path = buf = malloc(bufsz);
 491         if (buf == NULL) {
 492                 /* We can't exit, so print a warning and limp along */
 493                 fprintf(stderr, "Can't malloc dynamic PYTHONPATH.\n");
 494                 if (envpath) {
 495                         fprintf(stderr, "Using environment $PYTHONPATH.\n");
 496                         module_search_path = envpath;
 497                 }
 498                 else {
 499                         fprintf(stderr, "Using default static path.\n");
 500                         module_search_path = PYTHONPATH;
 501                 }
 502 #ifdef MS_WIN32
 503                 if (machinepath)
 504                         free(machinepath);
 505                 if (userpath)
 506                         free(userpath);
 507 #endif /* MS_WIN32 */
 508                 return;
 509         }
 510
 511         if (envpath) {
 512                 strcpy(buf, envpath);
 513                 buf = strchr(buf, '\0');
 514                 *buf++ = DELIM;
 515         }
 516 #ifdef MS_WIN32
 517         if (userpath) {
 518                 strcpy(buf, userpath);
 519                 buf = strchr(buf, '\0');
 520                 *buf++ = DELIM;
 521                 free(userpath);
 522         }
 523         if (machinepath) {
 524                 strcpy(buf, machinepath);
 525                 buf = strchr(buf, '\0');
 526                 *buf++ = DELIM;
 527                 free(machinepath);
 528         }
 529         if (pythonhome == NULL) {
 530                 if (!skipdefault) {
 531                         strcpy(buf, PYTHONPATH);
 532                         buf = strchr(buf, '\0');
 533                 }
 534         }
 535 #else
 536         if (pythonhome == NULL) {
 537                 strcpy(buf, PYTHONPATH);
 538                 buf = strchr(buf, '\0');
 539         }
 540 #endif /* MS_WIN32 */
 541         else {
 542                 char *p = PYTHONPATH;
 543                 char *q;
 544                 size_t n;
 545                 for (;;) {
 546                         q = strchr(p, DELIM);
 547                         if (q == NULL)
 548                                 n = strlen(p);
 549                         else
 550                                 n = q-p;
 551                         if (p[0] == '.' && is_sep(p[1])) {
 552                                 strcpy(buf, pythonhome);
 553                                 buf = strchr(buf, '\0');
 554                                 p++;
 555                                 n--;
 556                         }
 557                         strncpy(buf, p, n);
 558                         buf += n;
 559                         if (q == NULL)
 560                                 break;
 561                         *buf++ = DELIM;
 562                         p = q+1;
 563                 }
 564         }
 565         if (argv0_path) {
 566                 *buf++ = DELIM;
 567                 strcpy(buf, argv0_path);
 568                 buf = strchr(buf, '\0');
 569         }
 570         *buf = '\0';
 571 }
 572
 573
 574 /* External interface */
 575
 576 char *
 577 Py_GetPath(void)
 578 {
 579         if (!module_search_path)
 580                 calculate_path();
 581         return module_search_path;
 582 }
 583
 584 char *
 585 Py_GetPrefix(void)
 586 {
 587         if (!module_search_path)
 588                 calculate_path();
 589         return prefix;
 590 }
 591
 592 char *
 593 Py_GetExecPrefix(void)
 594 {
 595         return Py_GetPrefix();
 596 }
 597
 598 char *
 599 Py_GetProgramFullPath(void)
 600 {
 601         if (!module_search_path)
 602                 calculate_path();
 603         return progpath;
 604 }