typewrappers.c

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