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                 char *errmsg = dlerror();
 190                 if (!errmsg)
 191                         errmsg = "dlopen() error";
 192                 PyErr_SetString(Dlerror, errmsg);
 193                 return NULL;
 194         }
 195 #ifdef __VMS
 196         /*   Under OpenVMS dlopen doesn't do any check, just save the name
 197          * for later use, so we have to check if the file is readable,
 198          * the name can be a logical or a file from SYS$SHARE.
 199          */
 200         if (access(name, R_OK)) {
 201                 char fname[strlen(name) + 20];
 202                 strcpy(fname, "SYS$SHARE:");
 203                 strcat(fname, name);
 204                 strcat(fname, ".EXE");
 205                 if (access(fname, R_OK)) {
 206                         dlclose(handle);
 207                         PyErr_SetString(Dlerror,
 208                                 "File not found or protection violation");
 209                         return NULL;
 210                 }
 211         }
 212 #endif
 213         return newdlobject(handle);
 214 }
 215
 216 static PyMethodDef dl_methods[] = {
 217         {"open",        dl_open, METH_VARARGS},
 218         {NULL,          NULL}           /* sentinel */
 219 };
 220
 221 /* From socketmodule.c
 222  * Convenience routine to export an integer value.
 223  *
 224  * Errors are silently ignored, for better or for worse...
 225  */
 226 static void
 227 insint(PyObject *d, char *name, int value)
 228 {
 229         PyObject *v = PyInt_FromLong((long) value);
 230         if (!v || PyDict_SetItemString(d, name, v))
 231                 PyErr_Clear();
 232
 233         Py_XDECREF(v);
 234 }
 235
 236 PyMODINIT_FUNC
 237 initdl(void)
 238 {
 239         PyObject *m, *d, *x;
 240
 241     if (PyErr_WarnPy3k("the dl module has been removed in "
 242                         "Python 3.0; use the ctypes module instead", 2) < 0)
 243         return;
 244
 245         /* Initialize object type */
 246         Py_TYPE(&Dltype) = &PyType_Type;
 247
 248         /* Create the module and add the functions */
 249         m = Py_InitModule("dl", dl_methods);
 250         if (m == NULL)
 251                 return;
 252
 253         /* Add some symbolic constants to the module */
 254         d = PyModule_GetDict(m);
 255         Dlerror = x = PyErr_NewException("dl.error", NULL, NULL);
 256         PyDict_SetItemString(d, "error", x);
 257         x = PyInt_FromLong((long)RTLD_LAZY);
 258         PyDict_SetItemString(d, "RTLD_LAZY", x);
 259 #define INSINT(X)    insint(d,#X,X)
 260 #ifdef RTLD_NOW
 261         INSINT(RTLD_NOW);
 262 #endif
 263 #ifdef RTLD_NOLOAD
 264         INSINT(RTLD_NOLOAD);
 265 #endif
 266 #ifdef RTLD_GLOBAL
 267         INSINT(RTLD_GLOBAL);
 268 #endif
 269 #ifdef RTLD_LOCAL
 270         INSINT(RTLD_LOCAL);
 271 #endif
 272 #ifdef RTLD_PARENT
 273         INSINT(RTLD_PARENT);
 274 #endif
 275 #ifdef RTLD_GROUP
 276         INSINT(RTLD_GROUP);
 277 #endif
 278 #ifdef RTLD_WORLD
 279         INSINT(RTLD_WORLD);
 280 #endif
 281 #ifdef RTLD_NODELETE
 282         INSINT(RTLD_NODELETE);
 283 #endif
 284 }