| /*********************************************************** |
| Copyright (c) 2000, BeOpen.com. |
| Copyright (c) 1995-2000, Corporation for National Research Initiatives. |
| Copyright (c) 1990-1995, Stichting Mathematisch Centrum. |
| All rights reserved. |
| |
| See the file "Misc/COPYRIGHT" for information on usage and |
| redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES. |
| ******************************************************************/ |
| |
| /* Return the initial module search path. */ |
| /* Used by DOS, OS/2, Windows 3.1. Works on NT too. */ |
| |
| #include "Python.h" |
| #include "osdefs.h" |
| |
| #ifdef MS_WIN32 |
| #include <windows.h> |
| extern BOOL PyWin_IsWin32s(void); |
| #endif |
| |
| #include <sys/types.h> |
| #include <sys/stat.h> |
| #include <string.h> |
| |
| #if HAVE_UNISTD_H |
| #include <unistd.h> |
| #endif /* HAVE_UNISTD_H */ |
| |
| /* Search in some common locations for the associated Python libraries. |
| * |
| * Two directories must be found, the platform independent directory |
| * (prefix), containing the common .py and .pyc files, and the platform |
| * dependent directory (exec_prefix), containing the shared library |
| * modules. Note that prefix and exec_prefix can be the same directory, |
| * but for some installations, they are different. |
| * |
| * Py_GetPath() tries to return a sensible Python module search path. |
| * |
| * First, we look to see if the executable is in a subdirectory of |
| * the Python build directory. We calculate the full path of the |
| * directory containing the executable as progpath. We work backwards |
| * along progpath and look for $dir/Modules/Setup.in, a distinctive |
| * landmark. If found, we use $dir/Lib as $root. The returned |
| * Python path is the compiled #define PYTHONPATH with all the initial |
| * "./lib" replaced by $root. |
| * |
| * Otherwise, if there is a PYTHONPATH environment variable, we return that. |
| * |
| * Otherwise we try to find $progpath/lib/os.py, and if found, then |
| * root is $progpath/lib, and we return Python path as compiled PYTHONPATH |
| * with all "./lib" replaced by $root (as above). |
| * |
| */ |
| |
| #ifndef LANDMARK |
| #define LANDMARK "lib\\os.py" |
| #endif |
| |
| static char prefix[MAXPATHLEN+1]; |
| static char exec_prefix[MAXPATHLEN+1]; |
| static char progpath[MAXPATHLEN+1]; |
| static char *module_search_path = NULL; |
| |
| |
| static int |
| is_sep(char ch) /* determine if "ch" is a separator character */ |
| { |
| #ifdef ALTSEP |
| return ch == SEP || ch == ALTSEP; |
| #else |
| return ch == SEP; |
| #endif |
| } |
| |
| |
| static void |
| reduce(char *dir) |
| { |
| int i = strlen(dir); |
| while (i > 0 && !is_sep(dir[i])) |
| --i; |
| dir[i] = '\0'; |
| } |
| |
| |
| static int |
| exists(char *filename) |
| { |
| struct stat buf; |
| return stat(filename, &buf) == 0; |
| } |
| |
| |
| static void |
| join(char *buffer, char *stuff) |
| { |
| int n, k; |
| if (is_sep(stuff[0])) |
| n = 0; |
| else { |
| n = strlen(buffer); |
| if (n > 0 && !is_sep(buffer[n-1]) && n < MAXPATHLEN) |
| buffer[n++] = SEP; |
| } |
| k = strlen(stuff); |
| if (n + k > MAXPATHLEN) |
| k = MAXPATHLEN - n; |
| strncpy(buffer+n, stuff, k); |
| buffer[n+k] = '\0'; |
| } |
| |
| |
| static int |
| search_for_prefix(char *argv0_path, char *landmark) |
| { |
| int n; |
| |
| /* Search from argv0_path, until root is found */ |
| strcpy(prefix, argv0_path); |
| do { |
| n = strlen(prefix); |
| join(prefix, landmark); |
| if (exists(prefix)) { |
| prefix[n] = '\0'; |
| return 1; |
| } |
| prefix[n] = '\0'; |
| reduce(prefix); |
| } while (prefix[0]); |
| return 0; |
| } |
| |
| #ifdef MS_WIN32 |
| #include "malloc.h" // for alloca - see comments below! |
| extern const char *PyWin_DLLVersionString; // a string loaded from the DLL at startup. |
| |
| |
| /* Load a PYTHONPATH value from the registry. |
| Load from either HKEY_LOCAL_MACHINE or HKEY_CURRENT_USER. |
| |
| Returns NULL, or a pointer that should be freed. |
| */ |
| |
| static char * |
| getpythonregpath(HKEY keyBase, BOOL bWin32s) |
| { |
| HKEY newKey = 0; |
| DWORD nameSize = 0; |
| DWORD dataSize = 0; |
| DWORD numEntries = 0; |
| LONG rc; |
| char *retval = NULL; |
| char *dataBuf; |
| const char keyPrefix[] = "Software\\Python\\PythonCore\\"; |
| const char keySuffix[] = "\\PythonPath"; |
| int versionLen; |
| char *keyBuf; |
| |
| // Tried to use sysget("winver") but here is too early :-( |
| versionLen = strlen(PyWin_DLLVersionString); |
| // alloca == no free required, but memory only local to fn. |
| // also no heap fragmentation! Am I being silly? |
| keyBuf = alloca(sizeof(keyPrefix)-1 + versionLen + sizeof(keySuffix)); // chars only, plus 1 NULL. |
| // lots of constants here for the compiler to optimize away :-) |
| memcpy(keyBuf, keyPrefix, sizeof(keyPrefix)-1); |
| memcpy(keyBuf+sizeof(keyPrefix)-1, PyWin_DLLVersionString, versionLen); |
| memcpy(keyBuf+sizeof(keyPrefix)-1+versionLen, keySuffix, sizeof(keySuffix)); // NULL comes with this one! |
| |
| rc=RegOpenKey(keyBase, |
| keyBuf, |
| &newKey); |
| if (rc==ERROR_SUCCESS) { |
| RegQueryInfoKey(newKey, NULL, NULL, NULL, NULL, NULL, NULL, |
| &numEntries, &nameSize, &dataSize, NULL, NULL); |
| } |
| if (bWin32s && numEntries==0 && dataSize==0) { |
| /* must hardcode for Win32s */ |
| numEntries = 1; |
| dataSize = 511; |
| } |
| if (numEntries) { |
| /* Loop over all subkeys. */ |
| /* Win32s doesnt know how many subkeys, so we do |
| it twice */ |
| char keyBuf[MAX_PATH+1]; |
| int index = 0; |
| int off = 0; |
| for(index=0;;index++) { |
| long reqdSize = 0; |
| DWORD rc = RegEnumKey(newKey, |
| index, keyBuf, MAX_PATH+1); |
| if (rc) break; |
| rc = RegQueryValue(newKey, keyBuf, NULL, &reqdSize); |
| if (rc) break; |
| if (bWin32s && reqdSize==0) reqdSize = 512; |
| dataSize += reqdSize + 1; /* 1 for the ";" */ |
| } |
| dataBuf = malloc(dataSize+1); |
| if (dataBuf==NULL) |
| return NULL; /* pretty serious? Raise error? */ |
| /* Now loop over, grabbing the paths. |
| Subkeys before main library */ |
| for(index=0;;index++) { |
| int adjust; |
| long reqdSize = dataSize; |
| DWORD rc = RegEnumKey(newKey, |
| index, keyBuf,MAX_PATH+1); |
| if (rc) break; |
| rc = RegQueryValue(newKey, |
| keyBuf, dataBuf+off, &reqdSize); |
| if (rc) break; |
| if (reqdSize>1) { |
| /* If Nothing, or only '\0' copied. */ |
| adjust = strlen(dataBuf+off); |
| dataSize -= adjust; |
| off += adjust; |
| dataBuf[off++] = ';'; |
| dataBuf[off] = '\0'; |
| dataSize--; |
| } |
| } |
| /* Additionally, win32s doesnt work as expected, so |
| the specific strlen() is required for 3.1. */ |
| rc = RegQueryValue(newKey, "", dataBuf+off, &dataSize); |
| if (rc==ERROR_SUCCESS) { |
| if (strlen(dataBuf)==0) |
| free(dataBuf); |
| else |
| retval = dataBuf; /* caller will free */ |
| } |
| else |
| free(dataBuf); |
| } |
| |
| if (newKey) |
| RegCloseKey(newKey); |
| return retval; |
| } |
| #endif /* MS_WIN32 */ |
| |
| static void |
| get_progpath(void) |
| { |
| extern char *Py_GetProgramName(void); |
| char *path = getenv("PATH"); |
| char *prog = Py_GetProgramName(); |
| |
| #ifdef MS_WIN32 |
| if (GetModuleFileName(NULL, progpath, MAXPATHLEN)) |
| return; |
| #endif |
| if (prog == NULL || *prog == '\0') |
| prog = "python"; |
| |
| /* If there is no slash in the argv0 path, then we have to |
| * assume python is on the user's $PATH, since there's no |
| * other way to find a directory to start the search from. If |
| * $PATH isn't exported, you lose. |
| */ |
| #ifdef ALTSEP |
| if (strchr(prog, SEP) || strchr(prog, ALTSEP)) |
| #else |
| if (strchr(prog, SEP)) |
| #endif |
| strcpy(progpath, prog); |
| else if (path) { |
| while (1) { |
| char *delim = strchr(path, DELIM); |
| |
| if (delim) { |
| int len = delim - path; |
| strncpy(progpath, path, len); |
| *(progpath + len) = '\0'; |
| } |
| else |
| strcpy(progpath, path); |
| |
| join(progpath, prog); |
| if (exists(progpath)) |
| break; |
| |
| if (!delim) { |
| progpath[0] = '\0'; |
| break; |
| } |
| path = delim + 1; |
| } |
| } |
| else |
| progpath[0] = '\0'; |
| } |
| |
| static void |
| calculate_path(void) |
| { |
| char argv0_path[MAXPATHLEN+1]; |
| char *buf; |
| int bufsz; |
| char *pythonhome = Py_GetPythonHome(); |
| char *envpath = getenv("PYTHONPATH"); |
| #ifdef MS_WIN32 |
| char *machinepath, *userpath; |
| |
| /* Are we running under Windows 3.1(1) Win32s? */ |
| if (PyWin_IsWin32s()) { |
| /* Only CLASSES_ROOT is supported */ |
| machinepath = getpythonregpath(HKEY_CLASSES_ROOT, TRUE); |
| userpath = NULL; |
| } else { |
| machinepath = getpythonregpath(HKEY_LOCAL_MACHINE, FALSE); |
| userpath = getpythonregpath(HKEY_CURRENT_USER, FALSE); |
| } |
| #endif |
| |
| get_progpath(); |
| strcpy(argv0_path, progpath); |
| reduce(argv0_path); |
| if (pythonhome == NULL || *pythonhome == '\0') { |
| if (search_for_prefix(argv0_path, LANDMARK)) |
| pythonhome = prefix; |
| else |
| pythonhome = NULL; |
| } |
| else { |
| char *delim; |
| |
| strcpy(prefix, pythonhome); |
| |
| /* Extract Any Optional Trailing EXEC_PREFIX */ |
| /* e.g. PYTHONHOME=<prefix>:<exec_prefix> */ |
| delim = strchr(prefix, DELIM); |
| if (delim) { |
| *delim = '\0'; |
| strcpy(exec_prefix, delim+1); |
| } else |
| strcpy(exec_prefix, EXEC_PREFIX); |
| } |
| |
| if (envpath && *envpath == '\0') |
| envpath = NULL; |
| |
| /* We need to construct a path from the following parts: |
| (1) the PYTHONPATH environment variable, if set; |
| (2) for Win32, the machinepath and userpath, if set; |
| (3) the PYTHONPATH config macro, with the leading "." |
| of each component replaced with pythonhome, if set; |
| (4) the directory containing the executable (argv0_path). |
| The length calculation calculates #3 first. |
| */ |
| |
| /* Calculate size of return buffer */ |
| if (pythonhome != NULL) { |
| char *p; |
| bufsz = 1; |
| for (p = PYTHONPATH; *p; p++) { |
| if (*p == DELIM) |
| bufsz++; /* number of DELIM plus one */ |
| } |
| bufsz *= strlen(pythonhome); |
| } |
| else |
| bufsz = 0; |
| bufsz += strlen(PYTHONPATH) + 1; |
| if (envpath != NULL) |
| bufsz += strlen(envpath) + 1; |
| bufsz += strlen(argv0_path) + 1; |
| #ifdef MS_WIN32 |
| if (machinepath) |
| bufsz += strlen(machinepath) + 1; |
| if (userpath) |
| bufsz += strlen(userpath) + 1; |
| #endif |
| |
| module_search_path = buf = malloc(bufsz); |
| if (buf == NULL) { |
| /* We can't exit, so print a warning and limp along */ |
| fprintf(stderr, "Can't malloc dynamic PYTHONPATH.\n"); |
| if (envpath) { |
| fprintf(stderr, "Using default static $PYTHONPATH.\n"); |
| module_search_path = envpath; |
| } |
| else { |
| fprintf(stderr, "Using environment $PYTHONPATH.\n"); |
| module_search_path = PYTHONPATH; |
| } |
| return; |
| } |
| |
| if (envpath) { |
| strcpy(buf, envpath); |
| buf = strchr(buf, '\0'); |
| *buf++ = DELIM; |
| } |
| #ifdef MS_WIN32 |
| if (machinepath) { |
| strcpy(buf, machinepath); |
| buf = strchr(buf, '\0'); |
| *buf++ = DELIM; |
| } |
| if (userpath) { |
| strcpy(buf, userpath); |
| buf = strchr(buf, '\0'); |
| *buf++ = DELIM; |
| } |
| #endif |
| if (pythonhome == NULL) { |
| strcpy(buf, PYTHONPATH); |
| buf = strchr(buf, '\0'); |
| } |
| else { |
| char *p = PYTHONPATH; |
| char *q; |
| int n; |
| for (;;) { |
| q = strchr(p, DELIM); |
| if (q == NULL) |
| n = strlen(p); |
| else |
| n = q-p; |
| if (p[0] == '.' && is_sep(p[1])) { |
| strcpy(buf, pythonhome); |
| buf = strchr(buf, '\0'); |
| p++; |
| n--; |
| } |
| strncpy(buf, p, n); |
| buf += n; |
| if (q == NULL) |
| break; |
| *buf++ = DELIM; |
| p = q+1; |
| } |
| } |
| if (argv0_path) { |
| *buf++ = DELIM; |
| strcpy(buf, argv0_path); |
| buf = strchr(buf, '\0'); |
| } |
| *buf = '\0'; |
| } |
| |
| |
| /* External interface */ |
| |
| char * |
| Py_GetPath(void) |
| { |
| if (!module_search_path) |
| calculate_path(); |
| |
| return module_search_path; |
| } |
| |
| char * |
| Py_GetPrefix(void) |
| { |
| if (!module_search_path) |
| calculate_path(); |
| |
| return prefix; |
| } |
| |
| char * |
| Py_GetExecPrefix(void) |
| { |
| if (!module_search_path) |
| calculate_path(); |
| |
| return exec_prefix; |
| } |
| |
| char * |
| Py_GetProgramFullPath(void) |
| { |
| if (!module_search_path) |
| calculate_path(); |
| |
| return progpath; |
| } |