#include "Python.h"

#include "osdefs.h"

#include <wchar.h>

#ifndef MS_WINDOWS

#error getpathp.c should only be built on Windows

#include <windows.h>

#include <Shlwapi.h>

#ifdef HAVE_SYS_TYPES_H

#include <sys/types.h>

#endif /* HAVE_SYS_TYPES_H */

#ifdef HAVE_SYS_STAT_H

#include <sys/stat.h>

#endif /* HAVE_SYS_STAT_H */

#include <string.h>

#ifndef LANDMARK

#define LANDMARK L"lib\\os.py"

static wchar_t prefix[MAXPATHLEN+1];

static wchar_t progpath[MAXPATHLEN+1];

static wchar_t dllpath[MAXPATHLEN+1];

static wchar_t *module_search_path = NULL;

static int

is_sep(wchar_t ch) /* determine if "ch" is a separator character */

{

#ifdef ALTSEP

return ch == SEP || ch == ALTSEP;

return ch == SEP;

}

static void

reduce(wchar_t *dir)

{

size_t i = wcsnlen_s(dir, MAXPATHLEN+1);

if (i >= MAXPATHLEN+1)

Py_FatalError("buffer overflow in getpathp.c's reduce()");

while (i > 0 && !is_sep(dir[i]))

--i;

dir[i] = '\0';

}

static int

change_ext(wchar_t *dest, const wchar_t *src, const wchar_t *ext)

{

size_t src_len = wcsnlen_s(src, MAXPATHLEN+1);

size_t i = src_len;

if (i >= MAXPATHLEN+1)

Py_FatalError("buffer overflow in getpathp.c's reduce()");

while (i > 0 && src[i] != '.' && !is_sep(src[i]))

--i;

if (i == 0) {

dest[0] = '\0';

return -1;

}

if (is_sep(src[i]))

i = src_len;

if (wcsncpy_s(dest, MAXPATHLEN+1, src, i) ||

wcscat_s(dest, MAXPATHLEN+1, ext)) {

dest[0] = '\0';

return -1;

}

return 0;

}

static int

exists(wchar_t *filename)

{

return GetFileAttributesW(filename) != 0xFFFFFFFF;

}

static int

ismodule(wchar_t *filename, int update_filename) /* Is module -- check for .pyc too */

{

size_t n;

if (exists(filename))

return 1;

/* Check for the compiled version of prefix. */

n = wcsnlen_s(filename, MAXPATHLEN+1);

if (n < MAXPATHLEN) {

int exist = 0;

filename[n] = L'c';

filename[n + 1] = L'\0';

exist = exists(filename);

if (!update_filename)

filename[n] = L'\0';

return exist;

}

return 0;

}

static int _PathCchCombineEx_Initialized = 0;

typedef HRESULT(__stdcall *PPathCchCombineEx)(PWSTR pszPathOut, size_t cchPathOut, PCWSTR pszPathIn, PCWSTR pszMore, unsigned long dwFlags);

static PPathCchCombineEx _PathCchCombineEx;

static void

join(wchar_t *buffer, const wchar_t *stuff)

{

if (_PathCchCombineEx_Initialized == 0) {

HMODULE pathapi = LoadLibraryW(L"api-ms-win-core-path-l1-1-0.dll");

if (pathapi)

_PathCchCombineEx = (PPathCchCombineEx)GetProcAddress(pathapi, "PathCchCombineEx");

else

_PathCchCombineEx = NULL;

_PathCchCombineEx_Initialized = 1;

}

if (_PathCchCombineEx) {

if (FAILED(_PathCchCombineEx(buffer, MAXPATHLEN+1, buffer, stuff, 0)))

Py_FatalError("buffer overflow in getpathp.c's join()");

} else {

if (!PathCombineW(buffer, buffer, stuff))

Py_FatalError("buffer overflow in getpathp.c's join()");

}

}

static int

gotlandmark(const wchar_t *landmark)

{

int ok;

Py_ssize_t n = wcsnlen_s(prefix, MAXPATHLEN);

join(prefix, landmark);

ok = ismodule(prefix, FALSE);

prefix[n] = '\0';

return ok;

}

static int

search_for_prefix(wchar_t *argv0_path, const wchar_t *landmark)

{

/* Search from argv0_path, until landmark is found */

wcscpy_s(prefix, MAXPATHLEN + 1, argv0_path);

do {

if (gotlandmark(landmark))

return 1;

reduce(prefix);

} while (prefix[0]);

return 0;

}

#ifdef Py_ENABLE_SHARED

extern const char *PyWin_DLLVersionString;

static wchar_t *

getpythonregpath(HKEY keyBase, int skipcore)

{

HKEY newKey = 0;

DWORD dataSize = 0;

DWORD numKeys = 0;

LONG rc;

wchar_t *retval = NULL;

WCHAR *dataBuf = NULL;

static const WCHAR keyPrefix[] = L"Software\\Python\\PythonCore\\";

static const WCHAR keySuffix[] = L"\\PythonPath";

size_t versionLen, keyBufLen;

DWORD index;

WCHAR *keyBuf = NULL;

WCHAR *keyBufPtr;

WCHAR **ppPaths = NULL;

/* Tried to use sysget("winver") but here is too early :-( */

versionLen = strlen(PyWin_DLLVersionString);

/* Space for all the chars, plus one \0 */

keyBufLen = sizeof(keyPrefix) +

sizeof(WCHAR)*(versionLen-1) +

sizeof(keySuffix);

keyBuf = keyBufPtr = PyMem_RawMalloc(keyBufLen);

if (keyBuf==NULL) goto done;

memcpy_s(keyBufPtr, keyBufLen, keyPrefix, sizeof(keyPrefix)-sizeof(WCHAR));

keyBufPtr += Py_ARRAY_LENGTH(keyPrefix) - 1;

mbstowcs(keyBufPtr, PyWin_DLLVersionString, versionLen);

keyBufPtr += versionLen;

/* NULL comes with this one! */

memcpy(keyBufPtr, keySuffix, sizeof(keySuffix));

/* Open the root Python key */

rc=RegOpenKeyExW(keyBase,

keyBuf, /* subkey */

0, /* reserved */

KEY_READ,

&newKey);

if (rc!=ERROR_SUCCESS) goto done;

/* Find out how big our core buffer is, and how many subkeys we have */

rc = RegQueryInfoKey(newKey, NULL, NULL, NULL, &numKeys, NULL, NULL,

NULL, NULL, &dataSize, NULL, NULL);

if (rc!=ERROR_SUCCESS) goto done;

if (skipcore) dataSize = 0; /* Only count core ones if we want them! */

/* Allocate a temp array of char buffers, so we only need to loop

ppPaths = PyMem_RawMalloc( sizeof(WCHAR *) * numKeys );

if (ppPaths==NULL) goto done;

memset(ppPaths, 0, sizeof(WCHAR *) * numKeys);

/* Loop over all subkeys, allocating a temp sub-buffer. */

for(index=0;index<numKeys;index++) {

WCHAR keyBuf[MAX_PATH+1];

HKEY subKey = 0;

DWORD reqdSize = MAX_PATH+1;

/* Get the sub-key name */

DWORD rc = RegEnumKeyExW(newKey, index, keyBuf, &reqdSize,

NULL, NULL, NULL, NULL );

if (rc!=ERROR_SUCCESS) goto done;

/* Open the sub-key */

rc=RegOpenKeyExW(newKey,

keyBuf, /* subkey */

0, /* reserved */

KEY_READ,

&subKey);

if (rc!=ERROR_SUCCESS) goto done;

/* Find the value of the buffer size, malloc, then read it */

RegQueryValueExW(subKey, NULL, 0, NULL, NULL, &reqdSize);

if (reqdSize) {

ppPaths[index] = PyMem_RawMalloc(reqdSize);

if (ppPaths[index]) {

RegQueryValueExW(subKey, NULL, 0, NULL,

(LPBYTE)ppPaths[index],

&reqdSize);

dataSize += reqdSize + 1; /* 1 for the ";" */

}

}

RegCloseKey(subKey);

}

/* return null if no path to return */

if (dataSize == 0) goto done;

/* original datasize from RegQueryInfo doesn't include the \0 */

dataBuf = PyMem_RawMalloc((dataSize+1) * sizeof(WCHAR));

if (dataBuf) {

WCHAR *szCur = dataBuf;

/* Copy our collected strings */

for (index=0;index<numKeys;index++) {

if (index > 0) {

*(szCur++) = L';';

dataSize--;

}

if (ppPaths[index]) {

Py_ssize_t len = wcslen(ppPaths[index]);

wcsncpy(szCur, ppPaths[index], len);

szCur += len;

assert(dataSize > (DWORD)len);

dataSize -= (DWORD)len;

}

}

if (skipcore)

*szCur = '\0';

else {

/* If we have no values, we dont need a ';' */

if (numKeys) {

*(szCur++) = L';';

dataSize--;

}

/* Now append the core path entries -

rc = RegQueryValueExW(newKey, NULL, 0, NULL,

(LPBYTE)szCur, &dataSize);

if (rc != ERROR_SUCCESS) {

PyMem_RawFree(dataBuf);

goto done;

}

}

/* And set the result - caller must free */

retval = dataBuf;

}

done:

/* Loop freeing my temp buffers */

if (ppPaths) {

for(index=0; index<numKeys; index++)

PyMem_RawFree(ppPaths[index]);

PyMem_RawFree(ppPaths);

}

if (newKey)

RegCloseKey(newKey);

PyMem_RawFree(keyBuf);

return retval;

}

#endif /* Py_ENABLE_SHARED */

static void

get_progpath(void)

{

extern wchar_t *Py_GetProgramName(void);

wchar_t *path = _wgetenv(L"PATH");

wchar_t *prog = Py_GetProgramName();

#ifdef Py_ENABLE_SHARED

extern HANDLE PyWin_DLLhModule;

/* static init of progpath ensures final char remains \0 */

if (PyWin_DLLhModule)

if (!GetModuleFileNameW(PyWin_DLLhModule, dllpath, MAXPATHLEN))

dllpath[0] = 0;

dllpath[0] = 0;

if (GetModuleFileNameW(NULL, progpath, MAXPATHLEN))

return;

if (prog == NULL || *prog == '\0')

prog = L"python";

/* If there is no slash in the argv0 path, then we have to

#ifdef ALTSEP

if (wcschr(prog, SEP) || wcschr(prog, ALTSEP))

if (wcschr(prog, SEP))

wcsncpy(progpath, prog, MAXPATHLEN);

else if (path) {

while (1) {

wchar_t *delim = wcschr(path, DELIM);

if (delim) {

size_t len = delim - path;

/* ensure we can't overwrite buffer */

len = min(MAXPATHLEN,len);

wcsncpy(progpath, path, len);

*(progpath + len) = '\0';

}

else

wcsncpy(progpath, path, MAXPATHLEN);

/* join() is safe for MAXPATHLEN+1 size buffer */

join(progpath, prog);

if (exists(progpath))

break;

if (!delim) {

progpath[0] = '\0';

break;

}

path = delim + 1;

}

}

else

progpath[0] = '\0';

}

static int

find_env_config_value(FILE * env_file, const wchar_t * key, wchar_t * value)

{

int result = 0; /* meaning not found */

char buffer[MAXPATHLEN*2+1]; /* allow extra for key, '=', etc. */

fseek(env_file, 0, SEEK_SET);

while (!feof(env_file)) {

char * p = fgets(buffer, MAXPATHLEN*2, env_file);

wchar_t tmpbuffer[MAXPATHLEN*2+1];

PyObject * decoded;

size_t n;

if (p == NULL)

break;

n = strlen(p);

if (p[n - 1] != '\n') {

/* line has overflowed - bail */

break;

}

if (p[0] == '#') /* Comment - skip */

continue;

decoded = PyUnicode_DecodeUTF8(buffer, n, "surrogateescape");

if (decoded != NULL) {

Py_ssize_t k;

k = PyUnicode_AsWideChar(decoded,

tmpbuffer, MAXPATHLEN * 2);

Py_DECREF(decoded);

if (k >= 0) {

wchar_t * context = NULL;

wchar_t * tok = wcstok_s(tmpbuffer, L" \t\r\n", &context);

if ((tok != NULL) && !wcscmp(tok, key)) {

tok = wcstok_s(NULL, L" \t", &context);

if ((tok != NULL) && !wcscmp(tok, L"=")) {

tok = wcstok_s(NULL, L"\r\n", &context);

if (tok != NULL) {

wcsncpy(value, tok, MAXPATHLEN);

result = 1;

break;

}

}

}

}

}

}

return result;

}

static int

read_pth_file(const wchar_t *path, wchar_t *prefix, int *isolated, int *nosite)

{

FILE *sp_file = _Py_wfopen(path, L"r");

if (sp_file == NULL)

return -1;

wcscpy_s(prefix, MAXPATHLEN+1, path);

reduce(prefix);

*isolated = 1;

*nosite = 1;

size_t bufsiz = MAXPATHLEN;

size_t prefixlen = wcslen(prefix);

wchar_t *buf = (wchar_t*)PyMem_RawMalloc(bufsiz * sizeof(wchar_t));

buf[0] = '\0';

while (!feof(sp_file)) {

char line[MAXPATHLEN + 1];

char *p = fgets(line, MAXPATHLEN + 1, sp_file);

if (!p)

break;

if (*p == '\0' || *p == '\r' || *p == '\n' || *p == '#')

continue;

while (*++p) {

if (*p == '\r' || *p == '\n') {

*p = '\0';

break;

}

}

if (strcmp(line, "import site") == 0) {

*nosite = 0;

continue;

} else if (strncmp(line, "import ", 7) == 0) {

Py_FatalError("only 'import site' is supported in ._pth file");

}

DWORD wn = MultiByteToWideChar(CP_UTF8, 0, line, -1, NULL, 0);

wchar_t *wline = (wchar_t*)PyMem_RawMalloc((wn + 1) * sizeof(wchar_t));

wn = MultiByteToWideChar(CP_UTF8, 0, line, -1, wline, wn + 1);

wline[wn] = '\0';

size_t usedsiz = wcslen(buf);

while (usedsiz + wn + prefixlen + 4 > bufsiz) {

bufsiz += MAXPATHLEN;

buf = (wchar_t*)PyMem_RawRealloc(buf, (bufsiz + 1) * sizeof(wchar_t));

if (!buf) {

PyMem_RawFree(wline);

goto error;

}

}

if (usedsiz) {

wcscat_s(buf, bufsiz, L";");

usedsiz += 1;

}

errno_t result;

_Py_BEGIN_SUPPRESS_IPH

result = wcscat_s(buf, bufsiz, prefix);

_Py_END_SUPPRESS_IPH

if (result == EINVAL) {

Py_FatalError("invalid argument during ._pth processing");

} else if (result == ERANGE) {

Py_FatalError("buffer overflow during ._pth processing");

}

wchar_t *b = &buf[usedsiz];

join(b, wline);

PyMem_RawFree(wline);

}

module_search_path = buf;

fclose(sp_file);

return 0;

error:

PyMem_RawFree(buf);

fclose(sp_file);

return -1;

}

static void

calculate_path(void)

{

wchar_t argv0_path[MAXPATHLEN+1];

wchar_t *buf;

size_t bufsz;

wchar_t *pythonhome = Py_GetPythonHome();

wchar_t *envpath = NULL;

int skiphome, skipdefault;

wchar_t *machinepath = NULL;

wchar_t *userpath = NULL;

wchar_t zip_path[MAXPATHLEN+1];

if (!Py_IgnoreEnvironmentFlag) {

envpath = _wgetenv(L"PYTHONPATH");

}

get_progpath();

/* progpath guaranteed \0 terminated in MAXPATH+1 bytes. */

wcscpy_s(argv0_path, MAXPATHLEN+1, progpath);

reduce(argv0_path);

/* Search for a sys.path file */

{

wchar_t spbuffer[MAXPATHLEN+1];

if ((dllpath[0] && !change_ext(spbuffer, dllpath, L"._pth") && exists(spbuffer)) ||

(progpath[0] && !change_ext(spbuffer, progpath, L"._pth") && exists(spbuffer))) {

if (!read_pth_file(spbuffer, prefix, &Py_IsolatedFlag, &Py_NoSiteFlag)) {

return;

}

}

}

/* Search for an environment configuration file, first in the

{

wchar_t envbuffer[MAXPATHLEN+1];

wchar_t tmpbuffer[MAXPATHLEN+1];

const wchar_t *env_cfg = L"pyvenv.cfg";

FILE * env_file = NULL;

wcscpy_s(envbuffer, MAXPATHLEN+1, argv0_path);

join(envbuffer, env_cfg);

env_file = _Py_wfopen(envbuffer, L"r");

if (env_file == NULL) {

errno = 0;

reduce(envbuffer);

reduce(envbuffer);

join(envbuffer, env_cfg);

env_file = _Py_wfopen(envbuffer, L"r");

if (env_file == NULL) {

errno = 0;

}

}

if (env_file != NULL) {

/* Look for a 'home' variable and set argv0_path to it, if found */

if (find_env_config_value(env_file, L"home", tmpbuffer)) {

wcscpy_s(argv0_path, MAXPATHLEN+1, tmpbuffer);

}

fclose(env_file);

env_file = NULL;

}

}

/* Calculate zip archive path from DLL or exe path */

change_ext(zip_path, dllpath[0] ? dllpath : progpath, L".zip");

if (pythonhome == NULL || *pythonhome == '\0') {

if (zip_path[0] && exists(zip_path)) {

wcscpy_s(prefix, MAXPATHLEN+1, zip_path);

reduce(prefix);

pythonhome = prefix;

} else if (search_for_prefix(argv0_path, LANDMARK))

pythonhome = prefix;

else

pythonhome = NULL;

}

else

wcscpy_s(prefix, MAXPATHLEN+1, pythonhome);

if (envpath && *envpath == '\0')

envpath = NULL;

skiphome = pythonhome==NULL ? 0 : 1;

#ifdef Py_ENABLE_SHARED

machinepath = getpythonregpath(HKEY_LOCAL_MACHINE, skiphome);

userpath = getpythonregpath(HKEY_CURRENT_USER, skiphome);

/* We only use the default relative PYTHONPATH if we havent

skipdefault = envpath!=NULL || pythonhome!=NULL || \

machinepath!=NULL || userpath!=NULL;

/* We need to construct a path from the following parts.

/* Calculate size of return buffer */

if (pythonhome != NULL) {

wchar_t *p;

bufsz = 1;

for (p = PYTHONPATH; *p; p++) {

if (*p == DELIM)

bufsz++; /* number of DELIM plus one */

}

bufsz *= wcslen(pythonhome);

}

else

bufsz = 0;

bufsz += wcslen(PYTHONPATH) + 1;

bufsz += wcslen(argv0_path) + 1;

if (userpath)

bufsz += wcslen(userpath) + 1;

if (machinepath)

bufsz += wcslen(machinepath) + 1;

bufsz += wcslen(zip_path) + 1;

if (envpath != NULL)

bufsz += wcslen(envpath) + 1;

module_search_path = buf = PyMem_RawMalloc(bufsz*sizeof(wchar_t));

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 environment $PYTHONPATH.\n");

module_search_path = envpath;

}

else {

fprintf(stderr, "Using default static path.\n");

module_search_path = PYTHONPATH;

}

PyMem_RawFree(machinepath);

PyMem_RawFree(userpath);

return;

}

if (envpath) {

if (wcscpy_s(buf, bufsz - (buf - module_search_path), envpath))

Py_FatalError("buffer overflow in getpathp.c's calculate_path()");

buf = wcschr(buf, L'\0');

*buf++ = DELIM;

}

if (zip_path[0]) {

if (wcscpy_s(buf, bufsz - (buf - module_search_path), zip_path))

Py_FatalError("buffer overflow in getpathp.c's calculate_path()");

buf = wcschr(buf, L'\0');

*buf++ = DELIM;

}

if (userpath) {

if (wcscpy_s(buf, bufsz - (buf - module_search_path), userpath))

Py_FatalError("buffer overflow in getpathp.c's calculate_path()");

buf = wcschr(buf, L'\0');

*buf++ = DELIM;

PyMem_RawFree(userpath);

}

if (machinepath) {

if (wcscpy_s(buf, bufsz - (buf - module_search_path), machinepath))

Py_FatalError("buffer overflow in getpathp.c's calculate_path()");

buf = wcschr(buf, L'\0');

*buf++ = DELIM;

PyMem_RawFree(machinepath);

}

if (pythonhome == NULL) {

if (!skipdefault) {

if (wcscpy_s(buf, bufsz - (buf - module_search_path), PYTHONPATH))

Py_FatalError("buffer overflow in getpathp.c's calculate_path()");

buf = wcschr(buf, L'\0');

*buf++ = DELIM;

}

} else {

wchar_t *p = PYTHONPATH;

wchar_t *q;

size_t n;

for (;;) {

q = wcschr(p, DELIM);

if (q == NULL)

n = wcslen(p);

else

n = q-p;

if (p[0] == '.' && is_sep(p[1])) {

if (wcscpy_s(buf, bufsz - (buf - module_search_path), pythonhome))

Py_FatalError("buffer overflow in getpathp.c's calculate_path()");

buf = wcschr(buf, L'\0');

p++;

n--;

}

wcsncpy(buf, p, n);

buf += n;

*buf++ = DELIM;

if (q == NULL)

break;

p = q+1;

}

}

if (argv0_path) {

wcscpy(buf, argv0_path);

buf = wcschr(buf, L'\0');

*buf++ = DELIM;

}

*(buf - 1) = L'\0';

/* Now to pull one last hack/trick. If sys.prefix is

if (*prefix==L'\0') {

wchar_t lookBuf[MAXPATHLEN+1];

wchar_t *look = buf - 1; /* 'buf' is at the end of the buffer */

while (1) {

Py_ssize_t nchars;

wchar_t *lookEnd = look;

/* 'look' will end up one character before the

while (look >= module_search_path && *look != DELIM)

look--;

nchars = lookEnd-look;

wcsncpy(lookBuf, look+1, nchars);

lookBuf[nchars] = L'\0';

/* Up one level to the parent */

reduce(lookBuf);

if (search_for_prefix(lookBuf, LANDMARK)) {

break;

}

/* If we are out of paths to search - give up */

if (look < module_search_path)

break;

look--;

}

}

}

Py_SetPath(const wchar_t *path)

{

if (module_search_path != NULL) {

PyMem_RawFree(module_search_path);

module_search_path = NULL;

}

if (path != NULL) {

extern wchar_t *Py_GetProgramName(void);

wchar_t *prog = Py_GetProgramName();

wcsncpy(progpath, prog, MAXPATHLEN);

prefix[0] = L'\0';

module_search_path = PyMem_RawMalloc((wcslen(path) + 1) * sizeof(wchar_t));

if (module_search_path != NULL)

wcscpy(module_search_path, path);

}

}

wchar_t *

Py_GetPath(void)

{

if (!module_search_path)

calculate_path();

return module_search_path;

}

wchar_t *

Py_GetPrefix(void)

{

if (!module_search_path)

calculate_path();

return prefix;

}

wchar_t *

Py_GetExecPrefix(void)

{

return Py_GetPrefix();

}

wchar_t *

Py_GetProgramFullPath(void)

{

if (!module_search_path)

calculate_path();

return progpath;

}

static int python3_checked = 0;

static HANDLE hPython3;

_Py_CheckPython3()

{

wchar_t py3path[MAXPATHLEN+1];

wchar_t *s;

if (python3_checked)

return hPython3 != NULL;

python3_checked = 1;

/* If there is a python3.dll next to the python3y.dll,

wcscpy(py3path, dllpath);

s = wcsrchr(py3path, L'\\');

if (!s)

s = py3path;

wcscpy(s, L"\\python3.dll");

hPython3 = LoadLibraryExW(py3path, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);

if (hPython3 != NULL)

return 1;

/* Check sys.prefix\DLLs\python3.dll */

wcscpy(py3path, Py_GetPrefix());

wcscat(py3path, L"\\DLLs\\python3.dll");

hPython3 = LoadLibraryExW(py3path, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);

return hPython3 != NULL;

}