source: vendor/python/2.5/PC/getpathp.c

Last change on this file was 3225, checked in by bird, 18 years ago

Python 2.5
File size: 18.3 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
205/* a string loaded from the DLL at startup.*/
206extern const char *PyWin_DLLVersionString;
207
208
209/* Load a PYTHONPATH value from the registry.
210 Load from either HKEY_LOCAL_MACHINE or HKEY_CURRENT_USER.
211
212 Works in both Unicode and 8bit environments. Only uses the
213 Ex family of functions so it also works with Windows CE.
214
215 Returns NULL, or a pointer that should be freed.
216
217 XXX - this code is pretty strange, as it used to also
218 work on Win16, where the buffer sizes werent available
219 in advance. It could be simplied now Win16/Win32s is dead!
220*/
221
222static char *
223getpythonregpath(HKEY keyBase, int skipcore)
224{
225 HKEY newKey = 0;
226 DWORD dataSize = 0;
227 DWORD numKeys = 0;
228 LONG rc;
229 char *retval = NULL;
230 TCHAR *dataBuf = NULL;
231 static const TCHAR keyPrefix[] = _T("Software\\Python\\PythonCore\\");
232 static const TCHAR keySuffix[] = _T("\\PythonPath");
233 size_t versionLen;
234 DWORD index;
235 TCHAR *keyBuf = NULL;
236 TCHAR *keyBufPtr;
237 TCHAR **ppPaths = NULL;
238
239 /* Tried to use sysget("winver") but here is too early :-( */
240 versionLen = _tcslen(PyWin_DLLVersionString);
241 /* Space for all the chars, plus one \0 */
242 keyBuf = keyBufPtr = malloc(sizeof(keyPrefix) +
243 sizeof(TCHAR)*(versionLen-1) +
244 sizeof(keySuffix));
245 if (keyBuf==NULL) goto done;
246
247 memcpy(keyBufPtr, keyPrefix, sizeof(keyPrefix)-sizeof(TCHAR));
248 keyBufPtr += sizeof(keyPrefix)/sizeof(TCHAR) - 1;
249 memcpy(keyBufPtr, PyWin_DLLVersionString, versionLen * sizeof(TCHAR));
250 keyBufPtr += versionLen;
251 /* NULL comes with this one! */
252 memcpy(keyBufPtr, keySuffix, sizeof(keySuffix));
253 /* Open the root Python key */
254 rc=RegOpenKeyEx(keyBase,
255 keyBuf, /* subkey */
256 0, /* reserved */
257 KEY_READ,
258 &newKey);
259 if (rc!=ERROR_SUCCESS) goto done;
260 /* Find out how big our core buffer is, and how many subkeys we have */
261 rc = RegQueryInfoKey(newKey, NULL, NULL, NULL, &numKeys, NULL, NULL,
262 NULL, NULL, &dataSize, NULL, NULL);
263 if (rc!=ERROR_SUCCESS) goto done;
264 if (skipcore) dataSize = 0; /* Only count core ones if we want them! */
265 /* Allocate a temp array of char buffers, so we only need to loop
266 reading the registry once
267 */
268 ppPaths = malloc( sizeof(TCHAR *) * numKeys );
269 if (ppPaths==NULL) goto done;
270 memset(ppPaths, 0, sizeof(TCHAR *) * numKeys);
271 /* Loop over all subkeys, allocating a temp sub-buffer. */
272 for(index=0;index<numKeys;index++) {
273 TCHAR keyBuf[MAX_PATH+1];
274 HKEY subKey = 0;
275 DWORD reqdSize = MAX_PATH+1;
276 /* Get the sub-key name */
277 DWORD rc = RegEnumKeyEx(newKey, index, keyBuf, &reqdSize,
278 NULL, NULL, NULL, NULL );
279 if (rc!=ERROR_SUCCESS) goto done;
280 /* Open the sub-key */
281 rc=RegOpenKeyEx(newKey,
282 keyBuf, /* subkey */
283 0, /* reserved */
284 KEY_READ,
285 &subKey);
286 if (rc!=ERROR_SUCCESS) goto done;
287 /* Find the value of the buffer size, malloc, then read it */
288 RegQueryValueEx(subKey, NULL, 0, NULL, NULL, &reqdSize);
289 if (reqdSize) {
290 ppPaths[index] = malloc(reqdSize);
291 if (ppPaths[index]) {
292 RegQueryValueEx(subKey, NULL, 0, NULL,
293 (LPBYTE)ppPaths[index],
294 &reqdSize);
295 dataSize += reqdSize + 1; /* 1 for the ";" */
296 }
297 }
298 RegCloseKey(subKey);
299 }
300
301 /* return null if no path to return */
302 if (dataSize == 0) goto done;
303
304 /* original datasize from RegQueryInfo doesn't include the \0 */
305 dataBuf = malloc((dataSize+1) * sizeof(TCHAR));
306 if (dataBuf) {
307 TCHAR *szCur = dataBuf;
308 DWORD reqdSize = dataSize;
309 /* Copy our collected strings */
310 for (index=0;index<numKeys;index++) {
311 if (index > 0) {
312 *(szCur++) = _T(';');
313 dataSize--;
314 }
315 if (ppPaths[index]) {
316 Py_ssize_t len = _tcslen(ppPaths[index]);
317 _tcsncpy(szCur, ppPaths[index], len);
318 szCur += len;
319 assert(dataSize > (DWORD)len);
320 dataSize -= (DWORD)len;
321 }
322 }
323 if (skipcore)
324 *szCur = '\0';
325 else {
326 /* If we have no values, we dont need a ';' */
327 if (numKeys) {
328 *(szCur++) = _T(';');
329 dataSize--;
330 }
331 /* Now append the core path entries -
332 this will include the NULL
333 */
334 rc = RegQueryValueEx(newKey, NULL, 0, NULL,
335 (LPBYTE)szCur, &dataSize);
336 }
337 /* And set the result - caller must free
338 If MBCS, it is fine as is. If Unicode, allocate new
339 buffer and convert.
340 */
341#ifdef UNICODE
342 retval = (char *)malloc(reqdSize+1);
343 if (retval)
344 WideCharToMultiByte(CP_ACP, 0,
345 dataBuf, -1, /* source */
346 retval, reqdSize+1, /* dest */
347 NULL, NULL);
348 free(dataBuf);
349#else
350 retval = dataBuf;
351#endif
352 }
353done:
354 /* Loop freeing my temp buffers */
355 if (ppPaths) {
356 for(index=0;index<numKeys;index++)
357 if (ppPaths[index]) free(ppPaths[index]);
358 free(ppPaths);
359 }
360 if (newKey)
361 RegCloseKey(newKey);
362 if (keyBuf)
363 free(keyBuf);
364 return retval;
365}
366#endif /* MS_WINDOWS */
367
368static void
369get_progpath(void)
370{
371 extern char *Py_GetProgramName(void);
372 char *path = getenv("PATH");
373 char *prog = Py_GetProgramName();
374
375#ifdef MS_WINDOWS
376 extern HANDLE PyWin_DLLhModule;
377#ifdef UNICODE
378 WCHAR wprogpath[MAXPATHLEN+1];
379 /* Windows documents that GetModuleFileName() will "truncate",
380 but makes no mention of the null terminator. Play it safe.
381 PLUS Windows itself defines MAX_PATH as the same, but anyway...
382 */
383 wprogpath[MAXPATHLEN]=_T('\0');
384 if (PyWin_DLLhModule &&
385 GetModuleFileName(PyWin_DLLhModule, wprogpath, MAXPATHLEN)) {
386 WideCharToMultiByte(CP_ACP, 0,
387 wprogpath, -1,
388 dllpath, MAXPATHLEN+1,
389 NULL, NULL);
390 }
391 wprogpath[MAXPATHLEN]=_T('\0');
392 if (GetModuleFileName(NULL, wprogpath, MAXPATHLEN)) {
393 WideCharToMultiByte(CP_ACP, 0,
394 wprogpath, -1,
395 progpath, MAXPATHLEN+1,
396 NULL, NULL);
397 return;
398 }
399#else
400 /* static init of progpath ensures final char remains \0 */
401 if (PyWin_DLLhModule)
402 if (!GetModuleFileName(PyWin_DLLhModule, dllpath, MAXPATHLEN))
403 dllpath[0] = 0;
404 if (GetModuleFileName(NULL, progpath, MAXPATHLEN))
405 return;
406#endif
407#endif
408 if (prog == NULL || *prog == '\0')
409 prog = "python";
410
411 /* If there is no slash in the argv0 path, then we have to
412 * assume python is on the user's $PATH, since there's no
413 * other way to find a directory to start the search from. If
414 * $PATH isn't exported, you lose.
415 */
416#ifdef ALTSEP
417 if (strchr(prog, SEP) || strchr(prog, ALTSEP))
418#else
419 if (strchr(prog, SEP))
420#endif
421 strncpy(progpath, prog, MAXPATHLEN);
422 else if (path) {
423 while (1) {
424 char *delim = strchr(path, DELIM);
425
426 if (delim) {
427 size_t len = delim - path;
428 /* ensure we can't overwrite buffer */
429 len = min(MAXPATHLEN,len);
430 strncpy(progpath, path, len);
431 *(progpath + len) = '\0';
432 }
433 else
434 strncpy(progpath, path, MAXPATHLEN);
435
436 /* join() is safe for MAXPATHLEN+1 size buffer */
437 join(progpath, prog);
438 if (exists(progpath))
439 break;
440
441 if (!delim) {
442 progpath[0] = '\0';
443 break;
444 }
445 path = delim + 1;
446 }
447 }
448 else
449 progpath[0] = '\0';
450}
451
452static void
453calculate_path(void)
454{
455 char argv0_path[MAXPATHLEN+1];
456 char *buf;
457 size_t bufsz;
458 char *pythonhome = Py_GetPythonHome();
459 char *envpath = Py_GETENV("PYTHONPATH");
460
461#ifdef MS_WINDOWS
462 int skiphome, skipdefault;
463 char *machinepath = NULL;
464 char *userpath = NULL;
465 char zip_path[MAXPATHLEN+1];
466 size_t len;
467#endif
468
469 get_progpath();
470 /* progpath guaranteed \0 terminated in MAXPATH+1 bytes. */
471 strcpy(argv0_path, progpath);
472 reduce(argv0_path);
473 if (pythonhome == NULL || *pythonhome == '\0') {
474 if (search_for_prefix(argv0_path, LANDMARK))
475 pythonhome = prefix;
476 else
477 pythonhome = NULL;
478 }
479 else
480 strncpy(prefix, pythonhome, MAXPATHLEN);
481
482 if (envpath && *envpath == '\0')
483 envpath = NULL;
484
485
486#ifdef MS_WINDOWS
487 /* Calculate zip archive path */
488 if (dllpath[0]) /* use name of python DLL */
489 strncpy(zip_path, dllpath, MAXPATHLEN);
490 else /* use name of executable program */
491 strncpy(zip_path, progpath, MAXPATHLEN);
492 zip_path[MAXPATHLEN] = '\0';
493 len = strlen(zip_path);
494 if (len > 4) {
495 zip_path[len-3] = 'z'; /* change ending to "zip" */
496 zip_path[len-2] = 'i';
497 zip_path[len-1] = 'p';
498 }
499 else {
500 zip_path[0] = 0;
501 }
502
503 skiphome = pythonhome==NULL ? 0 : 1;
504 machinepath = getpythonregpath(HKEY_LOCAL_MACHINE, skiphome);
505 userpath = getpythonregpath(HKEY_CURRENT_USER, skiphome);
506 /* We only use the default relative PYTHONPATH if we havent
507 anything better to use! */
508 skipdefault = envpath!=NULL || pythonhome!=NULL || \
509 machinepath!=NULL || userpath!=NULL;
510#endif
511
512 /* We need to construct a path from the following parts.
513 (1) the PYTHONPATH environment variable, if set;
514 (2) for Win32, the zip archive file path;
515 (3) for Win32, the machinepath and userpath, if set;
516 (4) the PYTHONPATH config macro, with the leading "."
517 of each component replaced with pythonhome, if set;
518 (5) the directory containing the executable (argv0_path).
519 The length calculation calculates #4 first.
520 Extra rules:
521 - If PYTHONHOME is set (in any way) item (3) is ignored.
522 - If registry values are used, (4) and (5) are ignored.
523 */
524
525 /* Calculate size of return buffer */
526 if (pythonhome != NULL) {
527 char *p;
528 bufsz = 1;
529 for (p = PYTHONPATH; *p; p++) {
530 if (*p == DELIM)
531 bufsz++; /* number of DELIM plus one */
532 }
533 bufsz *= strlen(pythonhome);
534 }
535 else
536 bufsz = 0;
537 bufsz += strlen(PYTHONPATH) + 1;
538 bufsz += strlen(argv0_path) + 1;
539#ifdef MS_WINDOWS
540 if (userpath)
541 bufsz += strlen(userpath) + 1;
542 if (machinepath)
543 bufsz += strlen(machinepath) + 1;
544 bufsz += strlen(zip_path) + 1;
545#endif
546 if (envpath != NULL)
547 bufsz += strlen(envpath) + 1;
548
549 module_search_path = buf = malloc(bufsz);
550 if (buf == NULL) {
551 /* We can't exit, so print a warning and limp along */
552 fprintf(stderr, "Can't malloc dynamic PYTHONPATH.\n");
553 if (envpath) {
554 fprintf(stderr, "Using environment $PYTHONPATH.\n");
555 module_search_path = envpath;
556 }
557 else {
558 fprintf(stderr, "Using default static path.\n");
559 module_search_path = PYTHONPATH;
560 }
561#ifdef MS_WINDOWS
562 if (machinepath)
563 free(machinepath);
564 if (userpath)
565 free(userpath);
566#endif /* MS_WINDOWS */
567 return;
568 }
569
570 if (envpath) {
571 strcpy(buf, envpath);
572 buf = strchr(buf, '\0');
573 *buf++ = DELIM;
574 }
575#ifdef MS_WINDOWS
576 if (zip_path[0]) {
577 strcpy(buf, zip_path);
578 buf = strchr(buf, '\0');
579 *buf++ = DELIM;
580 }
581 if (userpath) {
582 strcpy(buf, userpath);
583 buf = strchr(buf, '\0');
584 *buf++ = DELIM;
585 free(userpath);
586 }
587 if (machinepath) {
588 strcpy(buf, machinepath);
589 buf = strchr(buf, '\0');
590 *buf++ = DELIM;
591 free(machinepath);
592 }
593 if (pythonhome == NULL) {
594 if (!skipdefault) {
595 strcpy(buf, PYTHONPATH);
596 buf = strchr(buf, '\0');
597 }
598 }
599#else
600 if (pythonhome == NULL) {
601 strcpy(buf, PYTHONPATH);
602 buf = strchr(buf, '\0');
603 }
604#endif /* MS_WINDOWS */
605 else {
606 char *p = PYTHONPATH;
607 char *q;
608 size_t n;
609 for (;;) {
610 q = strchr(p, DELIM);
611 if (q == NULL)
612 n = strlen(p);
613 else
614 n = q-p;
615 if (p[0] == '.' && is_sep(p[1])) {
616 strcpy(buf, pythonhome);
617 buf = strchr(buf, '\0');
618 p++;
619 n--;
620 }
621 strncpy(buf, p, n);
622 buf += n;
623 if (q == NULL)
624 break;
625 *buf++ = DELIM;
626 p = q+1;
627 }
628 }
629 if (argv0_path) {
630 *buf++ = DELIM;
631 strcpy(buf, argv0_path);
632 buf = strchr(buf, '\0');
633 }
634 *buf = '\0';
635 /* Now to pull one last hack/trick. If sys.prefix is
636 empty, then try and find it somewhere on the paths
637 we calculated. We scan backwards, as our general policy
638 is that Python core directories are at the *end* of
639 sys.path. We assume that our "lib" directory is
640 on the path, and that our 'prefix' directory is
641 the parent of that.
642 */
643 if (*prefix=='\0') {
644 char lookBuf[MAXPATHLEN+1];
645 char *look = buf - 1; /* 'buf' is at the end of the buffer */
646 while (1) {
647 Py_ssize_t nchars;
648 char *lookEnd = look;
649 /* 'look' will end up one character before the
650 start of the path in question - even if this
651 is one character before the start of the buffer
652 */
653 while (*look != DELIM && look >= module_search_path)
654 look--;
655 nchars = lookEnd-look;
656 strncpy(lookBuf, look+1, nchars);
657 lookBuf[nchars] = '\0';
658 /* Up one level to the parent */
659 reduce(lookBuf);
660 if (search_for_prefix(lookBuf, LANDMARK)) {
661 break;
662 }
663 /* If we are out of paths to search - give up */
664 if (look < module_search_path)
665 break;
666 look--;
667 }
668 }
669}
670
671
672/* External interface */
673
674char *
675Py_GetPath(void)
676{
677 if (!module_search_path)
678 calculate_path();
679 return module_search_path;
680}
681
682char *
683Py_GetPrefix(void)
684{
685 if (!module_search_path)
686 calculate_path();
687 return prefix;
688}
689
690char *
691Py_GetExecPrefix(void)
692{
693 return Py_GetPrefix();
694}
695
696char *
697Py_GetProgramFullPath(void)
698{
699 if (!module_search_path)
700 calculate_path();
701 return progpath;
702}
Note: See TracBrowser for help on using the repository browser.