typewrappers.c

   1 /*
   2  * types.c: converter functions between the internal representation
   3  *          and the Python objects
   4  *
   5  * Copyright (C) 2005-2019 Red Hat, Inc.
   6  *
   7  * Daniel Veillard <veillard@redhat.com>
   8  */
   9
  10 /* Horrible kludge to work around even more horrible name-space pollution
  11  * via Python.h.  That file includes /usr/include/python3.x/pyconfig*.h,
  12  * which has over 180 autoconf-style HAVE_* definitions.  Shame on them.  */
  13 #undef HAVE_PTHREAD_H
  14
  15 #include <stdio.h>
  16 #include <string.h>
  17 #include "typewrappers.h"
  18 #include "libvirt-utils.h"
  19
  20 static PyObject *
  21 libvirt_buildPyObject(void *cobj,
  22                       const char *name,
  23                       PyCapsule_Destructor destr)
  24 {
  25     return PyCapsule_New(cobj, name, destr);
  26 }
  27
  28 PyObject *
  29 libvirt_intWrap(int val)
  30 {
  31     return PyLong_FromLong(val);
  32 }
  33
  34 PyObject *
  35 libvirt_uintWrap(unsigned int val)
  36 {
  37     return PyLong_FromUnsignedLong(val);
  38 }
  39
  40 PyObject *
  41 libvirt_longWrap(long val)
  42 {
  43     return PyLong_FromLong(val);
  44 }
  45
  46 PyObject *
  47 libvirt_ulongWrap(unsigned long val)
  48 {
  49     return PyLong_FromLong(val);
  50 }
  51
  52 PyObject *
  53 libvirt_longlongWrap(long long val)
  54 {
  55     return PyLong_FromLongLong(val);
  56 }
  57
  58 PyObject *
  59 libvirt_ulonglongWrap(unsigned long long val)
  60 {
  61     return PyLong_FromUnsignedLongLong(val);
  62 }
  63
  64 PyObject *
  65 libvirt_charPtrSizeWrap(char *str, Py_ssize_t size)
  66 {
  67     if (str == NULL) {
  68         return VIR_PY_NONE;
  69     }
  70     return PyBytes_FromStringAndSize(str, size);
  71 }
  72
  73 PyObject *
  74 libvirt_charPtrWrap(char *str)
  75 {
  76     if (str == NULL) {
  77         return VIR_PY_NONE;
  78     }
  79     return PyUnicode_FromString(str);
  80 }
  81
  82 PyObject *
  83 libvirt_constcharPtrWrap(const char *str)
  84 {
  85     if (str == NULL) {
  86         return VIR_PY_NONE;
  87     }
  88     return PyUnicode_FromString(str);
  89 }
  90
  91 PyObject *
  92 libvirt_boolWrap(int val)
  93 {
  94     if (val)
  95         Py_RETURN_TRUE;
  96     else
  97         Py_RETURN_FALSE;
  98 }
  99
 100 int
 101 libvirt_intUnwrap(PyObject *obj,
 102                   int *val)
 103 {
 104     long long_val;
 105
 106     if (!obj) {
 107         PyErr_SetString(PyExc_TypeError, "unexpected type");
 108         return -1;
 109     }
 110
 111     /* If obj is type of PyInt_Type, PyInt_AsLong converts it
 112      * to C long type directly. If it is of PyLong_Type, PyInt_AsLong
 113      * will call PyLong_AsLong() to deal with it automatically.
 114      */
 115     long_val = PyLong_AsLong(obj);
 116     if ((long_val == -1) && PyErr_Occurred())
 117         return -1;
 118
 119 #if LONG_MAX != INT_MAX
 120     if (long_val >= INT_MIN && long_val <= INT_MAX) {
 121         *val = long_val;
 122     } else {
 123         PyErr_SetString(PyExc_OverflowError,
 124                         "Python int too large to convert to C int");
 125         return -1;
 126     }
 127 #else
 128     *val = long_val;
 129 #endif
 130     return 0;
 131 }
 132
 133 int
 134 libvirt_uintUnwrap(PyObject *obj,
 135                    unsigned int *val)
 136 {
 137     unsigned long long_val;
 138
 139     if (!obj) {
 140         PyErr_SetString(PyExc_TypeError, "unexpected type");
 141         return -1;
 142     }
 143
 144     long_val = PyLong_AsUnsignedLong(obj);
 145     if ((long_val == (unsigned long)-1) && PyErr_Occurred())
 146         return -1;
 147
 148     if (long_val <= UINT_MAX) {
 149         *val = long_val;
 150     } else {
 151         PyErr_SetString(PyExc_OverflowError,
 152                         "Python int too large to convert to C unsigned int");
 153         return -1;
 154     }
 155     return 0;
 156 }
 157
 158 int
 159 libvirt_longUnwrap(PyObject *obj,
 160                    long *val)
 161 {
 162     long long_val;
 163
 164     if (!obj) {
 165         PyErr_SetString(PyExc_TypeError, "unexpected type");
 166         return -1;
 167     }
 168
 169     long_val = PyLong_AsLong(obj);
 170     if ((long_val == -1) && PyErr_Occurred())
 171         return -1;
 172
 173     *val = long_val;
 174     return 0;
 175 }
 176
 177 int
 178 libvirt_ulongUnwrap(PyObject *obj,
 179                     unsigned long *val)
 180 {
 181     long long_val;
 182
 183     if (!obj) {
 184         PyErr_SetString(PyExc_TypeError, "unexpected type");
 185         return -1;
 186     }
 187
 188     long_val = PyLong_AsLong(obj);
 189     if ((long_val == -1) && PyErr_Occurred())
 190         return -1;
 191
 192     if (long_val >= 0) {
 193         *val = long_val;
 194     } else {
 195         PyErr_SetString(PyExc_OverflowError,
 196                         "negative Python int cannot be converted to C unsigned long");
 197         return -1;
 198     }
 199     return 0;
 200 }
 201
 202 int
 203 libvirt_longlongUnwrap(PyObject *obj,
 204                        long long *val)
 205 {
 206     long long llong_val = -1;
 207
 208     if (!obj) {
 209         PyErr_SetString(PyExc_TypeError, "unexpected type");
 210         return -1;
 211     }
 212
 213     if (PyLong_Check(obj))
 214         llong_val = PyLong_AsLongLong(obj);
 215     else
 216         PyErr_SetString(PyExc_TypeError, "an integer is required");
 217
 218     if ((llong_val == -1) && PyErr_Occurred())
 219         return -1;
 220
 221     *val = llong_val;
 222     return 0;
 223 }
 224
 225 int
 226 libvirt_ulonglongUnwrap(PyObject *obj,
 227                         unsigned long long *val)
 228 {
 229     unsigned long long ullong_val = -1;
 230
 231     if (!obj) {
 232         PyErr_SetString(PyExc_TypeError, "unexpected type");
 233         return -1;
 234     }
 235
 236     if (PyLong_Check(obj)) {
 237         ullong_val = PyLong_AsUnsignedLongLong(obj);
 238     } else {
 239         PyErr_SetString(PyExc_TypeError, "an integer is required");
 240     }
 241
 242     if ((ullong_val == (unsigned long long)-1) && PyErr_Occurred())
 243         return -1;
 244
 245     *val = ullong_val;
 246     return 0;
 247 }
 248
 249 int
 250 libvirt_doubleUnwrap(PyObject *obj,
 251                      double *val)
 252 {
 253     double double_val;
 254
 255     if (!obj) {
 256         PyErr_SetString(PyExc_TypeError, "unexpected type");
 257         return -1;
 258     }
 259
 260     double_val = PyFloat_AsDouble(obj);
 261     if ((double_val == -1) && PyErr_Occurred())
 262         return -1;
 263
 264     *val = double_val;
 265     return 0;
 266 }
 267
 268 int
 269 libvirt_boolUnwrap(PyObject *obj,
 270                    bool *val)
 271 {
 272     int ret;
 273
 274     if (!obj) {
 275         PyErr_SetString(PyExc_TypeError, "unexpected type");
 276         return -1;
 277     }
 278
 279     if ((ret = PyObject_IsTrue(obj)) < 0)
 280         return ret;
 281
 282     *val = ret > 0;
 283     return 0;
 284 }
 285
 286 int
 287 libvirt_charPtrUnwrap(PyObject *obj,
 288                       char **str)
 289 {
 290     PyObject *bytes;
 291     const char *ret;
 292     *str = NULL;
 293     if (!obj) {
 294         PyErr_SetString(PyExc_TypeError, "unexpected type");
 295         return -1;
 296     }
 297
 298     if (!(bytes = PyUnicode_AsUTF8String(obj)))
 299         return -1;
 300     ret = PyBytes_AsString(bytes);
 301     if (ret) {
 302         *str = strdup(ret);
 303         if (!*str)
 304             PyErr_NoMemory();
 305     }
 306     Py_DECREF(bytes);
 307     return ret && *str ? 0 : -1;
 308 }
 309
 310 int
 311 libvirt_charPtrSizeUnwrap(PyObject *obj,
 312                           char **str,
 313                           Py_ssize_t *size)
 314 {
 315     *str = NULL;
 316     *size = 0;
 317     if (!obj) {
 318         PyErr_SetString(PyExc_TypeError, "unexpected type");
 319         return -1;
 320     }
 321
 322     return PyBytes_AsStringAndSize(obj, str, size);
 323 }
 324
 325 PyObject *
 326 libvirt_virDomainPtrWrap(virDomainPtr node)
 327 {
 328     PyObject *ret;
 329
 330     if (node == NULL) {
 331         return VIR_PY_NONE;
 332     }
 333
 334     ret = libvirt_buildPyObject(node, "virDomainPtr", NULL);
 335     return ret;
 336 }
 337
 338 PyObject *
 339 libvirt_virNetworkPtrWrap(virNetworkPtr node)
 340 {
 341     PyObject *ret;
 342
 343     if (node == NULL) {
 344         return VIR_PY_NONE;
 345     }
 346
 347     ret = libvirt_buildPyObject(node, "virNetworkPtr", NULL);
 348     return ret;
 349 }
 350
 351 PyObject *
 352 libvirt_virNetworkPortPtrWrap(virNetworkPortPtr node)
 353 {
 354     PyObject *ret;
 355
 356     if (node == NULL) {
 357         return VIR_PY_NONE;
 358     }
 359
 360     ret = libvirt_buildPyObject(node, "virNetworkPortPtr", NULL);
 361     return ret;
 362 }
 363
 364 PyObject *
 365 libvirt_virInterfacePtrWrap(virInterfacePtr node)
 366 {
 367     PyObject *ret;
 368
 369     if (node == NULL) {
 370         return VIR_PY_NONE;
 371     }
 372
 373     ret = libvirt_buildPyObject(node, "virInterfacePtr", NULL);
 374     return ret;
 375 }
 376
 377 PyObject *
 378 libvirt_virStoragePoolPtrWrap(virStoragePoolPtr node)
 379 {
 380     PyObject *ret;
 381
 382     if (node == NULL) {
 383         return VIR_PY_NONE;
 384     }
 385
 386     ret = libvirt_buildPyObject(node, "virStoragePoolPtr", NULL);
 387     return ret;
 388 }
 389
 390 PyObject *
 391 libvirt_virStorageVolPtrWrap(virStorageVolPtr node)
 392 {
 393     PyObject *ret;
 394
 395     if (node == NULL) {
 396         return VIR_PY_NONE;
 397     }
 398
 399     ret = libvirt_buildPyObject(node, "virStorageVolPtr", NULL);
 400     return ret;
 401 }
 402
 403 PyObject *
 404 libvirt_virConnectPtrWrap(virConnectPtr node)
 405 {
 406     PyObject *ret;
 407
 408     if (node == NULL) {
 409         return VIR_PY_NONE;
 410     }
 411
 412     ret = libvirt_buildPyObject(node, "virConnectPtr", NULL);
 413     return ret;
 414 }
 415
 416 PyObject *
 417 libvirt_virNodeDevicePtrWrap(virNodeDevicePtr node)
 418 {
 419     PyObject *ret;
 420
 421     if (node == NULL) {
 422         return VIR_PY_NONE;
 423     }
 424
 425     ret = libvirt_buildPyObject(node, "virNodeDevicePtr", NULL);
 426     return ret;
 427 }
 428
 429 PyObject *
 430 libvirt_virSecretPtrWrap(virSecretPtr node)
 431 {
 432     PyObject *ret;
 433
 434     if (node == NULL) {
 435         return VIR_PY_NONE;
 436     }
 437
 438     ret = libvirt_buildPyObject(node, "virSecretPtr", NULL);
 439     return ret;
 440 }
 441
 442 PyObject *
 443 libvirt_virNWFilterPtrWrap(virNWFilterPtr node)
 444 {
 445     PyObject *ret;
 446
 447     if (node == NULL) {
 448         return VIR_PY_NONE;
 449     }
 450
 451     ret = libvirt_buildPyObject(node, "virNWFilterPtr", NULL);
 452     return ret;
 453 }
 454
 455 PyObject *
 456 libvirt_virNWFilterBindingPtrWrap(virNWFilterBindingPtr node)
 457 {
 458     PyObject *ret;
 459
 460     if (node == NULL) {
 461         return VIR_PY_NONE;
 462     }
 463
 464     ret = libvirt_buildPyObject(node, "virNWFilterBindingPtr", NULL);
 465     return ret;
 466 }
 467
 468 PyObject *
 469 libvirt_virStreamPtrWrap(virStreamPtr node)
 470 {
 471     PyObject *ret;
 472
 473     if (node == NULL) {
 474         return VIR_PY_NONE;
 475     }
 476
 477     ret = libvirt_buildPyObject(node, "virStreamPtr", NULL);
 478     return ret;
 479 }
 480
 481 PyObject *
 482 libvirt_virDomainCheckpointPtrWrap(virDomainCheckpointPtr node)
 483 {
 484     PyObject *ret;
 485
 486     if (node == NULL) {
 487         return VIR_PY_NONE;
 488     }
 489
 490     ret = libvirt_buildPyObject(node, "virDomainCheckpointPtr", NULL);
 491     return ret;
 492 }
 493
 494 PyObject *
 495 libvirt_virDomainSnapshotPtrWrap(virDomainSnapshotPtr node)
 496 {
 497     PyObject *ret;
 498
 499     if (node == NULL) {
 500         return VIR_PY_NONE;
 501     }
 502
 503     ret = libvirt_buildPyObject(node, "virDomainSnapshotPtr", NULL);
 504     return ret;
 505 }
 506
 507 PyObject *
 508 libvirt_virEventHandleCallbackWrap(virEventHandleCallback node)
 509 {
 510     PyObject *ret;
 511
 512     if (node == NULL) {
 513         printf("%s: WARNING - Wrapping None\n", __func__);
 514         return VIR_PY_NONE;
 515     }
 516
 517     ret = libvirt_buildPyObject(node, "virEventHandleCallback", NULL);
 518     return ret;
 519 }
 520
 521 PyObject *
 522 libvirt_virEventTimeoutCallbackWrap(virEventTimeoutCallback node)
 523 {
 524     PyObject *ret;
 525
 526     if (node == NULL) {
 527         printf("%s: WARNING - Wrapping None\n", __func__);
 528         return VIR_PY_NONE;
 529     }
 530
 531     ret = libvirt_buildPyObject(node, "virEventTimeoutCallback", NULL);
 532     return ret;
 533 }
 534
 535 PyObject *
 536 libvirt_virFreeCallbackWrap(virFreeCallback node)
 537 {
 538     PyObject *ret;
 539
 540     if (node == NULL) {
 541         return VIR_PY_NONE;
 542     }
 543
 544     ret = libvirt_buildPyObject(node, "virFreeCallback", NULL);
 545     return ret;
 546 }
 547
 548 PyObject *
 549 libvirt_virVoidPtrWrap(void* node)
 550 {
 551     PyObject *ret;
 552
 553     if (node == NULL) {
 554         return VIR_PY_NONE;
 555     }
 556
 557     ret = libvirt_buildPyObject(node, "void*", NULL);
 558     return ret;
 559 }