source: python/trunk/PC/getpathp.c@ 1538

Last change on this file since 1538 was 391, checked in by dmik, 12 years ago

python: Merge vendor 2.7.6 to trunk.
  • Property svn:eol-style set to native
File size: 21.0 KB
Line 
1
2/* Return the initial module search path. */
3/* Used by DOS, OS/2, Windows 3.1, Windows 95/98, Windows NT. */
4
5/* ----------------------------------------------------------------
6 PATH RULES FOR WINDOWS:
7 This describes how sys.path is formed on Windows. 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 look in the registry for "application paths" - that is, sub-keys
17 under the main PythonPath registry key. These are added next (the
18 order of sub-key processing is undefined).
19 HKEY_CURRENT_USER is searched and added first.
20 HKEY_LOCAL_MACHINE is searched and added next.
21 (Note that all known installers only use HKLM, so HKCU is typically
22 empty)
23
24 * We attempt to locate the "Python Home" - if the PYTHONHOME env var
25 is set, we believe it. Otherwise, we use the path of our host .EXE's
26 to try and locate our "landmark" (lib\\os.py) and deduce our home.
27 - If we DO have a Python Home: The relevant sub-directories (Lib,
28 plat-win, lib-tk, etc) are based on the Python Home
29 - If we DO NOT have a Python Home, the core Python Path is
30 loaded from the registry. This is the main PythonPath key,
31 and both HKLM and HKCU are combined to form the path)
32
33 * Iff - we can not locate the Python Home, have not had a PYTHONPATH
34 specified, and can't locate any Registry entries (ie, we have _nothing_
35 we can assume is a good path), a default path with relative entries is
36 used (eg. .\Lib;.\plat-win, etc)
37
38
39 The end result of all this is:
40 * When running python.exe, or any other .exe in the main Python directory
41 (either an installed version, or directly from the PCbuild directory),
42 the core path is deduced, and the core paths in the registry are
43 ignored. Other "application paths" in the registry are always read.
44
45 * When Python is hosted in another exe (different directory, embedded via
46 COM, etc), the Python Home will not be deduced, so the core path from
47 the registry is used. Other "application paths" in the registry are
48 always read.
49
50 * If Python can't find its home and there is no registry (eg, frozen
51 exe, some very strange installation setup) you get a path with
52 some default, but relative, paths.
53
54 ---------------------------------------------------------------- */
55
56
57#include "Python.h"
58#include "osdefs.h"
59
60#ifdef MS_WINDOWS
61#include <windows.h>
62#include <tchar.h>
63#endif
64
65#ifdef HAVE_SYS_TYPES_H
66#include <sys/types.h>
67#endif /* HAVE_SYS_TYPES_H */
68
69#ifdef HAVE_SYS_STAT_H
70#include <sys/stat.h>
71#endif /* HAVE_SYS_STAT_H */
72
73#include <string.h>
74
75/* Search in some common locations for the associated Python libraries.
76 *
77 * Py_GetPath() tries to return a sensible Python module search path.
78 *
79 * The approach is an adaptation for Windows of the strategy used in
80 * ../Modules/getpath.c; it uses the Windows Registry as one of its
81 * information sources.
82 */
83
84#ifndef LANDMARK
85#define LANDMARK "lib\\os.py"
86#endif
87
88static char prefix[MAXPATHLEN+1];
89static char progpath[MAXPATHLEN+1];
90static char dllpath[MAXPATHLEN+1];
91static char *module_search_path = NULL;
92
93
94static int
95is_sep(char ch) /* determine if "ch" is a separator character */
96{
97#ifdef ALTSEP
98 return ch == SEP || ch == ALTSEP;
99#else
100 return ch == SEP;
101#endif
102}
103
104/* assumes 'dir' null terminated in bounds. Never writes
105 beyond existing terminator.
106*/
107static void
108reduce(char *dir)
109{
110 size_t i = strlen(dir);
111 while (i > 0 && !is_sep(dir[i]))
112 --i;
113 dir[i] = '\0';
114}
115
116
117static int
118exists(char *filename)
119{
120 struct stat buf;
121 return stat(filename, &buf) == 0;
122}
123
124/* Assumes 'filename' MAXPATHLEN+1 bytes long -
125 may extend 'filename' by one character.
126*/
127static int
128ismodule(char *filename) /* Is module -- check for .pyc/.pyo too */
129{
130 if (exists(filename))
131 return 1;
132
133 /* Check for the compiled version of prefix. */
134 if (strlen(filename) < MAXPATHLEN) {
135 strcat(filename, Py_OptimizeFlag ? "o" : "c");
136 if (exists(filename))
137 return 1;
138 }
139 return 0;
140}
141
142/* Add a path component, by appending stuff to buffer.
143 buffer must have at least MAXPATHLEN + 1 bytes allocated, and contain a
144 NUL-terminated string with no more than MAXPATHLEN characters (not counting
145 the trailing NUL). It's a fatal error if it contains a string longer than
146 that (callers must be careful!). If these requirements are met, it's
147 guaranteed that buffer will still be a NUL-terminated string with no more
148 than MAXPATHLEN characters at exit. If stuff is too long, only as much of
149 stuff as fits will be appended.
150*/
151static void
152join(char *buffer, char *stuff)
153{
154 size_t n, k;
155 if (is_sep(stuff[0]))
156 n = 0;
157 else {
158 n = strlen(buffer);
159 if (n > 0 && !is_sep(buffer[n-1]) && n < MAXPATHLEN)
160 buffer[n++] = SEP;
161 }
162 if (n > MAXPATHLEN)
163 Py_FatalError("buffer overflow in getpathp.c's joinpath()");
164 k = strlen(stuff);
165 if (n + k > MAXPATHLEN)
166 k = MAXPATHLEN - n;
167 strncpy(buffer+n, stuff, k);
168 buffer[n+k] = '\0';
169}
170
171/* gotlandmark only called by search_for_prefix, which ensures
172 'prefix' is null terminated in bounds. join() ensures
173 'landmark' can not overflow prefix if too long.
174*/
175static int
176gotlandmark(char *landmark)
177{
178 int ok;
179 Py_ssize_t n;
180
181 n = strlen(prefix);
182 join(prefix, landmark);
183 ok = ismodule(prefix);
184 prefix[n] = '\0';
185 return ok;
186}
187
188/* assumes argv0_path is MAXPATHLEN+1 bytes long, already \0 term'd.
189 assumption provided by only caller, calculate_path() */
190static int
191search_for_prefix(char *argv0_path, char *landmark)
192{
193 /* Search from argv0_path, until landmark is found */
194 strcpy(prefix, argv0_path);
195 do {
196 if (gotlandmark(landmark))
197 return 1;
198 reduce(prefix);
199 } while (prefix[0]);
200 return 0;
201}
202
203#ifdef MS_WINDOWS
204#ifdef Py_ENABLE_SHARED
205
206/* a string loaded from the DLL at startup.*/
207extern const char *PyWin_DLLVersionString;
208
209
210/* Load a PYTHONPATH value from the registry.
211 Load from either HKEY_LOCAL_MACHINE or HKEY_CURRENT_USER.
212
213 Works in both Unicode and 8bit environments. Only uses the
214 Ex family of functions so it also works with Windows CE.
215
216 Returns NULL, or a pointer that should be freed.
217
218 XXX - this code is pretty strange, as it used to also
219 work on Win16, where the buffer sizes werent available
220 in advance. It could be simplied now Win16/Win32s is dead!
221*/
222
223static char *
224getpythonregpath(HKEY keyBase, int skipcore)
225{
226 HKEY newKey = 0;
227 DWORD dataSize = 0;
228 DWORD numKeys = 0;
229 LONG rc;
230 char *retval = NULL;
231 TCHAR *dataBuf = NULL;
232 static const TCHAR keyPrefix[] = _T("Software\\Python\\PythonCore\\");
233 static const TCHAR keySuffix[] = _T("\\PythonPath");
234 size_t versionLen;
235 DWORD index;
236 TCHAR *keyBuf = NULL;
237 TCHAR *keyBufPtr;
238 TCHAR **ppPaths = NULL;
239
240 /* Tried to use sysget("winver") but here is too early :-( */
241 versionLen = _tcslen(PyWin_DLLVersionString);
242 /* Space for all the chars, plus one \0 */
243 keyBuf = keyBufPtr = malloc(sizeof(keyPrefix) +
244 sizeof(TCHAR)*(versionLen-1) +
245 sizeof(keySuffix));
246 if (keyBuf==NULL) goto done;
247
248 memcpy(keyBufPtr, keyPrefix, sizeof(keyPrefix)-sizeof(TCHAR));
249 keyBufPtr += sizeof(keyPrefix)/sizeof(TCHAR) - 1;
250 memcpy(keyBufPtr, PyWin_DLLVersionString, versionLen * sizeof(TCHAR));
251 keyBufPtr += versionLen;
252 /* NULL comes with this one! */
253 memcpy(keyBufPtr, keySuffix, sizeof(keySuffix));
254 /* Open the root Python key */
255 rc=RegOpenKeyEx(keyBase,
256 keyBuf, /* subkey */
257 0, /* reserved */
258 KEY_READ,
259 &newKey);
260 if (rc!=ERROR_SUCCESS) goto done;
261 /* Find out how big our core buffer is, and how many subkeys we have */
262 rc = RegQueryInfoKey(newKey, NULL, NULL, NULL, &numKeys, NULL, NULL,
263 NULL, NULL, &dataSize, NULL, NULL);
264 if (rc!=ERROR_SUCCESS) goto done;
265 if (skipcore) dataSize = 0; /* Only count core ones if we want them! */
266 /* Allocate a temp array of char buffers, so we only need to loop
267 reading the registry once
268 */
269 ppPaths = malloc( sizeof(TCHAR *) * numKeys );
270 if (ppPaths==NULL) goto done;
271 memset(ppPaths, 0, sizeof(TCHAR *) * numKeys);
272 /* Loop over all subkeys, allocating a temp sub-buffer. */
273 for(index=0;index<numKeys;index++) {
274 TCHAR keyBuf[MAX_PATH+1];
275 HKEY subKey = 0;
276 DWORD reqdSize = MAX_PATH+1;
277 /* Get the sub-key name */
278 DWORD rc = RegEnumKeyEx(newKey, index, keyBuf, &reqdSize,
279 NULL, NULL, NULL, NULL );
280 if (rc!=ERROR_SUCCESS) goto done;
281 /* Open the sub-key */
282 rc=RegOpenKeyEx(newKey,
283 keyBuf, /* subkey */
284 0, /* reserved */
285 KEY_READ,
286 &subKey);
287 if (rc!=ERROR_SUCCESS) goto done;
288 /* Find the value of the buffer size, malloc, then read it */
289 RegQueryValueEx(subKey, NULL, 0, NULL, NULL, &reqdSize);
290 if (reqdSize) {
291 ppPaths[index] = malloc(reqdSize);
292 if (ppPaths[index]) {
293 RegQueryValueEx(subKey, NULL, 0, NULL,
294 (LPBYTE)ppPaths[index],
295 &reqdSize);
296 dataSize += reqdSize + 1; /* 1 for the ";" */
297 }
298 }
299 RegCloseKey(subKey);
300 }
301
302 /* return null if no path to return */
303 if (dataSize == 0) goto done;
304
305 /* original datasize from RegQueryInfo doesn't include the \0 */
306 dataBuf = malloc((dataSize+1) * sizeof(TCHAR));
307 if (dataBuf) {
308 TCHAR *szCur = dataBuf;
309 DWORD reqdSize = dataSize;
310 /* Copy our collected strings */
311 for (index=0;index<numKeys;index++) {
312 if (index > 0) {
313 *(szCur++) = _T(';');
314 dataSize--;
315 }
316 if (ppPaths[index]) {
317 Py_ssize_t len = _tcslen(ppPaths[index]);
318 _tcsncpy(szCur, ppPaths[index], len);
319 szCur += len;
320 assert(dataSize > (DWORD)len);
321 dataSize -= (DWORD)len;
322 }
323 }
324 if (skipcore)
325 *szCur = '\0';
326 else {
327 /* If we have no values, we dont need a ';' */
328 if (numKeys) {
329 *(szCur++) = _T(';');
330 dataSize--;
331 }
332 /* Now append the core path entries -
333 this will include the NULL
334 */
335 rc = RegQueryValueEx(newKey, NULL, 0, NULL,
336 (LPBYTE)szCur, &dataSize);
337 }
338 /* And set the result - caller must free
339 If MBCS, it is fine as is. If Unicode, allocate new
340 buffer and convert.
341 */
342#ifdef UNICODE
343 retval = (char *)malloc(reqdSize+1);
344 if (retval)
345 WideCharToMultiByte(CP_ACP, 0,
346 dataBuf, -1, /* source */
347 retval, reqdSize+1, /* dest */
348 NULL, NULL);
349 free(dataBuf);
350#else
351 retval = dataBuf;
352#endif
353 }
354done:
355 /* Loop freeing my temp buffers */
356 if (ppPaths) {
357 for(index=0;index<numKeys;index++)
358 if (ppPaths[index]) free(ppPaths[index]);
359 free(ppPaths);
360 }
361 if (newKey)
362 RegCloseKey(newKey);
363 if (keyBuf)
364 free(keyBuf);
365 return retval;
366}
367#endif /* Py_ENABLE_SHARED */
368#endif /* MS_WINDOWS */
369
370static void
371get_progpath(void)
372{
373 extern char *Py_GetProgramName(void);
374 char *path = getenv("PATH");
375 char *prog = Py_GetProgramName();
376
377#ifdef MS_WINDOWS
378 extern HANDLE PyWin_DLLhModule;
379#ifdef UNICODE
380 WCHAR wprogpath[MAXPATHLEN+1];
381 /* Windows documents that GetModuleFileName() will "truncate",
382 but makes no mention of the null terminator. Play it safe.
383 PLUS Windows itself defines MAX_PATH as the same, but anyway...
384 */
385#ifdef Py_ENABLE_SHARED
386 wprogpath[MAXPATHLEN]=_T('\0');
387 if (PyWin_DLLhModule &&
388 GetModuleFileName(PyWin_DLLhModule, wprogpath, MAXPATHLEN)) {
389 WideCharToMultiByte(CP_ACP, 0,
390 wprogpath, -1,
391 dllpath, MAXPATHLEN+1,
392 NULL, NULL);
393 }
394#else
395 dllpath[0] = 0;
396#endif
397 wprogpath[MAXPATHLEN]=_T('\0');
398 if (GetModuleFileName(NULL, wprogpath, MAXPATHLEN)) {
399 WideCharToMultiByte(CP_ACP, 0,
400 wprogpath, -1,
401 progpath, MAXPATHLEN+1,
402 NULL, NULL);
403 return;
404 }
405#else
406 /* static init of progpath ensures final char remains \0 */
407#ifdef Py_ENABLE_SHARED
408 if (PyWin_DLLhModule)
409 if (!GetModuleFileName(PyWin_DLLhModule, dllpath, MAXPATHLEN))
410 dllpath[0] = 0;
411#else
412 dllpath[0] = 0;
413#endif
414 if (GetModuleFileName(NULL, progpath, MAXPATHLEN))
415 return;
416#endif
417#endif
418 if (prog == NULL || *prog == '\0')
419 prog = "python";
420
421 /* If there is no slash in the argv0 path, then we have to
422 * assume python is on the user's $PATH, since there's no
423 * other way to find a directory to start the search from. If
424 * $PATH isn't exported, you lose.
425 */
426#ifdef ALTSEP
427 if (strchr(prog, SEP) || strchr(prog, ALTSEP))
428#else
429 if (strchr(prog, SEP))
430#endif
431 strncpy(progpath, prog, MAXPATHLEN);
432 else if (path) {
433 while (1) {
434 char *delim = strchr(path, DELIM);
435
436 if (delim) {
437 size_t len = delim - path;
438 /* ensure we can't overwrite buffer */
439 len = min(MAXPATHLEN,len);
440 strncpy(progpath, path, len);
441 *(progpath + len) = '\0';
442 }
443 else
444 strncpy(progpath, path, MAXPATHLEN);
445
446 /* join() is safe for MAXPATHLEN+1 size buffer */
447 join(progpath, prog);
448 if (exists(progpath))
449 break;
450
451 if (!delim) {
452 progpath[0] = '\0';
453 break;
454 }
455 path = delim + 1;
456 }
457 }
458 else
459 progpath[0] = '\0';
460}
461
462static void
463calculate_path(void)
464{
465 char argv0_path[MAXPATHLEN+1];
466 char *buf;
467 size_t bufsz;
468 char *pythonhome = Py_GetPythonHome();
469 char *envpath = Py_GETENV("PYTHONPATH");
470
471#ifdef MS_WINDOWS
472 int skiphome, skipdefault;
473 char *machinepath = NULL;
474 char *userpath = NULL;
475 char zip_path[MAXPATHLEN+1];
476 size_t len;
477#endif
478
479 get_progpath();
480 /* progpath guaranteed \0 terminated in MAXPATH+1 bytes. */
481 strcpy(argv0_path, progpath);
482 reduce(argv0_path);
483 if (pythonhome == NULL || *pythonhome == '\0') {
484 if (search_for_prefix(argv0_path, LANDMARK))
485 pythonhome = prefix;
486 else
487 pythonhome = NULL;
488 }
489 else
490 strncpy(prefix, pythonhome, MAXPATHLEN);
491
492 if (envpath && *envpath == '\0')
493 envpath = NULL;
494
495
496#ifdef MS_WINDOWS
497 /* Calculate zip archive path */
498 if (dllpath[0]) /* use name of python DLL */
499 strncpy(zip_path, dllpath, MAXPATHLEN);
500 else /* use name of executable program */
501 strncpy(zip_path, progpath, MAXPATHLEN);
502 zip_path[MAXPATHLEN] = '\0';
503 len = strlen(zip_path);
504 if (len > 4) {
505 zip_path[len-3] = 'z'; /* change ending to "zip" */
506 zip_path[len-2] = 'i';
507 zip_path[len-1] = 'p';
508 }
509 else {
510 zip_path[0] = 0;
511 }
512
513 skiphome = pythonhome==NULL ? 0 : 1;
514#ifdef Py_ENABLE_SHARED
515 machinepath = getpythonregpath(HKEY_LOCAL_MACHINE, skiphome);
516 userpath = getpythonregpath(HKEY_CURRENT_USER, skiphome);
517#endif
518 /* We only use the default relative PYTHONPATH if we havent
519 anything better to use! */
520 skipdefault = envpath!=NULL || pythonhome!=NULL || \
521 machinepath!=NULL || userpath!=NULL;
522#endif
523
524 /* We need to construct a path from the following parts.
525 (1) the PYTHONPATH environment variable, if set;
526 (2) for Win32, the zip archive file path;
527 (3) for Win32, the machinepath and userpath, if set;
528 (4) the PYTHONPATH config macro, with the leading "."
529 of each component replaced with pythonhome, if set;
530 (5) the directory containing the executable (argv0_path).
531 The length calculation calculates #4 first.
532 Extra rules:
533 - If PYTHONHOME is set (in any way) item (3) is ignored.
534 - If registry values are used, (4) and (5) are ignored.
535 */
536
537 /* Calculate size of return buffer */
538 if (pythonhome != NULL) {
539 char *p;
540 bufsz = 1;
541 for (p = PYTHONPATH; *p; p++) {
542 if (*p == DELIM)
543 bufsz++; /* number of DELIM plus one */
544 }
545 bufsz *= strlen(pythonhome);
546 }
547 else
548 bufsz = 0;
549 bufsz += strlen(PYTHONPATH) + 1;
550 bufsz += strlen(argv0_path) + 1;
551#ifdef MS_WINDOWS
552 if (userpath)
553 bufsz += strlen(userpath) + 1;
554 if (machinepath)
555 bufsz += strlen(machinepath) + 1;
556 bufsz += strlen(zip_path) + 1;
557#endif
558 if (envpath != NULL)
559 bufsz += strlen(envpath) + 1;
560
561 module_search_path = buf = malloc(bufsz);
562 if (buf == NULL) {
563 /* We can't exit, so print a warning and limp along */
564 fprintf(stderr, "Can't malloc dynamic PYTHONPATH.\n");
565 if (envpath) {
566 fprintf(stderr, "Using environment $PYTHONPATH.\n");
567 module_search_path = envpath;
568 }
569 else {
570 fprintf(stderr, "Using default static path.\n");
571 module_search_path = PYTHONPATH;
572 }
573#ifdef MS_WINDOWS
574 if (machinepath)
575 free(machinepath);
576 if (userpath)
577 free(userpath);
578#endif /* MS_WINDOWS */
579 return;
580 }
581
582 if (envpath) {
583 strcpy(buf, envpath);
584 buf = strchr(buf, '\0');
585 *buf++ = DELIM;
586 }
587#ifdef MS_WINDOWS
588 if (zip_path[0]) {
589 strcpy(buf, zip_path);
590 buf = strchr(buf, '\0');
591 *buf++ = DELIM;
592 }
593 if (userpath) {
594 strcpy(buf, userpath);
595 buf = strchr(buf, '\0');
596 *buf++ = DELIM;
597 free(userpath);
598 }
599 if (machinepath) {
600 strcpy(buf, machinepath);
601 buf = strchr(buf, '\0');
602 *buf++ = DELIM;
603 free(machinepath);
604 }
605 if (pythonhome == NULL) {
606 if (!skipdefault) {
607 strcpy(buf, PYTHONPATH);
608 buf = strchr(buf, '\0');
609 }
610 }
611#else
612 if (pythonhome == NULL) {
613 strcpy(buf, PYTHONPATH);
614 buf = strchr(buf, '\0');
615 }
616#endif /* MS_WINDOWS */
617 else {
618 char *p = PYTHONPATH;
619 char *q;
620 size_t n;
621 for (;;) {
622 q = strchr(p, DELIM);
623 if (q == NULL)
624 n = strlen(p);
625 else
626 n = q-p;
627 if (p[0] == '.' && is_sep(p[1])) {
628 strcpy(buf, pythonhome);
629 buf = strchr(buf, '\0');
630 p++;
631 n--;
632 }
633 strncpy(buf, p, n);
634 buf += n;
635 if (q == NULL)
636 break;
637 *buf++ = DELIM;
638 p = q+1;
639 }
640 }
641 if (argv0_path) {
642 *buf++ = DELIM;
643 strcpy(buf, argv0_path);
644 buf = strchr(buf, '\0');
645 }
646 *buf = '\0';
647 /* Now to pull one last hack/trick. If sys.prefix is
648 empty, then try and find it somewhere on the paths
649 we calculated. We scan backwards, as our general policy
650 is that Python core directories are at the *end* of
651 sys.path. We assume that our "lib" directory is
652 on the path, and that our 'prefix' directory is
653 the parent of that.
654 */
655 if (*prefix=='\0') {
656 char lookBuf[MAXPATHLEN+1];
657 char *look = buf - 1; /* 'buf' is at the end of the buffer */
658 while (1) {
659 Py_ssize_t nchars;
660 char *lookEnd = look;
661 /* 'look' will end up one character before the
662 start of the path in question - even if this
663 is one character before the start of the buffer
664 */
665 while (look >= module_search_path && *look != DELIM)
666 look--;
667 nchars = lookEnd-look;
668 strncpy(lookBuf, look+1, nchars);
669 lookBuf[nchars] = '\0';
670 /* Up one level to the parent */
671 reduce(lookBuf);
672 if (search_for_prefix(lookBuf, LANDMARK)) {
673 break;
674 }
675 /* If we are out of paths to search - give up */
676 if (look < module_search_path)
677 break;
678 look--;
679 }
680 }
681}
682
683
684/* External interface */
685
686char *
687Py_GetPath(void)
688{
689 if (!module_search_path)
690 calculate_path();
691 return module_search_path;
692}
693
694char *
695Py_GetPrefix(void)
696{
697 if (!module_search_path)
698 calculate_path();
699 return prefix;
700}
701
702char *
703Py_GetExecPrefix(void)
704{
705 return Py_GetPrefix();
706}
707
708char *
709Py_GetProgramFullPath(void)
710{
711 if (!module_search_path)
712 calculate_path();
713 return progpath;
714}
Note: See TracBrowser for help on using the repository browser.