PC/os2emx/getpathp.c

   1
   2 /* Return the initial module search path. */
   3 /* This version used by OS/2+EMX */
   4
   5 /* ----------------------------------------------------------------
   6    PATH RULES FOR OS/2+EMX:
   7    This describes how sys.path is formed on OS/2+EMX.  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 attempt to locate the "Python Home" - if the PYTHONHOME env var
  17      is set, we believe it.  Otherwise, we use the path of our host .EXE's
  18      to try and locate our "landmark" (lib\\os.py) and deduce our home.
  19      - If we DO have a Python Home: The relevant sub-directories (Lib,
  20        plat-win, lib-tk, etc) are based on the Python Home
  21      - If we DO NOT have a Python Home, the core Python Path is
  22        loaded from the registry.  This is the main PythonPath key,
  23        and both HKLM and HKCU are combined to form the path)
  24
  25    * Iff - we can not locate the Python Home, and have not had a PYTHONPATH
  26      specified (ie, we have _nothing_ we can assume is a good path), a
  27      default path with relative entries is used (eg. .\Lib;.\plat-win, etc)
  28
  29
  30   The end result of all this is:
  31   * When running python.exe, or any other .exe in the main Python directory
  32     (either an installed version, or directly from the PCbuild directory),
  33     the core path is deduced.
  34
  35   * When Python is hosted in another exe (different directory, embedded via
  36     COM, etc), the Python Home will not be deduced, so the core path from
  37     the registry is used.  Other "application paths "in the registry are
  38     always read.
  39
  40   * If Python can't find its home and there is no registry (eg, frozen
  41     exe, some very strange installation setup) you get a path with
  42     some default, but relative, paths.
  43
  44    ---------------------------------------------------------------- */
  45
  46
  47 #include "Python.h"
  48 #include "osdefs.h"
  49
  50 #ifndef PYOS_OS2
  51 #error This file only compilable on OS/2
  52 #endif
  53
  54 #define INCL_DOS
  55 #include <os2.h>
  56
  57 #include <sys/types.h>
  58 #include <sys/stat.h>
  59 #include <string.h>
  60
  61 #if HAVE_UNISTD_H
  62 #include <unistd.h>
  63 #endif /* HAVE_UNISTD_H */
  64
  65 /* Search in some common locations for the associated Python libraries.
  66  *
  67  * Py_GetPath() tries to return a sensible Python module search path.
  68  *
  69  * The approach is an adaptation for Windows of the strategy used in
  70  * ../Modules/getpath.c; it uses the Windows Registry as one of its
  71  * information sources.
  72  */
  73
  74 #ifndef LANDMARK
  75 #if defined(PYCC_GCC)
  76 #define LANDMARK "lib/os.py"
  77 #else
  78 #define LANDMARK "lib\\os.py"
  79 #endif
  80 #endif
  81
  82 static char prefix[MAXPATHLEN+1];
  83 static char progpath[MAXPATHLEN+1];
  84 static char *module_search_path = NULL;
  85
  86
  87 static int
  88 is_sep(char ch) /* determine if "ch" is a separator character */
  89 {
  90 #ifdef ALTSEP
  91         return ch == SEP || ch == ALTSEP;
  92 #else
  93         return ch == SEP;
  94 #endif
  95 }
  96
  97 /* assumes 'dir' null terminated in bounds.
  98  * Never writes beyond existing terminator.
  99  */
 100 static void
 101 reduce(char *dir)
 102 {
 103         size_t i = strlen(dir);
 104         while (i > 0 && !is_sep(dir[i]))
 105                 --i;
 106         dir[i] = '\0';
 107 }
 108
 109 static int
 110 exists(char *filename)
 111 {
 112         struct stat buf;
 113         return stat(filename, &buf) == 0;
 114 }
 115
 116 /* Is module  (check for .pyc/.pyo too)
 117  * Assumes 'filename' MAXPATHLEN+1 bytes long -
 118  * may extend 'filename' by one character.
 119  */
 120 static int
 121 ismodule(char *filename)
 122 {
 123         if (exists(filename))
 124                 return 1;
 125
 126         /* Check for the compiled version of prefix. */
 127         if (strlen(filename) < MAXPATHLEN) {
 128                 strcat(filename, Py_OptimizeFlag ? "o" : "c");
 129                 if (exists(filename))
 130                         return 1;
 131         }
 132         return 0;
 133 }
 134
 135 /* Add a path component, by appending stuff to buffer.
 136    buffer must have at least MAXPATHLEN + 1 bytes allocated, and contain a
 137    NUL-terminated string with no more than MAXPATHLEN characters (not counting
 138    the trailing NUL).  It's a fatal error if it contains a string longer than
 139    that (callers must be careful!).  If these requirements are met, it's
 140    guaranteed that buffer will still be a NUL-terminated string with no more
 141    than MAXPATHLEN characters at exit.  If stuff is too long, only as much of
 142    stuff as fits will be appended.
 143 */
 144
 145 static void
 146 join(char *buffer, char *stuff)
 147 {
 148         size_t n, k;
 149         if (is_sep(stuff[0]))
 150                 n = 0;
 151         else {
 152                 n = strlen(buffer);
 153                 if (n > 0 && !is_sep(buffer[n-1]) && n < MAXPATHLEN)
 154                         buffer[n++] = SEP;
 155         }
 156         if (n > MAXPATHLEN)
 157                 Py_FatalError("buffer overflow in getpathp.c's joinpath()");
 158         k = strlen(stuff);
 159         if (n + k > MAXPATHLEN)
 160                 k = MAXPATHLEN - n;
 161         strncpy(buffer+n, stuff, k);
 162         buffer[n+k] = '\0';
 163 }
 164
 165 /* gotlandmark only called by search_for_prefix, which ensures
 166  * 'prefix' is null terminated in bounds.  join() ensures
 167  * 'landmark' can not overflow prefix if too long.
 168  */
 169 static int
 170 gotlandmark(char *landmark)
 171 {
 172         int n, ok;
 173
 174         n = strlen(prefix);
 175         join(prefix, landmark);
 176         ok = ismodule(prefix);
 177         prefix[n] = '\0';
 178         return ok;
 179 }
 180
 181 /* assumes argv0_path is MAXPATHLEN+1 bytes long, already \0 term'd.
 182  * assumption provided by only caller, calculate_path()
 183  */
 184 static int
 185 search_for_prefix(char *argv0_path, char *landmark)
 186 {
 187         /* Search from argv0_path, until landmark is found */
 188         strcpy(prefix, argv0_path);
 189         do {
 190                 if (gotlandmark(landmark))
 191                         return 1;
 192                 reduce(prefix);
 193         } while (prefix[0]);
 194         return 0;
 195 }
 196
 197
 198 static void
 199 get_progpath(void)
 200 {
 201         extern char *Py_GetProgramName(void);
 202         char *path = getenv("PATH");
 203         char *prog = Py_GetProgramName();
 204
 205         PPIB pib;
 206         if ((DosGetInfoBlocks(NULL, &pib) == 0) &&
 207             (DosQueryModuleName(pib->pib_hmte, sizeof(progpath), progpath) == 0))
 208                 return;
 209
 210         if (prog == NULL || *prog == '\0')
 211                 prog = "python";
 212
 213         /* If there is no slash in the argv0 path, then we have to
 214          * assume python is on the user's $PATH, since there's no
 215          * other way to find a directory to start the search from.  If
 216          * $PATH isn't exported, you lose.
 217          */
 218 #ifdef ALTSEP
 219         if (strchr(prog, SEP) || strchr(prog, ALTSEP))
 220 #else
 221         if (strchr(prog, SEP))
 222 #endif
 223                 strncpy(progpath, prog, MAXPATHLEN);
 224         else if (path) {
 225                 while (1) {
 226                         char *delim = strchr(path, DELIM);
 227
 228                         if (delim) {
 229                                 size_t len = delim - path;
 230                                 /* ensure we can't overwrite buffer */
 231 #if !defined(PYCC_GCC)
 232                                 len = min(MAXPATHLEN,len);
 233 #else
 234                                 len = MAXPATHLEN < len ? MAXPATHLEN : len;
 235 #endif
 236                                 strncpy(progpath, path, len);
 237                                 *(progpath + len) = '\0';
 238                         }
 239                         else
 240                                 strncpy(progpath, path, MAXPATHLEN);
 241
 242                         /* join() is safe for MAXPATHLEN+1 size buffer */
 243                         join(progpath, prog);
 244                         if (exists(progpath))
 245                                 break;
 246
 247                         if (!delim) {
 248                                 progpath[0] = '\0';
 249                                 break;
 250                         }
 251                         path = delim + 1;
 252                 }
 253         }
 254         else
 255                 progpath[0] = '\0';
 256 }
 257
 258 static void
 259 calculate_path(void)
 260 {
 261         char argv0_path[MAXPATHLEN+1];
 262         char *buf;
 263         size_t bufsz;
 264         char *pythonhome = Py_GetPythonHome();
 265         char *envpath = getenv("PYTHONPATH");
 266         char zip_path[MAXPATHLEN+1];
 267         size_t len;
 268
 269         get_progpath();
 270         /* progpath guaranteed \0 terminated in MAXPATH+1 bytes. */
 271         strcpy(argv0_path, progpath);
 272         reduce(argv0_path);
 273         if (pythonhome == NULL || *pythonhome == '\0') {
 274                 if (search_for_prefix(argv0_path, LANDMARK))
 275                         pythonhome = prefix;
 276                 else
 277                         pythonhome = NULL;
 278         }
 279         else
 280                 strncpy(prefix, pythonhome, MAXPATHLEN);
 281
 282         if (envpath && *envpath == '\0')
 283                 envpath = NULL;
 284
 285         /* Calculate zip archive path */
 286         strncpy(zip_path, progpath, MAXPATHLEN);
 287         zip_path[MAXPATHLEN] = '\0';
 288         len = strlen(zip_path);
 289         if (len > 4) {
 290                 zip_path[len-3] = 'z';  /* change ending to "zip" */
 291                 zip_path[len-2] = 'i';
 292                 zip_path[len-1] = 'p';
 293         }
 294         else {
 295                 zip_path[0] = 0;
 296         }
 297
 298         /* We need to construct a path from the following parts.
 299          * (1) the PYTHONPATH environment variable, if set;
 300          * (2) the zip archive file path;
 301          * (3) the PYTHONPATH config macro, with the leading "."
 302          *     of each component replaced with pythonhome, if set;
 303          * (4) the directory containing the executable (argv0_path).
 304          * The length calculation calculates #3 first.
 305          */
 306
 307         /* Calculate size of return buffer */
 308         if (pythonhome != NULL) {
 309                 char *p;
 310                 bufsz = 1;
 311                 for (p = PYTHONPATH; *p; p++) {
 312                         if (*p == DELIM)
 313                                 bufsz++; /* number of DELIM plus one */
 314                 }
 315                 bufsz *= strlen(pythonhome);
 316         }
 317         else
 318                 bufsz = 0;
 319         bufsz += strlen(PYTHONPATH) + 1;
 320         bufsz += strlen(argv0_path) + 1;
 321         bufsz += strlen(zip_path) + 1;
 322         if (envpath != NULL)
 323                 bufsz += strlen(envpath) + 1;
 324
 325         module_search_path = buf = malloc(bufsz);
 326         if (buf == NULL) {
 327                 /* We can't exit, so print a warning and limp along */
 328                 fprintf(stderr, "Can't malloc dynamic PYTHONPATH.\n");
 329                 if (envpath) {
 330                         fprintf(stderr, "Using environment $PYTHONPATH.\n");
 331                         module_search_path = envpath;
 332                 }
 333                 else {
 334                         fprintf(stderr, "Using default static path.\n");
 335                         module_search_path = PYTHONPATH;
 336                 }
 337                 return;
 338         }
 339
 340         if (envpath) {
 341                 strcpy(buf, envpath);
 342                 buf = strchr(buf, '\0');
 343                 *buf++ = DELIM;
 344         }
 345         if (zip_path[0]) {
 346                 strcpy(buf, zip_path);
 347                 buf = strchr(buf, '\0');
 348                 *buf++ = DELIM;
 349         }
 350
 351         if (pythonhome == NULL) {
 352                 strcpy(buf, PYTHONPATH);
 353                 buf = strchr(buf, '\0');
 354         }
 355         else {
 356                 char *p = PYTHONPATH;
 357                 char *q;
 358                 size_t n;
 359                 for (;;) {
 360                         q = strchr(p, DELIM);
 361                         if (q == NULL)
 362                                 n = strlen(p);
 363                         else
 364                                 n = q-p;
 365                         if (p[0] == '.' && is_sep(p[1])) {
 366                                 strcpy(buf, pythonhome);
 367                                 buf = strchr(buf, '\0');
 368                                 p++;
 369                                 n--;
 370                         }
 371                         strncpy(buf, p, n);
 372                         buf += n;
 373                         if (q == NULL)
 374                                 break;
 375                         *buf++ = DELIM;
 376                         p = q+1;
 377                 }
 378         }
 379         if (argv0_path) {
 380                 *buf++ = DELIM;
 381                 strcpy(buf, argv0_path);
 382                 buf = strchr(buf, '\0');
 383         }
 384         *buf = '\0';
 385 }
 386
 387
 388 /* External interface */
 389
 390 char *
 391 Py_GetPath(void)
 392 {
 393         if (!module_search_path)
 394                 calculate_path();
 395         return module_search_path;
 396 }
 397
 398 char *
 399 Py_GetPrefix(void)
 400 {
 401         if (!module_search_path)
 402                 calculate_path();
 403         return prefix;
 404 }
 405
 406 char *
 407 Py_GetExecPrefix(void)
 408 {
 409         return Py_GetPrefix();
 410 }
 411
 412 char *
 413 Py_GetProgramFullPath(void)
 414 {
 415         if (!module_search_path)
 416                 calculate_path();
 417         return progpath;
 418 }