PC/os2vacpp/getpathp.c

   1
   2 /* Return the initial module search path. */
   3 /* Used by DOS, OS/2, Windows 3.1.  Works on NT too. */
   4
   5 #include "Python.h"
   6 #include "osdefs.h"
   7
   8 #ifdef MS_WIN32
   9 #include <windows.h>
  10 extern BOOL PyWin_IsWin32s(void);
  11 #endif
  12
  13 #include <sys/types.h>
  14 #include <sys/stat.h>
  15 #include <string.h>
  16
  17 #if HAVE_UNISTD_H
  18 #include <unistd.h>
  19 #endif /* HAVE_UNISTD_H */
  20
  21 /* Search in some common locations for the associated Python libraries.
  22  *
  23  * Two directories must be found, the platform independent directory
  24  * (prefix), containing the common .py and .pyc files, and the platform
  25  * dependent directory (exec_prefix), containing the shared library
  26  * modules.  Note that prefix and exec_prefix can be the same directory,
  27  * but for some installations, they are different.
  28  *
  29  * Py_GetPath() tries to return a sensible Python module search path.
  30  *
  31  * First, we look to see if the executable is in a subdirectory of
  32  * the Python build directory.  We calculate the full path of the
  33  * directory containing the executable as progpath.  We work backwards
  34  * along progpath and look for $dir/Modules/Setup.in, a distinctive
  35  * landmark.  If found, we use $dir/Lib as $root.  The returned
  36  * Python path is the compiled #define PYTHONPATH with all the initial
  37  * "./lib" replaced by $root.
  38  *
  39  * Otherwise, if there is a PYTHONPATH environment variable, we return that.
  40  *
  41  * Otherwise we try to find $progpath/lib/os.py, and if found, then
  42  * root is $progpath/lib, and we return Python path as compiled PYTHONPATH
  43  * with all "./lib" replaced by $root (as above).
  44  *
  45  */
  46
  47 #ifndef LANDMARK
  48 #define LANDMARK "lib\\os.py"
  49 #endif
  50
  51 static char prefix[MAXPATHLEN+1];
  52 static char exec_prefix[MAXPATHLEN+1];
  53 static char progpath[MAXPATHLEN+1];
  54 static char *module_search_path = NULL;
  55
  56
  57 static int
  58 is_sep(char ch) /* determine if "ch" is a separator character */
  59 {
  60 #ifdef ALTSEP
  61         return ch == SEP || ch == ALTSEP;
  62 #else
  63         return ch == SEP;
  64 #endif
  65 }
  66
  67
  68 static void
  69 reduce(char *dir)
  70 {
  71         int i = strlen(dir);
  72         while (i > 0 && !is_sep(dir[i]))
  73                 --i;
  74         dir[i] = '\0';
  75 }
  76
  77
  78 static int
  79 exists(char *filename)
  80 {
  81         struct stat buf;
  82         return stat(filename, &buf) == 0;
  83 }
  84
  85
  86 /* Add a path component, by appending stuff to buffer.
  87    buffer must have at least MAXPATHLEN + 1 bytes allocated, and contain a
  88    NUL-terminated string with no more than MAXPATHLEN characters (not counting
  89    the trailing NUL).  It's a fatal error if it contains a string longer than
  90    that (callers must be careful!).  If these requirements are met, it's
  91    guaranteed that buffer will still be a NUL-terminated string with no more
  92    than MAXPATHLEN characters at exit.  If stuff is too long, only as much of
  93    stuff as fits will be appended.
  94 */
  95 static void
  96 join(char *buffer, char *stuff)
  97 {
  98         int n, k;
  99         if (is_sep(stuff[0]))
 100                 n = 0;
 101         else {
 102                 n = strlen(buffer);
 103                 if (n > 0 && !is_sep(buffer[n-1]) && n < MAXPATHLEN)
 104                         buffer[n++] = SEP;
 105         }
 106         if (n > MAXPATHLEN)
 107                 Py_FatalError("buffer overflow in getpathp.c's joinpath()");
 108         k = strlen(stuff);
 109         if (n + k > MAXPATHLEN)
 110                 k = MAXPATHLEN - n;
 111         strncpy(buffer+n, stuff, k);
 112         buffer[n+k] = '\0';
 113 }
 114
 115
 116 static int
 117 search_for_prefix(char *argv0_path, char *landmark)
 118 {
 119         int n;
 120
 121         /* Search from argv0_path, until root is found */
 122         strcpy(prefix, argv0_path);
 123         do {
 124                 n = strlen(prefix);
 125                 join(prefix, landmark);
 126                 if (exists(prefix)) {
 127                         prefix[n] = '\0';
 128                         return 1;
 129                 }
 130                 prefix[n] = '\0';
 131                 reduce(prefix);
 132         } while (prefix[0]);
 133         return 0;
 134 }
 135
 136 #ifdef MS_WIN32
 137 #include "malloc.h" // for alloca - see comments below!
 138 extern const char *PyWin_DLLVersionString; // a string loaded from the DLL at startup.
 139
 140
 141 /* Load a PYTHONPATH value from the registry.
 142    Load from either HKEY_LOCAL_MACHINE or HKEY_CURRENT_USER.
 143
 144    Returns NULL, or a pointer that should be freed.
 145 */
 146
 147 static char *
 148 getpythonregpath(HKEY keyBase, BOOL bWin32s)
 149 {
 150         HKEY newKey = 0;
 151         DWORD nameSize = 0;
 152         DWORD dataSize = 0;
 153         DWORD numEntries = 0;
 154         LONG rc;
 155         char *retval = NULL;
 156         char *dataBuf;
 157         const char keyPrefix[] = "Software\\Python\\PythonCore\\";
 158         const char keySuffix[] = "\\PythonPath";
 159         int versionLen;
 160         char *keyBuf;
 161
 162         // Tried to use sysget("winver") but here is too early :-(
 163         versionLen = strlen(PyWin_DLLVersionString);
 164         // alloca == no free required, but memory only local to fn.
 165         // also no heap fragmentation!  Am I being silly?
 166         keyBuf = alloca(sizeof(keyPrefix)-1 + versionLen + sizeof(keySuffix)); // chars only, plus 1 NULL.
 167         // lots of constants here for the compiler to optimize away :-)
 168         memcpy(keyBuf, keyPrefix, sizeof(keyPrefix)-1);
 169         memcpy(keyBuf+sizeof(keyPrefix)-1, PyWin_DLLVersionString, versionLen);
 170         memcpy(keyBuf+sizeof(keyPrefix)-1+versionLen, keySuffix, sizeof(keySuffix)); // NULL comes with this one!
 171
 172         rc=RegOpenKey(keyBase,
 173                       keyBuf,
 174                       &newKey);
 175         if (rc==ERROR_SUCCESS) {
 176                 RegQueryInfoKey(newKey, NULL, NULL, NULL, NULL, NULL, NULL,
 177                                 &numEntries, &nameSize, &dataSize, NULL, NULL);
 178         }
 179         if (bWin32s && numEntries==0 && dataSize==0) {
 180                 /* must hardcode for Win32s */
 181                 numEntries = 1;
 182                 dataSize = 511;
 183         }
 184         if (numEntries) {
 185                 /* Loop over all subkeys. */
 186                 /* Win32s doesnt know how many subkeys, so we do
 187                    it twice */
 188                 char keyBuf[MAX_PATH+1];
 189                 int index = 0;
 190                 int off = 0;
 191                 for(index=0;;index++) {
 192                         long reqdSize = 0;
 193                         DWORD rc = RegEnumKey(newKey,
 194                                               index, keyBuf, MAX_PATH+1);
 195                         if (rc) break;
 196                         rc = RegQueryValue(newKey, keyBuf, NULL, &reqdSize);
 197                         if (rc) break;
 198                         if (bWin32s && reqdSize==0) reqdSize = 512;
 199                         dataSize += reqdSize + 1; /* 1 for the ";" */
 200                 }
 201                 dataBuf = malloc(dataSize+1);
 202                 if (dataBuf==NULL)
 203                         return NULL; /* pretty serious?  Raise error? */
 204                 /* Now loop over, grabbing the paths.
 205                    Subkeys before main library */
 206                 for(index=0;;index++) {
 207                         int adjust;
 208                         long reqdSize = dataSize;
 209                         DWORD rc = RegEnumKey(newKey,
 210                                               index, keyBuf,MAX_PATH+1);
 211                         if (rc) break;
 212                         rc = RegQueryValue(newKey,
 213                                            keyBuf, dataBuf+off, &reqdSize);
 214                         if (rc) break;
 215                         if (reqdSize>1) {
 216                                 /* If Nothing, or only '\0' copied. */
 217                                 adjust = strlen(dataBuf+off);
 218                                 dataSize -= adjust;
 219                                 off += adjust;
 220                                 dataBuf[off++] = ';';
 221                                 dataBuf[off] = '\0';
 222                                 dataSize--;
 223                         }
 224                 }
 225                 /* Additionally, win32s doesnt work as expected, so
 226                    the specific strlen() is required for 3.1. */
 227                 rc = RegQueryValue(newKey, "", dataBuf+off, &dataSize);
 228                 if (rc==ERROR_SUCCESS) {
 229                         if (strlen(dataBuf)==0)
 230                                 free(dataBuf);
 231                         else
 232                                 retval = dataBuf; /* caller will free */
 233                 }
 234                 else
 235                         free(dataBuf);
 236         }
 237
 238         if (newKey)
 239                 RegCloseKey(newKey);
 240         return retval;
 241 }
 242 #endif /* MS_WIN32 */
 243
 244 static void
 245 get_progpath(void)
 246 {
 247         extern char *Py_GetProgramName(void);
 248         char *path = getenv("PATH");
 249         char *prog = Py_GetProgramName();
 250
 251 #ifdef MS_WIN32
 252         if (GetModuleFileName(NULL, progpath, MAXPATHLEN))
 253                 return;
 254 #endif
 255         if (prog == NULL || *prog == '\0')
 256                 prog = "python";
 257
 258         /* If there is no slash in the argv0 path, then we have to
 259          * assume python is on the user's $PATH, since there's no
 260          * other way to find a directory to start the search from.  If
 261          * $PATH isn't exported, you lose.
 262          */
 263 #ifdef ALTSEP
 264         if (strchr(prog, SEP) || strchr(prog, ALTSEP))
 265 #else
 266         if (strchr(prog, SEP))
 267 #endif
 268                 strcpy(progpath, prog);
 269         else if (path) {
 270                 while (1) {
 271                         char *delim = strchr(path, DELIM);
 272
 273                         if (delim) {
 274                                 int len = delim - path;
 275                                 strncpy(progpath, path, len);
 276                                 *(progpath + len) = '\0';
 277                         }
 278                         else
 279                                 strcpy(progpath, path);
 280
 281                         join(progpath, prog);
 282                         if (exists(progpath))
 283                                 break;
 284
 285                         if (!delim) {
 286                                 progpath[0] = '\0';
 287                                 break;
 288                         }
 289                         path = delim + 1;
 290                 }
 291         }
 292         else
 293                 progpath[0] = '\0';
 294 }
 295
 296 static void
 297 calculate_path(void)
 298 {
 299         char argv0_path[MAXPATHLEN+1];
 300         char *buf;
 301         int bufsz;
 302         char *pythonhome = Py_GetPythonHome();
 303         char *envpath = Py_GETENV("PYTHONPATH");
 304 #ifdef MS_WIN32
 305         char *machinepath, *userpath;
 306
 307         /* Are we running under Windows 3.1(1) Win32s? */
 308         if (PyWin_IsWin32s()) {
 309                 /* Only CLASSES_ROOT is supported */
 310                 machinepath = getpythonregpath(HKEY_CLASSES_ROOT, TRUE);
 311                 userpath = NULL;
 312         } else {
 313                 machinepath = getpythonregpath(HKEY_LOCAL_MACHINE, FALSE);
 314                 userpath = getpythonregpath(HKEY_CURRENT_USER, FALSE);
 315         }
 316 #endif
 317
 318         get_progpath();
 319         strcpy(argv0_path, progpath);
 320         reduce(argv0_path);
 321         if (pythonhome == NULL || *pythonhome == '\0') {
 322                 if (search_for_prefix(argv0_path, LANDMARK))
 323                         pythonhome = prefix;
 324                 else
 325                         pythonhome = NULL;
 326         }
 327         else {
 328         char *delim;
 329
 330                 strcpy(prefix, pythonhome);
 331
 332         /* Extract Any Optional Trailing EXEC_PREFIX */
 333         /* e.g. PYTHONHOME=<prefix>:<exec_prefix>   */
 334         delim = strchr(prefix, DELIM);
 335         if (delim) {
 336             *delim = '\0';
 337             strcpy(exec_prefix, delim+1);
 338         } else
 339             strcpy(exec_prefix, EXEC_PREFIX);
 340     }
 341
 342         if (envpath && *envpath == '\0')
 343                 envpath = NULL;
 344
 345         /* We need to construct a path from the following parts:
 346            (1) the PYTHONPATH environment variable, if set;
 347            (2) for Win32, the machinepath and userpath, if set;
 348            (3) the PYTHONPATH config macro, with the leading "."
 349                of each component replaced with pythonhome, if set;
 350            (4) the directory containing the executable (argv0_path).
 351            The length calculation calculates #3 first.
 352         */
 353
 354         /* Calculate size of return buffer */
 355         if (pythonhome != NULL) {
 356                 char *p;
 357                 bufsz = 1;
 358                 for (p = PYTHONPATH; *p; p++) {
 359                         if (*p == DELIM)
 360                                 bufsz++; /* number of DELIM plus one */
 361                 }
 362                 bufsz *= strlen(pythonhome);
 363         }
 364         else
 365                 bufsz = 0;
 366         bufsz += strlen(PYTHONPATH) + 1;
 367         if (envpath != NULL)
 368                 bufsz += strlen(envpath) + 1;
 369         bufsz += strlen(argv0_path) + 1;
 370 #ifdef MS_WIN32
 371         if (machinepath)
 372                 bufsz += strlen(machinepath) + 1;
 373         if (userpath)
 374                 bufsz += strlen(userpath) + 1;
 375 #endif
 376
 377         module_search_path = buf = malloc(bufsz);
 378         if (buf == NULL) {
 379                 /* We can't exit, so print a warning and limp along */
 380                 fprintf(stderr, "Can't malloc dynamic PYTHONPATH.\n");
 381                 if (envpath) {
 382                         fprintf(stderr, "Using default static $PYTHONPATH.\n");
 383                         module_search_path = envpath;
 384                 }
 385                 else {
 386                         fprintf(stderr, "Using environment $PYTHONPATH.\n");
 387                         module_search_path = PYTHONPATH;
 388                 }
 389                 return;
 390         }
 391
 392         if (envpath) {
 393                 strcpy(buf, envpath);
 394                 buf = strchr(buf, '\0');
 395                 *buf++ = DELIM;
 396         }
 397 #ifdef MS_WIN32
 398         if (machinepath) {
 399                 strcpy(buf, machinepath);
 400                 buf = strchr(buf, '\0');
 401                 *buf++ = DELIM;
 402         }
 403         if (userpath) {
 404                 strcpy(buf, userpath);
 405                 buf = strchr(buf, '\0');
 406                 *buf++ = DELIM;
 407         }
 408 #endif
 409         if (pythonhome == NULL) {
 410                 strcpy(buf, PYTHONPATH);
 411                 buf = strchr(buf, '\0');
 412         }
 413         else {
 414                 char *p = PYTHONPATH;
 415                 char *q;
 416                 int n;
 417                 for (;;) {
 418                         q = strchr(p, DELIM);
 419                         if (q == NULL)
 420                                 n = strlen(p);
 421                         else
 422                                 n = q-p;
 423                         if (p[0] == '.' && is_sep(p[1])) {
 424                                 strcpy(buf, pythonhome);
 425                                 buf = strchr(buf, '\0');
 426                                 p++;
 427                                 n--;
 428                         }
 429                         strncpy(buf, p, n);
 430                         buf += n;
 431                         if (q == NULL)
 432                                 break;
 433                         *buf++ = DELIM;
 434                         p = q+1;
 435                 }
 436         }
 437         if (argv0_path) {
 438                 *buf++ = DELIM;
 439                 strcpy(buf, argv0_path);
 440                 buf = strchr(buf, '\0');
 441         }
 442         *buf = '\0';
 443 }
 444
 445
 446 /* External interface */
 447
 448 char *
 449 Py_GetPath(void)
 450 {
 451         if (!module_search_path)
 452                 calculate_path();
 453
 454         return module_search_path;
 455 }
 456
 457 char *
 458 Py_GetPrefix(void)
 459 {
 460         if (!module_search_path)
 461                 calculate_path();
 462
 463         return prefix;
 464 }
 465
 466 char *
 467 Py_GetExecPrefix(void)
 468 {
 469         if (!module_search_path)
 470                 calculate_path();
 471
 472         return exec_prefix;
 473 }
 474
 475 char *
 476 Py_GetProgramFullPath(void)
 477 {
 478         if (!module_search_path)
 479                 calculate_path();
 480
 481         return progpath;
 482 }