diff options
Diffstat (limited to 'sysv_ipc_module.c')
| -rw-r--r-- | sysv_ipc_module.c | 876 |
1 files changed, 876 insertions, 0 deletions
diff --git a/sysv_ipc_module.c b/sysv_ipc_module.c new file mode 100644 index 0000000..fd0dfdf --- /dev/null +++ b/sysv_ipc_module.c @@ -0,0 +1,876 @@ +/* +sysv_ipc - A Python module for accessing System V semaphores, shared memory + and message queues. + +Copyright (c) 2008, Philip Semanchuk +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + * Neither the name of sysv_ipc nor the + names of its contributors may be used to endorse or promote products + derived from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY Philip Semanchuk ''AS IS'' AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL Philip Semanchuk BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +*/ +#include "Python.h" +#include "structmember.h" + +// For memset +#include <string.h> + +// For srand +#include <stdlib.h> +#include <time.h> + +// For the math surrounding timeouts for semtimedop() +#include <math.h> + +#include "common.h" +#include "semaphore.h" +#include "memory.h" +#include "mq.h" + +PyObject *pBaseException; +PyObject *pInternalException; +PyObject *pPermissionsException; +PyObject *pExistentialException; +PyObject *pBusyException; +PyObject *pNotAttachedException; + +// sysv_ipc_attach() needs this forward declaration of SharedMemoryType +static PyTypeObject SharedMemoryType; + +/* + + Module methods + +*/ + + +static PyObject * +sysv_ipc_attach(PyObject *self, PyObject *args, PyObject *keywords) { + // Given the id of an extant shared memory segment and (optionally) an + // address and shmat flags, attempts to attach the memory. If successful, + // returns a new SharedMemory object with the key permanently set to -1. + SharedMemory *shm = NULL; + PyObject *py_address = NULL; + int id = -1; + void *address = NULL; + int flags = 0; + char *keyword_list[ ] = {"id", "address", "flags", NULL}; + + if (!PyArg_ParseTupleAndKeywords(args, keywords, "i|Oi", keyword_list, + &id, &py_address, &flags)) + goto error_return; + + if ((!py_address) || (py_address == Py_None)) + address = NULL; + else { + if (PyLong_Check(py_address)) + address = PyLong_AsVoidPtr(py_address); + else { + PyErr_SetString(PyExc_TypeError, "address must be a long"); + goto error_return; + } + } + + DPRINTF("About to create a new SharedMemory object.\n"); + + /* Create a new SharedMemory object. Some tutorials recommend using + PyObject_CallObject() to create this, but that invokes the __init__ method + which I don't want to do. + */ + shm = (SharedMemory *)PyObject_New(SharedMemory, &SharedMemoryType); + shm->id = id; + shm->address = address; + + DPRINTF("About to call shm_attach()\n"); + if (Py_None == shm_attach(shm, flags)) + // All is well + return (PyObject *)shm; + else + // abandon this object and fall through to the error return below. + Py_DECREF(shm); + + error_return: + return NULL; +} + + +static PyObject * +sysv_ipc_ftok(PyObject *self, PyObject *args, PyObject *keywords) { + char *path; + int id = 0; + int silence_warning = 0; + char *keyword_list[ ] = {"path", "id", "silence_warning", NULL}; + + key_t rc = 0; + + if (!PyArg_ParseTupleAndKeywords(args, keywords, "si|i", keyword_list, + &path, &id, &silence_warning)) + goto error_return; + + if (!silence_warning) { + DPRINTF("path=%s, id=%d, rc=%ld\n", path, id, rc); + PyErr_WarnEx(PyExc_Warning, + "Use of ftok() is not recommended; see sysv_ipc documentation", 1); + } + + rc = ftok(path, id); + + DPRINTF("path=%s, id=%d, rc=%ld\n", path, id, rc); + + return Py_BuildValue("i", rc); + + error_return: + return NULL; +} + + +static PyObject * +sysv_ipc_remove_semaphore(PyObject *self, PyObject *args) { + int id; + + if (!PyArg_ParseTuple(args, "i", &id)) + goto error_return; + + DPRINTF("removing sem with id %d\n", id); + if (NULL == sem_remove(id)) + goto error_return; + + Py_RETURN_NONE; + + error_return: + return NULL; +} + + +static PyObject * +sysv_ipc_remove_shared_memory(PyObject *self, PyObject *args) { + int id; + + if (!PyArg_ParseTuple(args, "i", &id)) + goto error_return; + + return shm_remove(id); + + error_return: + return NULL; +} + + +static PyObject * +sysv_ipc_remove_message_queue(PyObject *self, PyObject *args) { + int id; + + if (!PyArg_ParseTuple(args, "i", &id)) + goto error_return; + + return mq_remove(id); + + error_return: + return NULL; +} + + +static PyMemberDef Semaphore_members[] = { + {"id", T_INT, offsetof(Semaphore, id), READONLY, "The id assigned by the system"}, + {NULL} /* Sentinel */ +}; + + +static PyMethodDef Semaphore_methods[] = { + { "__enter__", + (PyCFunction)Semaphore_enter, + METH_NOARGS, + }, + { "__exit__", + (PyCFunction)Semaphore_exit, + METH_VARARGS, + }, + { "P", + (PyCFunction)Semaphore_P, + METH_VARARGS | METH_KEYWORDS, + "Acquire (decrement) the semaphore, waiting if necessary" + }, + { "acquire", + (PyCFunction)Semaphore_acquire, + METH_VARARGS | METH_KEYWORDS, + "Acquire (decrement) the semaphore, waiting if necessary" + }, + { "V", + (PyCFunction)Semaphore_V, + METH_VARARGS | METH_KEYWORDS, + "Release (increment) the semaphore" + }, + { "release", + (PyCFunction)Semaphore_release, + METH_VARARGS | METH_KEYWORDS, + "Release (increment) the semaphore" + }, + { "Z", + (PyCFunction)Semaphore_Z, + METH_VARARGS | METH_KEYWORDS, + "Waits until zee zemaphore is zero" + }, + { "remove", + (PyCFunction)Semaphore_remove, + METH_NOARGS, + "Removes (deletes) the semaphore from the system" + }, + {NULL, NULL, 0, NULL} /* Sentinel */ +}; + + + +static PyGetSetDef Semaphore_gets_and_sets[] = { + { "key", + (getter)sem_get_key, + (setter)NULL, + "The key passed to the constructor", + NULL + }, + { "value", + (getter)sem_get_value, + (setter)sem_set_value, + "The semaphore's current value", + NULL + }, + { "undo", + (getter)sem_get_undo, + (setter)sem_set_undo, + "When True, acquire/release operations will be undone when the process exits. Non-portable.", + NULL + }, + { "block", + (getter)sem_get_block, + (setter)sem_set_block, + "When True (the default), calls to acquire/release/P/V/Z will wait (block) if the semaphore is busy", + NULL + }, + { "mode", + (getter)sem_get_mode, + (setter)sem_set_mode, + "Permissions", + NULL + }, + { "uid", + (getter)sem_get_uid, + (setter)sem_set_uid, + "The semaphore's UID", + NULL + }, + { "gid", + (getter)sem_get_gid, + (setter)sem_set_gid, + "The semaphore's GID", + NULL + }, + { "cuid", + (getter)sem_get_c_uid, + (setter)NULL, + "The semaphore creator's UID. Read only.", + NULL + }, + { "cgid", + (getter)sem_get_c_gid, + (setter)NULL, + "The semaphore creator's GID. Read only.", + NULL + }, + { "last_pid", + (getter)sem_get_last_pid, + (setter)NULL, + "The id of the last process to call acquire()/release()/Z() on this semaphore. Read only.", + NULL + }, + { "waiting_for_nonzero", + (getter)sem_get_waiting_for_nonzero, + (setter)NULL, + "The number of processes waiting for the semaphore to become non-zero. Read only.", + NULL + }, + { "waiting_for_zero", + (getter)sem_get_waiting_for_zero, + (setter)NULL, + "The number of processes waiting for the semaphore to become zero. Read only.", + NULL + }, + { "o_time", + (getter)sem_get_o_time, + (setter)NULL, + "The last time semop (acquire/release/P/V/Z) was called on this semaphore. Initialized to zero. Read only.", + NULL + }, + {NULL} /* Sentinel */ +}; + + + + +static PyTypeObject SemaphoreType = { + PyVarObject_HEAD_INIT(NULL, 0) + "sysv_ipc.Semaphore", // tp_name + sizeof(Semaphore), // tp_basicsize + 0, // tp_itemsize + (destructor)Semaphore_dealloc, // tp_dealloc + 0, // tp_print + 0, // tp_getattr + 0, // tp_setattr + 0, // tp_compare + (reprfunc)sem_repr, // tp_repr + 0, // tp_as_number + 0, // tp_as_sequence + 0, // tp_as_mapping + 0, // tp_hash + 0, // tp_call + (reprfunc)sem_str, // tp_str + 0, // tp_getattro + 0, // tp_setattro + 0, // tp_as_buffer + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, // tp_flags + "System V semaphore object", // tp_doc + 0, // tp_traverse + 0, // tp_clear + 0, // tp_richcompare + 0, // tp_weaklistoffset + 0, // tp_iter + 0, // tp_iternext + Semaphore_methods, // tp_methods + Semaphore_members, // tp_members + Semaphore_gets_and_sets, // tp_getset + 0, // tp_base + 0, // tp_dict + 0, // tp_descr_get + 0, // tp_descr_set + 0, // tp_dictoffset + (initproc)Semaphore_init, // tp_init + 0, // tp_alloc + Semaphore_new, // tp_new +}; + + + +static PyMemberDef SharedMemory_members[] = { + {"id", T_INT, offsetof(SharedMemory, id), READONLY, "The id assigned by the system"}, + {NULL} /* Sentinel */ +}; + + +static PyMethodDef SharedMemory_methods[] = { + { "read", + (PyCFunction)SharedMemory_read, + METH_VARARGS | METH_KEYWORDS, + "Read n bytes from the shared memory at the given offset into a Python string" + }, + { "write", + (PyCFunction)SharedMemory_write, + METH_VARARGS | METH_KEYWORDS, + "Write the string to the shared memory at the offset given" + }, + { "remove", + (PyCFunction)SharedMemory_remove, + METH_NOARGS, + "Removes (deletes) the shared memory from the system" + }, + { "attach", + (PyCFunction)SharedMemory_attach, + METH_VARARGS, + "Attaches the shared memory" + }, + { "detach", + (PyCFunction)SharedMemory_detach, + METH_NOARGS, + "Detaches the shared memory" + }, + {NULL, NULL, 0, NULL} /* Sentinel */ +}; + + + +static PyGetSetDef SharedMemory_gets_and_sets[] = { + { "key", + (getter)shm_get_key, + (setter)NULL, + "The key passed to the constructor. Read only.", + NULL + }, + { "size", + (getter)shm_get_size, + (setter)NULL, + "The size of the segment in bytes. Read only.", + NULL + }, + { "address", + (getter)shm_get_address, + (setter)NULL, + "The memory address of the segment. Read only.", + NULL + }, + { "attached", + (getter)shm_get_attached, + (setter)NULL, + "True if the segment is attached. Read only.", + NULL + }, + { "last_attach_time", + (getter)shm_get_last_attach_time, + (setter)NULL, + "The most recent time this segment was attached. Read only.", + NULL + }, + { "last_detach_time", + (getter)shm_get_last_detach_time, + (setter)NULL, + "The most recent time this segment was detached. Read only.", + NULL + }, + { "last_change_time", + (getter)shm_get_last_change_time, + (setter)NULL, + "The time of the most recent change to this segment's uid, gid, mode, or the time the segment was removed. Read only.", + NULL + }, + { "creator_pid", + (getter)shm_get_creator_pid, + (setter)NULL, + "The process id of the creator. Read only.", + NULL + }, + { "last_pid", + (getter)shm_get_last_pid, + (setter)NULL, + "The id of the process that performed the most recent attach or detach. Read only.", + NULL + }, + { "number_attached", + (getter)shm_get_number_attached, + (setter)NULL, + "The current number of attached processes. Read only.", + NULL + }, + { "uid", + (getter)shm_get_uid, + (setter)shm_set_uid, + "The segment's UID.", + NULL + }, + { "gid", + (getter)shm_get_gid, + (setter)shm_set_gid, + "The segment's GID.", + NULL + }, + { "cuid", + (getter)shm_get_cuid, + (setter)NULL, + "The UID of the segment's creator. Read only.", + NULL + }, + { "cgid", + (getter)shm_get_cgid, + (setter)NULL, + "The GID of the segment's creator. Read only.", + NULL + }, + { "mode", + (getter)shm_get_mode, + (setter)shm_set_mode, + "Permissions.", + NULL + }, + {NULL} /* Sentinel */ +}; + + + +static PyTypeObject SharedMemoryType = { + PyVarObject_HEAD_INIT(NULL, 0) + "sysv_ipc.SharedMemory", // tp_name + sizeof(SharedMemory), // tp_basicsize + 0, // tp_itemsize + (destructor)SharedMemory_dealloc, // tp_dealloc + 0, // tp_print + 0, // tp_getattr + 0, // tp_setattr + 0, // tp_compare + (reprfunc)shm_repr, // tp_repr + 0, // tp_as_number + 0, // tp_as_sequence + 0, // tp_as_mapping + 0, // tp_hash + 0, // tp_call + (reprfunc)shm_str, // tp_str + 0, // tp_getattro + 0, // tp_setattro + 0, // tp_as_buffer + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, // tp_flags + "System V shared memory object", // tp_doc + 0, // tp_traverse + 0, // tp_clear + 0, // tp_richcompare + 0, // tp_weaklistoffset + 0, // tp_iter + 0, // tp_iternext + SharedMemory_methods, // tp_methods + SharedMemory_members, // tp_members + SharedMemory_gets_and_sets, // tp_getset + 0, // tp_base + 0, // tp_dict + 0, // tp_descr_get + 0, // tp_descr_set + 0, // tp_dictoffset + (initproc)SharedMemory_init, // tp_init + 0, // tp_alloc + SharedMemory_new, // tp_new +}; + + + + +static PyMemberDef MessageQueue_members[] = { + {"id", T_INT, offsetof(MessageQueue, id), READONLY, "Message queue id"}, + {NULL} /* Sentinel */ +}; + + +static PyMethodDef MessageQueue_methods[] = { + { "send", + (PyCFunction)MessageQueue_send, + METH_VARARGS | METH_KEYWORDS, + "Place a message on the queue" + }, + { "receive", + (PyCFunction)MessageQueue_receive, + METH_VARARGS | METH_KEYWORDS, + "Receive a message from the queue" + }, + { "remove", + (PyCFunction)MessageQueue_remove, + METH_NOARGS, + "Removes (deletes) the queue from the system" + }, + {NULL, NULL, 0, NULL} /* Sentinel */ +}; + + + +static PyGetSetDef MessageQueue_gets_and_sets[] = { + { "key", + (getter)mq_get_key, + (setter)NULL, + "The key passed to the constructor.", + NULL + }, + { "last_send_time", + (getter)mq_get_last_send_time, + (setter)NULL, + "A Unix timestamp representing the last time a message was sent.", + NULL + }, + { "last_receive_time", + (getter)mq_get_last_receive_time, + (setter)NULL, + "A Unix timestamp representing the last time a message was received.", + NULL + }, + { "last_change_time", + (getter)mq_get_last_change_time, + (setter)NULL, + "A Unix timestamp representing the last time the queue was changed.", + NULL + }, + { "current_messages", + (getter)mq_get_current_messages, + (setter)NULL, + "The number of messages currently in the queue", + NULL + }, + { "last_send_pid", + (getter)mq_get_last_send_pid, + (setter)NULL, + "The id of the last process which sent via the queue", + NULL}, + { "last_receive_pid", + (getter)mq_get_last_receive_pid, + (setter)NULL, + "The id of the last process which received from the queue", + NULL + }, + { "max_size", + (getter)mq_get_max_size, + (setter)mq_set_max_size, + "The maximum size of the queue (in bytes). Read-write if you have sufficient privileges.", + NULL + }, + { "mode", + (getter)mq_get_mode, + (setter)mq_set_mode, + "Permissions", + NULL + }, + { "uid", + (getter)mq_get_uid, + (setter)mq_set_uid, + "The queue's UID.", + NULL + }, + { "gid", + (getter)mq_get_gid, + (setter)mq_set_gid, + "The queue's GID.", + NULL + }, + { "cuid", + (getter)mq_get_c_uid, + (setter)NULL, + "The UID of the queue's creator. Read only.", + NULL + }, + { "cgid", + (getter)mq_get_c_gid, + (setter)NULL, + "The GID of the queue's creator. Read only.", + NULL + }, + {NULL} /* Sentinel */ +}; + + +static PyTypeObject MessageQueueType = { + PyVarObject_HEAD_INIT(NULL, 0) + "sysv_ipc.MessageQueue", // tp_name + sizeof(MessageQueue), // tp_basicsize + 0, // tp_itemsize + (destructor)MessageQueue_dealloc, // tp_dealloc + 0, // tp_print + 0, // tp_getattr + 0, // tp_setattr + 0, // tp_compare + (reprfunc)mq_repr, // tp_repr + 0, // tp_as_number + 0, // tp_as_sequence + 0, // tp_as_mapping + 0, // tp_hash + 0, // tp_call + (reprfunc)mq_str, // tp_str + 0, // tp_getattro + 0, // tp_setattro + 0, // tp_as_buffer + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, // tp_flags + "System V message queue object", // tp_doc + 0, // tp_traverse + 0, // tp_clear + 0, // tp_richcompare + 0, // tp_weaklistoffset + 0, // tp_iter + 0, // tp_iternext + MessageQueue_methods, // tp_methods + MessageQueue_members, // tp_members + MessageQueue_gets_and_sets, // tp_getset + 0, // tp_base + 0, // tp_dict + 0, // tp_descr_get + 0, // tp_descr_set + 0, // tp_dictoffset + (initproc)MessageQueue_init, // tp_init + 0, // tp_alloc + MessageQueue_new, // tp_new +}; + + +/* + + Module level stuff + +*/ + +static PyMethodDef module_methods[ ] = { + { "attach", + (PyCFunction)sysv_ipc_attach, + METH_VARARGS | METH_KEYWORDS, + "Attaches the memory identified by the id and returns a new SharedMemory object." + }, + { "ftok", + (PyCFunction)sysv_ipc_ftok, + METH_VARARGS | METH_KEYWORDS, + "Calls ftok(). Not recommended; see sysv_ipc documentation." + }, + { "remove_semaphore", + (PyCFunction)sysv_ipc_remove_semaphore, + METH_VARARGS, + "Remove (delete) the semaphore identified by id" + }, + { "remove_shared_memory", + (PyCFunction)sysv_ipc_remove_shared_memory, + METH_VARARGS, + "Remove shared memory identified by id" + }, + { "remove_message_queue", + (PyCFunction)sysv_ipc_remove_message_queue, + METH_VARARGS, + "Remove the message queue identified by id" + }, + {NULL} /* Sentinel */ +}; + + +#if PY_MAJOR_VERSION > 2 +static struct PyModuleDef this_module = { + PyModuleDef_HEAD_INIT, // m_base + "sysv_ipc", // m_name + "SYSV IPC module", // m_doc + -1, // m_size (space allocated for module globals) + module_methods, // m_methods + NULL, // m_reload + NULL, // m_traverse + NULL, // m_clear + NULL // m_free +}; +#endif + + +/* Module init function */ +#if PY_MAJOR_VERSION > 2 +#define SYSV_IPC_INIT_FUNCTION_NAME PyInit_sysv_ipc +#else +#define SYSV_IPC_INIT_FUNCTION_NAME initsysv_ipc +#endif + + +/* Module init function */ +PyMODINIT_FUNC +SYSV_IPC_INIT_FUNCTION_NAME(void) { + PyObject *module; + PyObject *module_dict; + + // I seed the random number generator in case I'm asked to make some + // random keys. + srand((unsigned int)time(NULL)); + +#if PY_MAJOR_VERSION > 2 + module = PyModule_Create(&this_module); +#else + module = Py_InitModule3("sysv_ipc", module_methods, "System V IPC module"); +#endif + + if (!module) + goto error_return; + + if (PyType_Ready(&SemaphoreType) < 0) + goto error_return; + + if (PyType_Ready(&SharedMemoryType) < 0) + goto error_return; + + if (PyType_Ready(&MessageQueueType) < 0) + goto error_return; + +#ifdef SEMTIMEDOP_EXISTS + Py_INCREF(Py_True); + PyModule_AddObject(module, "SEMAPHORE_TIMEOUT_SUPPORTED", Py_True); +#else + Py_INCREF(Py_False); + PyModule_AddObject(module, "SEMAPHORE_TIMEOUT_SUPPORTED", Py_False); +#endif + + PyModule_AddStringConstant(module, "VERSION", SYSV_IPC_VERSION); + PyModule_AddStringConstant(module, "__version__", SYSV_IPC_VERSION); + PyModule_AddStringConstant(module, "__copyright__", "Copyright 2008 - 2014 Philip Semanchuk"); + PyModule_AddStringConstant(module, "__author__", "Philip Semanchuk"); + PyModule_AddStringConstant(module, "__license__", "BSD"); + + PyModule_AddIntConstant(module, "PAGE_SIZE", PAGE_SIZE); + PyModule_AddIntConstant(module, "KEY_MIN", KEY_MIN); + PyModule_AddIntConstant(module, "KEY_MAX", KEY_MAX); + PyModule_AddIntConstant(module, "SEMAPHORE_VALUE_MAX", SEMAPHORE_VALUE_MAX); + PyModule_AddIntConstant(module, "IPC_CREAT", IPC_CREAT); + PyModule_AddIntConstant(module, "IPC_EXCL", IPC_EXCL); + PyModule_AddIntConstant(module, "IPC_CREX", IPC_CREX); + PyModule_AddIntConstant(module, "IPC_PRIVATE", IPC_PRIVATE); + PyModule_AddIntConstant(module, "SHM_RND", SHM_RND); + PyModule_AddIntConstant(module, "SHM_RDONLY", SHM_RDONLY); + + + // These flags are Linux-specific. +#ifdef SHM_HUGETLB + PyModule_AddIntConstant(module, "SHM_HUGETLB", SHM_HUGETLB); +#endif +#ifdef SHM_NORESERVE + PyModule_AddIntConstant(module, "SHM_NORESERVE", SHM_NORESERVE); +#endif +#ifdef SHM_REMAP + PyModule_AddIntConstant(module, "SHM_REMAP", SHM_REMAP); +#endif + + Py_INCREF(&SemaphoreType); + PyModule_AddObject(module, "Semaphore", (PyObject *)&SemaphoreType); + + Py_INCREF(&SharedMemoryType); + PyModule_AddObject(module, "SharedMemory", (PyObject *)&SharedMemoryType); + + Py_INCREF(&MessageQueueType); + PyModule_AddObject(module, "MessageQueue", (PyObject *)&MessageQueueType); + + // Exceptions + if (!(module_dict = PyModule_GetDict(module))) + goto error_return; + + if (!(pBaseException = PyErr_NewException("sysv_ipc.Error", NULL, NULL))) + goto error_return; + else + PyDict_SetItemString(module_dict, "Error", pBaseException); + + if (!(pInternalException = PyErr_NewException("sysv_ipc.InternalError", NULL, NULL))) + goto error_return; + else + PyDict_SetItemString(module_dict, "InternalError", pInternalException); + + if (!(pPermissionsException = PyErr_NewException("sysv_ipc.PermissionsError", pBaseException, NULL))) + goto error_return; + else + PyDict_SetItemString(module_dict, "PermissionsError", pPermissionsException); + + if (!(pExistentialException = PyErr_NewException("sysv_ipc.ExistentialError", pBaseException, NULL))) + goto error_return; + else + PyDict_SetItemString(module_dict, "ExistentialError", pExistentialException); + + if (!(pBusyException = PyErr_NewException("sysv_ipc.BusyError", pBaseException, NULL))) + goto error_return; + else + PyDict_SetItemString(module_dict, "BusyError", pBusyException); + + if (!(pNotAttachedException = PyErr_NewException("sysv_ipc.NotAttachedError", pBaseException, NULL))) + goto error_return; + else + PyDict_SetItemString(module_dict, "NotAttachedError", pNotAttachedException); + +#if PY_MAJOR_VERSION > 2 + return module; +#endif + + error_return: +#if PY_MAJOR_VERSION > 2 + return NULL; +#else + ; // Nothing to do +#endif +} + |