1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
|
/*
* This wrapper program executes a python executable hidden inside an
* application bundle inside the Python framework. This is needed to run
* GUI code: some GUI API's don't work unless the program is inside an
* application bundle.
*
* This program uses posix_spawn rather than plain execv because we need
* slightly more control over how the "real" interpreter is executed.
*
* On OSX 10.4 (and earlier) this falls back to using exec because the
* posix_spawnv functions aren't available there.
*/
#pragma weak_import posix_spawnattr_init
#pragma weak_import posix_spawnattr_setbinpref_np
#pragma weak_import posix_spawnattr_setflags
#pragma weak_import posix_spawn
#include <Python.h>
#include <unistd.h>
#ifdef HAVE_SPAWN_H
#include <spawn.h>
#endif
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <err.h>
#include <dlfcn.h>
#include <stdlib.h>
#include <Python.h>
#include <mach-o/dyld.h>
extern char** environ;
/*
* Locate the python framework by looking for the
* library that contains Py_Initialize.
*
* In a regular framework the structure is:
*
* Python.framework/Versions/2.7
* /Python
* /Resources/Python.app/Contents/MacOS/Python
*
* In a virtualenv style structure the expected
* structure is:
*
* ROOT
* /bin/pythonw
* /.Python <- the dylib
* /.Resources/Python.app/Contents/MacOS/Python
*
* NOTE: virtualenv's are not an officially supported
* feature, support for that structure is provided as
* a convenience.
*/
static char* get_python_path(void)
{
size_t len;
Dl_info info;
char* end;
char* g_path;
if (dladdr(Py_Initialize, &info) == 0) {
return NULL;
}
len = strlen(info.dli_fname);
g_path = malloc(len+60);
if (g_path == NULL) {
return NULL;
}
strcpy(g_path, info.dli_fname);
end = g_path + len - 1;
while (end != g_path && *end != '/') {
end --;
}
end++;
if (*end == '.') {
end++;
}
strcpy(end, "Resources/Python.app/Contents/MacOS/" PYTHONFRAMEWORK);
return g_path;
}
#ifdef HAVE_SPAWN_H
static void
setup_spawnattr(posix_spawnattr_t* spawnattr)
{
size_t ocount;
size_t count;
cpu_type_t cpu_types[1];
short flags = 0;
if ((errno = posix_spawnattr_init(spawnattr)) != 0) {
err(2, "posix_spawnattr_int");
/* NOTREACHTED */
}
count = 1;
/* Run the real python executable using the same architecture as this
* executable, this allows users to control the architecture using
* "arch -ppc python"
*/
#if defined(__ppc64__)
cpu_types[0] = CPU_TYPE_POWERPC64;
#elif defined(__x86_64__)
cpu_types[0] = CPU_TYPE_X86_64;
#elif defined(__ppc__)
cpu_types[0] = CPU_TYPE_POWERPC;
#elif defined(__i386__)
cpu_types[0] = CPU_TYPE_X86;
#elif defined(__arm64__)
cpu_types[0] = CPU_TYPE_ARM64;
#else
# error "Unknown CPU"
#endif
if (posix_spawnattr_setbinpref_np(spawnattr, count,
cpu_types, &ocount) == -1) {
err(1, "posix_spawnattr_setbinpref");
/* NOTREACHTED */
}
if (count != ocount) {
fprintf(stderr, "posix_spawnattr_setbinpref failed to copy\n");
exit(1);
/* NOTREACHTED */
}
/*
* Set flag that causes posix_spawn to behave like execv
*/
flags |= POSIX_SPAWN_SETEXEC;
if ((errno = posix_spawnattr_setflags(spawnattr, flags)) != 0) {
err(1, "posix_spawnattr_setflags");
/* NOTREACHTED */
}
}
#endif
int
main(int argc, char **argv) {
char* exec_path = get_python_path();
static char path[PATH_MAX * 2];
static char real_path[PATH_MAX * 2];
int status;
uint32_t size = PATH_MAX * 2;
/* Set the original executable path in the environment. */
status = _NSGetExecutablePath(path, &size);
if (status == 0) {
/*
* Note: don't call 'realpath', that will
* erase symlink information, and that
* breaks "pyvenv --symlink"
*
* It is nice to have the directory name
* as a cleaned up absolute path though,
* therefore call realpath on dirname(path)
*/
char* slash = strrchr(path, '/');
if (slash) {
char replaced;
replaced = slash[1];
slash[1] = 0;
if (realpath(path, real_path) == NULL) {
err(1, "realpath: %s", path);
}
slash[1] = replaced;
if (strlcat(real_path, slash, sizeof(real_path)) > sizeof(real_path)) {
errno = EINVAL;
err(1, "realpath: %s", path);
}
} else {
if (realpath(".", real_path) == NULL) {
err(1, "realpath: %s", path);
}
if (strlcat(real_path, "/", sizeof(real_path)) > sizeof(real_path)) {
errno = EINVAL;
err(1, "realpath: %s", path);
}
if (strlcat(real_path, path, sizeof(real_path)) > sizeof(real_path)) {
errno = EINVAL;
err(1, "realpath: %s", path);
}
}
/*
* The environment variable is used to pass the value of real_path
* to the actual python interpreter, and is read by code in
* Python/coreconfig.c.
*
* This way the real interpreter knows how the user invoked the
* interpreter and can behave as if this launcher is the real
* interpreter (looking for pyvenv configuration, ...)
*/
setenv("__PYVENV_LAUNCHER__", real_path, 1);
}
/*
* Let argv[0] refer to the new interpreter. This is needed to
* get the effect we want on OSX 10.5 or earlier. That is, without
* changing argv[0] the real interpreter won't have access to
* the Window Server.
*/
argv[0] = exec_path;
#ifdef HAVE_SPAWN_H
/* We're weak-linking to posix-spawnv to ensure that
* an executable build on 10.5 can work on 10.4.
*/
if (&posix_spawn != NULL) {
posix_spawnattr_t spawnattr = NULL;
setup_spawnattr(&spawnattr);
posix_spawn(NULL, exec_path, NULL,
&spawnattr, argv, environ);
err(1, "posix_spawn: %s", exec_path);
}
#endif
execve(exec_path, argv, environ);
err(1, "execve: %s", argv[0]);
/* NOTREACHED */
}
|
