No issues found
1 /*
2 * Extension module used by multiprocessing package
3 *
4 * multiprocessing.c
5 *
6 * Copyright (c) 2006-2008, R Oudkerk --- see COPYING.txt
7 */
8
9 #include "multiprocessing.h"
10
11 #if (defined(CMSG_LEN) && defined(SCM_RIGHTS))
12 #define HAVE_FD_TRANSFER 1
13 #else
14 #define HAVE_FD_TRANSFER 0
15 #endif
16
17 PyObject *create_win32_namespace(void);
18
19 PyObject *pickle_dumps, *pickle_loads, *pickle_protocol;
20 PyObject *ProcessError, *BufferTooShort;
21
22 /*
23 * Function which raises exceptions based on error codes
24 */
25
26 PyObject *
27 mp_SetError(PyObject *Type, int num)
28 {
29 switch (num) {
30 #ifdef MS_WINDOWS
31 case MP_STANDARD_ERROR:
32 if (Type == NULL)
33 Type = PyExc_WindowsError;
34 PyErr_SetExcFromWindowsErr(Type, 0);
35 break;
36 case MP_SOCKET_ERROR:
37 if (Type == NULL)
38 Type = PyExc_WindowsError;
39 PyErr_SetExcFromWindowsErr(Type, WSAGetLastError());
40 break;
41 #else /* !MS_WINDOWS */
42 case MP_STANDARD_ERROR:
43 case MP_SOCKET_ERROR:
44 if (Type == NULL)
45 Type = PyExc_OSError;
46 PyErr_SetFromErrno(Type);
47 break;
48 #endif /* !MS_WINDOWS */
49 case MP_MEMORY_ERROR:
50 PyErr_NoMemory();
51 break;
52 case MP_END_OF_FILE:
53 PyErr_SetNone(PyExc_EOFError);
54 break;
55 case MP_EARLY_END_OF_FILE:
56 PyErr_SetString(PyExc_IOError,
57 "got end of file during message");
58 break;
59 case MP_BAD_MESSAGE_LENGTH:
60 PyErr_SetString(PyExc_IOError, "bad message length");
61 break;
62 case MP_EXCEPTION_HAS_BEEN_SET:
63 break;
64 default:
65 PyErr_Format(PyExc_RuntimeError,
66 "unkown error number %d", num);
67 }
68 return NULL;
69 }
70
71
72 /*
73 * Windows only
74 */
75
76 #ifdef MS_WINDOWS
77
78 /* On Windows we set an event to signal Ctrl-C; compare with timemodule.c */
79
80 HANDLE sigint_event = NULL;
81
82 static BOOL WINAPI
83 ProcessingCtrlHandler(DWORD dwCtrlType)
84 {
85 SetEvent(sigint_event);
86 return FALSE;
87 }
88
89 /*
90 * Unix only
91 */
92
93 #else /* !MS_WINDOWS */
94
95 #if HAVE_FD_TRANSFER
96
97 /* Functions for transferring file descriptors between processes.
98 Reimplements some of the functionality of the fdcred
99 module at http://www.mca-ltd.com/resources/fdcred_1.tgz. */
100 /* Based in http://resin.csoft.net/cgi-bin/man.cgi?section=3&topic=CMSG_DATA */
101
102 static PyObject *
103 multiprocessing_sendfd(PyObject *self, PyObject *args)
104 {
105 int conn, fd, res;
106 struct iovec dummy_iov;
107 char dummy_char;
108 struct msghdr msg;
109 struct cmsghdr *cmsg;
110 union {
111 struct cmsghdr hdr;
112 unsigned char buf[CMSG_SPACE(sizeof(int))];
113 } cmsgbuf;
114
115 if (!PyArg_ParseTuple(args, "ii", &conn, &fd))
116 return NULL;
117
118 dummy_iov.iov_base = &dummy_char;
119 dummy_iov.iov_len = 1;
120
121 memset(&msg, 0, sizeof(msg));
122 msg.msg_control = &cmsgbuf.buf;
123 msg.msg_controllen = sizeof(cmsgbuf.buf);
124 msg.msg_iov = &dummy_iov;
125 msg.msg_iovlen = 1;
126
127 cmsg = CMSG_FIRSTHDR(&msg);
128 cmsg->cmsg_len = CMSG_LEN(sizeof(int));
129 cmsg->cmsg_level = SOL_SOCKET;
130 cmsg->cmsg_type = SCM_RIGHTS;
131 * (int *) CMSG_DATA(cmsg) = fd;
132
133 Py_BEGIN_ALLOW_THREADS
134 res = sendmsg(conn, &msg, 0);
135 Py_END_ALLOW_THREADS
136
137 if (res < 0)
138 return PyErr_SetFromErrno(PyExc_OSError);
139 Py_RETURN_NONE;
140 }
141
142 static PyObject *
143 multiprocessing_recvfd(PyObject *self, PyObject *args)
144 {
145 int conn, fd, res;
146 char dummy_char;
147 struct iovec dummy_iov;
148 struct msghdr msg = {0};
149 struct cmsghdr *cmsg;
150 union {
151 struct cmsghdr hdr;
152 unsigned char buf[CMSG_SPACE(sizeof(int))];
153 } cmsgbuf;
154
155 if (!PyArg_ParseTuple(args, "i", &conn))
156 return NULL;
157
158 dummy_iov.iov_base = &dummy_char;
159 dummy_iov.iov_len = 1;
160
161 memset(&msg, 0, sizeof(msg));
162 msg.msg_control = &cmsgbuf.buf;
163 msg.msg_controllen = sizeof(cmsgbuf.buf);
164 msg.msg_iov = &dummy_iov;
165 msg.msg_iovlen = 1;
166
167 cmsg = CMSG_FIRSTHDR(&msg);
168 cmsg->cmsg_level = SOL_SOCKET;
169 cmsg->cmsg_type = SCM_RIGHTS;
170 cmsg->cmsg_len = CMSG_LEN(sizeof(int));
171 msg.msg_controllen = cmsg->cmsg_len;
172
173 Py_BEGIN_ALLOW_THREADS
174 res = recvmsg(conn, &msg, 0);
175 Py_END_ALLOW_THREADS
176
177 if (res < 0)
178 return PyErr_SetFromErrno(PyExc_OSError);
179
180 if (msg.msg_controllen < CMSG_LEN(sizeof(int)) ||
181 (cmsg = CMSG_FIRSTHDR(&msg)) == NULL ||
182 cmsg->cmsg_level != SOL_SOCKET ||
183 cmsg->cmsg_type != SCM_RIGHTS ||
184 cmsg->cmsg_len < CMSG_LEN(sizeof(int))) {
185 /* If at least one control message is present, there should be
186 no room for any further data in the buffer. */
187 PyErr_SetString(PyExc_RuntimeError, "No file descriptor received");
188 return NULL;
189 }
190
191 fd = * (int *) CMSG_DATA(cmsg);
192 return Py_BuildValue("i", fd);
193 }
194
195 #endif /* HAVE_FD_TRANSFER */
196
197 #endif /* !MS_WINDOWS */
198
199
200 /*
201 * All platforms
202 */
203
204 static PyObject*
205 multiprocessing_address_of_buffer(PyObject *self, PyObject *obj)
206 {
207 void *buffer;
208 Py_ssize_t buffer_len;
209
210 if (PyObject_AsWriteBuffer(obj, &buffer, &buffer_len) < 0)
211 return NULL;
212
213 return Py_BuildValue("N" F_PY_SSIZE_T,
214 PyLong_FromVoidPtr(buffer), buffer_len);
215 }
216
217
218 /*
219 * Function table
220 */
221
222 static PyMethodDef module_methods[] = {
223 {"address_of_buffer", multiprocessing_address_of_buffer, METH_O,
224 "address_of_buffer(obj) -> int\n"
225 "Return address of obj assuming obj supports buffer inteface"},
226 #if HAVE_FD_TRANSFER
227 {"sendfd", multiprocessing_sendfd, METH_VARARGS,
228 "sendfd(sockfd, fd) -> None\n"
229 "Send file descriptor given by fd over the unix domain socket\n"
230 "whose file decriptor is sockfd"},
231 {"recvfd", multiprocessing_recvfd, METH_VARARGS,
232 "recvfd(sockfd) -> fd\n"
233 "Receive a file descriptor over a unix domain socket\n"
234 "whose file decriptor is sockfd"},
235 #endif
236 {NULL}
237 };
238
239
240 /*
241 * Initialize
242 */
243
244 PyMODINIT_FUNC
245 init_multiprocessing(void)
246 {
247 PyObject *module, *temp, *value;
248
249 /* Initialize module */
250 module = Py_InitModule("_multiprocessing", module_methods);
251 if (!module)
252 return;
253
254 /* Get copy of objects from pickle */
255 temp = PyImport_ImportModule(PICKLE_MODULE);
256 if (!temp)
257 return;
258 pickle_dumps = PyObject_GetAttrString(temp, "dumps");
259 pickle_loads = PyObject_GetAttrString(temp, "loads");
260 pickle_protocol = PyObject_GetAttrString(temp, "HIGHEST_PROTOCOL");
261 Py_XDECREF(temp);
262
263 /* Get copy of BufferTooShort */
264 temp = PyImport_ImportModule("multiprocessing");
265 if (!temp)
266 return;
267 BufferTooShort = PyObject_GetAttrString(temp, "BufferTooShort");
268 Py_XDECREF(temp);
269
270 /* Add connection type to module */
271 if (PyType_Ready(&ConnectionType) < 0)
272 return;
273 Py_INCREF(&ConnectionType);
274 PyModule_AddObject(module, "Connection", (PyObject*)&ConnectionType);
275
276 #if defined(MS_WINDOWS) || \
277 (defined(HAVE_SEM_OPEN) && !defined(POSIX_SEMAPHORES_NOT_ENABLED))
278 /* Add SemLock type to module */
279 if (PyType_Ready(&SemLockType) < 0)
280 return;
281 Py_INCREF(&SemLockType);
282 {
283 PyObject *py_sem_value_max;
284 /* Some systems define SEM_VALUE_MAX as an unsigned value that
285 * causes it to be negative when used as an int (NetBSD). */
286 if ((int)(SEM_VALUE_MAX) < 0)
287 py_sem_value_max = PyLong_FromLong(INT_MAX);
288 else
289 py_sem_value_max = PyLong_FromLong(SEM_VALUE_MAX);
290 if (py_sem_value_max == NULL)
291 return;
292 PyDict_SetItemString(SemLockType.tp_dict, "SEM_VALUE_MAX",
293 py_sem_value_max);
294 }
295 PyModule_AddObject(module, "SemLock", (PyObject*)&SemLockType);
296 #endif
297
298 #ifdef MS_WINDOWS
299 /* Add PipeConnection to module */
300 if (PyType_Ready(&PipeConnectionType) < 0)
301 return;
302 Py_INCREF(&PipeConnectionType);
303 PyModule_AddObject(module, "PipeConnection",
304 (PyObject*)&PipeConnectionType);
305
306 /* Initialize win32 class and add to multiprocessing */
307 temp = create_win32_namespace();
308 if (!temp)
309 return;
310 PyModule_AddObject(module, "win32", temp);
311
312 /* Initialize the event handle used to signal Ctrl-C */
313 sigint_event = CreateEvent(NULL, TRUE, FALSE, NULL);
314 if (!sigint_event) {
315 PyErr_SetFromWindowsErr(0);
316 return;
317 }
318 if (!SetConsoleCtrlHandler(ProcessingCtrlHandler, TRUE)) {
319 PyErr_SetFromWindowsErr(0);
320 return;
321 }
322 #endif
323
324 /* Add configuration macros */
325 temp = PyDict_New();
326 if (!temp)
327 return;
328 #define ADD_FLAG(name) \
329 value = Py_BuildValue("i", name); \
330 if (value == NULL) { Py_DECREF(temp); return; } \
331 if (PyDict_SetItemString(temp, #name, value) < 0) { \
332 Py_DECREF(temp); Py_DECREF(value); return; } \
333 Py_DECREF(value)
334
335 #if defined(HAVE_SEM_OPEN) && !defined(POSIX_SEMAPHORES_NOT_ENABLED)
336 ADD_FLAG(HAVE_SEM_OPEN);
337 #endif
338 #ifdef HAVE_SEM_TIMEDWAIT
339 ADD_FLAG(HAVE_SEM_TIMEDWAIT);
340 #endif
341 #ifdef HAVE_FD_TRANSFER
342 ADD_FLAG(HAVE_FD_TRANSFER);
343 #endif
344 #ifdef HAVE_BROKEN_SEM_GETVALUE
345 ADD_FLAG(HAVE_BROKEN_SEM_GETVALUE);
346 #endif
347 #ifdef HAVE_BROKEN_SEM_UNLINK
348 ADD_FLAG(HAVE_BROKEN_SEM_UNLINK);
349 #endif
350 if (PyModule_AddObject(module, "flags", temp) < 0)
351 return;
352 }