Modules/dlmodule.c

   1
   2 /* dl module */
   3
   4 #include "Python.h"
   5
   6 #include <dlfcn.h>
   7
   8 #ifdef __VMS
   9 #include <unistd.h>
  10 #endif
  11
  12 #ifndef RTLD_LAZY
  13 #define RTLD_LAZY 1
  14 #endif
  15
  16 typedef void *PyUnivPtr;
  17 typedef struct {
  18         PyObject_HEAD
  19         PyUnivPtr *dl_handle;
  20 } dlobject;
  21
  22 static PyTypeObject Dltype;
  23
  24 static PyObject *Dlerror;
  25
  26 static PyObject *
  27 newdlobject(PyUnivPtr *handle)
  28 {
  29         dlobject *xp;
  30         xp = PyObject_New(dlobject, &Dltype);
  31         if (xp == NULL)
  32                 return NULL;
  33         xp->dl_handle = handle;
  34         return (PyObject *)xp;
  35 }
  36
  37 static void
  38 dl_dealloc(dlobject *xp)
  39 {
  40         if (xp->dl_handle != NULL)
  41                 dlclose(xp->dl_handle);
  42         PyObject_Del(xp);
  43 }
  44
  45 static PyObject *
  46 dl_close(dlobject *xp)
  47 {
  48         if (xp->dl_handle != NULL) {
  49                 dlclose(xp->dl_handle);
  50                 xp->dl_handle = NULL;
  51         }
  52         Py_INCREF(Py_None);
  53         return Py_None;
  54 }
  55
  56 static PyObject *
  57 dl_sym(dlobject *xp, PyObject *args)
  58 {
  59         char *name;
  60         PyUnivPtr *func;
  61         if (PyString_Check(args)) {
  62                 name = PyString_AS_STRING(args);
  63         } else {
  64                 PyErr_Format(PyExc_TypeError, "expected string, found %.200s",
  65                              Py_TYPE(args)->tp_name);
  66                 return NULL;
  67         }
  68         func = dlsym(xp->dl_handle, name);
  69         if (func == NULL) {
  70                 Py_INCREF(Py_None);
  71                 return Py_None;
  72         }
  73         return PyInt_FromLong((long)func);
  74 }
  75
  76 static PyObject *
  77 dl_call(dlobject *xp, PyObject *args)
  78 {
  79         PyObject *name;
  80         long (*func)(long, long, long, long, long,
  81                      long, long, long, long, long);
  82         long alist[10];
  83         long res;
  84         Py_ssize_t i;
  85         Py_ssize_t n = PyTuple_Size(args);
  86         if (n < 1) {
  87                 PyErr_SetString(PyExc_TypeError, "at least a name is needed");
  88                 return NULL;
  89         }
  90         name = PyTuple_GetItem(args, 0);
  91         if (!PyString_Check(name)) {
  92                 PyErr_SetString(PyExc_TypeError,
  93                                 "function name must be a string");
  94                 return NULL;
  95         }
  96         func = (long (*)(long, long, long, long, long,
  97                          long, long, long, long, long))
  98           dlsym(xp->dl_handle, PyString_AsString(name));
  99         if (func == NULL) {
 100                 PyErr_SetString(PyExc_ValueError, dlerror());
 101                 return NULL;
 102         }
 103         if (n-1 > 10) {
 104                 PyErr_SetString(PyExc_TypeError,
 105                                 "too many arguments (max 10)");
 106                 return NULL;
 107         }
 108         for (i = 1; i < n; i++) {
 109                 PyObject *v = PyTuple_GetItem(args, i);
 110                 if (PyInt_Check(v))
 111                         alist[i-1] = PyInt_AsLong(v);
 112                 else if (PyString_Check(v))
 113                         alist[i-1] = (long)PyString_AsString(v);
 114                 else if (v == Py_None)
 115                         alist[i-1] = (long) ((char *)NULL);
 116                 else {
 117                         PyErr_SetString(PyExc_TypeError,
 118                                    "arguments must be int, string or None");
 119                         return NULL;
 120                 }
 121         }
 122         for (; i <= 10; i++)
 123                 alist[i-1] = 0;
 124         res = (*func)(alist[0], alist[1], alist[2], alist[3], alist[4],
 125                       alist[5], alist[6], alist[7], alist[8], alist[9]);
 126         return PyInt_FromLong(res);
 127 }
 128
 129 static PyMethodDef dlobject_methods[] = {
 130         {"call",        (PyCFunction)dl_call, METH_VARARGS},
 131         {"sym",         (PyCFunction)dl_sym, METH_O},
 132         {"close",       (PyCFunction)dl_close, METH_NOARGS},
 133         {NULL,          NULL}                    /* Sentinel */
 134 };
 135
 136 static PyObject *
 137 dl_getattr(dlobject *xp, char *name)
 138 {
 139         return Py_FindMethod(dlobject_methods, (PyObject *)xp, name);
 140 }
 141
 142
 143 static PyTypeObject Dltype = {
 144         PyVarObject_HEAD_INIT(NULL, 0)
 145         "dl.dl",                /*tp_name*/
 146         sizeof(dlobject),       /*tp_basicsize*/
 147         0,                      /*tp_itemsize*/
 148         /* methods */
 149         (destructor)dl_dealloc, /*tp_dealloc*/
 150         0,                      /*tp_print*/
 151         (getattrfunc)dl_getattr,/*tp_getattr*/
 152         0,                      /*tp_setattr*/
 153         0,                      /*tp_compare*/
 154         0,                      /*tp_repr*/
 155         0,                      /*tp_as_number*/
 156         0,                      /*tp_as_sequence*/
 157         0,                      /*tp_as_mapping*/
 158         0,                      /*tp_hash*/
 159 };
 160
 161 static PyObject *
 162 dl_open(PyObject *self, PyObject *args)
 163 {
 164         char *name;
 165         int mode;
 166         PyUnivPtr *handle;
 167         if (sizeof(int) != sizeof(long) ||
 168             sizeof(long) != sizeof(char *)) {
 169                 PyErr_SetString(PyExc_SystemError,
 170  "module dl requires sizeof(int) == sizeof(long) == sizeof(char*)");
 171                 return NULL;
 172         }
 173
 174         if (PyArg_ParseTuple(args, "z:open", &name))
 175                 mode = RTLD_LAZY;
 176         else {
 177                 PyErr_Clear();
 178                 if (!PyArg_ParseTuple(args, "zi:open", &name, &mode))
 179                         return NULL;
 180 #ifndef RTLD_NOW
 181                 if (mode != RTLD_LAZY) {
 182                         PyErr_SetString(PyExc_ValueError, "mode must be 1");
 183                         return NULL;
 184                 }
 185 #endif
 186         }
 187         handle = dlopen(name, mode);
 188         if (handle == NULL) {
 189                 PyErr_SetString(Dlerror, dlerror());
 190                 return NULL;
 191         }
 192 #ifdef __VMS
 193         /*   Under OpenVMS dlopen doesn't do any check, just save the name
 194          * for later use, so we have to check if the file is readable,
 195          * the name can be a logical or a file from SYS$SHARE.
 196          */
 197         if (access(name, R_OK)) {
 198                 char fname[strlen(name) + 20];
 199                 strcpy(fname, "SYS$SHARE:");
 200                 strcat(fname, name);
 201                 strcat(fname, ".EXE");
 202                 if (access(fname, R_OK)) {
 203                         dlclose(handle);
 204                         PyErr_SetString(Dlerror,
 205                                 "File not found or protection violation");
 206                         return NULL;
 207                 }
 208         }
 209 #endif
 210         return newdlobject(handle);
 211 }
 212
 213 static PyMethodDef dl_methods[] = {
 214         {"open",        dl_open, METH_VARARGS},
 215         {NULL,          NULL}           /* sentinel */
 216 };
 217
 218 /* From socketmodule.c
 219  * Convenience routine to export an integer value.
 220  *
 221  * Errors are silently ignored, for better or for worse...
 222  */
 223 static void
 224 insint(PyObject *d, char *name, int value)
 225 {
 226         PyObject *v = PyInt_FromLong((long) value);
 227         if (!v || PyDict_SetItemString(d, name, v))
 228                 PyErr_Clear();
 229
 230         Py_XDECREF(v);
 231 }
 232
 233 PyMODINIT_FUNC
 234 initdl(void)
 235 {
 236         PyObject *m, *d, *x;
 237
 238         /* Initialize object type */
 239         Py_TYPE(&Dltype) = &PyType_Type;
 240
 241         /* Create the module and add the functions */
 242         m = Py_InitModule("dl", dl_methods);
 243         if (m == NULL)
 244                 return;
 245
 246         /* Add some symbolic constants to the module */
 247         d = PyModule_GetDict(m);
 248         Dlerror = x = PyErr_NewException("dl.error", NULL, NULL);
 249         PyDict_SetItemString(d, "error", x);
 250         x = PyInt_FromLong((long)RTLD_LAZY);
 251         PyDict_SetItemString(d, "RTLD_LAZY", x);
 252 #define INSINT(X)    insint(d,#X,X)
 253 #ifdef RTLD_NOW
 254         INSINT(RTLD_NOW);
 255 #endif
 256 #ifdef RTLD_NOLOAD
 257         INSINT(RTLD_NOLOAD);
 258 #endif
 259 #ifdef RTLD_GLOBAL
 260         INSINT(RTLD_GLOBAL);
 261 #endif
 262 #ifdef RTLD_LOCAL
 263         INSINT(RTLD_LOCAL);
 264 #endif
 265 #ifdef RTLD_PARENT
 266         INSINT(RTLD_PARENT);
 267 #endif
 268 #ifdef RTLD_GROUP
 269         INSINT(RTLD_GROUP);
 270 #endif
 271 #ifdef RTLD_WORLD
 272         INSINT(RTLD_WORLD);
 273 #endif
 274 #ifdef RTLD_NODELETE
 275         INSINT(RTLD_NODELETE);
 276 #endif
 277 }