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 }