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                              args->ob_type->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         PyObject_HEAD_INIT(NULL)
 145         0,                      /*ob_size*/
 146         "dl.dl",                /*tp_name*/
 147         sizeof(dlobject),       /*tp_basicsize*/
 148         0,                      /*tp_itemsize*/
 149         /* methods */
 150         (destructor)dl_dealloc, /*tp_dealloc*/
 151         0,                      /*tp_print*/
 152         (getattrfunc)dl_getattr,/*tp_getattr*/
 153         0,                      /*tp_setattr*/
 154         0,                      /*tp_compare*/
 155         0,                      /*tp_repr*/
 156         0,                      /*tp_as_number*/
 157         0,                      /*tp_as_sequence*/
 158         0,                      /*tp_as_mapping*/
 159         0,                      /*tp_hash*/
 160 };
 161
 162 static PyObject *
 163 dl_open(PyObject *self, PyObject *args)
 164 {
 165         char *name;
 166         int mode;
 167         PyUnivPtr *handle;
 168         if (sizeof(int) != sizeof(long) ||
 169             sizeof(long) != sizeof(char *)) {
 170                 PyErr_SetString(PyExc_SystemError,
 171  "module dl requires sizeof(int) == sizeof(long) == sizeof(char*)");
 172                 return NULL;
 173         }
 174
 175         if (PyArg_ParseTuple(args, "z:open", &name))
 176                 mode = RTLD_LAZY;
 177         else {
 178                 PyErr_Clear();
 179                 if (!PyArg_ParseTuple(args, "zi:open", &name, &mode))
 180                         return NULL;
 181 #ifndef RTLD_NOW
 182                 if (mode != RTLD_LAZY) {
 183                         PyErr_SetString(PyExc_ValueError, "mode must be 1");
 184                         return NULL;
 185                 }
 186 #endif
 187         }
 188         handle = dlopen(name, mode);
 189         if (handle == NULL) {
 190                 PyErr_SetString(Dlerror, dlerror());
 191                 return NULL;
 192         }
 193 #ifdef __VMS
 194         /*   Under OpenVMS dlopen doesn't do any check, just save the name
 195          * for later use, so we have to check if the file is readable,
 196          * the name can be a logical or a file from SYS$SHARE.
 197          */
 198         if (access(name, R_OK)) {
 199                 char fname[strlen(name) + 20];
 200                 strcpy(fname, "SYS$SHARE:");
 201                 strcat(fname, name);
 202                 strcat(fname, ".EXE");
 203                 if (access(fname, R_OK)) {
 204                         dlclose(handle);
 205                         PyErr_SetString(Dlerror,
 206                                 "File not found or protection violation");
 207                         return NULL;
 208                 }
 209         }
 210 #endif
 211         return newdlobject(handle);
 212 }
 213
 214 static PyMethodDef dl_methods[] = {
 215         {"open",        dl_open, METH_VARARGS},
 216         {NULL,          NULL}           /* sentinel */
 217 };
 218
 219 /* From socketmodule.c
 220  * Convenience routine to export an integer value.
 221  *
 222  * Errors are silently ignored, for better or for worse...
 223  */
 224 static void
 225 insint(PyObject *d, char *name, int value)
 226 {
 227         PyObject *v = PyInt_FromLong((long) value);
 228         if (!v || PyDict_SetItemString(d, name, v))
 229                 PyErr_Clear();
 230
 231         Py_XDECREF(v);
 232 }
 233
 234 PyMODINIT_FUNC
 235 initdl(void)
 236 {
 237         PyObject *m, *d, *x;
 238
 239         /* Initialize object type */
 240         Dltype.ob_type = &PyType_Type;
 241
 242         /* Create the module and add the functions */
 243         m = Py_InitModule("dl", dl_methods);
 244         if (m == NULL)
 245                 return;
 246
 247         /* Add some symbolic constants to the module */
 248         d = PyModule_GetDict(m);
 249         Dlerror = x = PyErr_NewException("dl.error", NULL, NULL);
 250         PyDict_SetItemString(d, "error", x);
 251         x = PyInt_FromLong((long)RTLD_LAZY);
 252         PyDict_SetItemString(d, "RTLD_LAZY", x);
 253 #define INSINT(X)    insint(d,#X,X)
 254 #ifdef RTLD_NOW
 255         INSINT(RTLD_NOW);
 256 #endif
 257 #ifdef RTLD_NOLOAD
 258         INSINT(RTLD_NOLOAD);
 259 #endif
 260 #ifdef RTLD_GLOBAL
 261         INSINT(RTLD_GLOBAL);
 262 #endif
 263 #ifdef RTLD_LOCAL
 264         INSINT(RTLD_LOCAL);
 265 #endif
 266 #ifdef RTLD_PARENT
 267         INSINT(RTLD_PARENT);
 268 #endif
 269 #ifdef RTLD_GROUP
 270         INSINT(RTLD_GROUP);
 271 #endif
 272 #ifdef RTLD_WORLD
 273         INSINT(RTLD_WORLD);
 274 #endif
 275 #ifdef RTLD_NODELETE
 276         INSINT(RTLD_NODELETE);
 277 #endif
 278 }