?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ci: Update Fedora and Debian versions and regenerate
[libvirt-python.git] / libvirt-override.c
blobac073469703e5700b8bfa0357035b884aaf41328
1 /*
2 * libvir.c: this modules implements the main part of the glue of the
3 * libvir library and the Python interpreter. It provides the
4 * entry points where an automatically generated stub is
5 * unpractical
6 *
7 * Copyright (C) 2005-2019 Red Hat, Inc.
8 *
9 * Daniel Veillard <veillard@redhat.com>
10 */
11
12 /* Horrible kludge to work around even more horrible name-space pollution
13 via Python.h. That file includes /usr/include/python3.x/pyconfig*.h,
14 which has over 180 autoconf-style HAVE_* definitions. Shame on them. */
15 #undef HAVE_PTHREAD_H
16
17 /* We want to see *_LAST enums. */
18 #define VIR_ENUM_SENTINELS
19
20 #define PY_SSIZE_T_CLEAN
21
22 #include <stdio.h>
23 #include <string.h>
24 #include <Python.h>
25 #include <libvirt/libvirt.h>
26 #include <libvirt/virterror.h>
27 #include <stddef.h>
28 #include "typewrappers.h"
29 #include "build/libvirt.h"
30 #include "libvirt-utils.h"
31
32 #ifndef __CYGWIN__
33 extern PyObject *PyInit_libvirtmod(void);
34 #else
35 extern PyObject *PyInit_cygvirtmod(void);
36 #endif
37
38 #if 0
39 # define DEBUG_ERROR 1
40 #endif
41
42 #if DEBUG_ERROR
43 # define DEBUG(fmt, ...) \
44 printf(fmt, __VA_ARGS__)
45 #else
46 # define DEBUG(fmt, ...) \
47 while (0) {printf(fmt, __VA_ARGS__);}
48 #endif
49
50
51 /*
52 * Utility function to retrieve the number of node CPUs present.
53 * It first tries virNodeGetCPUMap, which will return the
54 * number reliably, if available.
55 * As a fallback and for compatibility with backlevel libvirt
56 * versions virNodeGetInfo will be called to calculate the
57 * CPU number, which has the potential to return a too small
58 * number if some host CPUs are offline.
59 */
60 static int
61 getPyNodeCPUCount(virConnectPtr conn)
62 {
63 int i_retval;
64
65 #if LIBVIR_CHECK_VERSION(1, 0, 0)
66 LIBVIRT_BEGIN_ALLOW_THREADS;
67 i_retval = virNodeGetCPUMap(conn, NULL, NULL, 0);
68 LIBVIRT_END_ALLOW_THREADS;
69 #else /* fallback: use nodeinfo */
70 virNodeInfo nodeinfo;
71
72 LIBVIRT_BEGIN_ALLOW_THREADS;
73 i_retval = virNodeGetInfo(conn, &nodeinfo);
74 LIBVIRT_END_ALLOW_THREADS;
75
76 if (i_retval >= 0)
77 i_retval = VIR_NODEINFO_MAXCPUS(nodeinfo);
78 #endif /* LIBVIR_CHECK_VERSION(1, 0, 0) */
79
80 return i_retval;
81 }
82
83 /************************************************************************
84 * *
85 * Statistics *
86 * *
87 ************************************************************************/
88
89 static PyObject *
90 libvirt_virDomainBlockStats(PyObject *self ATTRIBUTE_UNUSED,
91 PyObject *args)
92 {
93 virDomainPtr domain;
94 PyObject *pyobj_domain;
95 char * path;
96 int c_retval;
97 virDomainBlockStatsStruct stats;
98 PyObject *info;
99
100 if (!PyArg_ParseTuple(args, (char *)"Oz:virDomainBlockStats",
101 &pyobj_domain, &path))
102 return NULL;
103 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
104
105 LIBVIRT_BEGIN_ALLOW_THREADS;
106 c_retval = virDomainBlockStats(domain, path, &stats, sizeof(stats));
107 LIBVIRT_END_ALLOW_THREADS;
108
109 if (c_retval < 0)
110 return VIR_PY_NONE;
111
112 /* convert to a Python tuple of long objects */
113 if ((info = PyTuple_New(5)) == NULL)
114 return NULL;
115
116 VIR_PY_TUPLE_SET_GOTO(info, 0, libvirt_longlongWrap(stats.rd_req), error);
117 VIR_PY_TUPLE_SET_GOTO(info, 1, libvirt_longlongWrap(stats.rd_bytes), error);
118 VIR_PY_TUPLE_SET_GOTO(info, 2, libvirt_longlongWrap(stats.wr_req), error);
119 VIR_PY_TUPLE_SET_GOTO(info, 3, libvirt_longlongWrap(stats.wr_bytes), error);
120 VIR_PY_TUPLE_SET_GOTO(info, 4, libvirt_longlongWrap(stats.errs), error);
121
122 return info;
123
124 error:
125 Py_DECREF(info);
126 return NULL;
127 }
128
129 static PyObject *
130 libvirt_virDomainBlockStatsFlags(PyObject *self ATTRIBUTE_UNUSED,
131 PyObject *args)
132 {
133 virDomainPtr domain;
134 PyObject *pyobj_domain;
135 PyObject *ret = NULL;
136 int i_retval;
137 int nparams = 0;
138 unsigned int flags;
139 virTypedParameterPtr params;
140 const char *path;
141
142 if (!PyArg_ParseTuple(args, (char *)"OzI:virDomainBlockStatsFlags",
143 &pyobj_domain, &path, &flags))
144 return NULL;
145 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
146
147 LIBVIRT_BEGIN_ALLOW_THREADS;
148 i_retval = virDomainBlockStatsFlags(domain, path, NULL, &nparams, flags);
149 LIBVIRT_END_ALLOW_THREADS;
150
151 if (i_retval < 0)
152 return VIR_PY_NONE;
153
154 if (!nparams)
155 return PyDict_New();
156
157 if (VIR_ALLOC_N(params, nparams) < 0)
158 return PyErr_NoMemory();
159
160 LIBVIRT_BEGIN_ALLOW_THREADS;
161 i_retval = virDomainBlockStatsFlags(domain, path, params, &nparams, flags);
162 LIBVIRT_END_ALLOW_THREADS;
163
164 if (i_retval < 0) {
165 ret = VIR_PY_NONE;
166 goto cleanup;
167 }
168
169 ret = getPyVirTypedParameter(params, nparams);
170
171 cleanup:
172 virTypedParamsFree(params, nparams);
173 return ret;
174 }
175
176 static PyObject *
177 libvirt_virDomainGetCPUStats(PyObject *self ATTRIBUTE_UNUSED,
178 PyObject *args)
179 {
180 virDomainPtr domain;
181 PyObject *pyobj_domain, *totalbool;
182 PyObject *ret = NULL;
183 PyObject *error = NULL;
184 int ncpus = -1, start_cpu = 0;
185 int sumparams = 0, nparams = -1;
186 ssize_t i;
187 int i_retval;
188 unsigned int flags;
189 bool totalflag;
190 virTypedParameterPtr params = NULL, cpuparams;
191
192 if (!PyArg_ParseTuple(args, (char *)"OOI:virDomainGetCPUStats",
193 &pyobj_domain, &totalbool, &flags))
194 return NULL;
195 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
196
197 if (libvirt_boolUnwrap(totalbool, &totalflag) < 0)
198 return NULL;
199
200 if ((ret = PyList_New(0)) == NULL)
201 return NULL;
202
203 if (!totalflag) {
204 LIBVIRT_BEGIN_ALLOW_THREADS;
205 ncpus = virDomainGetCPUStats(domain, NULL, 0, 0, 0, flags);
206 LIBVIRT_END_ALLOW_THREADS;
207
208 if (ncpus < 0) {
209 error = VIR_PY_NONE;
210 goto error;
211 }
212
213 LIBVIRT_BEGIN_ALLOW_THREADS;
214 nparams = virDomainGetCPUStats(domain, NULL, 0, 0, 1, flags);
215 LIBVIRT_END_ALLOW_THREADS;
216
217 if (nparams < 0) {
218 error = VIR_PY_NONE;
219 goto error;
220 }
221
222 sumparams = nparams * MIN(ncpus, 128);
223
224 if (VIR_ALLOC_N(params, sumparams) < 0) {
225 error = PyErr_NoMemory();
226 goto error;
227 }
228
229 while (ncpus) {
230 int queried_ncpus = MIN(ncpus, 128);
231 if (nparams) {
232
233 LIBVIRT_BEGIN_ALLOW_THREADS;
234 i_retval = virDomainGetCPUStats(domain, params,
235 nparams, start_cpu,
236 queried_ncpus, flags);
237 LIBVIRT_END_ALLOW_THREADS;
238
239 if (i_retval < 0) {
240 error = VIR_PY_NONE;
241 goto error;
242 }
243 } else {
244 i_retval = 0;
245 }
246
247 for (i = 0; i < queried_ncpus; i++) {
248 cpuparams = &params[i * nparams];
249 VIR_PY_LIST_APPEND_GOTO(ret,
250 getPyVirTypedParameter(cpuparams,
251 i_retval),
252 error);
253 }
254
255 start_cpu += queried_ncpus;
256 ncpus -= queried_ncpus;
257 virTypedParamsClear(params, sumparams);
258 }
259 } else {
260 LIBVIRT_BEGIN_ALLOW_THREADS;
261 nparams = virDomainGetCPUStats(domain, NULL, 0, -1, 1, flags);
262 LIBVIRT_END_ALLOW_THREADS;
263
264 if (nparams < 0) {
265 error = VIR_PY_NONE;
266 goto error;
267 }
268
269 if (nparams) {
270 sumparams = nparams;
271
272 if (VIR_ALLOC_N(params, nparams) < 0) {
273 error = PyErr_NoMemory();
274 goto error;
275 }
276
277 LIBVIRT_BEGIN_ALLOW_THREADS;
278 i_retval = virDomainGetCPUStats(domain, params, nparams,
279 -1, 1, flags);
280 LIBVIRT_END_ALLOW_THREADS;
281
282 if (i_retval < 0) {
283 error = VIR_PY_NONE;
284 goto error;
285 }
286 } else {
287 i_retval = 0;
288 }
289
290 VIR_PY_LIST_APPEND_GOTO(ret, getPyVirTypedParameter(params, i_retval),
291 error);
292 }
293
294 virTypedParamsFree(params, sumparams);
295 return ret;
296
297 error:
298 virTypedParamsFree(params, sumparams);
299 Py_DECREF(ret);
300 return error;
301 }
302
303 static PyObject *
304 libvirt_virDomainInterfaceStats(PyObject *self ATTRIBUTE_UNUSED,
305 PyObject *args)
306 {
307 virDomainPtr domain;
308 PyObject *pyobj_domain;
309 char * path;
310 int c_retval;
311 virDomainInterfaceStatsStruct stats;
312 PyObject *info;
313
314 if (!PyArg_ParseTuple(args, (char *)"Oz:virDomainInterfaceStats",
315 &pyobj_domain, &path))
316 return NULL;
317 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
318
319 LIBVIRT_BEGIN_ALLOW_THREADS;
320 c_retval = virDomainInterfaceStats(domain, path, &stats, sizeof(stats));
321 LIBVIRT_END_ALLOW_THREADS;
322
323 if (c_retval < 0)
324 return VIR_PY_NONE;
325
326 /* convert to a Python tuple of long objects */
327 if ((info = PyTuple_New(8)) == NULL)
328 return NULL;
329
330 VIR_PY_TUPLE_SET_GOTO(info, 0, libvirt_longlongWrap(stats.rx_bytes), error);
331 VIR_PY_TUPLE_SET_GOTO(info, 1, libvirt_longlongWrap(stats.rx_packets), error);
332 VIR_PY_TUPLE_SET_GOTO(info, 2, libvirt_longlongWrap(stats.rx_errs), error);
333 VIR_PY_TUPLE_SET_GOTO(info, 3, libvirt_longlongWrap(stats.rx_drop), error);
334 VIR_PY_TUPLE_SET_GOTO(info, 4, libvirt_longlongWrap(stats.tx_bytes), error);
335 VIR_PY_TUPLE_SET_GOTO(info, 5, libvirt_longlongWrap(stats.tx_packets), error);
336 VIR_PY_TUPLE_SET_GOTO(info, 6, libvirt_longlongWrap(stats.tx_errs), error);
337 VIR_PY_TUPLE_SET_GOTO(info, 7, libvirt_longlongWrap(stats.tx_drop), error);
338
339 return info;
340
341 error:
342 Py_DECREF(info);
343 return NULL;
344 }
345
346 static PyObject *
347 libvirt_virDomainMemoryStats(PyObject *self ATTRIBUTE_UNUSED,
348 PyObject *args)
349 {
350 virDomainPtr domain;
351 PyObject *pyobj_domain;
352 unsigned int nr_stats;
353 size_t i;
354 virDomainMemoryStatStruct stats[VIR_DOMAIN_MEMORY_STAT_NR];
355 PyObject *info;
356 PyObject *key = NULL, *val = NULL;
357
358 if (!PyArg_ParseTuple(args, (char *)"O:virDomainMemoryStats", &pyobj_domain))
359 return NULL;
360 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
361
362 LIBVIRT_BEGIN_ALLOW_THREADS;
363 nr_stats = virDomainMemoryStats(domain, stats,
364 VIR_DOMAIN_MEMORY_STAT_NR, 0);
365 LIBVIRT_END_ALLOW_THREADS;
366
367 if (nr_stats == (unsigned int)-1)
368 return VIR_PY_NONE;
369
370 /* convert to a Python dictionary */
371 if ((info = PyDict_New()) == NULL)
372 return NULL;
373
374 for (i = 0; i < nr_stats; i++) {
375 switch (stats[i].tag) {
376 case VIR_DOMAIN_MEMORY_STAT_SWAP_IN:
377 key = libvirt_constcharPtrWrap("swap_in");
378 break;
379 case VIR_DOMAIN_MEMORY_STAT_SWAP_OUT:
380 key = libvirt_constcharPtrWrap("swap_out");
381 break;
382 case VIR_DOMAIN_MEMORY_STAT_MAJOR_FAULT:
383 key = libvirt_constcharPtrWrap("major_fault");
384 break;
385 case VIR_DOMAIN_MEMORY_STAT_MINOR_FAULT:
386 key = libvirt_constcharPtrWrap("minor_fault");
387 break;
388 case VIR_DOMAIN_MEMORY_STAT_UNUSED:
389 key = libvirt_constcharPtrWrap("unused");
390 break;
391 case VIR_DOMAIN_MEMORY_STAT_AVAILABLE:
392 key = libvirt_constcharPtrWrap("available");
393 break;
394 case VIR_DOMAIN_MEMORY_STAT_ACTUAL_BALLOON:
395 key = libvirt_constcharPtrWrap("actual");
396 break;
397 case VIR_DOMAIN_MEMORY_STAT_RSS:
398 key = libvirt_constcharPtrWrap("rss");
399 break;
400 #if LIBVIR_CHECK_VERSION(2, 1, 0)
401 case VIR_DOMAIN_MEMORY_STAT_USABLE:
402 key = libvirt_constcharPtrWrap("usable");
403 break;
404 case VIR_DOMAIN_MEMORY_STAT_LAST_UPDATE:
405 key = libvirt_constcharPtrWrap("last_update");
406 break;
407 #endif /* LIBVIR_CHECK_VERSION(2, 1, 0) */
408 #if LIBVIR_CHECK_VERSION(4, 6, 0)
409 case VIR_DOMAIN_MEMORY_STAT_DISK_CACHES:
410 key = libvirt_constcharPtrWrap("disk_caches");
411 break;
412 #endif /* LIBVIR_CHECK_VERSION(4, 6, 0) */
413 #if LIBVIR_CHECK_VERSION(5, 4, 0)
414 case VIR_DOMAIN_MEMORY_STAT_HUGETLB_PGALLOC:
415 key = libvirt_constcharPtrWrap("hugetlb_pgalloc");
416 break;
417 case VIR_DOMAIN_MEMORY_STAT_HUGETLB_PGFAIL:
418 key = libvirt_constcharPtrWrap("hugetlb_pgfail");
419 break;
420 #endif /* LIBVIR_CHECK_VERSION(5, 4, 0) */
421 default:
422 continue;
423 }
424 val = libvirt_ulonglongWrap(stats[i].val);
425
426 VIR_PY_DICT_SET_GOTO(info, key, val, error);
427 }
428
429 return info;
430
431 error:
432 Py_DECREF(info);
433 return NULL;
434 }
435
436 static PyObject *
437 libvirt_virDomainGetSchedulerType(PyObject *self ATTRIBUTE_UNUSED,
438 PyObject *args)
439 {
440 virDomainPtr domain;
441 PyObject *pyobj_domain, *info;
442 char *c_retval;
443 int nparams;
444
445 if (!PyArg_ParseTuple(args, (char *)"O:virDomainGetScedulerType",
446 &pyobj_domain))
447 return NULL;
448 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
449
450 LIBVIRT_BEGIN_ALLOW_THREADS;
451 c_retval = virDomainGetSchedulerType(domain, &nparams);
452 LIBVIRT_END_ALLOW_THREADS;
453
454 if (c_retval == NULL)
455 return VIR_PY_NONE;
456
457 /* convert to a Python tuple of long objects */
458 if ((info = PyTuple_New(2)) == NULL)
459 goto cleanup;
460
461 VIR_PY_TUPLE_SET_GOTO(info, 0, libvirt_constcharPtrWrap(c_retval), error);
462 VIR_PY_TUPLE_SET_GOTO(info, 1, libvirt_intWrap(nparams), error);
463
464 cleanup:
465 VIR_FREE(c_retval);
466 return info;
467
468 error:
469 Py_CLEAR(info);
470 goto cleanup;
471
472 }
473
474 static PyObject *
475 libvirt_virDomainGetSchedulerParameters(PyObject *self ATTRIBUTE_UNUSED,
476 PyObject *args)
477 {
478 virDomainPtr domain;
479 PyObject *pyobj_domain;
480 PyObject *ret = NULL;
481 char *c_retval;
482 int i_retval;
483 int nparams = 0;
484 virTypedParameterPtr params;
485
486 if (!PyArg_ParseTuple(args, (char *)"O:virDomainGetScedulerParameters",
487 &pyobj_domain))
488 return NULL;
489 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
490
491 LIBVIRT_BEGIN_ALLOW_THREADS;
492 c_retval = virDomainGetSchedulerType(domain, &nparams);
493 LIBVIRT_END_ALLOW_THREADS;
494
495 if (c_retval == NULL)
496 return VIR_PY_NONE;
497 VIR_FREE(c_retval);
498
499 if (!nparams)
500 return PyDict_New();
501
502 if (VIR_ALLOC_N(params, nparams) < 0)
503 return PyErr_NoMemory();
504
505 LIBVIRT_BEGIN_ALLOW_THREADS;
506 i_retval = virDomainGetSchedulerParameters(domain, params, &nparams);
507 LIBVIRT_END_ALLOW_THREADS;
508
509 if (i_retval < 0) {
510 ret = VIR_PY_NONE;
511 goto cleanup;
512 }
513
514 ret = getPyVirTypedParameter(params, nparams);
515
516 cleanup:
517 virTypedParamsFree(params, nparams);
518 return ret;
519 }
520
521 static PyObject *
522 libvirt_virDomainGetSchedulerParametersFlags(PyObject *self ATTRIBUTE_UNUSED,
523 PyObject *args)
524 {
525 virDomainPtr domain;
526 PyObject *pyobj_domain;
527 PyObject *ret = NULL;
528 char *c_retval;
529 int i_retval;
530 int nparams = 0;
531 unsigned int flags;
532 virTypedParameterPtr params;
533
534 if (!PyArg_ParseTuple(args, (char *)"OI:virDomainGetScedulerParametersFlags",
535 &pyobj_domain, &flags))
536 return NULL;
537 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
538
539 LIBVIRT_BEGIN_ALLOW_THREADS;
540 c_retval = virDomainGetSchedulerType(domain, &nparams);
541 LIBVIRT_END_ALLOW_THREADS;
542
543 if (c_retval == NULL)
544 return VIR_PY_NONE;
545 VIR_FREE(c_retval);
546
547 if (!nparams)
548 return PyDict_New();
549
550 if (VIR_ALLOC_N(params, nparams) < 0)
551 return PyErr_NoMemory();
552
553 LIBVIRT_BEGIN_ALLOW_THREADS;
554 i_retval = virDomainGetSchedulerParametersFlags(domain, params, &nparams,
555 flags);
556 LIBVIRT_END_ALLOW_THREADS;
557
558 if (i_retval < 0) {
559 ret = VIR_PY_NONE;
560 goto cleanup;
561 }
562
563 ret = getPyVirTypedParameter(params, nparams);
564
565 cleanup:
566 virTypedParamsFree(params, nparams);
567 return ret;
568 }
569
570 static PyObject *
571 libvirt_virDomainSetSchedulerParameters(PyObject *self ATTRIBUTE_UNUSED,
572 PyObject *args)
573 {
574 virDomainPtr domain;
575 PyObject *pyobj_domain, *info;
576 PyObject *ret = NULL;
577 char *c_retval;
578 int i_retval;
579 int nparams = 0;
580 Py_ssize_t size = 0;
581 virTypedParameterPtr params = NULL, new_params = NULL;
582
583 if (!PyArg_ParseTuple(args, (char *)"OO:virDomainSetSchedulerParameters",
584 &pyobj_domain, &info))
585 return NULL;
586 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
587
588 if ((size = PyDict_Size(info)) < 0)
589 return NULL;
590
591 if (size == 0) {
592 PyErr_Format(PyExc_LookupError,
593 "Need non-empty dictionary to set attributes");
594 return NULL;
595 }
596
597 LIBVIRT_BEGIN_ALLOW_THREADS;
598 c_retval = virDomainGetSchedulerType(domain, &nparams);
599 LIBVIRT_END_ALLOW_THREADS;
600
601 if (c_retval == NULL)
602 return VIR_PY_INT_FAIL;
603 VIR_FREE(c_retval);
604
605 if (nparams == 0) {
606 PyErr_Format(PyExc_LookupError,
607 "Domain has no settable attributes");
608 return NULL;
609 }
610
611 if (VIR_ALLOC_N(params, nparams) < 0)
612 return PyErr_NoMemory();
613
614 LIBVIRT_BEGIN_ALLOW_THREADS;
615 i_retval = virDomainGetSchedulerParameters(domain, params, &nparams);
616 LIBVIRT_END_ALLOW_THREADS;
617
618 if (i_retval < 0) {
619 ret = VIR_PY_INT_FAIL;
620 goto cleanup;
621 }
622
623 new_params = setPyVirTypedParameter(info, params, nparams);
624 if (!new_params)
625 goto cleanup;
626
627 LIBVIRT_BEGIN_ALLOW_THREADS;
628 i_retval = virDomainSetSchedulerParameters(domain, new_params, size);
629 LIBVIRT_END_ALLOW_THREADS;
630
631 if (i_retval < 0) {
632 ret = VIR_PY_INT_FAIL;
633 goto cleanup;
634 }
635
636 ret = VIR_PY_INT_SUCCESS;
637
638 cleanup:
639 virTypedParamsFree(params, nparams);
640 virTypedParamsFree(new_params, size);
641 return ret;
642 }
643
644 static PyObject *
645 libvirt_virDomainSetSchedulerParametersFlags(PyObject *self ATTRIBUTE_UNUSED,
646 PyObject *args)
647 {
648 virDomainPtr domain;
649 PyObject *pyobj_domain, *info;
650 PyObject *ret = NULL;
651 char *c_retval;
652 int i_retval;
653 int nparams = 0;
654 Py_ssize_t size = 0;
655 unsigned int flags;
656 virTypedParameterPtr params = NULL, new_params = NULL;
657
658 if (!PyArg_ParseTuple(args,
659 (char *)"OOI:virDomainSetSchedulerParametersFlags",
660 &pyobj_domain, &info, &flags))
661 return NULL;
662 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
663
664 if ((size = PyDict_Size(info)) < 0)
665 return NULL;
666
667 if (size == 0) {
668 PyErr_Format(PyExc_LookupError,
669 "Need non-empty dictionary to set attributes");
670 return NULL;
671 }
672
673 LIBVIRT_BEGIN_ALLOW_THREADS;
674 c_retval = virDomainGetSchedulerType(domain, &nparams);
675 LIBVIRT_END_ALLOW_THREADS;
676
677 if (c_retval == NULL)
678 return VIR_PY_INT_FAIL;
679 VIR_FREE(c_retval);
680
681 if (nparams == 0) {
682 PyErr_Format(PyExc_LookupError,
683 "Domain has no settable attributes");
684 return NULL;
685 }
686
687 if (VIR_ALLOC_N(params, nparams) < 0)
688 return PyErr_NoMemory();
689
690 LIBVIRT_BEGIN_ALLOW_THREADS;
691 i_retval = virDomainGetSchedulerParametersFlags(domain, params, &nparams,
692 flags);
693 LIBVIRT_END_ALLOW_THREADS;
694
695 if (i_retval < 0) {
696 ret = VIR_PY_INT_FAIL;
697 goto cleanup;
698 }
699
700 new_params = setPyVirTypedParameter(info, params, nparams);
701 if (!new_params)
702 goto cleanup;
703
704 LIBVIRT_BEGIN_ALLOW_THREADS;
705 i_retval = virDomainSetSchedulerParametersFlags(domain, new_params, size,
706 flags);
707 LIBVIRT_END_ALLOW_THREADS;
708
709 if (i_retval < 0) {
710 ret = VIR_PY_INT_FAIL;
711 goto cleanup;
712 }
713
714 ret = VIR_PY_INT_SUCCESS;
715
716 cleanup:
717 virTypedParamsFree(params, nparams);
718 virTypedParamsFree(new_params, size);
719 return ret;
720 }
721
722 static PyObject *
723 libvirt_virDomainSetBlkioParameters(PyObject *self ATTRIBUTE_UNUSED,
724 PyObject *args)
725 {
726 virDomainPtr domain;
727 PyObject *pyobj_domain, *info;
728 PyObject *ret = NULL;
729 int i_retval;
730 int nparams = 0;
731 Py_ssize_t size = 0;
732 unsigned int flags;
733 virTypedParameterPtr params = NULL, new_params = NULL;
734
735 if (!PyArg_ParseTuple(args,
736 (char *)"OOI:virDomainSetBlkioParameters",
737 &pyobj_domain, &info, &flags))
738 return NULL;
739 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
740
741 if ((size = PyDict_Size(info)) < 0)
742 return NULL;
743
744 if (size == 0) {
745 PyErr_Format(PyExc_LookupError,
746 "Need non-empty dictionary to set attributes");
747 return NULL;
748 }
749
750 LIBVIRT_BEGIN_ALLOW_THREADS;
751 i_retval = virDomainGetBlkioParameters(domain, NULL, &nparams, flags);
752 LIBVIRT_END_ALLOW_THREADS;
753
754 if (i_retval < 0)
755 return VIR_PY_INT_FAIL;
756
757 if (nparams == 0) {
758 PyErr_Format(PyExc_LookupError,
759 "Domain has no settable attributes");
760 return NULL;
761 }
762
763 if (VIR_ALLOC_N(params, nparams) < 0)
764 return PyErr_NoMemory();
765
766 LIBVIRT_BEGIN_ALLOW_THREADS;
767 i_retval = virDomainGetBlkioParameters(domain, params, &nparams, flags);
768 LIBVIRT_END_ALLOW_THREADS;
769
770 if (i_retval < 0) {
771 ret = VIR_PY_INT_FAIL;
772 goto cleanup;
773 }
774
775 new_params = setPyVirTypedParameter(info, params, nparams);
776 if (!new_params)
777 goto cleanup;
778
779 LIBVIRT_BEGIN_ALLOW_THREADS;
780 i_retval = virDomainSetBlkioParameters(domain, new_params, size, flags);
781 LIBVIRT_END_ALLOW_THREADS;
782
783 if (i_retval < 0) {
784 ret = VIR_PY_INT_FAIL;
785 goto cleanup;
786 }
787
788 ret = VIR_PY_INT_SUCCESS;
789
790 cleanup:
791 virTypedParamsFree(params, nparams);
792 virTypedParamsFree(new_params, size);
793 return ret;
794 }
795
796 static PyObject *
797 libvirt_virDomainGetBlkioParameters(PyObject *self ATTRIBUTE_UNUSED,
798 PyObject *args)
799 {
800 virDomainPtr domain;
801 PyObject *pyobj_domain;
802 PyObject *ret = NULL;
803 int i_retval;
804 int nparams = 0;
805 unsigned int flags;
806 virTypedParameterPtr params;
807
808 if (!PyArg_ParseTuple(args, (char *)"OI:virDomainGetBlkioParameters",
809 &pyobj_domain, &flags))
810 return NULL;
811 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
812
813 LIBVIRT_BEGIN_ALLOW_THREADS;
814 i_retval = virDomainGetBlkioParameters(domain, NULL, &nparams, flags);
815 LIBVIRT_END_ALLOW_THREADS;
816
817 if (i_retval < 0)
818 return VIR_PY_NONE;
819
820 if (!nparams)
821 return PyDict_New();
822
823 if (VIR_ALLOC_N(params, nparams) < 0)
824 return PyErr_NoMemory();
825
826 LIBVIRT_BEGIN_ALLOW_THREADS;
827 i_retval = virDomainGetBlkioParameters(domain, params, &nparams, flags);
828 LIBVIRT_END_ALLOW_THREADS;
829
830 if (i_retval < 0) {
831 ret = VIR_PY_NONE;
832 goto cleanup;
833 }
834
835 ret = getPyVirTypedParameter(params, nparams);
836
837 cleanup:
838 virTypedParamsFree(params, nparams);
839 return ret;
840 }
841
842 static PyObject *
843 libvirt_virDomainSetMemoryParameters(PyObject *self ATTRIBUTE_UNUSED,
844 PyObject *args)
845 {
846 virDomainPtr domain;
847 PyObject *pyobj_domain, *info;
848 PyObject *ret = NULL;
849 int i_retval;
850 int nparams = 0;
851 Py_ssize_t size = 0;
852 unsigned int flags;
853 virTypedParameterPtr params = NULL, new_params = NULL;
854
855 if (!PyArg_ParseTuple(args,
856 (char *)"OOI:virDomainSetMemoryParameters",
857 &pyobj_domain, &info, &flags))
858 return NULL;
859 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
860
861 if ((size = PyDict_Size(info)) < 0)
862 return NULL;
863
864 if (size == 0) {
865 PyErr_Format(PyExc_LookupError,
866 "Need non-empty dictionary to set attributes");
867 return NULL;
868 }
869
870 LIBVIRT_BEGIN_ALLOW_THREADS;
871 i_retval = virDomainGetMemoryParameters(domain, NULL, &nparams, flags);
872 LIBVIRT_END_ALLOW_THREADS;
873
874 if (i_retval < 0)
875 return VIR_PY_INT_FAIL;
876
877 if (nparams == 0) {
878 PyErr_Format(PyExc_LookupError,
879 "Domain has no settable attributes");
880 return NULL;
881 }
882
883 if (VIR_ALLOC_N(params, nparams) < 0)
884 return PyErr_NoMemory();
885
886 LIBVIRT_BEGIN_ALLOW_THREADS;
887 i_retval = virDomainGetMemoryParameters(domain, params, &nparams, flags);
888 LIBVIRT_END_ALLOW_THREADS;
889
890 if (i_retval < 0) {
891 ret = VIR_PY_INT_FAIL;
892 goto cleanup;
893 }
894
895 new_params = setPyVirTypedParameter(info, params, nparams);
896 if (!new_params)
897 goto cleanup;
898
899 LIBVIRT_BEGIN_ALLOW_THREADS;
900 i_retval = virDomainSetMemoryParameters(domain, new_params, size, flags);
901 LIBVIRT_END_ALLOW_THREADS;
902
903 if (i_retval < 0) {
904 ret = VIR_PY_INT_FAIL;
905 goto cleanup;
906 }
907
908 ret = VIR_PY_INT_SUCCESS;
909
910 cleanup:
911 virTypedParamsFree(params, nparams);
912 virTypedParamsFree(new_params, size);
913 return ret;
914 }
915
916 static PyObject *
917 libvirt_virDomainGetMemoryParameters(PyObject *self ATTRIBUTE_UNUSED,
918 PyObject *args)
919 {
920 virDomainPtr domain;
921 PyObject *pyobj_domain;
922 PyObject *ret = NULL;
923 int i_retval;
924 int nparams = 0;
925 unsigned int flags;
926 virTypedParameterPtr params;
927
928 if (!PyArg_ParseTuple(args, (char *)"OI:virDomainGetMemoryParameters",
929 &pyobj_domain, &flags))
930 return NULL;
931 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
932
933 LIBVIRT_BEGIN_ALLOW_THREADS;
934 i_retval = virDomainGetMemoryParameters(domain, NULL, &nparams, flags);
935 LIBVIRT_END_ALLOW_THREADS;
936
937 if (i_retval < 0)
938 return VIR_PY_NONE;
939
940 if (!nparams)
941 return PyDict_New();
942
943 if (VIR_ALLOC_N(params, nparams) < 0)
944 return PyErr_NoMemory();
945
946 LIBVIRT_BEGIN_ALLOW_THREADS;
947 i_retval = virDomainGetMemoryParameters(domain, params, &nparams, flags);
948 LIBVIRT_END_ALLOW_THREADS;
949
950 if (i_retval < 0) {
951 ret = VIR_PY_NONE;
952 goto cleanup;
953 }
954
955 ret = getPyVirTypedParameter(params, nparams);
956
957 cleanup:
958 virTypedParamsFree(params, nparams);
959 return ret;
960 }
961
962 static PyObject *
963 libvirt_virDomainSetNumaParameters(PyObject *self ATTRIBUTE_UNUSED,
964 PyObject *args)
965 {
966 virDomainPtr domain;
967 PyObject *pyobj_domain, *info;
968 PyObject *ret = NULL;
969 int i_retval;
970 int nparams = 0;
971 Py_ssize_t size = 0;
972 unsigned int flags;
973 virTypedParameterPtr params = NULL, new_params = NULL;
974
975 if (!PyArg_ParseTuple(args,
976 (char *)"OOI:virDomainSetNumaParameters",
977 &pyobj_domain, &info, &flags))
978 return NULL;
979 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
980
981 if ((size = PyDict_Size(info)) < 0)
982 return NULL;
983
984 if (size == 0) {
985 PyErr_Format(PyExc_LookupError,
986 "Need non-empty dictionary to set attributes");
987 return NULL;
988 }
989
990 LIBVIRT_BEGIN_ALLOW_THREADS;
991 i_retval = virDomainGetNumaParameters(domain, NULL, &nparams, flags);
992 LIBVIRT_END_ALLOW_THREADS;
993
994 if (i_retval < 0)
995 return VIR_PY_INT_FAIL;
996
997 if (nparams == 0) {
998 PyErr_Format(PyExc_LookupError,
999 "Domain has no settable attributes");
1000 return NULL;
1001 }
1002
1003 if (VIR_ALLOC_N(params, nparams) < 0)
1004 return PyErr_NoMemory();
1005
1006 LIBVIRT_BEGIN_ALLOW_THREADS;
1007 i_retval = virDomainGetNumaParameters(domain, params, &nparams, flags);
1008 LIBVIRT_END_ALLOW_THREADS;
1009
1010 if (i_retval < 0) {
1011 ret = VIR_PY_INT_FAIL;
1012 goto cleanup;
1013 }
1014
1015 new_params = setPyVirTypedParameter(info, params, nparams);
1016 if (!new_params)
1017 goto cleanup;
1018
1019 LIBVIRT_BEGIN_ALLOW_THREADS;
1020 i_retval = virDomainSetNumaParameters(domain, new_params, size, flags);
1021 LIBVIRT_END_ALLOW_THREADS;
1022
1023 if (i_retval < 0) {
1024 ret = VIR_PY_INT_FAIL;
1025 goto cleanup;
1026 }
1027
1028 ret = VIR_PY_INT_SUCCESS;
1029
1030 cleanup:
1031 virTypedParamsFree(params, nparams);
1032 virTypedParamsFree(new_params, size);
1033 return ret;
1034 }
1035
1036 static PyObject *
1037 libvirt_virDomainGetNumaParameters(PyObject *self ATTRIBUTE_UNUSED,
1038 PyObject *args)
1039 {
1040 virDomainPtr domain;
1041 PyObject *pyobj_domain;
1042 PyObject *ret = NULL;
1043 int i_retval;
1044 int nparams = 0;
1045 unsigned int flags;
1046 virTypedParameterPtr params;
1047
1048 if (!PyArg_ParseTuple(args, (char *)"OI:virDomainGetNumaParameters",
1049 &pyobj_domain, &flags))
1050 return NULL;
1051 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
1052
1053 LIBVIRT_BEGIN_ALLOW_THREADS;
1054 i_retval = virDomainGetNumaParameters(domain, NULL, &nparams, flags);
1055 LIBVIRT_END_ALLOW_THREADS;
1056
1057 if (i_retval < 0)
1058 return VIR_PY_NONE;
1059
1060 if (!nparams)
1061 return PyDict_New();
1062
1063 if (VIR_ALLOC_N(params, nparams) < 0)
1064 return PyErr_NoMemory();
1065
1066 LIBVIRT_BEGIN_ALLOW_THREADS;
1067 i_retval = virDomainGetNumaParameters(domain, params, &nparams, flags);
1068 LIBVIRT_END_ALLOW_THREADS;
1069
1070 if (i_retval < 0) {
1071 ret = VIR_PY_NONE;
1072 goto cleanup;
1073 }
1074
1075 ret = getPyVirTypedParameter(params, nparams);
1076
1077 cleanup:
1078 virTypedParamsFree(params, nparams);
1079 return ret;
1080 }
1081
1082 static PyObject *
1083 libvirt_virDomainSetInterfaceParameters(PyObject *self ATTRIBUTE_UNUSED,
1084 PyObject *args)
1085 {
1086 virDomainPtr domain;
1087 PyObject *pyobj_domain, *info;
1088 PyObject *ret = NULL;
1089 int i_retval;
1090 int nparams = 0;
1091 Py_ssize_t size = 0;
1092 unsigned int flags;
1093 const char *device = NULL;
1094 virTypedParameterPtr params = NULL, new_params = NULL;
1095
1096 if (!PyArg_ParseTuple(args,
1097 (char *)"OzOI:virDomainSetInterfaceParameters",
1098 &pyobj_domain, &device, &info, &flags))
1099 return NULL;
1100 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
1101
1102 if ((size = PyDict_Size(info)) < 0)
1103 return NULL;
1104
1105 if (size == 0) {
1106 PyErr_Format(PyExc_LookupError,
1107 "Need non-empty dictionary to set attributes");
1108 return NULL;
1109 }
1110
1111 LIBVIRT_BEGIN_ALLOW_THREADS;
1112 i_retval = virDomainGetInterfaceParameters(domain, device, NULL, &nparams,
1113 flags);
1114 LIBVIRT_END_ALLOW_THREADS;
1115
1116 if (i_retval < 0)
1117 return VIR_PY_INT_FAIL;
1118
1119 if (nparams == 0) {
1120 PyErr_Format(PyExc_LookupError,
1121 "Domain has no settable attributes");
1122 return NULL;
1123 }
1124
1125 if (VIR_ALLOC_N(params, nparams) < 0)
1126 return PyErr_NoMemory();
1127
1128 LIBVIRT_BEGIN_ALLOW_THREADS;
1129 i_retval = virDomainGetInterfaceParameters(domain, device, params, &nparams,
1130 flags);
1131 LIBVIRT_END_ALLOW_THREADS;
1132
1133 if (i_retval < 0) {
1134 ret = VIR_PY_INT_FAIL;
1135 goto cleanup;
1136 }
1137
1138 new_params = setPyVirTypedParameter(info, params, nparams);
1139 if (!new_params)
1140 goto cleanup;
1141
1142 LIBVIRT_BEGIN_ALLOW_THREADS;
1143 i_retval = virDomainSetInterfaceParameters(domain, device, new_params, size,
1144 flags);
1145 LIBVIRT_END_ALLOW_THREADS;
1146
1147 if (i_retval < 0) {
1148 ret = VIR_PY_INT_FAIL;
1149 goto cleanup;
1150 }
1151
1152 ret = VIR_PY_INT_SUCCESS;
1153
1154 cleanup:
1155 virTypedParamsFree(params, nparams);
1156 virTypedParamsFree(new_params, size);
1157 return ret;
1158 }
1159
1160 static PyObject *
1161 libvirt_virDomainGetInterfaceParameters(PyObject *self ATTRIBUTE_UNUSED,
1162 PyObject *args)
1163 {
1164 virDomainPtr domain;
1165 PyObject *pyobj_domain;
1166 PyObject *ret = NULL;
1167 int i_retval;
1168 int nparams = 0;
1169 unsigned int flags;
1170 const char *device = NULL;
1171 virTypedParameterPtr params;
1172
1173 if (!PyArg_ParseTuple(args, (char *)"OzI:virDomainGetInterfaceParameters",
1174 &pyobj_domain, &device, &flags))
1175 return NULL;
1176 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
1177
1178 LIBVIRT_BEGIN_ALLOW_THREADS;
1179 i_retval = virDomainGetInterfaceParameters(domain, device, NULL, &nparams,
1180 flags);
1181 LIBVIRT_END_ALLOW_THREADS;
1182
1183 if (i_retval < 0)
1184 return VIR_PY_NONE;
1185
1186 if (!nparams)
1187 return PyDict_New();
1188
1189 if (VIR_ALLOC_N(params, nparams) < 0)
1190 return PyErr_NoMemory();
1191
1192 LIBVIRT_BEGIN_ALLOW_THREADS;
1193 i_retval = virDomainGetInterfaceParameters(domain, device, params, &nparams,
1194 flags);
1195 LIBVIRT_END_ALLOW_THREADS;
1196
1197 if (i_retval < 0) {
1198 ret = VIR_PY_NONE;
1199 goto cleanup;
1200 }
1201
1202 ret = getPyVirTypedParameter(params, nparams);
1203
1204 cleanup:
1205 virTypedParamsFree(params, nparams);
1206 return ret;
1207 }
1208
1209 static PyObject *
1210 libvirt_virDomainGetVcpus(PyObject *self ATTRIBUTE_UNUSED,
1211 PyObject *args)
1212 {
1213 virDomainPtr domain;
1214 PyObject *pyobj_domain, *pyretval = NULL;
1215 PyObject *pycpuinfo = NULL, *pycpumap = NULL;
1216 PyObject *error = NULL;
1217 virDomainInfo dominfo;
1218 virVcpuInfoPtr cpuinfo = NULL;
1219 unsigned char *cpumap = NULL;
1220 ssize_t cpumaplen, i;
1221 int i_retval, cpunum;
1222
1223 if (!PyArg_ParseTuple(args, (char *)"O:virDomainGetVcpus",
1224 &pyobj_domain))
1225 return NULL;
1226 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
1227
1228 if ((cpunum = getPyNodeCPUCount(virDomainGetConnect(domain))) < 0)
1229 return VIR_PY_NONE;
1230
1231 LIBVIRT_BEGIN_ALLOW_THREADS;
1232 i_retval = virDomainGetInfo(domain, &dominfo);
1233 LIBVIRT_END_ALLOW_THREADS;
1234
1235 if (i_retval < 0)
1236 return VIR_PY_NONE;
1237
1238 if (VIR_ALLOC_N(cpuinfo, dominfo.nrVirtCpu) < 0)
1239 return PyErr_NoMemory();
1240
1241 cpumaplen = VIR_CPU_MAPLEN(cpunum);
1242 if (xalloc_oversized(dominfo.nrVirtCpu, cpumaplen) ||
1243 VIR_ALLOC_N(cpumap, dominfo.nrVirtCpu * cpumaplen) < 0) {
1244 error = PyErr_NoMemory();
1245 goto cleanup;
1246 }
1247
1248 LIBVIRT_BEGIN_ALLOW_THREADS;
1249 i_retval = virDomainGetVcpus(domain,
1250 cpuinfo, dominfo.nrVirtCpu,
1251 cpumap, cpumaplen);
1252 LIBVIRT_END_ALLOW_THREADS;
1253
1254 if (i_retval < 0) {
1255 error = VIR_PY_NONE;
1256 goto cleanup;
1257 }
1258
1259 /* convert to a Python tuple of long objects */
1260 if ((pyretval = PyTuple_New(2)) == NULL)
1261 goto cleanup;
1262 if ((pycpuinfo = PyList_New(dominfo.nrVirtCpu)) == NULL)
1263 goto cleanup;
1264
1265 VIR_PY_TUPLE_SET_GOTO(pyretval, 0, pycpuinfo, cleanup);
1266
1267 if ((pycpumap = PyList_New(dominfo.nrVirtCpu)) == NULL)
1268 goto cleanup;
1269
1270 VIR_PY_TUPLE_SET_GOTO(pyretval, 1, pycpumap, cleanup);
1271
1272 for (i = 0; i < dominfo.nrVirtCpu; i++) {
1273 PyObject *info = PyTuple_New(4);
1274
1275 if (info == NULL)
1276 goto cleanup;
1277
1278 VIR_PY_LIST_SET_GOTO(pycpuinfo, i, info, cleanup);
1279
1280 VIR_PY_TUPLE_SET_GOTO(info, 0, libvirt_intWrap(cpuinfo[i].number),
1281 cleanup);
1282 VIR_PY_TUPLE_SET_GOTO(info, 1, libvirt_intWrap(cpuinfo[i].state),
1283 cleanup);
1284 VIR_PY_TUPLE_SET_GOTO(info, 2,
1285 libvirt_ulonglongWrap(cpuinfo[i].cpuTime),
1286 cleanup);
1287 VIR_PY_TUPLE_SET_GOTO(info, 3, libvirt_intWrap(cpuinfo[i].cpu),
1288 cleanup);
1289 }
1290 for (i = 0; i < dominfo.nrVirtCpu; i++) {
1291 PyObject *info = PyTuple_New(cpunum);
1292 ssize_t j;
1293 if (info == NULL)
1294 goto cleanup;
1295
1296 VIR_PY_LIST_SET_GOTO(pycpumap, i, info, cleanup);
1297
1298 for (j = 0; j < cpunum; j++) {
1299 VIR_PY_TUPLE_SET_GOTO(info, j,
1300 PyBool_FromLong(VIR_CPU_USABLE(cpumap,
1301 cpumaplen,
1302 i, j)),
1303 cleanup);
1304 }
1305 }
1306
1307 VIR_FREE(cpuinfo);
1308 VIR_FREE(cpumap);
1309
1310 return pyretval;
1311
1312 cleanup:
1313 VIR_FREE(cpuinfo);
1314 VIR_FREE(cpumap);
1315 Py_XDECREF(pyretval);
1316 return error;
1317 }
1318
1319
1320 static PyObject *
1321 libvirt_virDomainPinVcpu(PyObject *self ATTRIBUTE_UNUSED,
1322 PyObject *args)
1323 {
1324 virDomainPtr domain;
1325 PyObject *pyobj_domain, *pycpumap;
1326 PyObject *ret = NULL;
1327 unsigned char *cpumap;
1328 int cpumaplen, vcpu, cpunum;
1329 int i_retval;
1330
1331 if (!PyArg_ParseTuple(args, (char *)"OiO:virDomainPinVcpu",
1332 &pyobj_domain, &vcpu, &pycpumap))
1333 return NULL;
1334 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
1335
1336 if ((cpunum = getPyNodeCPUCount(virDomainGetConnect(domain))) < 0)
1337 return VIR_PY_INT_FAIL;
1338
1339 if (virPyCpumapConvert(cpunum, pycpumap, &cpumap, &cpumaplen) < 0)
1340 return NULL;
1341
1342 LIBVIRT_BEGIN_ALLOW_THREADS;
1343 i_retval = virDomainPinVcpu(domain, vcpu, cpumap, cpumaplen);
1344 LIBVIRT_END_ALLOW_THREADS;
1345
1346 if (i_retval < 0) {
1347 ret = VIR_PY_INT_FAIL;
1348 goto cleanup;
1349 }
1350 ret = VIR_PY_INT_SUCCESS;
1351
1352 cleanup:
1353 VIR_FREE(cpumap);
1354 return ret;
1355 }
1356
1357 static PyObject *
1358 libvirt_virDomainPinVcpuFlags(PyObject *self ATTRIBUTE_UNUSED,
1359 PyObject *args)
1360 {
1361 virDomainPtr domain;
1362 PyObject *pyobj_domain, *pycpumap;
1363 PyObject *ret = NULL;
1364 unsigned char *cpumap;
1365 int cpumaplen, vcpu, cpunum;
1366 unsigned int flags;
1367 int i_retval;
1368
1369 if (!PyArg_ParseTuple(args, (char *)"OiOI:virDomainPinVcpuFlags",
1370 &pyobj_domain, &vcpu, &pycpumap, &flags))
1371 return NULL;
1372 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
1373
1374 if ((cpunum = getPyNodeCPUCount(virDomainGetConnect(domain))) < 0)
1375 return VIR_PY_INT_FAIL;
1376
1377 if (virPyCpumapConvert(cpunum, pycpumap, &cpumap, &cpumaplen) < 0)
1378 return NULL;
1379
1380 LIBVIRT_BEGIN_ALLOW_THREADS;
1381 i_retval = virDomainPinVcpuFlags(domain, vcpu, cpumap, cpumaplen, flags);
1382 LIBVIRT_END_ALLOW_THREADS;
1383 if (i_retval < 0) {
1384 ret = VIR_PY_INT_FAIL;
1385 goto cleanup;
1386 }
1387 ret = VIR_PY_INT_SUCCESS;
1388
1389 cleanup:
1390 VIR_FREE(cpumap);
1391 return ret;
1392 }
1393
1394 static PyObject *
1395 libvirt_virDomainGetVcpuPinInfo(PyObject *self ATTRIBUTE_UNUSED,
1396 PyObject *args)
1397 {
1398 virDomainPtr domain;
1399 PyObject *pyobj_domain, *pycpumaps = NULL, *error = NULL;
1400 virDomainInfo dominfo;
1401 unsigned char *cpumaps = NULL;
1402 ssize_t cpumaplen, vcpu, pcpu;
1403 unsigned int flags;
1404 int i_retval, cpunum;
1405
1406 if (!PyArg_ParseTuple(args, (char *)"OI:virDomainGetVcpuPinInfo",
1407 &pyobj_domain, &flags))
1408 return NULL;
1409 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
1410
1411 if ((cpunum = getPyNodeCPUCount(virDomainGetConnect(domain))) < 0)
1412 return VIR_PY_NONE;
1413
1414 LIBVIRT_BEGIN_ALLOW_THREADS;
1415 i_retval = virDomainGetInfo(domain, &dominfo);
1416 LIBVIRT_END_ALLOW_THREADS;
1417
1418 if (i_retval < 0)
1419 return VIR_PY_NONE;
1420
1421 cpumaplen = VIR_CPU_MAPLEN(cpunum);
1422 if (xalloc_oversized(dominfo.nrVirtCpu, cpumaplen) ||
1423 VIR_ALLOC_N(cpumaps, dominfo.nrVirtCpu * cpumaplen) < 0)
1424 goto cleanup;
1425
1426 LIBVIRT_BEGIN_ALLOW_THREADS;
1427 i_retval = virDomainGetVcpuPinInfo(domain, dominfo.nrVirtCpu,
1428 cpumaps, cpumaplen, flags);
1429 LIBVIRT_END_ALLOW_THREADS;
1430
1431 if (i_retval < 0) {
1432 error = VIR_PY_NONE;
1433 goto cleanup;
1434 }
1435
1436 if ((pycpumaps = PyList_New(dominfo.nrVirtCpu)) == NULL)
1437 goto cleanup;
1438
1439 for (vcpu = 0; vcpu < dominfo.nrVirtCpu; vcpu++) {
1440 PyObject *mapinfo = PyTuple_New(cpunum);
1441 if (mapinfo == NULL)
1442 goto cleanup;
1443
1444 VIR_PY_LIST_SET_GOTO(pycpumaps, vcpu, mapinfo, cleanup);
1445
1446 for (pcpu = 0; pcpu < cpunum; pcpu++) {
1447 VIR_PY_TUPLE_SET_GOTO(mapinfo,
1448 pcpu,
1449 PyBool_FromLong(VIR_CPU_USABLE(cpumaps,
1450 cpumaplen,
1451 vcpu,
1452 pcpu)),
1453 cleanup);
1454 }
1455 }
1456
1457 VIR_FREE(cpumaps);
1458
1459 return pycpumaps;
1460
1461 cleanup:
1462 VIR_FREE(cpumaps);
1463
1464 Py_XDECREF(pycpumaps);
1465
1466 return error;
1467 }
1468
1469
1470 #if LIBVIR_CHECK_VERSION(0, 10, 0)
1471 static PyObject *
1472 libvirt_virDomainPinEmulator(PyObject *self ATTRIBUTE_UNUSED,
1473 PyObject *args)
1474 {
1475 virDomainPtr domain;
1476 PyObject *pyobj_domain, *pycpumap;
1477 unsigned char *cpumap = NULL;
1478 int cpumaplen, cpunum;
1479 int i_retval;
1480 unsigned int flags;
1481
1482 if (!PyArg_ParseTuple(args, (char *)"OOI:virDomainPinEmulator",
1483 &pyobj_domain, &pycpumap, &flags))
1484 return NULL;
1485
1486 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
1487
1488 if ((cpunum = getPyNodeCPUCount(virDomainGetConnect(domain))) < 0)
1489 return VIR_PY_INT_FAIL;
1490
1491 if (virPyCpumapConvert(cpunum, pycpumap, &cpumap, &cpumaplen) < 0)
1492 return NULL;
1493
1494 LIBVIRT_BEGIN_ALLOW_THREADS;
1495 i_retval = virDomainPinEmulator(domain, cpumap, cpumaplen, flags);
1496 LIBVIRT_END_ALLOW_THREADS;
1497
1498 VIR_FREE(cpumap);
1499
1500 if (i_retval < 0)
1501 return VIR_PY_INT_FAIL;
1502
1503 return VIR_PY_INT_SUCCESS;
1504 }
1505
1506
1507 static PyObject *
1508 libvirt_virDomainGetEmulatorPinInfo(PyObject *self ATTRIBUTE_UNUSED,
1509 PyObject *args)
1510 {
1511 virDomainPtr domain;
1512 PyObject *pyobj_domain;
1513 PyObject *pycpumap;
1514 unsigned char *cpumap;
1515 ssize_t cpumaplen;
1516 ssize_t pcpu;
1517 unsigned int flags;
1518 int ret;
1519 int cpunum;
1520
1521 if (!PyArg_ParseTuple(args, (char *)"OI:virDomainGetEmulatorPinInfo",
1522 &pyobj_domain, &flags))
1523 return NULL;
1524
1525 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
1526
1527 if ((cpunum = getPyNodeCPUCount(virDomainGetConnect(domain))) < 0)
1528 return VIR_PY_NONE;
1529
1530 cpumaplen = VIR_CPU_MAPLEN(cpunum);
1531
1532 if (VIR_ALLOC_N(cpumap, cpumaplen) < 0)
1533 return PyErr_NoMemory();
1534
1535 LIBVIRT_BEGIN_ALLOW_THREADS;
1536 ret = virDomainGetEmulatorPinInfo(domain, cpumap, cpumaplen, flags);
1537 LIBVIRT_END_ALLOW_THREADS;
1538
1539 if (ret < 0) {
1540 VIR_FREE(cpumap);
1541 return VIR_PY_NONE;
1542 }
1543
1544 if (!(pycpumap = PyTuple_New(cpunum))) {
1545 VIR_FREE(cpumap);
1546 return NULL;
1547 }
1548
1549 for (pcpu = 0; pcpu < cpunum; pcpu++) {
1550 VIR_PY_TUPLE_SET_GOTO(pycpumap,
1551 pcpu,
1552 PyBool_FromLong(VIR_CPU_USABLE(cpumap,
1553 cpumaplen,
1554 0,
1555 pcpu)),
1556 error);
1557 }
1558
1559 cleanup:
1560 VIR_FREE(cpumap);
1561 return pycpumap;
1562
1563 error:
1564 Py_CLEAR(pycpumap);
1565 goto cleanup;
1566 }
1567 #endif /* LIBVIR_CHECK_VERSION(0, 10, 0) */
1568
1569 #if LIBVIR_CHECK_VERSION(1, 2, 14)
1570 static PyObject *
1571 libvirt_virDomainGetIOThreadInfo(PyObject *self ATTRIBUTE_UNUSED,
1572 PyObject *args)
1573 {
1574 virDomainPtr domain;
1575 PyObject *pyobj_domain;
1576 PyObject *py_retval = NULL;
1577 PyObject *py_iothrinfo = NULL;
1578 virDomainIOThreadInfoPtr *iothrinfo = NULL;
1579 unsigned int flags;
1580 ssize_t pcpu, i;
1581 int niothreads, cpunum;
1582
1583 if (!PyArg_ParseTuple(args, (char *)"OI:virDomainGetIOThreadInfo",
1584 &pyobj_domain, &flags))
1585 return NULL;
1586 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
1587
1588 if ((cpunum = getPyNodeCPUCount(virDomainGetConnect(domain))) < 0)
1589 return VIR_PY_NONE;
1590
1591 LIBVIRT_BEGIN_ALLOW_THREADS;
1592 niothreads = virDomainGetIOThreadInfo(domain, &iothrinfo, flags);
1593 LIBVIRT_END_ALLOW_THREADS;
1594
1595 if (niothreads < 0) {
1596 py_retval = VIR_PY_NONE;
1597 goto cleanup;
1598 }
1599
1600 /* convert to a Python list */
1601 if ((py_iothrinfo = PyList_New(niothreads)) == NULL)
1602 goto cleanup;
1603
1604 /* NOTE: If there are zero IOThreads we will return an empty list */
1605 for (i = 0; i < niothreads; i++) {
1606 PyObject *iothrtpl = NULL;
1607 PyObject *iothrmap = NULL;
1608 virDomainIOThreadInfoPtr iothr = iothrinfo[i];
1609
1610 if (iothr == NULL) {
1611 py_retval = VIR_PY_NONE;
1612 goto cleanup;
1613 }
1614
1615 if ((iothrtpl = PyTuple_New(2)) == NULL)
1616 goto cleanup;
1617
1618 VIR_PY_LIST_SET_GOTO(py_iothrinfo, i, iothrtpl, cleanup);
1619
1620 /* 0: IOThread ID */
1621 VIR_PY_TUPLE_SET_GOTO(iothrtpl, 0, libvirt_uintWrap(iothr->iothread_id),
1622 cleanup);
1623
1624 /* 1: CPU map */
1625 if ((iothrmap = PyList_New(cpunum)) == NULL)
1626 goto cleanup;
1627
1628 VIR_PY_TUPLE_SET_GOTO(iothrtpl, 1, iothrmap, cleanup);
1629
1630 for (pcpu = 0; pcpu < cpunum; pcpu++)
1631 if (VIR_CPU_MAPLEN(pcpu + 1) > iothr->cpumaplen) {
1632 VIR_PY_LIST_SET_GOTO(iothrmap, pcpu, PyBool_FromLong(0), cleanup);
1633 } else {
1634 VIR_PY_LIST_SET_GOTO(iothrmap, pcpu,
1635 PyBool_FromLong(VIR_CPU_USED(iothr->cpumap,
1636 pcpu)),
1637 cleanup);
1638 }
1639 }
1640
1641 py_retval = py_iothrinfo;
1642 py_iothrinfo = NULL;
1643
1644 cleanup:
1645 if (niothreads > 0) {
1646 for (i = 0; i < niothreads; i++)
1647 virDomainIOThreadInfoFree(iothrinfo[i]);
1648 }
1649 VIR_FREE(iothrinfo);
1650 Py_XDECREF(py_iothrinfo);
1651 return py_retval;
1652 }
1653
1654 static PyObject *
1655 libvirt_virDomainPinIOThread(PyObject *self ATTRIBUTE_UNUSED,
1656 PyObject *args)
1657 {
1658 virDomainPtr domain;
1659 PyObject *pyobj_domain, *pycpumap;
1660 PyObject *ret = NULL;
1661 unsigned char *cpumap;
1662 int cpumaplen, iothread_val, cpunum;
1663 unsigned int flags;
1664 int i_retval;
1665
1666 if (!PyArg_ParseTuple(args, (char *)"OiOI:virDomainPinIOThread",
1667 &pyobj_domain, &iothread_val, &pycpumap, &flags))
1668 return NULL;
1669 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
1670
1671 if ((cpunum = getPyNodeCPUCount(virDomainGetConnect(domain))) < 0)
1672 return VIR_PY_INT_FAIL;
1673
1674 if (virPyCpumapConvert(cpunum, pycpumap, &cpumap, &cpumaplen) < 0)
1675 return NULL;
1676
1677 LIBVIRT_BEGIN_ALLOW_THREADS;
1678 i_retval = virDomainPinIOThread(domain, iothread_val,
1679 cpumap, cpumaplen, flags);
1680 LIBVIRT_END_ALLOW_THREADS;
1681
1682 if (i_retval < 0) {
1683 ret = VIR_PY_INT_FAIL;
1684 goto cleanup;
1685 }
1686 ret = VIR_PY_INT_SUCCESS;
1687
1688 cleanup:
1689 VIR_FREE(cpumap);
1690 return ret;
1691 }
1692
1693 #endif /* LIBVIR_CHECK_VERSION(1, 2, 14) */
1694
1695 #if LIBVIR_CHECK_VERSION(4, 10, 0)
1696
1697 static virPyTypedParamsHint virPyDomainSetIOThreadParams[] = {
1698 { VIR_DOMAIN_IOTHREAD_POLL_MAX_NS, VIR_TYPED_PARAM_ULLONG },
1699 { VIR_DOMAIN_IOTHREAD_POLL_GROW, VIR_TYPED_PARAM_UINT },
1700 { VIR_DOMAIN_IOTHREAD_POLL_SHRINK, VIR_TYPED_PARAM_UINT },
1701 # if LIBVIR_CHECK_VERSION(8, 5, 0)
1702 { VIR_DOMAIN_IOTHREAD_THREAD_POOL_MIN, VIR_TYPED_PARAM_INT },
1703 { VIR_DOMAIN_IOTHREAD_THREAD_POOL_MAX, VIR_TYPED_PARAM_INT },
1704 # endif /* LIBVIR_CHECK_VERSION(8, 5, 0) */
1705 };
1706
1707 static PyObject *
1708 libvirt_virDomainSetIOThreadParams(PyObject *self ATTRIBUTE_UNUSED,
1709 PyObject *args)
1710 {
1711 PyObject *pyobj_dom = NULL;
1712 PyObject *pyobj_dict = NULL;
1713
1714 virDomainPtr dom;
1715 int iothread_val;
1716 virTypedParameterPtr params = NULL;
1717 int nparams = 0;
1718 unsigned int flags;
1719 int c_retval;
1720
1721 if (!PyArg_ParseTuple(args, (char *)"OiOI:virDomainSetIOThreadParams",
1722 &pyobj_dom, &iothread_val, &pyobj_dict, &flags))
1723 return NULL;
1724
1725 if (PyDict_Check(pyobj_dict)) {
1726 if (virPyDictToTypedParams(pyobj_dict, &params, &nparams,
1727 virPyDomainSetIOThreadParams,
1728 VIR_N_ELEMENTS(virPyDomainSetIOThreadParams)) < 0) {
1729 return NULL;
1730 }
1731 } else {
1732 PyErr_Format(PyExc_TypeError, "IOThread polling params must be "
1733 "a dictionary");
1734 return NULL;
1735 }
1736
1737 dom = (virDomainPtr) PyvirDomain_Get(pyobj_dom);
1738
1739 LIBVIRT_BEGIN_ALLOW_THREADS;
1740 c_retval = virDomainSetIOThreadParams(dom, iothread_val,
1741 params, nparams, flags);
1742 LIBVIRT_END_ALLOW_THREADS;
1743
1744 virTypedParamsFree(params, nparams);
1745
1746 return libvirt_intWrap(c_retval);
1747 }
1748 #endif /* LIBVIR_CHECK_VERSION(4, 10, 0) */
1749
1750 /************************************************************************
1751 * *
1752 * Global error handler at the Python level *
1753 * *
1754 ************************************************************************/
1755
1756 static PyObject *libvirt_virPythonErrorFuncHandler = NULL;
1757 static PyObject *libvirt_virPythonErrorFuncCtxt = NULL;
1758
1759 static PyObject *
1760 libvirt_virGetLastError(PyObject *self ATTRIBUTE_UNUSED,
1761 PyObject *args ATTRIBUTE_UNUSED)
1762 {
1763 virError *err;
1764 PyObject *info;
1765
1766 if ((err = virGetLastError()) == NULL)
1767 return VIR_PY_NONE;
1768
1769 if ((info = PyTuple_New(9)) == NULL)
1770 return NULL;
1771
1772 VIR_PY_TUPLE_SET_GOTO(info, 0, libvirt_intWrap(err->code), error);
1773 VIR_PY_TUPLE_SET_GOTO(info, 1, libvirt_intWrap(err->domain), error);
1774 VIR_PY_TUPLE_SET_GOTO(info, 2, libvirt_constcharPtrWrap(err->message), error);
1775 VIR_PY_TUPLE_SET_GOTO(info, 3, libvirt_intWrap(err->level), error);
1776 VIR_PY_TUPLE_SET_GOTO(info, 4, libvirt_constcharPtrWrap(err->str1), error);
1777 VIR_PY_TUPLE_SET_GOTO(info, 5, libvirt_constcharPtrWrap(err->str2), error);
1778 VIR_PY_TUPLE_SET_GOTO(info, 6, libvirt_constcharPtrWrap(err->str3), error);
1779 VIR_PY_TUPLE_SET_GOTO(info, 7, libvirt_intWrap(err->int1), error);
1780 VIR_PY_TUPLE_SET_GOTO(info, 8, libvirt_intWrap(err->int2), error);
1781
1782 return info;
1783
1784 error:
1785 Py_XDECREF(info);
1786 return NULL;
1787 }
1788
1789 static PyObject *
1790 libvirt_virConnGetLastError(PyObject *self ATTRIBUTE_UNUSED,
1791 PyObject *args)
1792 {
1793 virError *err;
1794 PyObject *info;
1795 virConnectPtr conn;
1796 PyObject *pyobj_conn;
1797
1798 if (!PyArg_ParseTuple(args, (char *)"O:virConGetLastError", &pyobj_conn))
1799 return NULL;
1800 conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
1801
1802 LIBVIRT_BEGIN_ALLOW_THREADS;
1803 err = virConnGetLastError(conn);
1804 LIBVIRT_END_ALLOW_THREADS;
1805
1806 if (err == NULL)
1807 return VIR_PY_NONE;
1808
1809 if ((info = PyTuple_New(9)) == NULL)
1810 return NULL;
1811
1812 VIR_PY_TUPLE_SET_GOTO(info, 0, libvirt_intWrap(err->code), error);
1813 VIR_PY_TUPLE_SET_GOTO(info, 1, libvirt_intWrap(err->domain), error);
1814 VIR_PY_TUPLE_SET_GOTO(info, 2, libvirt_constcharPtrWrap(err->message), error);
1815 VIR_PY_TUPLE_SET_GOTO(info, 3, libvirt_intWrap(err->level), error);
1816 VIR_PY_TUPLE_SET_GOTO(info, 4, libvirt_constcharPtrWrap(err->str1), error);
1817 VIR_PY_TUPLE_SET_GOTO(info, 5, libvirt_constcharPtrWrap(err->str2), error);
1818 VIR_PY_TUPLE_SET_GOTO(info, 6, libvirt_constcharPtrWrap(err->str3), error);
1819 VIR_PY_TUPLE_SET_GOTO(info, 7, libvirt_intWrap(err->int1), error);
1820 VIR_PY_TUPLE_SET_GOTO(info, 8, libvirt_intWrap(err->int2), error);
1821
1822 return info;
1823
1824 error:
1825 Py_XDECREF(info);
1826 return NULL;
1827 }
1828
1829 static void
1830 libvirt_virErrorFuncHandler(ATTRIBUTE_UNUSED void *ctx,
1831 virErrorPtr err)
1832 {
1833 PyObject *list = NULL, *info = NULL;
1834 PyObject *result;
1835
1836 DEBUG("libvirt_virErrorFuncHandler(%p, %s, ...) called\n", ctx,
1837 err->message);
1838
1839 if ((err == NULL) || (err->code == VIR_ERR_OK))
1840 return;
1841
1842 LIBVIRT_ENSURE_THREAD_STATE;
1843
1844 if ((libvirt_virPythonErrorFuncHandler == NULL) ||
1845 (libvirt_virPythonErrorFuncHandler == Py_None)) {
1846 virDefaultErrorFunc(err);
1847 } else {
1848 if ((list = PyTuple_New(2)) == NULL)
1849 goto cleanup;
1850
1851 Py_XINCREF(libvirt_virPythonErrorFuncCtxt);
1852 VIR_PY_TUPLE_SET_GOTO(list, 0, libvirt_virPythonErrorFuncCtxt, cleanup);
1853
1854 if ((info = PyTuple_New(9)) == NULL)
1855 goto cleanup;
1856
1857 VIR_PY_TUPLE_SET_GOTO(list, 1, info, cleanup);
1858
1859 VIR_PY_TUPLE_SET_GOTO(info, 0, libvirt_intWrap(err->code), cleanup);
1860 VIR_PY_TUPLE_SET_GOTO(info, 1, libvirt_intWrap(err->domain), cleanup);
1861 VIR_PY_TUPLE_SET_GOTO(info, 2, libvirt_constcharPtrWrap(err->message), cleanup);
1862 VIR_PY_TUPLE_SET_GOTO(info, 3, libvirt_intWrap(err->level), cleanup);
1863 VIR_PY_TUPLE_SET_GOTO(info, 4, libvirt_constcharPtrWrap(err->str1), cleanup);
1864 VIR_PY_TUPLE_SET_GOTO(info, 5, libvirt_constcharPtrWrap(err->str2), cleanup);
1865 VIR_PY_TUPLE_SET_GOTO(info, 6, libvirt_constcharPtrWrap(err->str3), cleanup);
1866 VIR_PY_TUPLE_SET_GOTO(info, 7, libvirt_intWrap(err->int1), cleanup);
1867 VIR_PY_TUPLE_SET_GOTO(info, 8, libvirt_intWrap(err->int2), cleanup);
1868
1869 /* TODO pass conn and dom if available */
1870 result = PyObject_Call(libvirt_virPythonErrorFuncHandler, list, NULL);
1871 Py_XDECREF(result);
1872 }
1873
1874 cleanup:
1875 Py_XDECREF(list);
1876 LIBVIRT_RELEASE_THREAD_STATE;
1877 }
1878
1879 static PyObject *
1880 libvirt_virRegisterErrorHandler(ATTRIBUTE_UNUSED PyObject *self,
1881 PyObject *args)
1882 {
1883 PyObject *py_retval;
1884 PyObject *pyobj_f;
1885 PyObject *pyobj_ctx;
1886
1887 if (!PyArg_ParseTuple(args, (char *) "OO:virRegisterErrorHandler",
1888 &pyobj_f, &pyobj_ctx))
1889 return NULL;
1890
1891 DEBUG("libvirt_virRegisterErrorHandler(%p, %p) called\n", pyobj_ctx,
1892 pyobj_f);
1893
1894 virSetErrorFunc(NULL, libvirt_virErrorFuncHandler);
1895
1896 Py_XDECREF(libvirt_virPythonErrorFuncHandler);
1897 Py_XDECREF(libvirt_virPythonErrorFuncCtxt);
1898
1899 if ((pyobj_f == Py_None) && (pyobj_ctx == Py_None)) {
1900 libvirt_virPythonErrorFuncHandler = NULL;
1901 libvirt_virPythonErrorFuncCtxt = NULL;
1902 } else {
1903 Py_XINCREF(pyobj_ctx);
1904 Py_XINCREF(pyobj_f);
1905
1906 /* TODO: check f is a function ! */
1907 libvirt_virPythonErrorFuncHandler = pyobj_f;
1908 libvirt_virPythonErrorFuncCtxt = pyobj_ctx;
1909 }
1910
1911 py_retval = libvirt_intWrap(1);
1912 return py_retval;
1913 }
1914
1915 static int
1916 virConnectCredCallbackWrapper(virConnectCredentialPtr cred,
1917 unsigned int ncred,
1918 void *cbdata)
1919 {
1920 PyObject *list = NULL;
1921 PyObject *pycred;
1922 PyObject *pyauth = (PyObject *)cbdata;
1923 PyObject *pycbdata;
1924 PyObject *pycb;
1925 PyObject *pyret = NULL;
1926 int ret = -1;
1927 size_t i;
1928
1929 LIBVIRT_ENSURE_THREAD_STATE;
1930
1931 pycb = PyList_GetItem(pyauth, 1);
1932 pycbdata = PyList_GetItem(pyauth, 2);
1933
1934 if ((list = PyTuple_New(2)) == NULL)
1935 goto cleanup;
1936
1937 if ((pycred = PyTuple_New(ncred)) == NULL)
1938 goto cleanup;
1939
1940 VIR_PY_TUPLE_SET_GOTO(list, 0, pycred, cleanup);
1941
1942 for (i = 0; i < ncred; i++) {
1943 PyObject *pycreditem;
1944 if ((pycreditem = PyList_New(5)) == NULL)
1945 goto cleanup;
1946
1947 VIR_PY_TUPLE_SET_GOTO(pycred, i, pycreditem, cleanup);
1948
1949 VIR_PY_LIST_SET_GOTO(pycreditem, 0,
1950 libvirt_intWrap(cred[i].type), cleanup);
1951 VIR_PY_LIST_SET_GOTO(pycreditem, 1,
1952 libvirt_constcharPtrWrap(cred[i].prompt), cleanup);
1953
1954 if (cred[i].challenge) {
1955 VIR_PY_LIST_SET_GOTO(pycreditem, 2,
1956 libvirt_constcharPtrWrap(cred[i].challenge),
1957 cleanup);
1958 } else {
1959 VIR_PY_LIST_SET_GOTO(pycreditem, 2, VIR_PY_NONE, cleanup);
1960 }
1961 if (cred[i].defresult) {
1962 VIR_PY_LIST_SET_GOTO(pycreditem, 3,
1963 libvirt_constcharPtrWrap(cred[i].defresult),
1964 cleanup);
1965 } else {
1966 VIR_PY_LIST_SET_GOTO(pycreditem, 3, VIR_PY_NONE, cleanup);
1967 }
1968 VIR_PY_LIST_SET_GOTO(pycreditem, 4, VIR_PY_NONE, cleanup);
1969 }
1970
1971 Py_XINCREF(pycbdata);
1972 VIR_PY_TUPLE_SET_GOTO(list, 1, pycbdata, cleanup);
1973
1974 PyErr_Clear();
1975 pyret = PyObject_Call(pycb, list, NULL);
1976 if (PyErr_Occurred()) {
1977 PyErr_Print();
1978 goto cleanup;
1979 }
1980
1981 ret = PyLong_AsLong(pyret);
1982 if (ret == 0) {
1983 for (i = 0; i < ncred; i++) {
1984 PyObject *pycreditem;
1985 PyObject *pyresult;
1986 char *result = NULL;
1987 pycreditem = PyTuple_GetItem(pycred, i);
1988 pyresult = PyList_GetItem(pycreditem, 4);
1989 if (pyresult != Py_None) {
1990 libvirt_charPtrUnwrap(pyresult, &result);
1991 PyErr_Clear();
1992 }
1993 if (result != NULL) {
1994 cred[i].result = result;
1995 cred[i].resultlen = strlen(result);
1996 } else {
1997 cred[i].result = NULL;
1998 cred[i].resultlen = 0;
1999 }
2000 }
2001 }
2002
2003 cleanup:
2004 Py_XDECREF(list);
2005 Py_XDECREF(pyret);
2006
2007 LIBVIRT_RELEASE_THREAD_STATE;
2008
2009 return ret;
2010 }
2011
2012
2013 static PyObject *
2014 libvirt_virConnectOpenAuth(PyObject *self ATTRIBUTE_UNUSED,
2015 PyObject *args)
2016 {
2017 PyObject *py_retval;
2018 virConnectPtr c_retval = NULL;
2019 char * name;
2020 unsigned int flags;
2021 PyObject *pyauth;
2022 PyObject *pycredcb;
2023 PyObject *pycredtype;
2024 virConnectAuth auth;
2025
2026 memset(&auth, 0, sizeof(auth));
2027 if (!PyArg_ParseTuple(args, (char *)"zOI:virConnectOpenAuth",
2028 &name, &pyauth, &flags))
2029 return NULL;
2030
2031 pycredtype = PyList_GetItem(pyauth, 0);
2032 pycredcb = PyList_GetItem(pyauth, 1);
2033
2034 auth.ncredtype = PyList_Size(pycredtype);
2035 if (auth.ncredtype) {
2036 size_t i;
2037 if (VIR_ALLOC_N(auth.credtype, auth.ncredtype) < 0)
2038 return PyErr_NoMemory();
2039 for (i = 0; i < auth.ncredtype; i++) {
2040 PyObject *val;
2041 val = PyList_GetItem(pycredtype, i);
2042 if (libvirt_intUnwrap(val, &auth.credtype[i]) < 0)
2043 goto cleanup;
2044 }
2045 }
2046 if (pycredcb && pycredcb != Py_None)
2047 auth.cb = virConnectCredCallbackWrapper;
2048 auth.cbdata = pyauth;
2049
2050 LIBVIRT_BEGIN_ALLOW_THREADS;
2051 c_retval = virConnectOpenAuth(name, &auth, flags);
2052 LIBVIRT_END_ALLOW_THREADS;
2053
2054 cleanup:
2055 VIR_FREE(auth.credtype);
2056 py_retval = libvirt_virConnectPtrWrap((virConnectPtr) c_retval);
2057 return py_retval;
2058 }
2059
2060
2061 /************************************************************************
2062 * *
2063 * Wrappers for functions where generator fails *
2064 * *
2065 ************************************************************************/
2066
2067 static PyObject *
2068 libvirt_virGetVersion(PyObject *self ATTRIBUTE_UNUSED,
2069 PyObject *args)
2070 {
2071 char *type = NULL;
2072 unsigned long libVer, typeVer = 0;
2073 int c_retval;
2074
2075 if (!PyArg_ParseTuple(args, (char *) "|s:virGetVersion", &type))
2076 return NULL;
2077
2078 LIBVIRT_BEGIN_ALLOW_THREADS;
2079 if (type == NULL)
2080 c_retval = virGetVersion(&libVer, NULL, NULL);
2081 else
2082 c_retval = virGetVersion(&libVer, type, &typeVer);
2083 LIBVIRT_END_ALLOW_THREADS;
2084
2085 if (c_retval == -1)
2086 return VIR_PY_NONE;
2087
2088 if (type == NULL)
2089 return libvirt_intWrap(libVer);
2090 else
2091 return Py_BuildValue((char *) "kk", libVer, typeVer);
2092 }
2093
2094 static PyObject *
2095 libvirt_virConnectGetVersion(PyObject *self ATTRIBUTE_UNUSED,
2096 PyObject *args)
2097 {
2098 unsigned long hvVersion;
2099 int c_retval;
2100 virConnectPtr conn;
2101 PyObject *pyobj_conn;
2102
2103 if (!PyArg_ParseTuple(args, (char *)"O:virConnectGetVersion",
2104 &pyobj_conn))
2105 return NULL;
2106 conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
2107
2108 LIBVIRT_BEGIN_ALLOW_THREADS;
2109 c_retval = virConnectGetVersion(conn, &hvVersion);
2110 LIBVIRT_END_ALLOW_THREADS;
2111
2112 if (c_retval == -1)
2113 return VIR_PY_INT_FAIL;
2114
2115 return libvirt_intWrap(hvVersion);
2116 }
2117
2118 #if LIBVIR_CHECK_VERSION(1, 1, 3)
2119 static PyObject *
2120 libvirt_virConnectGetCPUModelNames(PyObject *self ATTRIBUTE_UNUSED,
2121 PyObject *args)
2122 {
2123 int c_retval;
2124 virConnectPtr conn;
2125 PyObject *rv = NULL, *pyobj_conn;
2126 char **models = NULL;
2127 ssize_t i;
2128 unsigned int flags = 0;
2129 const char *arch = NULL;
2130
2131 if (!PyArg_ParseTuple(args, (char *)"OsI:virConnectGetCPUModelNames",
2132 &pyobj_conn, &arch, &flags))
2133 return NULL;
2134 conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
2135
2136 LIBVIRT_BEGIN_ALLOW_THREADS;
2137 c_retval = virConnectGetCPUModelNames(conn, arch, &models, flags);
2138 LIBVIRT_END_ALLOW_THREADS;
2139
2140 if (c_retval == -1)
2141 return VIR_PY_NONE;
2142
2143 if ((rv = PyList_New(c_retval)) == NULL)
2144 goto error;
2145
2146 for (i = 0; i < c_retval; i++)
2147 VIR_PY_LIST_SET_GOTO(rv, i, libvirt_constcharPtrWrap(models[i]), error);
2148
2149 done:
2150 if (models) {
2151 for (i = 0; i < c_retval; i++)
2152 VIR_FREE(models[i]);
2153 VIR_FREE(models);
2154 }
2155
2156 return rv;
2157
2158 error:
2159 Py_CLEAR(rv);
2160 goto done;
2161 }
2162 #endif /* LIBVIR_CHECK_VERSION(1, 1, 3) */
2163
2164 static PyObject *
2165 libvirt_virConnectGetLibVersion(PyObject *self ATTRIBUTE_UNUSED,
2166 PyObject *args)
2167 {
2168 unsigned long libVer;
2169 int c_retval;
2170 virConnectPtr conn;
2171 PyObject *pyobj_conn;
2172
2173 if (!PyArg_ParseTuple(args, (char *)"O:virConnectGetLibVersion",
2174 &pyobj_conn))
2175 return NULL;
2176 conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
2177
2178 LIBVIRT_BEGIN_ALLOW_THREADS;
2179 c_retval = virConnectGetLibVersion(conn, &libVer);
2180 LIBVIRT_END_ALLOW_THREADS;
2181
2182 if (c_retval == -1)
2183 return VIR_PY_INT_FAIL;
2184
2185 return libvirt_intWrap(libVer);
2186 }
2187
2188 static PyObject *
2189 libvirt_virConnectListDomainsID(PyObject *self ATTRIBUTE_UNUSED,
2190 PyObject *args)
2191 {
2192 PyObject *py_retval;
2193 int *ids = NULL, c_retval;
2194 ssize_t i;
2195 virConnectPtr conn;
2196 PyObject *pyobj_conn;
2197
2198
2199 if (!PyArg_ParseTuple(args, (char *)"O:virConnectListDomains", &pyobj_conn))
2200 return NULL;
2201 conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
2202
2203 LIBVIRT_BEGIN_ALLOW_THREADS;
2204 c_retval = virConnectNumOfDomains(conn);
2205 LIBVIRT_END_ALLOW_THREADS;
2206
2207 if (c_retval < 0)
2208 return VIR_PY_NONE;
2209
2210 if (c_retval) {
2211 if (VIR_ALLOC_N(ids, c_retval) < 0)
2212 return PyErr_NoMemory();
2213
2214 LIBVIRT_BEGIN_ALLOW_THREADS;
2215 c_retval = virConnectListDomains(conn, ids, c_retval);
2216 LIBVIRT_END_ALLOW_THREADS;
2217
2218 if (c_retval < 0) {
2219 py_retval = VIR_PY_NONE;
2220 goto cleanup;
2221 }
2222 }
2223
2224 if ((py_retval = PyList_New(c_retval)) == NULL)
2225 goto cleanup;
2226
2227 if (ids)
2228 for (i = 0; i < c_retval; i++)
2229 VIR_PY_LIST_SET_GOTO(py_retval, i, libvirt_intWrap(ids[i]), error);
2230
2231 cleanup:
2232 VIR_FREE(ids);
2233 return py_retval;
2234
2235 error:
2236 VIR_FREE(ids);
2237 Py_XDECREF(py_retval);
2238 return NULL;
2239 }
2240
2241 #if LIBVIR_CHECK_VERSION(0, 9, 13)
2242 static PyObject *
2243 libvirt_virConnectListAllDomains(PyObject *self ATTRIBUTE_UNUSED,
2244 PyObject *args)
2245 {
2246 PyObject *pyobj_conn;
2247 PyObject *py_retval = NULL;
2248 virConnectPtr conn;
2249 virDomainPtr *doms = NULL;
2250 int c_retval = 0;
2251 ssize_t i;
2252 unsigned int flags;
2253
2254 if (!PyArg_ParseTuple(args, (char *)"OI:virConnectListAllDomains",
2255 &pyobj_conn, &flags))
2256 return NULL;
2257 conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
2258
2259 LIBVIRT_BEGIN_ALLOW_THREADS;
2260 c_retval = virConnectListAllDomains(conn, &doms, flags);
2261 LIBVIRT_END_ALLOW_THREADS;
2262
2263 if (c_retval < 0)
2264 return VIR_PY_NONE;
2265
2266 if (!(py_retval = PyList_New(c_retval)))
2267 goto cleanup;
2268
2269 for (i = 0; i < c_retval; i++) {
2270 VIR_PY_LIST_SET_GOTO(py_retval, i, libvirt_virDomainPtrWrap(doms[i]), error);
2271 /* python steals the pointer */
2272 doms[i] = NULL;
2273 }
2274
2275 cleanup:
2276 for (i = 0; i < c_retval; i++)
2277 if (doms[i])
2278 virDomainFree(doms[i]);
2279 VIR_FREE(doms);
2280 return py_retval;
2281
2282 error:
2283 Py_CLEAR(py_retval);
2284 goto cleanup;
2285 }
2286 #endif /* LIBVIR_CHECK_VERSION(0, 9, 13) */
2287
2288 static PyObject *
2289 libvirt_virConnectListDefinedDomains(PyObject *self ATTRIBUTE_UNUSED,
2290 PyObject *args)
2291 {
2292 PyObject *py_retval;
2293 char **names = NULL;
2294 int c_retval;
2295 ssize_t i;
2296 virConnectPtr conn;
2297 PyObject *pyobj_conn;
2298
2299
2300 if (!PyArg_ParseTuple(args, (char *)"O:virConnectListDefinedDomains",
2301 &pyobj_conn))
2302 return NULL;
2303 conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
2304
2305 LIBVIRT_BEGIN_ALLOW_THREADS;
2306 c_retval = virConnectNumOfDefinedDomains(conn);
2307 LIBVIRT_END_ALLOW_THREADS;
2308
2309 if (c_retval < 0)
2310 return VIR_PY_NONE;
2311
2312 if (c_retval) {
2313 if (VIR_ALLOC_N(names, c_retval) < 0)
2314 return PyErr_NoMemory();
2315
2316 LIBVIRT_BEGIN_ALLOW_THREADS;
2317 c_retval = virConnectListDefinedDomains(conn, names, c_retval);
2318 LIBVIRT_END_ALLOW_THREADS;
2319
2320 if (c_retval < 0) {
2321 py_retval = VIR_PY_NONE;
2322 goto cleanup;
2323 }
2324 }
2325
2326 if ((py_retval = PyList_New(c_retval)) == NULL)
2327 goto cleanup;
2328
2329 if (names) {
2330 for (i = 0; i < c_retval; i++)
2331 VIR_PY_LIST_SET_GOTO(py_retval, i,
2332 libvirt_constcharPtrWrap(names[i]), error);
2333 }
2334
2335 cleanup:
2336 if (c_retval > 0)
2337 for (i = 0; i < c_retval; i++)
2338 VIR_FREE(names[i]);
2339 VIR_FREE(names);
2340 return py_retval;
2341
2342 error:
2343 Py_CLEAR(py_retval);
2344 goto cleanup;
2345 }
2346
2347 #if LIBVIR_CHECK_VERSION(5, 6, 0)
2348 static PyObject *
2349 libvirt_virDomainListAllCheckpoints(PyObject *self ATTRIBUTE_UNUSED,
2350 PyObject *args)
2351 {
2352 PyObject *py_retval = NULL;
2353 virDomainCheckpointPtr *chks = NULL;
2354 int c_retval;
2355 ssize_t i;
2356 virDomainPtr dom;
2357 PyObject *pyobj_dom;
2358 unsigned int flags;
2359
2360 if (!PyArg_ParseTuple(args, (char *)"OI:virDomainListAllCheckpoints",
2361 &pyobj_dom, &flags))
2362 return NULL;
2363 dom = (virDomainPtr) PyvirDomain_Get(pyobj_dom);
2364
2365 LIBVIRT_BEGIN_ALLOW_THREADS;
2366 c_retval = virDomainListAllCheckpoints(dom, &chks, flags);
2367 LIBVIRT_END_ALLOW_THREADS;
2368
2369 if (c_retval < 0)
2370 return VIR_PY_NONE;
2371
2372 if (!(py_retval = PyList_New(c_retval)))
2373 goto cleanup;
2374
2375 for (i = 0; i < c_retval; i++) {
2376 VIR_PY_LIST_SET_GOTO(py_retval, i,
2377 libvirt_virDomainCheckpointPtrWrap(chks[i]), error);
2378 chks[i] = NULL;
2379 }
2380
2381 cleanup:
2382 for (i = 0; i < c_retval; i++)
2383 if (chks[i])
2384 virDomainCheckpointFree(chks[i]);
2385 VIR_FREE(chks);
2386 return py_retval;
2387
2388 error:
2389 Py_CLEAR(py_retval);
2390 goto cleanup;
2391 }
2392
2393 static PyObject *
2394 libvirt_virDomainCheckpointListAllChildren(PyObject *self ATTRIBUTE_UNUSED,
2395 PyObject *args)
2396 {
2397 PyObject *py_retval = NULL;
2398 virDomainCheckpointPtr *chks = NULL;
2399 int c_retval;
2400 ssize_t i;
2401 virDomainCheckpointPtr parent;
2402 PyObject *pyobj_parent;
2403 unsigned int flags;
2404
2405 if (!PyArg_ParseTuple(args, (char *)"OI:virDomainCheckpointListAllChildren",
2406 &pyobj_parent, &flags))
2407 return NULL;
2408 parent = (virDomainCheckpointPtr) PyvirDomainCheckpoint_Get(pyobj_parent);
2409
2410 LIBVIRT_BEGIN_ALLOW_THREADS;
2411 c_retval = virDomainCheckpointListAllChildren(parent, &chks, flags);
2412 LIBVIRT_END_ALLOW_THREADS;
2413
2414 if (c_retval < 0)
2415 return VIR_PY_NONE;
2416
2417 if (!(py_retval = PyList_New(c_retval)))
2418 goto cleanup;
2419
2420 for (i = 0; i < c_retval; i++) {
2421 VIR_PY_LIST_SET_GOTO(py_retval, i,
2422 libvirt_virDomainCheckpointPtrWrap(chks[i]), error);
2423 chks[i] = NULL;
2424 }
2425
2426 cleanup:
2427 for (i = 0; i < c_retval; i++)
2428 if (chks[i])
2429 virDomainCheckpointFree(chks[i]);
2430 VIR_FREE(chks);
2431 return py_retval;
2432
2433 error:
2434 Py_CLEAR(py_retval);
2435 goto cleanup;
2436 }
2437 #endif /* LIBVIR_CHECK_VERSION(5, 6, 0) */
2438
2439 static PyObject *
2440 libvirt_virDomainSnapshotListNames(PyObject *self ATTRIBUTE_UNUSED,
2441 PyObject *args)
2442 {
2443 PyObject *py_retval;
2444 char **names = NULL;
2445 int c_retval;
2446 ssize_t i;
2447 virDomainPtr dom;
2448 PyObject *pyobj_dom;
2449 unsigned int flags;
2450
2451 if (!PyArg_ParseTuple(args, (char *)"OI:virDomainSnapshotListNames",
2452 &pyobj_dom, &flags))
2453 return NULL;
2454 dom = (virDomainPtr) PyvirDomain_Get(pyobj_dom);
2455
2456 LIBVIRT_BEGIN_ALLOW_THREADS;
2457 c_retval = virDomainSnapshotNum(dom, flags);
2458 LIBVIRT_END_ALLOW_THREADS;
2459
2460 if (c_retval < 0)
2461 return VIR_PY_NONE;
2462
2463 if (c_retval) {
2464 if (VIR_ALLOC_N(names, c_retval) < 0)
2465 return PyErr_NoMemory();
2466
2467 LIBVIRT_BEGIN_ALLOW_THREADS;
2468 c_retval = virDomainSnapshotListNames(dom, names, c_retval, flags);
2469 LIBVIRT_END_ALLOW_THREADS;
2470
2471 if (c_retval < 0) {
2472 py_retval = VIR_PY_NONE;
2473 goto cleanup;
2474 }
2475 }
2476 py_retval = PyList_New(c_retval);
2477 if (!py_retval)
2478 goto cleanup;
2479
2480 for (i = 0; i < c_retval; i++)
2481 VIR_PY_LIST_SET_GOTO(py_retval, i, libvirt_constcharPtrWrap(names[i]), error);
2482
2483 cleanup:
2484 if (c_retval > 0)
2485 for (i = 0; i < c_retval; i++)
2486 VIR_FREE(names[i]);
2487 VIR_FREE(names);
2488 return py_retval;
2489
2490 error:
2491 Py_CLEAR(py_retval);
2492 goto cleanup;
2493 }
2494
2495 #if LIBVIR_CHECK_VERSION(0, 9, 13)
2496 static PyObject *
2497 libvirt_virDomainListAllSnapshots(PyObject *self ATTRIBUTE_UNUSED,
2498 PyObject *args)
2499 {
2500 PyObject *py_retval = NULL;
2501 virDomainSnapshotPtr *snaps = NULL;
2502 int c_retval;
2503 ssize_t i;
2504 virDomainPtr dom;
2505 PyObject *pyobj_dom;
2506 unsigned int flags;
2507
2508 if (!PyArg_ParseTuple(args, (char *)"OI:virDomainListAllSnapshots",
2509 &pyobj_dom, &flags))
2510 return NULL;
2511 dom = (virDomainPtr) PyvirDomain_Get(pyobj_dom);
2512
2513 LIBVIRT_BEGIN_ALLOW_THREADS;
2514 c_retval = virDomainListAllSnapshots(dom, &snaps, flags);
2515 LIBVIRT_END_ALLOW_THREADS;
2516
2517 if (c_retval < 0)
2518 return VIR_PY_NONE;
2519
2520 if (!(py_retval = PyList_New(c_retval)))
2521 goto cleanup;
2522
2523 for (i = 0; i < c_retval; i++) {
2524 VIR_PY_LIST_SET_GOTO(py_retval, i,
2525 libvirt_virDomainSnapshotPtrWrap(snaps[i]), error);
2526 snaps[i] = NULL;
2527 }
2528
2529 cleanup:
2530 for (i = 0; i < c_retval; i++)
2531 if (snaps[i])
2532 virDomainSnapshotFree(snaps[i]);
2533 VIR_FREE(snaps);
2534 return py_retval;
2535
2536 error:
2537 Py_CLEAR(py_retval);
2538 goto cleanup;
2539 }
2540 #endif /* LIBVIR_CHECK_VERSION(0, 9, 13) */
2541
2542 static PyObject *
2543 libvirt_virDomainSnapshotListChildrenNames(PyObject *self ATTRIBUTE_UNUSED,
2544 PyObject *args)
2545 {
2546 PyObject *py_retval;
2547 char **names = NULL;
2548 int c_retval;
2549 ssize_t i;
2550 virDomainSnapshotPtr snap;
2551 PyObject *pyobj_snap;
2552 unsigned int flags;
2553
2554 if (!PyArg_ParseTuple(args, (char *)"OI:virDomainSnapshotListChildrenNames",
2555 &pyobj_snap, &flags))
2556 return NULL;
2557 snap = (virDomainSnapshotPtr) PyvirDomainSnapshot_Get(pyobj_snap);
2558
2559 LIBVIRT_BEGIN_ALLOW_THREADS;
2560 c_retval = virDomainSnapshotNumChildren(snap, flags);
2561 LIBVIRT_END_ALLOW_THREADS;
2562
2563 if (c_retval < 0)
2564 return VIR_PY_NONE;
2565
2566 if (c_retval) {
2567 if (VIR_ALLOC_N(names, c_retval) < 0)
2568 return PyErr_NoMemory();
2569
2570 LIBVIRT_BEGIN_ALLOW_THREADS;
2571 c_retval = virDomainSnapshotListChildrenNames(snap, names, c_retval,
2572 flags);
2573 LIBVIRT_END_ALLOW_THREADS;
2574
2575 if (c_retval < 0) {
2576 py_retval = VIR_PY_NONE;
2577 goto cleanup;
2578 }
2579 }
2580
2581 if ((py_retval = PyList_New(c_retval)) == NULL)
2582 goto cleanup;
2583
2584 for (i = 0; i < c_retval; i++)
2585 VIR_PY_LIST_SET_GOTO(py_retval, i, libvirt_constcharPtrWrap(names[i]), error);
2586
2587 cleanup:
2588 if (c_retval > 0)
2589 for (i = 0; i < c_retval; i++)
2590 VIR_FREE(names[i]);
2591 VIR_FREE(names);
2592 return py_retval;
2593
2594 error:
2595 Py_CLEAR(py_retval);
2596 goto cleanup;
2597 }
2598
2599 #if LIBVIR_CHECK_VERSION(0, 9, 13)
2600 static PyObject *
2601 libvirt_virDomainSnapshotListAllChildren(PyObject *self ATTRIBUTE_UNUSED,
2602 PyObject *args)
2603 {
2604 PyObject *py_retval = NULL;
2605 virDomainSnapshotPtr *snaps = NULL;
2606 int c_retval;
2607 ssize_t i;
2608 virDomainSnapshotPtr parent;
2609 PyObject *pyobj_parent;
2610 unsigned int flags;
2611
2612 if (!PyArg_ParseTuple(args, (char *)"OI:virDomainSnapshotListAllChildren",
2613 &pyobj_parent, &flags))
2614 return NULL;
2615 parent = (virDomainSnapshotPtr) PyvirDomainSnapshot_Get(pyobj_parent);
2616
2617 LIBVIRT_BEGIN_ALLOW_THREADS;
2618 c_retval = virDomainSnapshotListAllChildren(parent, &snaps, flags);
2619 LIBVIRT_END_ALLOW_THREADS;
2620
2621 if (c_retval < 0)
2622 return VIR_PY_NONE;
2623
2624 if (!(py_retval = PyList_New(c_retval)))
2625 goto cleanup;
2626
2627 for (i = 0; i < c_retval; i++) {
2628 VIR_PY_LIST_SET_GOTO(py_retval, i,
2629 libvirt_virDomainSnapshotPtrWrap(snaps[i]), error);
2630 snaps[i] = NULL;
2631 }
2632
2633 cleanup:
2634 for (i = 0; i < c_retval; i++)
2635 if (snaps[i])
2636 virDomainSnapshotFree(snaps[i]);
2637 VIR_FREE(snaps);
2638 return py_retval;
2639
2640 error:
2641 Py_CLEAR(py_retval);
2642 goto cleanup;
2643 }
2644 #endif /* LIBVIR_CHECK_VERSION(0, 9, 13) */
2645
2646 static PyObject *
2647 libvirt_virDomainRevertToSnapshot(PyObject *self ATTRIBUTE_UNUSED,
2648 PyObject *args)
2649 {
2650 int c_retval;
2651 virDomainSnapshotPtr snap;
2652 PyObject *pyobj_snap;
2653 PyObject *pyobj_dom;
2654 unsigned int flags;
2655
2656 if (!PyArg_ParseTuple(args, (char *)"OOI:virDomainRevertToSnapshot",
2657 &pyobj_dom, &pyobj_snap, &flags))
2658 return NULL;
2659 snap = (virDomainSnapshotPtr) PyvirDomainSnapshot_Get(pyobj_snap);
2660
2661 LIBVIRT_BEGIN_ALLOW_THREADS;
2662 c_retval = virDomainRevertToSnapshot(snap, flags);
2663 LIBVIRT_END_ALLOW_THREADS;
2664
2665 if (c_retval < 0)
2666 return VIR_PY_INT_FAIL;
2667
2668 return libvirt_intWrap(c_retval);
2669 }
2670
2671 static PyObject *
2672 libvirt_virDomainGetInfo(PyObject *self ATTRIBUTE_UNUSED,
2673 PyObject *args)
2674 {
2675 PyObject *py_retval;
2676 int c_retval;
2677 virDomainPtr domain;
2678 PyObject *pyobj_domain;
2679 virDomainInfo info;
2680
2681 if (!PyArg_ParseTuple(args, (char *)"O:virDomainGetInfo", &pyobj_domain))
2682 return NULL;
2683 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
2684
2685 LIBVIRT_BEGIN_ALLOW_THREADS;
2686 c_retval = virDomainGetInfo(domain, &info);
2687 LIBVIRT_END_ALLOW_THREADS;
2688
2689 if (c_retval < 0)
2690 return VIR_PY_NONE;
2691
2692 if ((py_retval = PyList_New(5)) == NULL)
2693 return NULL;
2694
2695 VIR_PY_LIST_SET_GOTO(py_retval, 0, libvirt_intWrap(info.state), error);
2696 VIR_PY_LIST_SET_GOTO(py_retval, 1, libvirt_ulongWrap(info.maxMem), error);
2697 VIR_PY_LIST_SET_GOTO(py_retval, 2, libvirt_ulongWrap(info.memory), error);
2698 VIR_PY_LIST_SET_GOTO(py_retval, 3,
2699 libvirt_intWrap(info.nrVirtCpu), error);
2700 VIR_PY_LIST_SET_GOTO(py_retval, 4,
2701 libvirt_ulonglongWrap(info.cpuTime), error);
2702
2703 return py_retval;
2704
2705 error:
2706 Py_XDECREF(py_retval);
2707 return NULL;
2708 }
2709
2710 static PyObject *
2711 libvirt_virDomainGetState(PyObject *self ATTRIBUTE_UNUSED,
2712 PyObject *args)
2713 {
2714 PyObject *py_retval;
2715 int c_retval;
2716 virDomainPtr domain;
2717 PyObject *pyobj_domain;
2718 int state;
2719 int reason;
2720 unsigned int flags;
2721
2722 if (!PyArg_ParseTuple(args, (char *)"OI:virDomainGetState",
2723 &pyobj_domain, &flags))
2724 return NULL;
2725
2726 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
2727
2728 LIBVIRT_BEGIN_ALLOW_THREADS;
2729 c_retval = virDomainGetState(domain, &state, &reason, flags);
2730 LIBVIRT_END_ALLOW_THREADS;
2731
2732 if (c_retval < 0)
2733 return VIR_PY_NONE;
2734
2735 if ((py_retval = PyList_New(2)) == NULL)
2736 return NULL;
2737
2738 VIR_PY_LIST_SET_GOTO(py_retval, 0, libvirt_intWrap(state), error);
2739 VIR_PY_LIST_SET_GOTO(py_retval, 1, libvirt_intWrap(reason), error);
2740
2741 return py_retval;
2742
2743 error:
2744 Py_XDECREF(py_retval);
2745 return NULL;
2746 }
2747
2748 static PyObject *
2749 libvirt_virDomainGetControlInfo(PyObject *self ATTRIBUTE_UNUSED,
2750 PyObject *args)
2751 {
2752 PyObject *py_retval;
2753 int c_retval;
2754 virDomainPtr domain;
2755 PyObject *pyobj_domain;
2756 virDomainControlInfo info;
2757 unsigned int flags;
2758
2759 if (!PyArg_ParseTuple(args, (char *)"OI:virDomainGetControlInfo",
2760 &pyobj_domain, &flags))
2761 return NULL;
2762 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
2763
2764 LIBVIRT_BEGIN_ALLOW_THREADS;
2765 c_retval = virDomainGetControlInfo(domain, &info, flags);
2766 LIBVIRT_END_ALLOW_THREADS;
2767
2768 if (c_retval < 0)
2769 return VIR_PY_NONE;
2770
2771 if ((py_retval = PyList_New(3)) == NULL)
2772 return NULL;
2773
2774 VIR_PY_LIST_SET_GOTO(py_retval, 0, libvirt_intWrap(info.state), error);
2775 VIR_PY_LIST_SET_GOTO(py_retval, 1, libvirt_intWrap(info.details), error);
2776 VIR_PY_LIST_SET_GOTO(py_retval, 2,
2777 libvirt_ulonglongWrap(info.stateTime), error);
2778
2779 return py_retval;
2780
2781 error:
2782 Py_XDECREF(py_retval);
2783 return NULL;
2784 }
2785
2786 static PyObject *
2787 libvirt_virDomainGetBlockInfo(PyObject *self ATTRIBUTE_UNUSED,
2788 PyObject *args)
2789 {
2790 PyObject *py_retval;
2791 int c_retval;
2792 virDomainPtr domain;
2793 PyObject *pyobj_domain;
2794 virDomainBlockInfo info;
2795 const char *path;
2796 unsigned int flags;
2797
2798 if (!PyArg_ParseTuple(args, (char *)"OzI:virDomainGetBlockInfo",
2799 &pyobj_domain, &path, &flags))
2800 return NULL;
2801 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
2802
2803 LIBVIRT_BEGIN_ALLOW_THREADS;
2804 c_retval = virDomainGetBlockInfo(domain, path, &info, flags);
2805 LIBVIRT_END_ALLOW_THREADS;
2806
2807 if (c_retval < 0)
2808 return VIR_PY_NONE;
2809
2810 if ((py_retval = PyList_New(3)) == NULL)
2811 return NULL;
2812
2813 VIR_PY_LIST_SET_GOTO(py_retval, 0,
2814 libvirt_ulonglongWrap(info.capacity), error);
2815 VIR_PY_LIST_SET_GOTO(py_retval, 1,
2816 libvirt_ulonglongWrap(info.allocation), error);
2817 VIR_PY_LIST_SET_GOTO(py_retval, 2,
2818 libvirt_ulonglongWrap(info.physical), error);
2819
2820 return py_retval;
2821
2822 error:
2823 Py_XDECREF(py_retval);
2824 return NULL;
2825 }
2826
2827 static PyObject *
2828 libvirt_virNodeGetInfo(PyObject *self ATTRIBUTE_UNUSED,
2829 PyObject *args)
2830 {
2831 PyObject *py_retval;
2832 int c_retval;
2833 virConnectPtr conn;
2834 PyObject *pyobj_conn;
2835 virNodeInfo info;
2836
2837 if (!PyArg_ParseTuple(args, (char *)"O:virNodeGetInfo", &pyobj_conn))
2838 return NULL;
2839 conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
2840
2841 LIBVIRT_BEGIN_ALLOW_THREADS;
2842 c_retval = virNodeGetInfo(conn, &info);
2843 LIBVIRT_END_ALLOW_THREADS;
2844
2845 if (c_retval < 0)
2846 return VIR_PY_NONE;
2847
2848 if ((py_retval = PyList_New(8)) == NULL)
2849 return NULL;
2850
2851 VIR_PY_LIST_SET_GOTO(py_retval, 0,
2852 libvirt_constcharPtrWrap(&info.model[0]), error);
2853 VIR_PY_LIST_SET_GOTO(py_retval, 1,
2854 libvirt_ulongWrap(info.memory >> 10), error);
2855 VIR_PY_LIST_SET_GOTO(py_retval, 2, libvirt_intWrap(info.cpus), error);
2856 VIR_PY_LIST_SET_GOTO(py_retval, 3, libvirt_intWrap(info.mhz), error);
2857 VIR_PY_LIST_SET_GOTO(py_retval, 4, libvirt_intWrap(info.nodes), error);
2858 VIR_PY_LIST_SET_GOTO(py_retval, 5, libvirt_intWrap(info.sockets), error);
2859 VIR_PY_LIST_SET_GOTO(py_retval, 6, libvirt_intWrap(info.cores), error);
2860 VIR_PY_LIST_SET_GOTO(py_retval, 7, libvirt_intWrap(info.threads), error);
2861
2862 return py_retval;
2863
2864 error:
2865 Py_XDECREF(py_retval);
2866 return NULL;
2867 }
2868
2869 static PyObject *
2870 libvirt_virNodeGetSecurityModel(PyObject *self ATTRIBUTE_UNUSED,
2871 PyObject *args)
2872 {
2873 PyObject *py_retval;
2874 int c_retval;
2875 virConnectPtr conn;
2876 PyObject *pyobj_conn;
2877 virSecurityModel model;
2878
2879 if (!PyArg_ParseTuple(args, (char *)"O:virDomainGetSecurityModel",
2880 &pyobj_conn))
2881 return NULL;
2882 conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
2883
2884 LIBVIRT_BEGIN_ALLOW_THREADS;
2885 c_retval = virNodeGetSecurityModel(conn, &model);
2886 LIBVIRT_END_ALLOW_THREADS;
2887
2888 if (c_retval < 0)
2889 return VIR_PY_NONE;
2890
2891 if ((py_retval = PyList_New(2)) == NULL)
2892 return NULL;
2893
2894 VIR_PY_LIST_SET_GOTO(py_retval, 0,
2895 libvirt_constcharPtrWrap(&model.model[0]), error);
2896 VIR_PY_LIST_SET_GOTO(py_retval, 1,
2897 libvirt_constcharPtrWrap(&model.doi[0]), error);
2898
2899 return py_retval;
2900
2901 error:
2902 Py_XDECREF(py_retval);
2903 return NULL;
2904 }
2905
2906 static PyObject *
2907 libvirt_virDomainGetSecurityLabel(PyObject *self ATTRIBUTE_UNUSED,
2908 PyObject *args)
2909 {
2910 PyObject *py_retval;
2911 int c_retval;
2912 virDomainPtr dom;
2913 PyObject *pyobj_dom;
2914 virSecurityLabel label;
2915
2916 if (!PyArg_ParseTuple(args, (char *)"O:virDomainGetSecurityLabel",
2917 &pyobj_dom))
2918 return NULL;
2919 dom = (virDomainPtr) PyvirDomain_Get(pyobj_dom);
2920
2921 LIBVIRT_BEGIN_ALLOW_THREADS;
2922 c_retval = virDomainGetSecurityLabel(dom, &label);
2923 LIBVIRT_END_ALLOW_THREADS;
2924
2925 if (c_retval < 0)
2926 return VIR_PY_NONE;
2927
2928 if ((py_retval = PyList_New(2)) == NULL)
2929 return NULL;
2930
2931 VIR_PY_LIST_SET_GOTO(py_retval, 0,
2932 libvirt_constcharPtrWrap(&label.label[0]), error);
2933 VIR_PY_LIST_SET_GOTO(py_retval, 1,
2934 libvirt_boolWrap(label.enforcing), error);
2935
2936 return py_retval;
2937
2938 error:
2939 Py_XDECREF(py_retval);
2940 return NULL;
2941 }
2942
2943 #if LIBVIR_CHECK_VERSION(0, 10, 0)
2944 static PyObject *
2945 libvirt_virDomainGetSecurityLabelList(PyObject *self ATTRIBUTE_UNUSED,
2946 PyObject *args)
2947 {
2948 PyObject *py_retval;
2949 int c_retval;
2950 virDomainPtr dom;
2951 PyObject *pyobj_dom;
2952 virSecurityLabel *labels = NULL;
2953 ssize_t i;
2954
2955 if (!PyArg_ParseTuple(args, (char *)"O:virDomainGetSecurityLabelList",
2956 &pyobj_dom))
2957 return NULL;
2958
2959 dom = (virDomainPtr) PyvirDomain_Get(pyobj_dom);
2960
2961 LIBVIRT_BEGIN_ALLOW_THREADS;
2962 c_retval = virDomainGetSecurityLabelList(dom, &labels);
2963 LIBVIRT_END_ALLOW_THREADS;
2964
2965 if (c_retval < 0)
2966 return VIR_PY_NONE;
2967
2968 if (!(py_retval = PyList_New(0)))
2969 goto error;
2970
2971 for (i = 0 ; i < c_retval ; i++) {
2972 PyObject *entry;
2973
2974 if (!(entry = PyList_New(2)))
2975 goto error;
2976
2977 VIR_PY_LIST_APPEND_GOTO(py_retval, entry, error);
2978
2979 VIR_PY_LIST_SET_GOTO(entry, 0,
2980 libvirt_constcharPtrWrap(&labels[i].label[0]),
2981 error);
2982 VIR_PY_LIST_SET_GOTO(entry, 1,
2983 libvirt_boolWrap(labels[i].enforcing), error);
2984 }
2985
2986 cleanup:
2987 VIR_FREE(labels);
2988 return py_retval;
2989
2990 error:
2991 Py_CLEAR(py_retval);
2992 goto cleanup;
2993 }
2994 #endif /* LIBVIR_CHECK_VERSION(0, 10, 0) */
2995
2996 static PyObject *
2997 libvirt_virDomainGetUUID(PyObject *self ATTRIBUTE_UNUSED,
2998 PyObject *args)
2999 {
3000 unsigned char uuid[VIR_UUID_BUFLEN];
3001 virDomainPtr domain;
3002 PyObject *pyobj_domain;
3003 int c_retval;
3004
3005 if (!PyArg_ParseTuple(args, (char *)"O:virDomainGetUUID", &pyobj_domain))
3006 return NULL;
3007 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
3008
3009 if (domain == NULL)
3010 return VIR_PY_NONE;
3011
3012 LIBVIRT_BEGIN_ALLOW_THREADS;
3013 c_retval = virDomainGetUUID(domain, &uuid[0]);
3014 LIBVIRT_END_ALLOW_THREADS;
3015
3016 if (c_retval < 0)
3017 return VIR_PY_NONE;
3018
3019 return libvirt_charPtrSizeWrap((char *) &uuid[0], VIR_UUID_BUFLEN);
3020 }
3021
3022 static PyObject *
3023 libvirt_virDomainGetUUIDString(PyObject *self ATTRIBUTE_UNUSED,
3024 PyObject *args)
3025 {
3026 char uuidstr[VIR_UUID_STRING_BUFLEN];
3027 virDomainPtr dom;
3028 PyObject *pyobj_dom;
3029 int c_retval;
3030
3031 if (!PyArg_ParseTuple(args, (char *)"O:virDomainGetUUIDString",
3032 &pyobj_dom))
3033 return NULL;
3034 dom = (virDomainPtr) PyvirDomain_Get(pyobj_dom);
3035
3036 if (dom == NULL)
3037 return VIR_PY_NONE;
3038
3039 LIBVIRT_BEGIN_ALLOW_THREADS;
3040 c_retval = virDomainGetUUIDString(dom, &uuidstr[0]);
3041 LIBVIRT_END_ALLOW_THREADS;
3042
3043 if (c_retval < 0)
3044 return VIR_PY_NONE;
3045
3046 return libvirt_constcharPtrWrap((char *) &uuidstr[0]);
3047 }
3048
3049 static PyObject *
3050 libvirt_virDomainLookupByUUID(PyObject *self ATTRIBUTE_UNUSED,
3051 PyObject *args)
3052 {
3053 virDomainPtr c_retval;
3054 virConnectPtr conn;
3055 PyObject *pyobj_conn;
3056 unsigned char * uuid;
3057 Py_ssize_t len;
3058
3059 if (!PyArg_ParseTuple(args, (char *)"Oz#:virDomainLookupByUUID",
3060 &pyobj_conn, &uuid, &len))
3061 return NULL;
3062 conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
3063
3064 if ((uuid == NULL) || (len != VIR_UUID_BUFLEN))
3065 return VIR_PY_NONE;
3066
3067 LIBVIRT_BEGIN_ALLOW_THREADS;
3068 c_retval = virDomainLookupByUUID(conn, uuid);
3069 LIBVIRT_END_ALLOW_THREADS;
3070
3071 return libvirt_virDomainPtrWrap((virDomainPtr) c_retval);
3072 }
3073
3074
3075 static PyObject *
3076 libvirt_virConnectListNetworks(PyObject *self ATTRIBUTE_UNUSED,
3077 PyObject *args)
3078 {
3079 PyObject *py_retval;
3080 char **names = NULL;
3081 int c_retval;
3082 ssize_t i;
3083 virConnectPtr conn;
3084 PyObject *pyobj_conn;
3085
3086
3087 if (!PyArg_ParseTuple(args, (char *)"O:virConnectListNetworks",
3088 &pyobj_conn))
3089 return NULL;
3090 conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
3091
3092 LIBVIRT_BEGIN_ALLOW_THREADS;
3093 c_retval = virConnectNumOfNetworks(conn);
3094 LIBVIRT_END_ALLOW_THREADS;
3095
3096 if (c_retval < 0)
3097 return VIR_PY_NONE;
3098
3099 if (c_retval) {
3100 if (VIR_ALLOC_N(names, c_retval) < 0)
3101 return PyErr_NoMemory();
3102
3103 LIBVIRT_BEGIN_ALLOW_THREADS;
3104 c_retval = virConnectListNetworks(conn, names, c_retval);
3105 LIBVIRT_END_ALLOW_THREADS;
3106
3107 if (c_retval < 0) {
3108 py_retval = VIR_PY_NONE;
3109 goto cleanup;
3110 }
3111 }
3112
3113 if ((py_retval = PyList_New(c_retval)) == NULL)
3114 goto cleanup;
3115
3116 if (names)
3117 for (i = 0; i < c_retval; i++)
3118 VIR_PY_LIST_SET_GOTO(py_retval, i,
3119 libvirt_constcharPtrWrap(names[i]), error);
3120
3121 cleanup:
3122 if (c_retval > 0)
3123 for (i = 0; i < c_retval; i++)
3124 VIR_FREE(names[i]);
3125 VIR_FREE(names);
3126 return py_retval;
3127
3128 error:
3129 Py_CLEAR(py_retval);
3130 goto cleanup;
3131 }
3132
3133
3134 static PyObject *
3135 libvirt_virConnectListDefinedNetworks(PyObject *self ATTRIBUTE_UNUSED,
3136 PyObject *args)
3137 {
3138 PyObject *py_retval;
3139 char **names = NULL;
3140 int c_retval;
3141 ssize_t i;
3142 virConnectPtr conn;
3143 PyObject *pyobj_conn;
3144
3145
3146 if (!PyArg_ParseTuple(args, (char *)"O:virConnectListDefinedNetworks",
3147 &pyobj_conn))
3148 return NULL;
3149 conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
3150
3151 LIBVIRT_BEGIN_ALLOW_THREADS;
3152 c_retval = virConnectNumOfDefinedNetworks(conn);
3153 LIBVIRT_END_ALLOW_THREADS;
3154
3155 if (c_retval < 0)
3156 return VIR_PY_NONE;
3157
3158 if (c_retval) {
3159 if (VIR_ALLOC_N(names, c_retval) < 0)
3160 return PyErr_NoMemory();
3161
3162 LIBVIRT_BEGIN_ALLOW_THREADS;
3163 c_retval = virConnectListDefinedNetworks(conn, names, c_retval);
3164 LIBVIRT_END_ALLOW_THREADS;
3165
3166 if (c_retval < 0) {
3167 py_retval = VIR_PY_NONE;
3168 goto cleanup;
3169 }
3170 }
3171
3172 if ((py_retval = PyList_New(c_retval)) == NULL)
3173 goto cleanup;
3174
3175 for (i = 0; i < c_retval; i++)
3176 VIR_PY_LIST_SET_GOTO(py_retval, i,
3177 libvirt_constcharPtrWrap(names[i]), error);
3178
3179 cleanup:
3180 if (c_retval > 0)
3181 for (i = 0; i < c_retval; i++)
3182 VIR_FREE(names[i]);
3183 VIR_FREE(names);
3184 return py_retval;
3185
3186 error:
3187 Py_CLEAR(py_retval);
3188 goto cleanup;
3189 }
3190
3191 #if LIBVIR_CHECK_VERSION(0, 10, 2)
3192 static PyObject *
3193 libvirt_virConnectListAllNetworks(PyObject *self ATTRIBUTE_UNUSED,
3194 PyObject *args)
3195 {
3196 PyObject *pyobj_conn;
3197 PyObject *py_retval = NULL;
3198 virConnectPtr conn;
3199 virNetworkPtr *nets = NULL;
3200 int c_retval = 0;
3201 ssize_t i;
3202 unsigned int flags;
3203
3204 if (!PyArg_ParseTuple(args, (char *)"OI:virConnectListAllNetworks",
3205 &pyobj_conn, &flags))
3206 return NULL;
3207 conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
3208
3209 LIBVIRT_BEGIN_ALLOW_THREADS;
3210 c_retval = virConnectListAllNetworks(conn, &nets, flags);
3211 LIBVIRT_END_ALLOW_THREADS;
3212
3213 if (c_retval < 0)
3214 return VIR_PY_NONE;
3215
3216 if (!(py_retval = PyList_New(c_retval)))
3217 goto cleanup;
3218
3219 for (i = 0; i < c_retval; i++) {
3220 VIR_PY_LIST_SET_GOTO(py_retval, i,
3221 libvirt_virNetworkPtrWrap(nets[i]), error);
3222 nets[i] = NULL;
3223 }
3224
3225 cleanup:
3226 for (i = 0; i < c_retval; i++)
3227 if (nets[i])
3228 virNetworkFree(nets[i]);
3229 VIR_FREE(nets);
3230 return py_retval;
3231
3232 error:
3233 Py_CLEAR(py_retval);
3234 goto cleanup;
3235 }
3236 #endif /* LIBVIR_CHECK_VERSION(0, 10, 2) */
3237
3238
3239 static PyObject *
3240 libvirt_virNetworkGetUUID(PyObject *self ATTRIBUTE_UNUSED,
3241 PyObject *args)
3242 {
3243 unsigned char uuid[VIR_UUID_BUFLEN];
3244 virNetworkPtr domain;
3245 PyObject *pyobj_domain;
3246 int c_retval;
3247
3248 if (!PyArg_ParseTuple(args, (char *)"O:virNetworkGetUUID", &pyobj_domain))
3249 return NULL;
3250 domain = (virNetworkPtr) PyvirNetwork_Get(pyobj_domain);
3251
3252 if (domain == NULL)
3253 return VIR_PY_NONE;
3254
3255 LIBVIRT_BEGIN_ALLOW_THREADS;
3256 c_retval = virNetworkGetUUID(domain, &uuid[0]);
3257 LIBVIRT_END_ALLOW_THREADS;
3258
3259 if (c_retval < 0)
3260 return VIR_PY_NONE;
3261
3262 return libvirt_charPtrSizeWrap((char *) &uuid[0], VIR_UUID_BUFLEN);
3263 }
3264
3265 static PyObject *
3266 libvirt_virNetworkGetUUIDString(PyObject *self ATTRIBUTE_UNUSED,
3267 PyObject *args)
3268 {
3269 char uuidstr[VIR_UUID_STRING_BUFLEN];
3270 virNetworkPtr net;
3271 PyObject *pyobj_net;
3272 int c_retval;
3273
3274 if (!PyArg_ParseTuple(args, (char *)"O:virNetworkGetUUIDString",
3275 &pyobj_net))
3276 return NULL;
3277 net = (virNetworkPtr) PyvirNetwork_Get(pyobj_net);
3278
3279 if (net == NULL)
3280 return VIR_PY_NONE;
3281
3282 LIBVIRT_BEGIN_ALLOW_THREADS;
3283 c_retval = virNetworkGetUUIDString(net, &uuidstr[0]);
3284 LIBVIRT_END_ALLOW_THREADS;
3285
3286 if (c_retval < 0)
3287 return VIR_PY_NONE;
3288
3289 return libvirt_constcharPtrWrap((char *) &uuidstr[0]);
3290 }
3291
3292 static PyObject *
3293 libvirt_virNetworkLookupByUUID(PyObject *self ATTRIBUTE_UNUSED,
3294 PyObject *args)
3295 {
3296 virNetworkPtr c_retval;
3297 virConnectPtr conn;
3298 PyObject *pyobj_conn;
3299 unsigned char * uuid;
3300 Py_ssize_t len;
3301
3302 if (!PyArg_ParseTuple(args, (char *)"Oz#:virNetworkLookupByUUID",
3303 &pyobj_conn, &uuid, &len))
3304 return NULL;
3305 conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
3306
3307 if ((uuid == NULL) || (len != VIR_UUID_BUFLEN))
3308 return VIR_PY_NONE;
3309
3310 LIBVIRT_BEGIN_ALLOW_THREADS;
3311 c_retval = virNetworkLookupByUUID(conn, uuid);
3312 LIBVIRT_END_ALLOW_THREADS;
3313
3314 return libvirt_virNetworkPtrWrap((virNetworkPtr) c_retval);
3315 }
3316
3317
3318 static PyObject *
3319 libvirt_virDomainGetAutostart(PyObject *self ATTRIBUTE_UNUSED,
3320 PyObject *args)
3321 {
3322 int c_retval, autostart;
3323 virDomainPtr domain;
3324 PyObject *pyobj_domain;
3325
3326 if (!PyArg_ParseTuple(args, (char *)"O:virDomainGetAutostart",
3327 &pyobj_domain))
3328 return NULL;
3329
3330 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
3331
3332 LIBVIRT_BEGIN_ALLOW_THREADS;
3333 c_retval = virDomainGetAutostart(domain, &autostart);
3334 LIBVIRT_END_ALLOW_THREADS;
3335
3336 if (c_retval < 0)
3337 return VIR_PY_INT_FAIL;
3338
3339 return libvirt_intWrap(autostart);
3340 }
3341
3342
3343 static PyObject *
3344 libvirt_virNetworkGetAutostart(PyObject *self ATTRIBUTE_UNUSED,
3345 PyObject *args)
3346 {
3347 int c_retval, autostart;
3348 virNetworkPtr network;
3349 PyObject *pyobj_network;
3350
3351 if (!PyArg_ParseTuple(args, (char *)"O:virNetworkGetAutostart",
3352 &pyobj_network))
3353 return NULL;
3354
3355 network = (virNetworkPtr) PyvirNetwork_Get(pyobj_network);
3356
3357 LIBVIRT_BEGIN_ALLOW_THREADS;
3358 c_retval = virNetworkGetAutostart(network, &autostart);
3359 LIBVIRT_END_ALLOW_THREADS;
3360
3361 if (c_retval < 0)
3362 return VIR_PY_INT_FAIL;
3363
3364 return libvirt_intWrap(autostart);
3365 }
3366
3367 #if LIBVIR_CHECK_VERSION(7, 8, 0)
3368 static PyObject *
3369 libvirt_virNodeDeviceGetAutostart(PyObject *self ATTRIBUTE_UNUSED,
3370 PyObject *args)
3371 {
3372 int c_retval, autostart;
3373 virNodeDevicePtr dev;
3374 PyObject *pyobj_dev;
3375
3376 if (!PyArg_ParseTuple(args, (char *)"O:virNodeDeviceGetAutostart",
3377 &pyobj_dev))
3378 return NULL;
3379
3380 dev = (virNodeDevicePtr) PyvirNodeDevice_Get(pyobj_dev);
3381
3382 LIBVIRT_BEGIN_ALLOW_THREADS;
3383 c_retval = virNodeDeviceGetAutostart(dev, &autostart);
3384 LIBVIRT_END_ALLOW_THREADS;
3385
3386 if (c_retval < 0)
3387 return VIR_PY_INT_FAIL;
3388
3389 return libvirt_intWrap(autostart);
3390 }
3391 #endif /* LIBVIR_CHECK_VERSION(7, 8, 0) */
3392
3393 static PyObject *
3394 libvirt_virNodeGetCellsFreeMemory(PyObject *self ATTRIBUTE_UNUSED,
3395 PyObject *args)
3396 {
3397 PyObject *py_retval;
3398 PyObject *pyobj_conn;
3399 int startCell, maxCells, c_retval;
3400 ssize_t i;
3401 virConnectPtr conn;
3402 unsigned long long *freeMems;
3403
3404 if (!PyArg_ParseTuple(args, (char *)"Oii:virNodeGetCellsFreeMemory",
3405 &pyobj_conn, &startCell, &maxCells))
3406 return NULL;
3407
3408 if ((startCell < 0) || (maxCells <= 0) || (startCell + maxCells > 10000))
3409 return VIR_PY_NONE;
3410
3411 conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
3412 if (VIR_ALLOC_N(freeMems, maxCells) < 0)
3413 return PyErr_NoMemory();
3414
3415 LIBVIRT_BEGIN_ALLOW_THREADS;
3416 c_retval = virNodeGetCellsFreeMemory(conn, freeMems, startCell, maxCells);
3417 LIBVIRT_END_ALLOW_THREADS;
3418
3419 if (c_retval < 0) {
3420 py_retval = VIR_PY_NONE;
3421 goto cleanup;
3422 }
3423
3424 if ((py_retval = PyList_New(c_retval)) == NULL)
3425 goto cleanup;
3426
3427 for (i = 0; i < c_retval; i++)
3428 VIR_PY_LIST_SET_GOTO(py_retval, i,
3429 libvirt_ulonglongWrap(freeMems[i]), error);
3430
3431 cleanup:
3432 VIR_FREE(freeMems);
3433 return py_retval;
3434
3435 error:
3436 Py_CLEAR(py_retval);
3437 goto cleanup;
3438 }
3439
3440 static PyObject *
3441 libvirt_virNodeGetCPUStats(PyObject *self ATTRIBUTE_UNUSED,
3442 PyObject *args)
3443 {
3444 PyObject *ret = NULL;
3445 PyObject *key = NULL;
3446 PyObject *val = NULL;
3447 PyObject *pyobj_conn;
3448 virConnectPtr conn;
3449 unsigned int flags;
3450 int cpuNum, c_retval;
3451 ssize_t i;
3452 int nparams = 0;
3453 virNodeCPUStatsPtr stats = NULL;
3454
3455 if (!PyArg_ParseTuple(args, (char *)"OiI:virNodeGetCPUStats",
3456 &pyobj_conn, &cpuNum, &flags))
3457 return ret;
3458 conn = (virConnectPtr)(PyvirConnect_Get(pyobj_conn));
3459
3460 LIBVIRT_BEGIN_ALLOW_THREADS;
3461 c_retval = virNodeGetCPUStats(conn, cpuNum, NULL, &nparams, flags);
3462 LIBVIRT_END_ALLOW_THREADS;
3463
3464 if (c_retval < 0)
3465 return VIR_PY_NONE;
3466
3467 if (nparams) {
3468 if (VIR_ALLOC_N(stats, nparams) < 0)
3469 return PyErr_NoMemory();
3470
3471 LIBVIRT_BEGIN_ALLOW_THREADS;
3472 c_retval = virNodeGetCPUStats(conn, cpuNum, stats, &nparams, flags);
3473 LIBVIRT_END_ALLOW_THREADS;
3474
3475 if (c_retval < 0) {
3476 VIR_FREE(stats);
3477 return VIR_PY_NONE;
3478 }
3479 }
3480
3481 if (!(ret = PyDict_New()))
3482 goto error;
3483
3484 for (i = 0; i < nparams; i++) {
3485 key = libvirt_constcharPtrWrap(stats[i].field);
3486 val = libvirt_ulonglongWrap(stats[i].value);
3487
3488 VIR_PY_DICT_SET_GOTO(ret, key, val, error);
3489 }
3490
3491 cleanup:
3492 VIR_FREE(stats);
3493 return ret;
3494
3495 error:
3496 Py_CLEAR(ret);
3497 goto cleanup;
3498 }
3499
3500 static PyObject *
3501 libvirt_virNodeGetMemoryStats(PyObject *self ATTRIBUTE_UNUSED,
3502 PyObject *args)
3503 {
3504 PyObject *ret = NULL;
3505 PyObject *key = NULL;
3506 PyObject *val = NULL;
3507 PyObject *pyobj_conn;
3508 virConnectPtr conn;
3509 unsigned int flags;
3510 int cellNum, c_retval;
3511 ssize_t i;
3512 int nparams = 0;
3513 virNodeMemoryStatsPtr stats = NULL;
3514
3515 if (!PyArg_ParseTuple(args, (char *)"OiI:virNodeGetMemoryStats",
3516 &pyobj_conn, &cellNum, &flags))
3517 return NULL;
3518 conn = (virConnectPtr)(PyvirConnect_Get(pyobj_conn));
3519
3520 LIBVIRT_BEGIN_ALLOW_THREADS;
3521 c_retval = virNodeGetMemoryStats(conn, cellNum, NULL, &nparams, flags);
3522 LIBVIRT_END_ALLOW_THREADS;
3523
3524 if (c_retval < 0)
3525 return VIR_PY_NONE;
3526
3527 if (nparams) {
3528 if (VIR_ALLOC_N(stats, nparams) < 0)
3529 return PyErr_NoMemory();
3530
3531 LIBVIRT_BEGIN_ALLOW_THREADS;
3532 c_retval = virNodeGetMemoryStats(conn, cellNum, stats, &nparams, flags);
3533 LIBVIRT_END_ALLOW_THREADS;
3534
3535 if (c_retval < 0) {
3536 VIR_FREE(stats);
3537 return VIR_PY_NONE;
3538 }
3539 }
3540
3541 if (!(ret = PyDict_New()))
3542 goto error;
3543
3544 for (i = 0; i < nparams; i++) {
3545 key = libvirt_constcharPtrWrap(stats[i].field);
3546 val = libvirt_ulonglongWrap(stats[i].value);
3547
3548 VIR_PY_DICT_SET_GOTO(ret, key, val, error);
3549 }
3550
3551 cleanup:
3552 VIR_FREE(stats);
3553 return ret;
3554
3555 error:
3556 Py_CLEAR(ret);
3557 goto cleanup;
3558 }
3559
3560 static PyObject *
3561 libvirt_virConnectListStoragePools(PyObject *self ATTRIBUTE_UNUSED,
3562 PyObject *args)
3563 {
3564 PyObject *py_retval;
3565 char **names = NULL;
3566 int c_retval;
3567 ssize_t i;
3568 virConnectPtr conn;
3569 PyObject *pyobj_conn;
3570
3571 if (!PyArg_ParseTuple(args, (char *)"O:virConnectListStoragePools",
3572 &pyobj_conn))
3573 return NULL;
3574 conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
3575
3576 LIBVIRT_BEGIN_ALLOW_THREADS;
3577 c_retval = virConnectNumOfStoragePools(conn);
3578 LIBVIRT_END_ALLOW_THREADS;
3579
3580 if (c_retval < 0)
3581 return VIR_PY_NONE;
3582
3583 if (c_retval) {
3584 if (VIR_ALLOC_N(names, c_retval) < 0)
3585 return PyErr_NoMemory();
3586
3587 LIBVIRT_BEGIN_ALLOW_THREADS;
3588 c_retval = virConnectListStoragePools(conn, names, c_retval);
3589 LIBVIRT_END_ALLOW_THREADS;
3590
3591 if (c_retval < 0) {
3592 py_retval = VIR_PY_NONE;
3593 goto cleanup;
3594 }
3595 }
3596
3597 if ((py_retval = PyList_New(c_retval)) == NULL)
3598 goto cleanup;
3599
3600 for (i = 0; i < c_retval; i++)
3601 VIR_PY_LIST_SET_GOTO(py_retval, i,
3602 libvirt_constcharPtrWrap(names[i]), error);
3603
3604 cleanup:
3605 if (c_retval > 0)
3606 for (i = 0; i < c_retval; i++)
3607 VIR_FREE(names[i]);
3608 VIR_FREE(names);
3609 return py_retval;
3610
3611 error:
3612 Py_CLEAR(py_retval);
3613 goto cleanup;
3614 }
3615
3616
3617 static PyObject *
3618 libvirt_virConnectListDefinedStoragePools(PyObject *self ATTRIBUTE_UNUSED,
3619 PyObject *args)
3620 {
3621 PyObject *py_retval;
3622 char **names = NULL;
3623 int c_retval;
3624 ssize_t i;
3625 virConnectPtr conn;
3626 PyObject *pyobj_conn;
3627
3628 if (!PyArg_ParseTuple(args, (char *)"O:virConnectListDefinedStoragePools",
3629 &pyobj_conn))
3630 return NULL;
3631 conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
3632
3633 LIBVIRT_BEGIN_ALLOW_THREADS;
3634 c_retval = virConnectNumOfDefinedStoragePools(conn);
3635 LIBVIRT_END_ALLOW_THREADS;
3636
3637 if (c_retval < 0)
3638 return VIR_PY_NONE;
3639
3640 if (c_retval) {
3641 if (VIR_ALLOC_N(names, c_retval) < 0)
3642 return PyErr_NoMemory();
3643
3644 LIBVIRT_BEGIN_ALLOW_THREADS;
3645 c_retval = virConnectListDefinedStoragePools(conn, names, c_retval);
3646 LIBVIRT_END_ALLOW_THREADS;
3647
3648 if (c_retval < 0) {
3649 py_retval = VIR_PY_NONE;
3650 goto cleanup;
3651 }
3652 }
3653
3654 if ((py_retval = PyList_New(c_retval)) == NULL)
3655 goto cleanup;
3656
3657 if (names) {
3658 for (i = 0; i < c_retval; i++)
3659 VIR_PY_LIST_SET_GOTO(py_retval, i,
3660 libvirt_constcharPtrWrap(names[i]), error);
3661 }
3662
3663 cleanup:
3664 if (c_retval > 0)
3665 for (i = 0; i < c_retval; i++)
3666 VIR_FREE(names[i]);
3667 VIR_FREE(names);
3668 return py_retval;
3669
3670 error:
3671 Py_CLEAR(py_retval);
3672 goto cleanup;
3673 }
3674
3675 #if LIBVIR_CHECK_VERSION(0, 10, 2)
3676 static PyObject *
3677 libvirt_virConnectListAllStoragePools(PyObject *self ATTRIBUTE_UNUSED,
3678 PyObject *args)
3679 {
3680 PyObject *pyobj_conn;
3681 PyObject *py_retval = NULL;
3682 virConnectPtr conn;
3683 virStoragePoolPtr *pools = NULL;
3684 int c_retval = 0;
3685 ssize_t i;
3686 unsigned int flags;
3687
3688 if (!PyArg_ParseTuple(args, (char *)"OI:virConnectListAllStoragePools",
3689 &pyobj_conn, &flags))
3690 return NULL;
3691 conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
3692
3693 LIBVIRT_BEGIN_ALLOW_THREADS;
3694 c_retval = virConnectListAllStoragePools(conn, &pools, flags);
3695 LIBVIRT_END_ALLOW_THREADS;
3696
3697 if (c_retval < 0)
3698 return VIR_PY_NONE;
3699
3700 if (!(py_retval = PyList_New(c_retval)))
3701 goto cleanup;
3702
3703 for (i = 0; i < c_retval; i++) {
3704 VIR_PY_LIST_SET_GOTO(py_retval, i,
3705 libvirt_virStoragePoolPtrWrap(pools[i]), error);
3706 /* python steals the pointer */
3707 pools[i] = NULL;
3708 }
3709
3710 cleanup:
3711 for (i = 0; i < c_retval; i++)
3712 if (pools[i])
3713 virStoragePoolFree(pools[i]);
3714 VIR_FREE(pools);
3715 return py_retval;
3716
3717 error:
3718 Py_CLEAR(py_retval);
3719 goto cleanup;
3720 }
3721 #endif /* LIBVIR_CHECK_VERSION(0, 10, 2) */
3722
3723 static PyObject *
3724 libvirt_virStoragePoolListVolumes(PyObject *self ATTRIBUTE_UNUSED,
3725 PyObject *args)
3726 {
3727 PyObject *py_retval;
3728 char **names = NULL;
3729 int c_retval;
3730 ssize_t i;
3731 virStoragePoolPtr pool;
3732 PyObject *pyobj_pool;
3733
3734 if (!PyArg_ParseTuple(args, (char *)"O:virStoragePoolListVolumes",
3735 &pyobj_pool))
3736 return NULL;
3737 pool = (virStoragePoolPtr) PyvirStoragePool_Get(pyobj_pool);
3738
3739 LIBVIRT_BEGIN_ALLOW_THREADS;
3740 c_retval = virStoragePoolNumOfVolumes(pool);
3741 LIBVIRT_END_ALLOW_THREADS;
3742
3743 if (c_retval < 0)
3744 return VIR_PY_NONE;
3745
3746 if (c_retval) {
3747 if (VIR_ALLOC_N(names, c_retval) < 0)
3748 return PyErr_NoMemory();
3749
3750 LIBVIRT_BEGIN_ALLOW_THREADS;
3751 c_retval = virStoragePoolListVolumes(pool, names, c_retval);
3752 LIBVIRT_END_ALLOW_THREADS;
3753
3754 if (c_retval < 0) {
3755 py_retval = VIR_PY_NONE;
3756 goto cleanup;
3757 }
3758 }
3759
3760 if ((py_retval = PyList_New(c_retval)) == NULL)
3761 goto cleanup;
3762
3763 if (names)
3764 for (i = 0; i < c_retval; i++)
3765 VIR_PY_LIST_SET_GOTO(py_retval, i,
3766 libvirt_constcharPtrWrap(names[i]), error);
3767
3768 cleanup:
3769 if (c_retval > 0)
3770 for (i = 0; i < c_retval; i++)
3771 VIR_FREE(names[i]);
3772 VIR_FREE(names);
3773 return py_retval;
3774
3775 error:
3776 Py_CLEAR(py_retval);
3777 goto cleanup;
3778 }
3779
3780 #if LIBVIR_CHECK_VERSION(0, 10, 2)
3781 static PyObject *
3782 libvirt_virStoragePoolListAllVolumes(PyObject *self ATTRIBUTE_UNUSED,
3783 PyObject *args)
3784 {
3785 PyObject *py_retval = NULL;
3786 virStoragePoolPtr pool;
3787 virStorageVolPtr *vols = NULL;
3788 int c_retval = 0;
3789 ssize_t i;
3790 unsigned int flags;
3791 PyObject *pyobj_pool;
3792
3793 if (!PyArg_ParseTuple(args, (char *)"OI:virStoragePoolListAllVolumes",
3794 &pyobj_pool, &flags))
3795 return NULL;
3796
3797 pool = (virStoragePoolPtr) PyvirStoragePool_Get(pyobj_pool);
3798
3799 LIBVIRT_BEGIN_ALLOW_THREADS;
3800 c_retval = virStoragePoolListAllVolumes(pool, &vols, flags);
3801 LIBVIRT_END_ALLOW_THREADS;
3802
3803 if (c_retval < 0)
3804 return VIR_PY_NONE;
3805
3806 if (!(py_retval = PyList_New(c_retval)))
3807 goto cleanup;
3808
3809 for (i = 0; i < c_retval; i++) {
3810 VIR_PY_LIST_SET_GOTO(py_retval, i,
3811 libvirt_virStorageVolPtrWrap(vols[i]), error);
3812 /* python steals the pointer */
3813 vols[i] = NULL;
3814 }
3815
3816 cleanup:
3817 for (i = 0; i < c_retval; i++)
3818 if (vols[i])
3819 virStorageVolFree(vols[i]);
3820 VIR_FREE(vols);
3821 return py_retval;
3822
3823 error:
3824 Py_CLEAR(py_retval);
3825 goto cleanup;
3826 }
3827 #endif /* LIBVIR_CHECK_VERSION(0, 10, 2) */
3828
3829
3830 static PyObject *
3831 libvirt_virStoragePoolGetAutostart(PyObject *self ATTRIBUTE_UNUSED,
3832 PyObject *args)
3833 {
3834 int c_retval, autostart;
3835 virStoragePoolPtr pool;
3836 PyObject *pyobj_pool;
3837
3838 if (!PyArg_ParseTuple(args, (char *)"O:virStoragePoolGetAutostart",
3839 &pyobj_pool))
3840 return NULL;
3841
3842 pool = (virStoragePoolPtr) PyvirStoragePool_Get(pyobj_pool);
3843
3844 LIBVIRT_BEGIN_ALLOW_THREADS;
3845 c_retval = virStoragePoolGetAutostart(pool, &autostart);
3846 LIBVIRT_END_ALLOW_THREADS;
3847
3848 if (c_retval < 0)
3849 return VIR_PY_INT_FAIL;
3850
3851 return libvirt_intWrap(autostart);
3852 }
3853
3854 static PyObject *
3855 libvirt_virStoragePoolGetInfo(PyObject *self ATTRIBUTE_UNUSED,
3856 PyObject *args)
3857 {
3858 PyObject *py_retval;
3859 int c_retval;
3860 virStoragePoolPtr pool;
3861 PyObject *pyobj_pool;
3862 virStoragePoolInfo info;
3863
3864 if (!PyArg_ParseTuple(args, (char *)"O:virStoragePoolGetInfo", &pyobj_pool))
3865 return NULL;
3866 pool = (virStoragePoolPtr) PyvirStoragePool_Get(pyobj_pool);
3867
3868 LIBVIRT_BEGIN_ALLOW_THREADS;
3869 c_retval = virStoragePoolGetInfo(pool, &info);
3870 LIBVIRT_END_ALLOW_THREADS;
3871
3872 if (c_retval < 0)
3873 return VIR_PY_NONE;
3874
3875 if ((py_retval = PyList_New(4)) == NULL)
3876 return NULL;
3877
3878 VIR_PY_LIST_SET_GOTO(py_retval, 0,
3879 libvirt_intWrap(info.state), error);
3880 VIR_PY_LIST_SET_GOTO(py_retval, 1,
3881 libvirt_ulonglongWrap(info.capacity), error);
3882 VIR_PY_LIST_SET_GOTO(py_retval, 2,
3883 libvirt_ulonglongWrap(info.allocation), error);
3884 VIR_PY_LIST_SET_GOTO(py_retval, 3,
3885 libvirt_ulonglongWrap(info.available), error);
3886
3887 return py_retval;
3888
3889 error:
3890 Py_XDECREF(py_retval);
3891 return NULL;
3892 }
3893
3894
3895 static PyObject *
3896 libvirt_virStorageVolGetInfo(PyObject *self ATTRIBUTE_UNUSED,
3897 PyObject *args)
3898 {
3899 PyObject *py_retval;
3900 int c_retval;
3901 virStorageVolPtr pool;
3902 PyObject *pyobj_pool;
3903 virStorageVolInfo info;
3904
3905 if (!PyArg_ParseTuple(args, (char *)"O:virStorageVolGetInfo", &pyobj_pool))
3906 return NULL;
3907 pool = (virStorageVolPtr) PyvirStorageVol_Get(pyobj_pool);
3908
3909 LIBVIRT_BEGIN_ALLOW_THREADS;
3910 c_retval = virStorageVolGetInfo(pool, &info);
3911 LIBVIRT_END_ALLOW_THREADS;
3912
3913 if (c_retval < 0)
3914 return VIR_PY_NONE;
3915
3916 if ((py_retval = PyList_New(3)) == NULL)
3917 return NULL;
3918
3919 VIR_PY_LIST_SET_GOTO(py_retval, 0,
3920 libvirt_intWrap(info.type), error);
3921 VIR_PY_LIST_SET_GOTO(py_retval, 1,
3922 libvirt_ulonglongWrap(info.capacity), error);
3923 VIR_PY_LIST_SET_GOTO(py_retval, 2,
3924 libvirt_ulonglongWrap(info.allocation), error);
3925
3926 return py_retval;
3927
3928 error:
3929 Py_DECREF(py_retval);
3930 return NULL;
3931 }
3932
3933 #if LIBVIR_CHECK_VERSION(3, 0, 0)
3934 static PyObject *
3935 libvirt_virStorageVolGetInfoFlags(PyObject *self ATTRIBUTE_UNUSED,
3936 PyObject *args)
3937 {
3938 PyObject *py_retval;
3939 int c_retval;
3940 virStorageVolPtr pool;
3941 PyObject *pyobj_pool;
3942 virStorageVolInfo info;
3943 unsigned int flags;
3944
3945 if (!PyArg_ParseTuple(args, (char *)"OI:virStorageVolGetInfoFlags", &pyobj_pool, &flags))
3946 return NULL;
3947 pool = (virStorageVolPtr) PyvirStorageVol_Get(pyobj_pool);
3948
3949 LIBVIRT_BEGIN_ALLOW_THREADS;
3950 c_retval = virStorageVolGetInfoFlags(pool, &info, flags);
3951 LIBVIRT_END_ALLOW_THREADS;
3952
3953 if (c_retval < 0)
3954 return VIR_PY_NONE;
3955
3956 if ((py_retval = PyList_New(3)) == NULL)
3957 return NULL;
3958
3959 VIR_PY_LIST_SET_GOTO(py_retval, 0,
3960 libvirt_intWrap(info.type), error);
3961 VIR_PY_LIST_SET_GOTO(py_retval, 1,
3962 libvirt_ulonglongWrap(info.capacity), error);
3963 VIR_PY_LIST_SET_GOTO(py_retval, 2,
3964 libvirt_ulonglongWrap(info.allocation), error);
3965
3966 return py_retval;
3967
3968 error:
3969 Py_DECREF(py_retval);
3970 return NULL;
3971 }
3972 #endif
3973
3974 static PyObject *
3975 libvirt_virStoragePoolGetUUID(PyObject *self ATTRIBUTE_UNUSED,
3976 PyObject *args)
3977 {
3978 unsigned char uuid[VIR_UUID_BUFLEN];
3979 virStoragePoolPtr pool;
3980 PyObject *pyobj_pool;
3981 int c_retval;
3982
3983 if (!PyArg_ParseTuple(args, (char *)"O:virStoragePoolGetUUID", &pyobj_pool))
3984 return NULL;
3985 pool = (virStoragePoolPtr) PyvirStoragePool_Get(pyobj_pool);
3986
3987 if (pool == NULL)
3988 return VIR_PY_NONE;
3989
3990 LIBVIRT_BEGIN_ALLOW_THREADS;
3991 c_retval = virStoragePoolGetUUID(pool, &uuid[0]);
3992 LIBVIRT_END_ALLOW_THREADS;
3993
3994 if (c_retval < 0)
3995 return VIR_PY_NONE;
3996
3997 return libvirt_charPtrSizeWrap((char *) &uuid[0], VIR_UUID_BUFLEN);
3998 }
3999
4000 static PyObject *
4001 libvirt_virStoragePoolGetUUIDString(PyObject *self ATTRIBUTE_UNUSED,
4002 PyObject *args)
4003 {
4004 char uuidstr[VIR_UUID_STRING_BUFLEN];
4005 virStoragePoolPtr pool;
4006 PyObject *pyobj_pool;
4007 int c_retval;
4008
4009 if (!PyArg_ParseTuple(args, (char *)"O:virStoragePoolGetUUIDString",
4010 &pyobj_pool))
4011 return NULL;
4012 pool = (virStoragePoolPtr) PyvirStoragePool_Get(pyobj_pool);
4013
4014 if (pool == NULL)
4015 return VIR_PY_NONE;
4016
4017 LIBVIRT_BEGIN_ALLOW_THREADS;
4018 c_retval = virStoragePoolGetUUIDString(pool, &uuidstr[0]);
4019 LIBVIRT_END_ALLOW_THREADS;
4020
4021 if (c_retval < 0)
4022 return VIR_PY_NONE;
4023
4024 return libvirt_constcharPtrWrap((char *) &uuidstr[0]);
4025 }
4026
4027 static PyObject *
4028 libvirt_virStoragePoolLookupByUUID(PyObject *self ATTRIBUTE_UNUSED,
4029 PyObject *args)
4030 {
4031 virStoragePoolPtr c_retval;
4032 virConnectPtr conn;
4033 PyObject *pyobj_conn;
4034 unsigned char * uuid;
4035 Py_ssize_t len;
4036
4037 if (!PyArg_ParseTuple(args, (char *)"Oz#:virStoragePoolLookupByUUID",
4038 &pyobj_conn, &uuid, &len))
4039 return NULL;
4040 conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
4041
4042 if ((uuid == NULL) || (len != VIR_UUID_BUFLEN))
4043 return VIR_PY_NONE;
4044
4045 LIBVIRT_BEGIN_ALLOW_THREADS;
4046 c_retval = virStoragePoolLookupByUUID(conn, uuid);
4047 LIBVIRT_END_ALLOW_THREADS;
4048
4049 return libvirt_virStoragePoolPtrWrap((virStoragePoolPtr) c_retval);
4050 }
4051
4052 static PyObject *
4053 libvirt_virNodeListDevices(PyObject *self ATTRIBUTE_UNUSED,
4054 PyObject *args)
4055 {
4056 PyObject *py_retval;
4057 char **names = NULL;
4058 int c_retval;
4059 ssize_t i;
4060 virConnectPtr conn;
4061 PyObject *pyobj_conn;
4062 char *cap;
4063 unsigned int flags;
4064
4065 if (!PyArg_ParseTuple(args, (char *)"OzI:virNodeListDevices",
4066 &pyobj_conn, &cap, &flags))
4067 return NULL;
4068 conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
4069
4070 LIBVIRT_BEGIN_ALLOW_THREADS;
4071 c_retval = virNodeNumOfDevices(conn, cap, flags);
4072 LIBVIRT_END_ALLOW_THREADS;
4073
4074 if (c_retval < 0)
4075 return VIR_PY_NONE;
4076
4077 if (c_retval) {
4078 if (VIR_ALLOC_N(names, c_retval) < 0)
4079 return PyErr_NoMemory();
4080
4081 LIBVIRT_BEGIN_ALLOW_THREADS;
4082 c_retval = virNodeListDevices(conn, cap, names, c_retval, flags);
4083 LIBVIRT_END_ALLOW_THREADS;
4084
4085 if (c_retval < 0) {
4086 py_retval = VIR_PY_NONE;
4087 goto cleanup;
4088 }
4089 }
4090
4091 if ((py_retval = PyList_New(c_retval)) == NULL)
4092 goto cleanup;
4093
4094 if (names)
4095 for (i = 0; i < c_retval; i++)
4096 VIR_PY_LIST_SET_GOTO(py_retval, i,
4097 libvirt_constcharPtrWrap(names[i]), error);
4098
4099 cleanup:
4100 if (c_retval > 0)
4101 for (i = 0; i < c_retval; i++)
4102 VIR_FREE(names[i]);
4103 VIR_FREE(names);
4104 return py_retval;
4105
4106 error:
4107 Py_CLEAR(py_retval);
4108 goto cleanup;
4109 }
4110
4111 #if LIBVIR_CHECK_VERSION(0, 10, 2)
4112 static PyObject *
4113 libvirt_virConnectListAllNodeDevices(PyObject *self ATTRIBUTE_UNUSED,
4114 PyObject *args)
4115 {
4116 PyObject *pyobj_conn;
4117 PyObject *py_retval = NULL;
4118 virConnectPtr conn;
4119 virNodeDevicePtr *devices = NULL;
4120 int c_retval = 0;
4121 ssize_t i;
4122 unsigned int flags;
4123
4124 if (!PyArg_ParseTuple(args, (char *)"OI:virConnectListAllNodeDevices",
4125 &pyobj_conn, &flags))
4126 return NULL;
4127 conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
4128
4129 LIBVIRT_BEGIN_ALLOW_THREADS;
4130 c_retval = virConnectListAllNodeDevices(conn, &devices, flags);
4131 LIBVIRT_END_ALLOW_THREADS;
4132
4133 if (c_retval < 0)
4134 return VIR_PY_NONE;
4135
4136 if (!(py_retval = PyList_New(c_retval)))
4137 goto cleanup;
4138
4139 for (i = 0; i < c_retval; i++) {
4140 VIR_PY_LIST_SET_GOTO(py_retval, i,
4141 libvirt_virNodeDevicePtrWrap(devices[i]), error);
4142 /* python steals the pointer */
4143 devices[i] = NULL;
4144 }
4145
4146 cleanup:
4147 for (i = 0; i < c_retval; i++)
4148 if (devices[i])
4149 virNodeDeviceFree(devices[i]);
4150 VIR_FREE(devices);
4151 return py_retval;
4152
4153 error:
4154 Py_CLEAR(py_retval);
4155 goto cleanup;
4156 }
4157 #endif /* LIBVIR_CHECK_VERSION(0, 10, 2) */
4158
4159 static PyObject *
4160 libvirt_virNodeDeviceListCaps(PyObject *self ATTRIBUTE_UNUSED,
4161 PyObject *args)
4162 {
4163 PyObject *py_retval;
4164 char **names = NULL;
4165 int c_retval;
4166 ssize_t i;
4167 virNodeDevicePtr dev;
4168 PyObject *pyobj_dev;
4169
4170 if (!PyArg_ParseTuple(args, (char *)"O:virNodeDeviceListCaps", &pyobj_dev))
4171 return NULL;
4172 dev = (virNodeDevicePtr) PyvirNodeDevice_Get(pyobj_dev);
4173
4174 LIBVIRT_BEGIN_ALLOW_THREADS;
4175 c_retval = virNodeDeviceNumOfCaps(dev);
4176 LIBVIRT_END_ALLOW_THREADS;
4177
4178 if (c_retval < 0)
4179 return VIR_PY_NONE;
4180
4181 if (c_retval) {
4182 if (VIR_ALLOC_N(names, c_retval) < 0)
4183 return PyErr_NoMemory();
4184
4185 LIBVIRT_BEGIN_ALLOW_THREADS;
4186 c_retval = virNodeDeviceListCaps(dev, names, c_retval);
4187 LIBVIRT_END_ALLOW_THREADS;
4188
4189 if (c_retval < 0) {
4190 py_retval = VIR_PY_NONE;
4191 goto cleanup;
4192 }
4193 }
4194
4195 if ((py_retval = PyList_New(c_retval)) == NULL)
4196 goto cleanup;
4197
4198 if (names)
4199 for (i = 0; i < c_retval; i++)
4200 VIR_PY_LIST_SET_GOTO(py_retval, i,
4201 libvirt_constcharPtrWrap(names[i]), error);
4202
4203 cleanup:
4204 if (c_retval > 0)
4205 for (i = 0; i < c_retval; i++)
4206 VIR_FREE(names[i]);
4207 VIR_FREE(names);
4208 return py_retval;
4209
4210 error:
4211 Py_CLEAR(py_retval);
4212 goto cleanup;
4213 }
4214
4215 static PyObject *
4216 libvirt_virSecretGetUUID(PyObject *self ATTRIBUTE_UNUSED,
4217 PyObject *args)
4218 {
4219 unsigned char uuid[VIR_UUID_BUFLEN];
4220 virSecretPtr secret;
4221 PyObject *pyobj_secret;
4222 int c_retval;
4223
4224 if (!PyArg_ParseTuple(args, (char *)"O:virSecretGetUUID", &pyobj_secret))
4225 return NULL;
4226 secret = (virSecretPtr) PyvirSecret_Get(pyobj_secret);
4227
4228 if (secret == NULL)
4229 return VIR_PY_NONE;
4230
4231 LIBVIRT_BEGIN_ALLOW_THREADS;
4232 c_retval = virSecretGetUUID(secret, &uuid[0]);
4233 LIBVIRT_END_ALLOW_THREADS;
4234
4235 if (c_retval < 0)
4236 return VIR_PY_NONE;
4237
4238 return libvirt_charPtrSizeWrap((char *) &uuid[0], VIR_UUID_BUFLEN);
4239 }
4240
4241 static PyObject *
4242 libvirt_virSecretGetUUIDString(PyObject *self ATTRIBUTE_UNUSED,
4243 PyObject *args)
4244 {
4245 char uuidstr[VIR_UUID_STRING_BUFLEN];
4246 virSecretPtr dom;
4247 PyObject *pyobj_dom;
4248 int c_retval;
4249
4250 if (!PyArg_ParseTuple(args, (char *)"O:virSecretGetUUIDString",
4251 &pyobj_dom))
4252 return NULL;
4253 dom = (virSecretPtr) PyvirSecret_Get(pyobj_dom);
4254
4255 if (dom == NULL)
4256 return VIR_PY_NONE;
4257
4258 LIBVIRT_BEGIN_ALLOW_THREADS;
4259 c_retval = virSecretGetUUIDString(dom, &uuidstr[0]);
4260 LIBVIRT_END_ALLOW_THREADS;
4261
4262 if (c_retval < 0)
4263 return VIR_PY_NONE;
4264
4265 return libvirt_constcharPtrWrap((char *) &uuidstr[0]);
4266 }
4267
4268 static PyObject *
4269 libvirt_virSecretLookupByUUID(PyObject *self ATTRIBUTE_UNUSED,
4270 PyObject *args)
4271 {
4272 virSecretPtr c_retval;
4273 virConnectPtr conn;
4274 PyObject *pyobj_conn;
4275 unsigned char * uuid;
4276 Py_ssize_t len;
4277
4278 if (!PyArg_ParseTuple(args, (char *)"Oz#:virSecretLookupByUUID",
4279 &pyobj_conn, &uuid, &len))
4280 return NULL;
4281 conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
4282
4283 if ((uuid == NULL) || (len != VIR_UUID_BUFLEN))
4284 return VIR_PY_NONE;
4285
4286 LIBVIRT_BEGIN_ALLOW_THREADS;
4287 c_retval = virSecretLookupByUUID(conn, uuid);
4288 LIBVIRT_END_ALLOW_THREADS;
4289
4290 return libvirt_virSecretPtrWrap((virSecretPtr) c_retval);
4291 }
4292
4293
4294 static PyObject *
4295 libvirt_virConnectListSecrets(PyObject *self ATTRIBUTE_UNUSED,
4296 PyObject *args)
4297 {
4298 PyObject *py_retval;
4299 char **uuids = NULL;
4300 virConnectPtr conn;
4301 int c_retval;
4302 ssize_t i;
4303 PyObject *pyobj_conn;
4304
4305 if (!PyArg_ParseTuple(args, (char *)"O:virConnectListSecrets", &pyobj_conn))
4306 return NULL;
4307 conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
4308
4309 LIBVIRT_BEGIN_ALLOW_THREADS;
4310 c_retval = virConnectNumOfSecrets(conn);
4311 LIBVIRT_END_ALLOW_THREADS;
4312
4313 if (c_retval < 0)
4314 return VIR_PY_NONE;
4315
4316 if (c_retval) {
4317 if (VIR_ALLOC_N(uuids, c_retval) < 0)
4318 return PyErr_NoMemory();
4319
4320 LIBVIRT_BEGIN_ALLOW_THREADS;
4321 c_retval = virConnectListSecrets(conn, uuids, c_retval);
4322 LIBVIRT_END_ALLOW_THREADS;
4323
4324 if (c_retval < 0) {
4325 py_retval = VIR_PY_NONE;
4326 goto cleanup;
4327 }
4328 }
4329
4330 if ((py_retval = PyList_New(c_retval)) == NULL)
4331 goto cleanup;
4332
4333 if (uuids) {
4334 for (i = 0; i < c_retval; i++)
4335 VIR_PY_LIST_SET_GOTO(py_retval, i,
4336 libvirt_constcharPtrWrap(uuids[i]), error);
4337 }
4338
4339 cleanup:
4340 if (c_retval > 0)
4341 for (i = 0; i < c_retval; i++)
4342 VIR_FREE(uuids[i]);
4343 VIR_FREE(uuids);
4344 return py_retval;
4345
4346 error:
4347 Py_CLEAR(py_retval);
4348 goto cleanup;
4349 }
4350
4351 #if LIBVIR_CHECK_VERSION(0, 10, 2)
4352 static PyObject *
4353 libvirt_virConnectListAllSecrets(PyObject *self ATTRIBUTE_UNUSED,
4354 PyObject *args)
4355 {
4356 PyObject *pyobj_conn;
4357 PyObject *py_retval = NULL;
4358 virConnectPtr conn;
4359 virSecretPtr *secrets = NULL;
4360 int c_retval = 0;
4361 ssize_t i;
4362 unsigned int flags;
4363
4364 if (!PyArg_ParseTuple(args, (char *)"OI:virConnectListAllSecrets",
4365 &pyobj_conn, &flags))
4366 return NULL;
4367 conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
4368
4369 LIBVIRT_BEGIN_ALLOW_THREADS;
4370 c_retval = virConnectListAllSecrets(conn, &secrets, flags);
4371 LIBVIRT_END_ALLOW_THREADS;
4372
4373 if (c_retval < 0)
4374 return VIR_PY_NONE;
4375
4376 if (!(py_retval = PyList_New(c_retval)))
4377 goto cleanup;
4378
4379 for (i = 0; i < c_retval; i++) {
4380 VIR_PY_LIST_SET_GOTO(py_retval, i,
4381 libvirt_virSecretPtrWrap(secrets[i]), error);
4382 /* python steals the pointer */
4383 secrets[i] = NULL;
4384 }
4385
4386 cleanup:
4387 for (i = 0; i < c_retval; i++)
4388 if (secrets[i])
4389 virSecretFree(secrets[i]);
4390 VIR_FREE(secrets);
4391 return py_retval;
4392
4393 error:
4394 Py_CLEAR(py_retval);
4395 goto cleanup;
4396 }
4397 #endif /* LIBVIR_CHECK_VERSION(0, 10, 2) */
4398
4399 static PyObject *
4400 libvirt_virSecretGetValue(PyObject *self ATTRIBUTE_UNUSED,
4401 PyObject *args)
4402 {
4403 PyObject *py_retval;
4404 unsigned char *c_retval;
4405 size_t size;
4406 virSecretPtr secret;
4407 PyObject *pyobj_secret;
4408 unsigned int flags;
4409
4410 if (!PyArg_ParseTuple(args, (char *)"OI:virSecretGetValue", &pyobj_secret,
4411 &flags))
4412 return NULL;
4413 secret = (virSecretPtr) PyvirSecret_Get(pyobj_secret);
4414
4415 LIBVIRT_BEGIN_ALLOW_THREADS;
4416 c_retval = virSecretGetValue(secret, &size, flags);
4417 LIBVIRT_END_ALLOW_THREADS;
4418
4419 if (c_retval == NULL)
4420 return VIR_PY_NONE;
4421
4422 py_retval = libvirt_charPtrSizeWrap((char*)c_retval, size);
4423 VIR_FREE(c_retval);
4424
4425 return py_retval;
4426 }
4427
4428 static PyObject *
4429 libvirt_virSecretSetValue(PyObject *self ATTRIBUTE_UNUSED,
4430 PyObject *args)
4431 {
4432 int c_retval;
4433 virSecretPtr secret;
4434 PyObject *pyobj_secret;
4435 const char *value;
4436 Py_ssize_t size;
4437 unsigned int flags;
4438
4439 if (!PyArg_ParseTuple(args, (char *)"Oz#I:virSecretSetValue", &pyobj_secret,
4440 &value, &size, &flags))
4441 return NULL;
4442 secret = (virSecretPtr) PyvirSecret_Get(pyobj_secret);
4443
4444 LIBVIRT_BEGIN_ALLOW_THREADS;
4445 c_retval = virSecretSetValue(secret, (const unsigned char *)value,
4446 (size_t) size, flags);
4447 LIBVIRT_END_ALLOW_THREADS;
4448
4449 return libvirt_intWrap(c_retval);
4450 }
4451
4452 static PyObject *
4453 libvirt_virNWFilterGetUUID(PyObject *self ATTRIBUTE_UNUSED,
4454 PyObject *args)
4455 {
4456 unsigned char uuid[VIR_UUID_BUFLEN];
4457 virNWFilterPtr nwfilter;
4458 PyObject *pyobj_nwfilter;
4459 int c_retval;
4460
4461 if (!PyArg_ParseTuple(args, (char *)"O:virNWFilterGetUUID",
4462 &pyobj_nwfilter))
4463 return NULL;
4464 nwfilter = (virNWFilterPtr) PyvirNWFilter_Get(pyobj_nwfilter);
4465
4466 if (nwfilter == NULL)
4467 return VIR_PY_NONE;
4468
4469 LIBVIRT_BEGIN_ALLOW_THREADS;
4470 c_retval = virNWFilterGetUUID(nwfilter, &uuid[0]);
4471 LIBVIRT_END_ALLOW_THREADS;
4472
4473 if (c_retval < 0)
4474 return VIR_PY_NONE;
4475
4476 return libvirt_charPtrSizeWrap((char *) &uuid[0], VIR_UUID_BUFLEN);
4477 }
4478
4479 static PyObject *
4480 libvirt_virNWFilterGetUUIDString(PyObject *self ATTRIBUTE_UNUSED,
4481 PyObject *args)
4482 {
4483 char uuidstr[VIR_UUID_STRING_BUFLEN];
4484 virNWFilterPtr nwfilter;
4485 PyObject *pyobj_nwfilter;
4486 int c_retval;
4487
4488 if (!PyArg_ParseTuple(args, (char *)"O:virNWFilterGetUUIDString",
4489 &pyobj_nwfilter))
4490 return NULL;
4491 nwfilter = (virNWFilterPtr) PyvirNWFilter_Get(pyobj_nwfilter);
4492
4493 if (nwfilter == NULL)
4494 return VIR_PY_NONE;
4495
4496 LIBVIRT_BEGIN_ALLOW_THREADS;
4497 c_retval = virNWFilterGetUUIDString(nwfilter, &uuidstr[0]);
4498 LIBVIRT_END_ALLOW_THREADS;
4499
4500 if (c_retval < 0)
4501 return VIR_PY_NONE;
4502
4503 return libvirt_constcharPtrWrap((char *) &uuidstr[0]);
4504 }
4505
4506 static PyObject *
4507 libvirt_virNWFilterLookupByUUID(PyObject *self ATTRIBUTE_UNUSED,
4508 PyObject *args)
4509 {
4510 virNWFilterPtr c_retval;
4511 virConnectPtr conn;
4512 PyObject *pyobj_conn;
4513 unsigned char * uuid;
4514 Py_ssize_t len;
4515
4516 if (!PyArg_ParseTuple(args, (char *)"Oz#:virNWFilterLookupByUUID",
4517 &pyobj_conn, &uuid, &len))
4518 return NULL;
4519 conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
4520
4521 if ((uuid == NULL) || (len != VIR_UUID_BUFLEN))
4522 return VIR_PY_NONE;
4523
4524 LIBVIRT_BEGIN_ALLOW_THREADS;
4525 c_retval = virNWFilterLookupByUUID(conn, uuid);
4526 LIBVIRT_END_ALLOW_THREADS;
4527
4528 return libvirt_virNWFilterPtrWrap((virNWFilterPtr) c_retval);
4529 }
4530
4531
4532 static PyObject *
4533 libvirt_virConnectListNWFilters(PyObject *self ATTRIBUTE_UNUSED,
4534 PyObject *args)
4535 {
4536 PyObject *py_retval;
4537 char **uuids = NULL;
4538 virConnectPtr conn;
4539 int c_retval;
4540 ssize_t i;
4541 PyObject *pyobj_conn;
4542
4543 if (!PyArg_ParseTuple(args, (char *)"O:virConnectListNWFilters",
4544 &pyobj_conn))
4545 return NULL;
4546 conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
4547
4548 LIBVIRT_BEGIN_ALLOW_THREADS;
4549 c_retval = virConnectNumOfNWFilters(conn);
4550 LIBVIRT_END_ALLOW_THREADS;
4551
4552 if (c_retval < 0)
4553 return VIR_PY_NONE;
4554
4555 if (c_retval) {
4556 if (VIR_ALLOC_N(uuids, c_retval) < 0)
4557 return PyErr_NoMemory();
4558
4559 LIBVIRT_BEGIN_ALLOW_THREADS;
4560 c_retval = virConnectListNWFilters(conn, uuids, c_retval);
4561 LIBVIRT_END_ALLOW_THREADS;
4562
4563 if (c_retval < 0) {
4564 py_retval = VIR_PY_NONE;
4565 goto cleanup;
4566 }
4567 }
4568
4569 if ((py_retval = PyList_New(c_retval)) == NULL)
4570 goto cleanup;
4571
4572 if (uuids)
4573 for (i = 0; i < c_retval; i++)
4574 VIR_PY_LIST_SET_GOTO(py_retval, i,
4575 libvirt_constcharPtrWrap(uuids[i]), error);
4576
4577 cleanup:
4578 if (c_retval > 0)
4579 for (i = 0; i < c_retval; i++)
4580 VIR_FREE(uuids[i]);
4581 VIR_FREE(uuids);
4582 return py_retval;
4583
4584 error:
4585 Py_CLEAR(py_retval);
4586 goto cleanup;
4587 }
4588
4589 #if LIBVIR_CHECK_VERSION(0, 10, 2)
4590 static PyObject *
4591 libvirt_virConnectListAllNWFilters(PyObject *self ATTRIBUTE_UNUSED,
4592 PyObject *args)
4593 {
4594 PyObject *pyobj_conn;
4595 PyObject *py_retval = NULL;
4596 virConnectPtr conn;
4597 virNWFilterPtr *filters = NULL;
4598 int c_retval = 0;
4599 ssize_t i;
4600 unsigned int flags;
4601
4602 if (!PyArg_ParseTuple(args, (char *)"OI:virConnectListAllNWFilters",
4603 &pyobj_conn, &flags))
4604 return NULL;
4605 conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
4606
4607 LIBVIRT_BEGIN_ALLOW_THREADS;
4608 c_retval = virConnectListAllNWFilters(conn, &filters, flags);
4609 LIBVIRT_END_ALLOW_THREADS;
4610
4611 if (c_retval < 0)
4612 return VIR_PY_NONE;
4613
4614 if (!(py_retval = PyList_New(c_retval)))
4615 goto cleanup;
4616
4617 for (i = 0; i < c_retval; i++) {
4618 VIR_PY_LIST_SET_GOTO(py_retval, i,
4619 libvirt_virNWFilterPtrWrap(filters[i]), error);
4620 /* python steals the pointer */
4621 filters[i] = NULL;
4622 }
4623
4624 cleanup:
4625 for (i = 0; i < c_retval; i++)
4626 if (filters[i])
4627 virNWFilterFree(filters[i]);
4628 VIR_FREE(filters);
4629 return py_retval;
4630
4631 error:
4632 Py_CLEAR(py_retval);
4633 goto cleanup;
4634 }
4635 #endif /* LIBVIR_CHECK_VERSION(0, 10, 2) */
4636
4637 #if LIBVIR_CHECK_VERSION(4, 5, 0)
4638 static PyObject *
4639 libvirt_virConnectListAllNWFilterBindings(PyObject *self ATTRIBUTE_UNUSED,
4640 PyObject *args)
4641 {
4642 PyObject *pyobj_conn;
4643 PyObject *py_retval = NULL;
4644 virConnectPtr conn;
4645 virNWFilterBindingPtr *bindings = NULL;
4646 int c_retval = 0;
4647 ssize_t i;
4648 unsigned int flags;
4649
4650 if (!PyArg_ParseTuple(args, (char *)"OI:virConnectListAllNWFilterBindings",
4651 &pyobj_conn, &flags))
4652 return NULL;
4653 conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
4654
4655 LIBVIRT_BEGIN_ALLOW_THREADS;
4656 c_retval = virConnectListAllNWFilterBindings(conn, &bindings, flags);
4657 LIBVIRT_END_ALLOW_THREADS;
4658
4659 if (c_retval < 0)
4660 return VIR_PY_NONE;
4661
4662 if (!(py_retval = PyList_New(c_retval)))
4663 goto cleanup;
4664
4665 for (i = 0; i < c_retval; i++) {
4666 VIR_PY_LIST_SET_GOTO(py_retval, i,
4667 libvirt_virNWFilterBindingPtrWrap(bindings[i]), error);
4668 /* python steals the pointer */
4669 bindings[i] = NULL;
4670 }
4671
4672 cleanup:
4673 for (i = 0; i < c_retval; i++)
4674 if (bindings[i])
4675 virNWFilterBindingFree(bindings[i]);
4676 VIR_FREE(bindings);
4677 return py_retval;
4678
4679 error:
4680 Py_CLEAR(py_retval);
4681 goto cleanup;
4682 }
4683 #endif /* LIBVIR_CHECK_VERSION(4, 5, 0) */
4684
4685 static PyObject *
4686 libvirt_virConnectListInterfaces(PyObject *self ATTRIBUTE_UNUSED,
4687 PyObject *args)
4688 {
4689 PyObject *py_retval;
4690 char **names = NULL;
4691 int c_retval;
4692 ssize_t i;
4693 virConnectPtr conn;
4694 PyObject *pyobj_conn;
4695
4696
4697 if (!PyArg_ParseTuple(args, (char *)"O:virConnectListInterfaces",
4698 &pyobj_conn))
4699 return NULL;
4700 conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
4701
4702 LIBVIRT_BEGIN_ALLOW_THREADS;
4703 c_retval = virConnectNumOfInterfaces(conn);
4704 LIBVIRT_END_ALLOW_THREADS;
4705
4706 if (c_retval < 0)
4707 return VIR_PY_NONE;
4708
4709 if (c_retval) {
4710 if (VIR_ALLOC_N(names, c_retval) < 0)
4711 return PyErr_NoMemory();
4712
4713 LIBVIRT_BEGIN_ALLOW_THREADS;
4714 c_retval = virConnectListInterfaces(conn, names, c_retval);
4715 LIBVIRT_END_ALLOW_THREADS;
4716
4717 if (c_retval < 0) {
4718 py_retval = VIR_PY_NONE;
4719 goto cleanup;
4720 }
4721 }
4722
4723 if ((py_retval = PyList_New(c_retval)) == NULL)
4724 goto cleanup;
4725
4726 if (names)
4727 for (i = 0; i < c_retval; i++)
4728 VIR_PY_LIST_SET_GOTO(py_retval, i,
4729 libvirt_constcharPtrWrap(names[i]), error);
4730
4731 cleanup:
4732 if (c_retval > 0)
4733 for (i = 0; i < c_retval; i++)
4734 VIR_FREE(names[i]);
4735 VIR_FREE(names);
4736 return py_retval;
4737
4738 error:
4739 Py_CLEAR(py_retval);
4740 goto cleanup;
4741 }
4742
4743
4744 static PyObject *
4745 libvirt_virConnectListDefinedInterfaces(PyObject *self ATTRIBUTE_UNUSED,
4746 PyObject *args)
4747 {
4748 PyObject *py_retval;
4749 char **names = NULL;
4750 int c_retval;
4751 ssize_t i;
4752 virConnectPtr conn;
4753 PyObject *pyobj_conn;
4754
4755
4756 if (!PyArg_ParseTuple(args, (char *)"O:virConnectListDefinedInterfaces",
4757 &pyobj_conn))
4758 return NULL;
4759 conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
4760
4761 LIBVIRT_BEGIN_ALLOW_THREADS;
4762 c_retval = virConnectNumOfDefinedInterfaces(conn);
4763 LIBVIRT_END_ALLOW_THREADS;
4764
4765 if (c_retval < 0)
4766 return VIR_PY_NONE;
4767
4768 if (c_retval) {
4769 if (VIR_ALLOC_N(names, c_retval) < 0)
4770 return PyErr_NoMemory();
4771
4772 LIBVIRT_BEGIN_ALLOW_THREADS;
4773 c_retval = virConnectListDefinedInterfaces(conn, names, c_retval);
4774 LIBVIRT_END_ALLOW_THREADS;
4775
4776 if (c_retval < 0) {
4777 py_retval = VIR_PY_NONE;
4778 goto cleanup;
4779 }
4780 }
4781
4782 if ((py_retval = PyList_New(c_retval)) == NULL)
4783 goto cleanup;
4784
4785 if (names) {
4786 for (i = 0; i < c_retval; i++)
4787 VIR_PY_LIST_SET_GOTO(py_retval, i,
4788 libvirt_constcharPtrWrap(names[i]), error);
4789 }
4790
4791 cleanup:
4792 if (c_retval > 0)
4793 for (i = 0; i < c_retval; i++)
4794 VIR_FREE(names[i]);
4795 VIR_FREE(names);
4796 return py_retval;
4797
4798 error:
4799 Py_CLEAR(py_retval);
4800 goto cleanup;
4801 }
4802
4803
4804 #if LIBVIR_CHECK_VERSION(0, 10, 2)
4805 static PyObject *
4806 libvirt_virConnectListAllInterfaces(PyObject *self ATTRIBUTE_UNUSED,
4807 PyObject *args)
4808 {
4809 PyObject *pyobj_conn;
4810 PyObject *py_retval = NULL;
4811 virConnectPtr conn;
4812 virInterfacePtr *ifaces = NULL;
4813 int c_retval = 0;
4814 ssize_t i;
4815 unsigned int flags;
4816
4817 if (!PyArg_ParseTuple(args, (char *)"OI:virConnectListAllInterfaces",
4818 &pyobj_conn, &flags))
4819 return NULL;
4820 conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
4821
4822 LIBVIRT_BEGIN_ALLOW_THREADS;
4823 c_retval = virConnectListAllInterfaces(conn, &ifaces, flags);
4824 LIBVIRT_END_ALLOW_THREADS;
4825
4826 if (c_retval < 0)
4827 return VIR_PY_NONE;
4828
4829 if (!(py_retval = PyList_New(c_retval)))
4830 goto cleanup;
4831
4832 for (i = 0; i < c_retval; i++) {
4833 VIR_PY_LIST_SET_GOTO(py_retval, i,
4834 libvirt_virInterfacePtrWrap(ifaces[i]), error);
4835 /* python steals the pointer */
4836 ifaces[i] = NULL;
4837 }
4838
4839 cleanup:
4840 for (i = 0; i < c_retval; i++)
4841 if (ifaces[i])
4842 virInterfaceFree(ifaces[i]);
4843 VIR_FREE(ifaces);
4844 return py_retval;
4845
4846 error:
4847 Py_CLEAR(py_retval);
4848 goto cleanup;
4849 }
4850 #endif /* LIBVIR_CHECK_VERSION(0, 10, 2) */
4851
4852 static PyObject *
4853 libvirt_virConnectBaselineCPU(PyObject *self ATTRIBUTE_UNUSED,
4854 PyObject *args)
4855 {
4856 PyObject *pyobj_conn;
4857 PyObject *list;
4858 virConnectPtr conn;
4859 unsigned int flags;
4860 char **xmlcpus = NULL;
4861 int ncpus = 0;
4862 char *base_cpu;
4863 PyObject *pybase_cpu;
4864 ssize_t i, j;
4865
4866 if (!PyArg_ParseTuple(args, (char *)"OOI:virConnectBaselineCPU",
4867 &pyobj_conn, &list, &flags))
4868 return NULL;
4869 conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
4870
4871 if (PyList_Check(list)) {
4872 ncpus = PyList_Size(list);
4873 if (VIR_ALLOC_N(xmlcpus, ncpus) < 0)
4874 return PyErr_NoMemory();
4875
4876 for (i = 0; i < ncpus; i++) {
4877 if (libvirt_charPtrUnwrap(PyList_GetItem(list, i),
4878 &(xmlcpus[i])) < 0) {
4879 for (j = 0 ; j < i ; j++)
4880 VIR_FREE(xmlcpus[j]);
4881 VIR_FREE(xmlcpus);
4882 return NULL;
4883 }
4884 }
4885 }
4886
4887 LIBVIRT_BEGIN_ALLOW_THREADS;
4888 base_cpu = virConnectBaselineCPU(conn, (const char **)xmlcpus, ncpus, flags);
4889 LIBVIRT_END_ALLOW_THREADS;
4890
4891 for (i = 0 ; i < ncpus ; i++)
4892 VIR_FREE(xmlcpus[i]);
4893 VIR_FREE(xmlcpus);
4894
4895 if (base_cpu == NULL)
4896 return VIR_PY_NONE;
4897
4898 pybase_cpu = libvirt_constcharPtrWrap(base_cpu);
4899 VIR_FREE(base_cpu);
4900
4901 return pybase_cpu;
4902 }
4903
4904
4905 static PyObject *
4906 libvirt_virDomainGetJobInfo(PyObject *self ATTRIBUTE_UNUSED,
4907 PyObject *args)
4908 {
4909 PyObject *py_retval;
4910 int c_retval;
4911 virDomainPtr domain;
4912 PyObject *pyobj_domain;
4913 virDomainJobInfo info;
4914
4915 if (!PyArg_ParseTuple(args, (char *)"O:virDomainGetJobInfo", &pyobj_domain))
4916 return NULL;
4917 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
4918
4919 LIBVIRT_BEGIN_ALLOW_THREADS;
4920 c_retval = virDomainGetJobInfo(domain, &info);
4921 LIBVIRT_END_ALLOW_THREADS;
4922
4923 if (c_retval < 0)
4924 return VIR_PY_NONE;
4925
4926 if ((py_retval = PyList_New(12)) == NULL)
4927 return NULL;
4928
4929 VIR_PY_LIST_SET_GOTO(py_retval, 0,
4930 libvirt_intWrap(info.type), error);
4931 VIR_PY_LIST_SET_GOTO(py_retval, 1,
4932 libvirt_ulonglongWrap(info.timeElapsed), error);
4933 VIR_PY_LIST_SET_GOTO(py_retval, 2,
4934 libvirt_ulonglongWrap(info.timeRemaining), error);
4935 VIR_PY_LIST_SET_GOTO(py_retval, 3,
4936 libvirt_ulonglongWrap(info.dataTotal), error);
4937 VIR_PY_LIST_SET_GOTO(py_retval, 4,
4938 libvirt_ulonglongWrap(info.dataProcessed), error);
4939 VIR_PY_LIST_SET_GOTO(py_retval, 5,
4940 libvirt_ulonglongWrap(info.dataRemaining), error);
4941 VIR_PY_LIST_SET_GOTO(py_retval, 6,
4942 libvirt_ulonglongWrap(info.memTotal), error);
4943 VIR_PY_LIST_SET_GOTO(py_retval, 7,
4944 libvirt_ulonglongWrap(info.memProcessed), error);
4945 VIR_PY_LIST_SET_GOTO(py_retval, 8,
4946 libvirt_ulonglongWrap(info.memRemaining), error);
4947 VIR_PY_LIST_SET_GOTO(py_retval, 9,
4948 libvirt_ulonglongWrap(info.fileTotal), error);
4949 VIR_PY_LIST_SET_GOTO(py_retval, 10,
4950 libvirt_ulonglongWrap(info.fileProcessed), error);
4951 VIR_PY_LIST_SET_GOTO(py_retval, 11,
4952 libvirt_ulonglongWrap(info.fileRemaining), error);
4953
4954 return py_retval;
4955
4956 error:
4957 Py_DECREF(py_retval);
4958 return NULL;
4959 }
4960
4961 #if LIBVIR_CHECK_VERSION(1, 0, 3)
4962 static PyObject *
4963 libvirt_virDomainGetJobStats(PyObject *self ATTRIBUTE_UNUSED,
4964 PyObject *args)
4965 {
4966 PyObject *pyobj_domain;
4967 virDomainPtr domain;
4968 unsigned int flags;
4969 virTypedParameterPtr params = NULL;
4970 int nparams = 0;
4971 int type;
4972 PyObject *dict = NULL;
4973 int rc;
4974
4975 if (!PyArg_ParseTuple(args, (char *) "OI:virDomainGetJobStats",
4976 &pyobj_domain, &flags))
4977 return NULL;
4978 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
4979
4980 LIBVIRT_BEGIN_ALLOW_THREADS;
4981 rc = virDomainGetJobStats(domain, &type, &params, &nparams, flags);
4982 LIBVIRT_END_ALLOW_THREADS;
4983
4984 if (rc < 0)
4985 return VIR_PY_NONE;
4986
4987 if (!(dict = getPyVirTypedParameter(params, nparams)))
4988 goto cleanup;
4989
4990 VIR_PY_DICT_SET_GOTO(dict, libvirt_constcharPtrWrap("type"),
4991 libvirt_intWrap(type), error);
4992
4993 cleanup:
4994 virTypedParamsFree(params, nparams);
4995 return dict;
4996
4997 error:
4998 Py_CLEAR(dict);
4999 goto cleanup;
5000 }
5001 #endif /* LIBVIR_CHECK_VERSION(1, 0, 3) */
5002
5003 static PyObject *
5004 libvirt_virDomainGetBlockJobInfo(PyObject *self ATTRIBUTE_UNUSED,
5005 PyObject *args)
5006 {
5007 virDomainPtr domain;
5008 PyObject *pyobj_domain;
5009 const char *path;
5010 unsigned int flags;
5011 virDomainBlockJobInfo info;
5012 int c_ret;
5013 PyObject *dict;
5014
5015 if (!PyArg_ParseTuple(args, (char *)"OzI:virDomainGetBlockJobInfo",
5016 &pyobj_domain, &path, &flags))
5017 return NULL;
5018 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
5019
5020 LIBVIRT_BEGIN_ALLOW_THREADS;
5021 c_ret = virDomainGetBlockJobInfo(domain, path, &info, flags);
5022 LIBVIRT_END_ALLOW_THREADS;
5023
5024 if (c_ret < 0)
5025 return VIR_PY_NONE;
5026
5027 if ((dict = PyDict_New()) == NULL)
5028 return NULL;
5029
5030 if (c_ret == 0)
5031 return dict;
5032
5033 VIR_PY_DICT_SET_GOTO(dict, libvirt_constcharPtrWrap("type"),
5034 libvirt_intWrap(info.type), error);
5035 VIR_PY_DICT_SET_GOTO(dict, libvirt_constcharPtrWrap("bandwidth"),
5036 libvirt_ulongWrap(info.bandwidth), error);
5037 VIR_PY_DICT_SET_GOTO(dict, libvirt_constcharPtrWrap("cur"),
5038 libvirt_ulonglongWrap(info.cur), error);
5039 VIR_PY_DICT_SET_GOTO(dict, libvirt_constcharPtrWrap("end"),
5040 libvirt_ulonglongWrap(info.end), error);
5041
5042 return dict;
5043
5044 error:
5045 Py_DECREF(dict);
5046 return NULL;
5047 }
5048
5049 static PyObject *
5050 libvirt_virDomainSetBlockIoTune(PyObject *self ATTRIBUTE_UNUSED,
5051 PyObject *args)
5052 {
5053 virDomainPtr domain;
5054 PyObject *pyobj_domain, *info;
5055 PyObject *ret = NULL;
5056 int i_retval;
5057 int nparams = 0;
5058 Py_ssize_t size = 0;
5059 const char *disk;
5060 unsigned int flags;
5061 virTypedParameterPtr params = NULL, new_params = NULL;
5062
5063 if (!PyArg_ParseTuple(args, (char *)"OzOI:virDomainSetBlockIoTune",
5064 &pyobj_domain, &disk, &info, &flags))
5065 return NULL;
5066 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
5067
5068 if ((size = PyDict_Size(info)) < 0)
5069 return NULL;
5070
5071 if (size == 0) {
5072 PyErr_Format(PyExc_LookupError,
5073 "Need non-empty dictionary to set attributes");
5074 return NULL;
5075 }
5076
5077 LIBVIRT_BEGIN_ALLOW_THREADS;
5078 i_retval = virDomainGetBlockIoTune(domain, disk, NULL, &nparams, flags);
5079 LIBVIRT_END_ALLOW_THREADS;
5080
5081 if (i_retval < 0)
5082 return VIR_PY_INT_FAIL;
5083
5084 if (nparams == 0) {
5085 PyErr_Format(PyExc_LookupError,
5086 "Domain has no settable attributes");
5087 return NULL;
5088 }
5089
5090 if (VIR_ALLOC_N(params, nparams) < 0)
5091 return PyErr_NoMemory();
5092
5093 LIBVIRT_BEGIN_ALLOW_THREADS;
5094 i_retval = virDomainGetBlockIoTune(domain, disk, params, &nparams, flags);
5095 LIBVIRT_END_ALLOW_THREADS;
5096
5097 if (i_retval < 0) {
5098 ret = VIR_PY_INT_FAIL;
5099 goto cleanup;
5100 }
5101
5102 new_params = setPyVirTypedParameter(info, params, nparams);
5103 if (!new_params)
5104 goto cleanup;
5105
5106 LIBVIRT_BEGIN_ALLOW_THREADS;
5107 i_retval = virDomainSetBlockIoTune(domain, disk, new_params, size, flags);
5108 LIBVIRT_END_ALLOW_THREADS;
5109
5110 if (i_retval < 0) {
5111 ret = VIR_PY_INT_FAIL;
5112 goto cleanup;
5113 }
5114
5115 ret = VIR_PY_INT_SUCCESS;
5116
5117 cleanup:
5118 virTypedParamsFree(params, nparams);
5119 virTypedParamsFree(new_params, size);
5120 return ret;
5121 }
5122
5123 static PyObject *
5124 libvirt_virDomainGetBlockIoTune(PyObject *self ATTRIBUTE_UNUSED,
5125 PyObject *args)
5126 {
5127 virDomainPtr domain;
5128 PyObject *pyobj_domain;
5129 PyObject *ret = NULL;
5130 int i_retval;
5131 int nparams = 0;
5132 const char *disk;
5133 unsigned int flags;
5134 virTypedParameterPtr params;
5135
5136 if (!PyArg_ParseTuple(args, (char *)"OzI:virDomainGetBlockIoTune",
5137 &pyobj_domain, &disk, &flags))
5138 return NULL;
5139 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
5140
5141 LIBVIRT_BEGIN_ALLOW_THREADS;
5142 i_retval = virDomainGetBlockIoTune(domain, disk, NULL, &nparams, flags);
5143 LIBVIRT_END_ALLOW_THREADS;
5144
5145 if (i_retval < 0)
5146 return VIR_PY_NONE;
5147
5148 if (!nparams)
5149 return PyDict_New();
5150
5151 if (VIR_ALLOC_N(params, nparams) < 0)
5152 return PyErr_NoMemory();
5153
5154 LIBVIRT_BEGIN_ALLOW_THREADS;
5155 i_retval = virDomainGetBlockIoTune(domain, disk, params, &nparams, flags);
5156 LIBVIRT_END_ALLOW_THREADS;
5157
5158 if (i_retval < 0) {
5159 ret = VIR_PY_NONE;
5160 goto cleanup;
5161 }
5162
5163 ret = getPyVirTypedParameter(params, nparams);
5164
5165 cleanup:
5166 virTypedParamsFree(params, nparams);
5167 return ret;
5168 }
5169
5170 static PyObject *
5171 libvirt_virDomainGetDiskErrors(PyObject *self ATTRIBUTE_UNUSED,
5172 PyObject *args)
5173 {
5174 PyObject *py_retval = VIR_PY_NONE;
5175 virDomainPtr domain;
5176 PyObject *pyobj_domain;
5177 unsigned int flags;
5178 virDomainDiskErrorPtr disks = NULL;
5179 unsigned int ndisks;
5180 int count;
5181 ssize_t i;
5182
5183 if (!PyArg_ParseTuple(args, (char *) "OI:virDomainGetDiskErrors",
5184 &pyobj_domain, &flags))
5185 return NULL;
5186
5187 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
5188
5189 LIBVIRT_BEGIN_ALLOW_THREADS;
5190 count = virDomainGetDiskErrors(domain, NULL, 0, 0);
5191 LIBVIRT_END_ALLOW_THREADS;
5192
5193 if (count < 0)
5194 return VIR_PY_NONE;
5195 ndisks = count;
5196
5197 if (ndisks) {
5198 if (VIR_ALLOC_N(disks, ndisks) < 0)
5199 return PyErr_NoMemory();
5200
5201 LIBVIRT_BEGIN_ALLOW_THREADS;
5202 count = virDomainGetDiskErrors(domain, disks, ndisks, 0);
5203 LIBVIRT_END_ALLOW_THREADS;
5204
5205 if (count < 0) {
5206 py_retval = VIR_PY_NONE;
5207 goto cleanup;
5208 }
5209 }
5210
5211 if (!(py_retval = PyDict_New()))
5212 goto cleanup;
5213
5214 for (i = 0; i < count; i++) {
5215 VIR_PY_DICT_SET_GOTO(py_retval,
5216 libvirt_constcharPtrWrap(disks[i].disk),
5217 libvirt_intWrap(disks[i].error),
5218 error);
5219 }
5220
5221 cleanup:
5222 if (count > 0)
5223 for (i = 0; i < count; i++)
5224 VIR_FREE(disks[i].disk);
5225 VIR_FREE(disks);
5226 return py_retval;
5227
5228 error:
5229 Py_CLEAR(py_retval);
5230 goto cleanup;
5231 }
5232
5233
5234 #if LIBVIR_CHECK_VERSION(1, 2, 14)
5235 static PyObject *
5236 libvirt_virDomainInterfaceAddresses(PyObject *self ATTRIBUTE_UNUSED,
5237 PyObject *args)
5238 {
5239 PyObject *py_retval = VIR_PY_NONE;
5240 PyObject *pyobj_domain;
5241 virDomainPtr domain;
5242 virDomainInterfacePtr *ifaces = NULL;
5243 unsigned int source;
5244 unsigned int flags;
5245 int ifaces_count = 0;
5246 ssize_t i;
5247
5248 if (!PyArg_ParseTuple(args, (char *) "OII:virDomainInterfaceAddresses",
5249 &pyobj_domain, &source, &flags))
5250 return NULL;
5251
5252 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
5253
5254 LIBVIRT_BEGIN_ALLOW_THREADS;
5255 ifaces_count = virDomainInterfaceAddresses(domain, &ifaces, source, flags);
5256 LIBVIRT_END_ALLOW_THREADS;
5257
5258 if (ifaces_count < 0)
5259 goto cleanup;
5260
5261 if (!(py_retval = PyDict_New()))
5262 goto error;
5263
5264 for (i = 0; i < ifaces_count; i++) {
5265 virDomainInterfacePtr iface = ifaces[i];
5266 PyObject *py_addrs = NULL;
5267 PyObject *py_iface = NULL;
5268 size_t j;
5269
5270 if (!(py_iface = PyDict_New()))
5271 goto error;
5272
5273 VIR_PY_DICT_SET_GOTO(py_retval, libvirt_charPtrWrap(iface->name),
5274 py_iface, error);
5275
5276 if (iface->naddrs) {
5277 if (!(py_addrs = PyList_New(iface->naddrs))) {
5278 goto error;
5279 }
5280 } else {
5281 py_addrs = VIR_PY_NONE;
5282 }
5283
5284 VIR_PY_DICT_SET_GOTO(py_iface, libvirt_constcharPtrWrap("addrs"),
5285 py_addrs, error);
5286
5287 VIR_PY_DICT_SET_GOTO(py_iface, libvirt_constcharPtrWrap("hwaddr"),
5288 libvirt_constcharPtrWrap(iface->hwaddr), error);
5289
5290 for (j = 0; j < iface->naddrs; j++) {
5291 virDomainIPAddressPtr addr = &(iface->addrs[j]);
5292 PyObject *py_addr = PyDict_New();
5293
5294 if (!py_addr)
5295 goto error;
5296
5297 VIR_PY_LIST_SET_GOTO(py_addrs, j, py_addr, error);
5298
5299 VIR_PY_DICT_SET_GOTO(py_addr, libvirt_constcharPtrWrap("addr"),
5300 libvirt_constcharPtrWrap(addr->addr), error);
5301 VIR_PY_DICT_SET_GOTO(py_addr, libvirt_constcharPtrWrap("prefix"),
5302 libvirt_uintWrap(addr->prefix), error);
5303 VIR_PY_DICT_SET_GOTO(py_addr, libvirt_constcharPtrWrap("type"),
5304 libvirt_intWrap(addr->type), error);
5305 }
5306 }
5307
5308 cleanup:
5309 if (ifaces && ifaces_count > 0) {
5310 for (i = 0; i < ifaces_count; i++) {
5311 virDomainInterfaceFree(ifaces[i]);
5312 }
5313 }
5314 VIR_FREE(ifaces);
5315
5316 return py_retval;
5317
5318 error:
5319 Py_CLEAR(py_retval);
5320 goto cleanup;
5321 }
5322 #endif /* LIBVIR_CHECK_VERSION(1, 2, 14) */
5323
5324
5325 /*******************************************
5326 * Helper functions to avoid importing modules
5327 * for every callback
5328 *******************************************/
5329 static PyObject *libvirt_module = NULL;
5330 static PyObject *libvirt_dict = NULL;
5331
5332 static PyObject *
5333 getLibvirtModuleObject(void)
5334 {
5335 if (libvirt_module)
5336 return libvirt_module;
5337
5338 // PyImport_ImportModule returns a new reference
5339 /* Bogus (char *) cast for RHEL-5 python API brokenness */
5340 libvirt_module = PyImport_ImportModule((char *)"libvirt");
5341 if (!libvirt_module) {
5342 DEBUG("%s Error importing libvirt module\n", __FUNCTION__);
5343 PyErr_Print();
5344 return NULL;
5345 }
5346
5347 return libvirt_module;
5348 }
5349
5350 static PyObject *
5351 getLibvirtDictObject(void)
5352 {
5353 if (libvirt_dict)
5354 return libvirt_dict;
5355
5356 // PyModule_GetDict returns a borrowed reference
5357 libvirt_dict = PyModule_GetDict(getLibvirtModuleObject());
5358 if (!libvirt_dict) {
5359 DEBUG("%s Error importing libvirt dictionary\n", __FUNCTION__);
5360 PyErr_Print();
5361 return NULL;
5362 }
5363
5364 Py_INCREF(libvirt_dict);
5365 return libvirt_dict;
5366 }
5367
5368
5369 static PyObject *
5370 libvirt_lookupPythonFunc(const char *funcname)
5371 {
5372 PyObject *python_cb;
5373
5374 /* Lookup the python callback */
5375 python_cb = PyDict_GetItemString(getLibvirtDictObject(), funcname);
5376
5377 if (!python_cb) {
5378 DEBUG("%s: Error finding %s\n", __FUNCTION__, funcname);
5379 PyErr_Print();
5380 PyErr_Clear();
5381 return NULL;
5382 }
5383
5384 if (!PyCallable_Check(python_cb)) {
5385 DEBUG("%s: %s is not callable\n", __FUNCTION__, funcname);
5386 return NULL;
5387 }
5388
5389 return python_cb;
5390 }
5391
5392 /*******************************************
5393 * Domain Events
5394 *******************************************/
5395
5396 static int
5397 libvirt_virConnectDomainEventCallback(virConnectPtr conn ATTRIBUTE_UNUSED,
5398 virDomainPtr dom,
5399 int event,
5400 int detail,
5401 void *opaque)
5402 {
5403 PyObject *pyobj_ret = NULL;
5404
5405 PyObject *pyobj_conn = (PyObject*)opaque;
5406 PyObject *pyobj_dom;
5407
5408 int ret = -1;
5409
5410 LIBVIRT_ENSURE_THREAD_STATE;
5411
5412 /* Create a python instance of this virDomainPtr */
5413 virDomainRef(dom);
5414 if (!(pyobj_dom = libvirt_virDomainPtrWrap(dom))) {
5415 virDomainFree(dom);
5416 goto cleanup;
5417 }
5418
5419 /* Call the Callback Dispatcher */
5420 pyobj_ret = PyObject_CallMethod(pyobj_conn,
5421 (char*)"_dispatchDomainEventCallbacks",
5422 (char*)"Oii",
5423 pyobj_dom,
5424 event, detail);
5425
5426 Py_DECREF(pyobj_dom);
5427
5428 cleanup:
5429 if (!pyobj_ret) {
5430 DEBUG("%s - ret:%p\n", __FUNCTION__, pyobj_ret);
5431 PyErr_Print();
5432 } else {
5433 Py_DECREF(pyobj_ret);
5434 ret = 0;
5435 }
5436
5437 LIBVIRT_RELEASE_THREAD_STATE;
5438 return ret;
5439 }
5440
5441 static PyObject *
5442 libvirt_virConnectDomainEventRegister(ATTRIBUTE_UNUSED PyObject *self,
5443 PyObject *args)
5444 {
5445 PyObject *pyobj_conn; /* virConnectPtr */
5446 PyObject *pyobj_conn_inst; /* virConnect Python object */
5447
5448 virConnectPtr conn;
5449 int ret = 0;
5450
5451 if (!PyArg_ParseTuple(args, (char *) "OO:virConnectDomainEventRegister",
5452 &pyobj_conn, &pyobj_conn_inst))
5453 return NULL;
5454
5455 DEBUG("libvirt_virConnectDomainEventRegister(%p %p) called\n",
5456 pyobj_conn, pyobj_conn_inst);
5457 conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
5458
5459 Py_INCREF(pyobj_conn_inst);
5460
5461 LIBVIRT_BEGIN_ALLOW_THREADS;
5462 ret = virConnectDomainEventRegister(conn,
5463 libvirt_virConnectDomainEventCallback,
5464 pyobj_conn_inst, NULL);
5465 LIBVIRT_END_ALLOW_THREADS;
5466
5467 return libvirt_intWrap(ret);
5468 }
5469
5470 static PyObject *
5471 libvirt_virConnectDomainEventDeregister(PyObject *self ATTRIBUTE_UNUSED,
5472 PyObject *args)
5473 {
5474 PyObject *pyobj_conn;
5475 PyObject *pyobj_conn_inst;
5476
5477 virConnectPtr conn;
5478 int ret = 0;
5479
5480 if (!PyArg_ParseTuple(args, (char *) "OO:virConnectDomainEventDeregister",
5481 &pyobj_conn, &pyobj_conn_inst))
5482 return NULL;
5483
5484 DEBUG("libvirt_virConnectDomainEventDeregister(%p) called\n", pyobj_conn);
5485
5486 conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
5487
5488 LIBVIRT_BEGIN_ALLOW_THREADS;
5489 ret = virConnectDomainEventDeregister(conn, libvirt_virConnectDomainEventCallback);
5490 LIBVIRT_END_ALLOW_THREADS;
5491
5492 Py_DECREF(pyobj_conn_inst);
5493 return libvirt_intWrap(ret);
5494 }
5495
5496 /*******************************************
5497 * Event Impl
5498 *******************************************/
5499 static PyObject *addHandleObj;
5500 static PyObject *updateHandleObj;
5501 static PyObject *removeHandleObj;
5502 static PyObject *addTimeoutObj;
5503 static PyObject *updateTimeoutObj;
5504 static PyObject *removeTimeoutObj;
5505
5506 static int
5507 libvirt_virEventAddHandleFunc(int fd,
5508 int event,
5509 virEventHandleCallback cb,
5510 void *opaque,
5511 virFreeCallback ff)
5512 {
5513 PyObject *result;
5514 PyObject *python_cb = NULL;
5515 PyObject *cb_args = NULL;
5516 PyObject *pyobj_args = NULL;
5517 int retval = -1;
5518
5519 LIBVIRT_ENSURE_THREAD_STATE;
5520
5521 if ((pyobj_args = PyTuple_New(4)) == NULL)
5522 goto cleanup;
5523
5524 VIR_PY_TUPLE_SET_GOTO(pyobj_args, 0, libvirt_intWrap(fd), cleanup);
5525 VIR_PY_TUPLE_SET_GOTO(pyobj_args, 1, libvirt_intWrap(event), cleanup);
5526
5527 /* Lookup the python callback */
5528 python_cb = libvirt_lookupPythonFunc("_eventInvokeHandleCallback");
5529 if (!python_cb) {
5530 goto cleanup;
5531 }
5532 Py_INCREF(python_cb);
5533
5534 VIR_PY_TUPLE_SET_GOTO(pyobj_args, 2, python_cb, cleanup);
5535
5536 if ((cb_args = PyTuple_New(3)) == NULL)
5537 goto cleanup;
5538
5539 VIR_PY_TUPLE_SET_GOTO(pyobj_args, 3, cb_args, cleanup);
5540
5541 /* If changing contents of the opaque object, please also change
5542 * virEventInvokeFreeCallback() in libvirt-override.py
5543 */
5544 VIR_PY_TUPLE_SET_GOTO(cb_args, 0, libvirt_virEventHandleCallbackWrap(cb), cleanup);
5545 VIR_PY_TUPLE_SET_GOTO(cb_args, 1, libvirt_virVoidPtrWrap(opaque), cleanup);
5546 VIR_PY_TUPLE_SET_GOTO(cb_args, 2, libvirt_virFreeCallbackWrap(ff), cleanup);
5547
5548 result = PyObject_Call(addHandleObj, pyobj_args, NULL);
5549 if (!result) {
5550 PyErr_Print();
5551 PyErr_Clear();
5552 } else {
5553 libvirt_intUnwrap(result, &retval);
5554 }
5555
5556 Py_XDECREF(result);
5557
5558 cleanup:
5559 Py_XDECREF(pyobj_args);
5560
5561 LIBVIRT_RELEASE_THREAD_STATE;
5562
5563 return retval;
5564 }
5565
5566 static void
5567 libvirt_virEventUpdateHandleFunc(int watch,
5568 int event)
5569 {
5570 PyObject *result = NULL;
5571 PyObject *pyobj_args;
5572
5573 LIBVIRT_ENSURE_THREAD_STATE;
5574
5575 if ((pyobj_args = PyTuple_New(2)) == NULL)
5576 goto cleanup;
5577
5578 VIR_PY_TUPLE_SET_GOTO(pyobj_args, 0, libvirt_intWrap(watch), cleanup);
5579 VIR_PY_TUPLE_SET_GOTO(pyobj_args, 1, libvirt_intWrap(event), cleanup);
5580
5581 result = PyObject_Call(updateHandleObj, pyobj_args, NULL);
5582 if (!result) {
5583 PyErr_Print();
5584 PyErr_Clear();
5585 }
5586
5587 cleanup:
5588 Py_XDECREF(result);
5589 Py_XDECREF(pyobj_args);
5590
5591 LIBVIRT_RELEASE_THREAD_STATE;
5592 }
5593
5594
5595 static int
5596 libvirt_virEventRemoveHandleFunc(int watch)
5597 {
5598 PyObject *result = NULL;
5599 PyObject *pyobj_args;
5600 int retval = -1;
5601
5602 LIBVIRT_ENSURE_THREAD_STATE;
5603
5604 if ((pyobj_args = PyTuple_New(1)) == NULL)
5605 goto cleanup;
5606
5607 VIR_PY_TUPLE_SET_GOTO(pyobj_args, 0, libvirt_intWrap(watch), cleanup);
5608
5609 result = PyObject_Call(removeHandleObj, pyobj_args, NULL);
5610 if (result) {
5611 retval = 0;
5612 } else {
5613 PyErr_Print();
5614 PyErr_Clear();
5615 }
5616
5617 cleanup:
5618 Py_XDECREF(result);
5619 Py_XDECREF(pyobj_args);
5620
5621 LIBVIRT_RELEASE_THREAD_STATE;
5622
5623 return retval;
5624 }
5625
5626
5627 static int
5628 libvirt_virEventAddTimeoutFunc(int timeout,
5629 virEventTimeoutCallback cb,
5630 void *opaque,
5631 virFreeCallback ff)
5632 {
5633 PyObject *result = NULL;
5634 PyObject *python_cb = NULL;
5635 PyObject *cb_args = NULL;
5636 PyObject *pyobj_args = NULL;
5637 int retval = -1;
5638
5639 LIBVIRT_ENSURE_THREAD_STATE;
5640
5641 if ((pyobj_args = PyTuple_New(3)) == NULL)
5642 goto cleanup;
5643
5644 VIR_PY_TUPLE_SET_GOTO(pyobj_args, 0, libvirt_intWrap(timeout), cleanup);
5645
5646 /* Lookup the python callback */
5647 python_cb = libvirt_lookupPythonFunc("_eventInvokeTimeoutCallback");
5648 if (!python_cb) {
5649 goto cleanup;
5650 }
5651 Py_INCREF(python_cb);
5652 VIR_PY_TUPLE_SET_GOTO(pyobj_args, 1, python_cb, cleanup);
5653
5654 if ((cb_args = PyTuple_New(3)) == NULL)
5655 goto cleanup;
5656
5657 VIR_PY_TUPLE_SET_GOTO(pyobj_args, 2, cb_args, cleanup);
5658
5659 /* If changing contents of the opaque object, please also change
5660 * virEventInvokeFreeCallback() in libvirt-override.py
5661 */
5662 VIR_PY_TUPLE_SET_GOTO(cb_args, 0, libvirt_virEventTimeoutCallbackWrap(cb), cleanup);
5663 VIR_PY_TUPLE_SET_GOTO(cb_args, 1, libvirt_virVoidPtrWrap(opaque), cleanup);
5664 VIR_PY_TUPLE_SET_GOTO(cb_args, 2, libvirt_virFreeCallbackWrap(ff), cleanup);
5665
5666 result = PyObject_Call(addTimeoutObj, pyobj_args, NULL);
5667 if (!result) {
5668 PyErr_Print();
5669 PyErr_Clear();
5670 } else {
5671 libvirt_intUnwrap(result, &retval);
5672 }
5673
5674 cleanup:
5675 Py_XDECREF(result);
5676 Py_XDECREF(pyobj_args);
5677
5678 LIBVIRT_RELEASE_THREAD_STATE;
5679 return retval;
5680 }
5681
5682 static void
5683 libvirt_virEventUpdateTimeoutFunc(int timer,
5684 int timeout)
5685 {
5686 PyObject *result = NULL;
5687 PyObject *pyobj_args;
5688
5689 LIBVIRT_ENSURE_THREAD_STATE;
5690
5691 if ((pyobj_args = PyTuple_New(2)) == NULL)
5692 goto cleanup;
5693
5694 VIR_PY_TUPLE_SET_GOTO(pyobj_args, 0, libvirt_intWrap(timer), cleanup);
5695 VIR_PY_TUPLE_SET_GOTO(pyobj_args, 1, libvirt_intWrap(timeout), cleanup);
5696
5697 result = PyObject_Call(updateTimeoutObj, pyobj_args, NULL);
5698 if (!result) {
5699 PyErr_Print();
5700 PyErr_Clear();
5701 }
5702
5703 cleanup:
5704 Py_XDECREF(result);
5705 Py_XDECREF(pyobj_args);
5706
5707 LIBVIRT_RELEASE_THREAD_STATE;
5708 }
5709
5710 static int
5711 libvirt_virEventRemoveTimeoutFunc(int timer)
5712 {
5713 PyObject *result = NULL;
5714 PyObject *pyobj_args;
5715 int retval = -1;
5716
5717 LIBVIRT_ENSURE_THREAD_STATE;
5718
5719 if ((pyobj_args = PyTuple_New(1)) == NULL)
5720 goto cleanup;
5721
5722 VIR_PY_TUPLE_SET_GOTO(pyobj_args, 0, libvirt_intWrap(timer), cleanup);
5723
5724 result = PyObject_Call(removeTimeoutObj, pyobj_args, NULL);
5725 if (result) {
5726 retval = 0;
5727 } else {
5728 PyErr_Print();
5729 PyErr_Clear();
5730 }
5731
5732 cleanup:
5733 Py_XDECREF(result);
5734 Py_XDECREF(pyobj_args);
5735
5736 LIBVIRT_RELEASE_THREAD_STATE;
5737
5738 return retval;
5739 }
5740
5741 static PyObject *
5742 libvirt_virEventRegisterImpl(PyObject *self ATTRIBUTE_UNUSED,
5743 PyObject *args)
5744 {
5745 if (addHandleObj || updateHandleObj || removeHandleObj ||
5746 addTimeoutObj || updateTimeoutObj || removeTimeoutObj) {
5747 PyErr_SetString(PyExc_RuntimeError,
5748 "Event loop is already registered");
5749 return NULL;
5750 }
5751
5752 /* Parse and check arguments */
5753 if (!PyArg_ParseTuple(args, (char *) "OOOOOO:virEventRegisterImpl",
5754 &addHandleObj, &updateHandleObj,
5755 &removeHandleObj, &addTimeoutObj,
5756 &updateTimeoutObj, &removeTimeoutObj) ||
5757 !PyCallable_Check(addHandleObj) ||
5758 !PyCallable_Check(updateHandleObj) ||
5759 !PyCallable_Check(removeHandleObj) ||
5760 !PyCallable_Check(addTimeoutObj) ||
5761 !PyCallable_Check(updateTimeoutObj) ||
5762 !PyCallable_Check(removeTimeoutObj))
5763 return NULL;
5764
5765 /* Inc refs since we're holding on to these objects until
5766 * the next call (if any) to this function.
5767 */
5768 Py_INCREF(addHandleObj);
5769 Py_INCREF(updateHandleObj);
5770 Py_INCREF(removeHandleObj);
5771 Py_INCREF(addTimeoutObj);
5772 Py_INCREF(updateTimeoutObj);
5773 Py_INCREF(removeTimeoutObj);
5774
5775 /* Now register our C EventImpl, which will dispatch
5776 * to the Python callbacks passed in as args.
5777 */
5778 LIBVIRT_BEGIN_ALLOW_THREADS;
5779 virEventRegisterImpl(libvirt_virEventAddHandleFunc,
5780 libvirt_virEventUpdateHandleFunc,
5781 libvirt_virEventRemoveHandleFunc,
5782 libvirt_virEventAddTimeoutFunc,
5783 libvirt_virEventUpdateTimeoutFunc,
5784 libvirt_virEventRemoveTimeoutFunc);
5785 LIBVIRT_END_ALLOW_THREADS;
5786
5787 return VIR_PY_INT_SUCCESS;
5788 }
5789
5790 static PyObject *
5791 libvirt_virEventInvokeHandleCallback(PyObject *self ATTRIBUTE_UNUSED,
5792 PyObject *args)
5793 {
5794 int watch, fd, event;
5795 PyObject *py_f;
5796 PyObject *py_opaque;
5797 virEventHandleCallback cb;
5798 void *opaque;
5799
5800 if (!PyArg_ParseTuple(args, (char *) "iiiOO:virEventInvokeHandleCallback",
5801 &watch, &fd, &event, &py_f, &py_opaque))
5802 return NULL;
5803
5804 cb = (virEventHandleCallback) PyvirEventHandleCallback_Get(py_f);
5805 opaque = (void *) PyvirVoidPtr_Get(py_opaque);
5806
5807 if (cb) {
5808 LIBVIRT_BEGIN_ALLOW_THREADS;
5809 cb(watch, fd, event, opaque);
5810 LIBVIRT_END_ALLOW_THREADS;
5811 }
5812
5813 return VIR_PY_INT_SUCCESS;
5814 }
5815
5816 static PyObject *
5817 libvirt_virEventInvokeTimeoutCallback(PyObject *self ATTRIBUTE_UNUSED,
5818 PyObject *args)
5819 {
5820 int timer;
5821 PyObject *py_f;
5822 PyObject *py_opaque;
5823 virEventTimeoutCallback cb;
5824 void *opaque;
5825
5826 if (!PyArg_ParseTuple(args, (char *) "iOO:virEventInvokeTimeoutCallback",
5827 &timer, &py_f, &py_opaque))
5828 return NULL;
5829
5830 cb = (virEventTimeoutCallback) PyvirEventTimeoutCallback_Get(py_f);
5831 opaque = (void *) PyvirVoidPtr_Get(py_opaque);
5832 if (cb) {
5833 LIBVIRT_BEGIN_ALLOW_THREADS;
5834 cb(timer, opaque);
5835 LIBVIRT_END_ALLOW_THREADS;
5836 }
5837
5838 return VIR_PY_INT_SUCCESS;
5839 }
5840
5841 static PyObject *
5842 libvirt_virEventInvokeFreeCallback(PyObject *self ATTRIBUTE_UNUSED,
5843 PyObject *args)
5844 {
5845 PyObject *py_f;
5846 PyObject *py_opaque;
5847 virFreeCallback cb;
5848 void *opaque;
5849
5850 if (!PyArg_ParseTuple(args, (char *) "OO:virEventInvokeFreeCallback",
5851 &py_f, &py_opaque))
5852 return NULL;
5853
5854 cb = (virFreeCallback) PyvirEventHandleCallback_Get(py_f);
5855 opaque = (void *) PyvirVoidPtr_Get(py_opaque);
5856
5857 if (cb) {
5858 LIBVIRT_BEGIN_ALLOW_THREADS;
5859 cb(opaque);
5860 LIBVIRT_END_ALLOW_THREADS;
5861 }
5862
5863 return VIR_PY_INT_SUCCESS;
5864 }
5865
5866 static void
5867 libvirt_virEventHandleCallback(int watch,
5868 int fd,
5869 int events,
5870 void *opaque)
5871 {
5872 PyObject *pyobj_cbData = (PyObject *)opaque;
5873 PyObject *pyobj_ret;
5874 PyObject *python_cb;
5875
5876 LIBVIRT_ENSURE_THREAD_STATE;
5877
5878 /* Lookup the python callback */
5879 python_cb = libvirt_lookupPythonFunc("_dispatchEventHandleCallback");
5880 if (!python_cb) {
5881 goto cleanup;
5882 }
5883
5884 Py_INCREF(pyobj_cbData);
5885
5886 /* Call the pure python dispatcher */
5887 pyobj_ret = PyObject_CallFunction(python_cb,
5888 (char *)"iiiO",
5889 watch, fd, events, pyobj_cbData);
5890
5891 Py_DECREF(pyobj_cbData);
5892
5893 if (!pyobj_ret) {
5894 DEBUG("%s - ret:%p\n", __FUNCTION__, pyobj_ret);
5895 PyErr_Print();
5896 } else {
5897 Py_DECREF(pyobj_ret);
5898 }
5899
5900 cleanup:
5901 LIBVIRT_RELEASE_THREAD_STATE;
5902 }
5903
5904 static PyObject *
5905 libvirt_virEventAddHandle(PyObject *self ATTRIBUTE_UNUSED,
5906 PyObject *args)
5907 {
5908 PyObject *pyobj_cbData;
5909 virEventHandleCallback cb = libvirt_virEventHandleCallback;
5910 int events;
5911 int fd;
5912 int ret;
5913
5914 if (!PyArg_ParseTuple(args, (char *) "iiO:virEventAddHandle",
5915 &fd, &events, &pyobj_cbData))
5916 return NULL;
5917
5918 Py_INCREF(pyobj_cbData);
5919
5920 LIBVIRT_BEGIN_ALLOW_THREADS;
5921 ret = virEventAddHandle(fd, events, cb, pyobj_cbData, NULL);
5922 LIBVIRT_END_ALLOW_THREADS;
5923
5924 if (ret < 0) {
5925 Py_DECREF(pyobj_cbData);
5926 }
5927
5928 return libvirt_intWrap(ret);
5929 }
5930
5931 static void
5932 libvirt_virEventTimeoutCallback(int timer,
5933 void *opaque)
5934 {
5935 PyObject *pyobj_cbData = (PyObject *)opaque;
5936 PyObject *pyobj_ret;
5937 PyObject *python_cb;
5938
5939 LIBVIRT_ENSURE_THREAD_STATE;
5940
5941 /* Lookup the python callback */
5942 python_cb = libvirt_lookupPythonFunc("_dispatchEventTimeoutCallback");
5943 if (!python_cb) {
5944 goto cleanup;
5945 }
5946
5947 Py_INCREF(pyobj_cbData);
5948
5949 /* Call the pure python dispatcher */
5950 pyobj_ret = PyObject_CallFunction(python_cb,
5951 (char *)"iO",
5952 timer, pyobj_cbData);
5953
5954 Py_DECREF(pyobj_cbData);
5955
5956 if (!pyobj_ret) {
5957 DEBUG("%s - ret:%p\n", __FUNCTION__, pyobj_ret);
5958 PyErr_Print();
5959 } else {
5960 Py_DECREF(pyobj_ret);
5961 }
5962
5963 cleanup:
5964 LIBVIRT_RELEASE_THREAD_STATE;
5965 }
5966
5967 static PyObject *
5968 libvirt_virEventAddTimeout(PyObject *self ATTRIBUTE_UNUSED,
5969 PyObject *args)
5970 {
5971 PyObject *pyobj_cbData;
5972 virEventTimeoutCallback cb = libvirt_virEventTimeoutCallback;
5973 int timeout;
5974 int ret;
5975
5976 if (!PyArg_ParseTuple(args, (char *) "iO:virEventAddTimeout",
5977 &timeout, &pyobj_cbData))
5978 return NULL;
5979
5980 Py_INCREF(pyobj_cbData);
5981
5982 LIBVIRT_BEGIN_ALLOW_THREADS;
5983 ret = virEventAddTimeout(timeout, cb, pyobj_cbData, NULL);
5984 LIBVIRT_END_ALLOW_THREADS;
5985
5986 if (ret < 0) {
5987 Py_DECREF(pyobj_cbData);
5988 }
5989
5990 return libvirt_intWrap(ret);
5991 }
5992
5993 static void
5994 libvirt_virConnectDomainEventFreeFunc(void *opaque)
5995 {
5996 PyObject *pyobj_conn = (PyObject*)opaque;
5997 LIBVIRT_ENSURE_THREAD_STATE;
5998 Py_DECREF(pyobj_conn);
5999 LIBVIRT_RELEASE_THREAD_STATE;
6000 }
6001
6002 static int
6003 libvirt_virConnectDomainEventLifecycleCallback(virConnectPtr conn ATTRIBUTE_UNUSED,
6004 virDomainPtr dom,
6005 int event,
6006 int detail,
6007 void *opaque)
6008 {
6009 PyObject *pyobj_cbData = (PyObject*)opaque;
6010 PyObject *pyobj_dom;
6011 PyObject *pyobj_ret = NULL;
6012 PyObject *pyobj_conn;
6013 PyObject *dictKey;
6014 int ret = -1;
6015
6016 LIBVIRT_ENSURE_THREAD_STATE;
6017
6018 if (!(dictKey = libvirt_constcharPtrWrap("conn")))
6019 goto cleanup;
6020 pyobj_conn = PyDict_GetItem(pyobj_cbData, dictKey);
6021 Py_DECREF(dictKey);
6022
6023 /* Create a python instance of this virDomainPtr */
6024 virDomainRef(dom);
6025 if (!(pyobj_dom = libvirt_virDomainPtrWrap(dom))) {
6026 virDomainFree(dom);
6027 goto cleanup;
6028 }
6029 Py_INCREF(pyobj_cbData);
6030
6031 /* Call the Callback Dispatcher */
6032 pyobj_ret = PyObject_CallMethod(pyobj_conn,
6033 (char*)"_dispatchDomainEventLifecycleCallback",
6034 (char*)"OiiO",
6035 pyobj_dom,
6036 event, detail,
6037 pyobj_cbData);
6038
6039 Py_DECREF(pyobj_cbData);
6040 Py_DECREF(pyobj_dom);
6041
6042 cleanup:
6043 if (!pyobj_ret) {
6044 DEBUG("%s - ret:%p\n", __FUNCTION__, pyobj_ret);
6045 PyErr_Print();
6046 } else {
6047 Py_DECREF(pyobj_ret);
6048 ret = 0;
6049 }
6050
6051 LIBVIRT_RELEASE_THREAD_STATE;
6052 return ret;
6053 }
6054
6055 static int
6056 libvirt_virConnectDomainEventGenericCallback(virConnectPtr conn ATTRIBUTE_UNUSED,
6057 virDomainPtr dom,
6058 void *opaque)
6059 {
6060 PyObject *pyobj_cbData = (PyObject*)opaque;
6061 PyObject *pyobj_dom;
6062 PyObject *pyobj_ret = NULL;
6063 PyObject *pyobj_conn;
6064 PyObject *dictKey;
6065 int ret = -1;
6066
6067 LIBVIRT_ENSURE_THREAD_STATE;
6068
6069 if (!(dictKey = libvirt_constcharPtrWrap("conn")))
6070 goto cleanup;
6071 pyobj_conn = PyDict_GetItem(pyobj_cbData, dictKey);
6072 Py_DECREF(dictKey);
6073
6074 /* Create a python instance of this virDomainPtr */
6075 virDomainRef(dom);
6076 if (!(pyobj_dom = libvirt_virDomainPtrWrap(dom))) {
6077 virDomainFree(dom);
6078 goto cleanup;
6079 }
6080 Py_INCREF(pyobj_cbData);
6081
6082 /* Call the Callback Dispatcher */
6083 pyobj_ret = PyObject_CallMethod(pyobj_conn,
6084 (char*)"_dispatchDomainEventGenericCallback",
6085 (char*)"OO",
6086 pyobj_dom, pyobj_cbData);
6087
6088 Py_DECREF(pyobj_cbData);
6089 Py_DECREF(pyobj_dom);
6090
6091 cleanup:
6092 if (!pyobj_ret) {
6093 DEBUG("%s - ret:%p\n", __FUNCTION__, pyobj_ret);
6094 PyErr_Print();
6095 } else {
6096 Py_DECREF(pyobj_ret);
6097 ret = 0;
6098 }
6099
6100 LIBVIRT_RELEASE_THREAD_STATE;
6101 return ret;
6102 }
6103
6104 static int
6105 libvirt_virConnectDomainEventRTCChangeCallback(virConnectPtr conn ATTRIBUTE_UNUSED,
6106 virDomainPtr dom,
6107 long long utcoffset,
6108 void *opaque)
6109 {
6110 PyObject *pyobj_cbData = (PyObject*)opaque;
6111 PyObject *pyobj_dom;
6112 PyObject *pyobj_ret = NULL;
6113 PyObject *pyobj_conn;
6114 PyObject *dictKey;
6115 int ret = -1;
6116
6117 LIBVIRT_ENSURE_THREAD_STATE;
6118
6119 if (!(dictKey = libvirt_constcharPtrWrap("conn")))
6120 goto cleanup;
6121 pyobj_conn = PyDict_GetItem(pyobj_cbData, dictKey);
6122 Py_DECREF(dictKey);
6123
6124 /* Create a python instance of this virDomainPtr */
6125 virDomainRef(dom);
6126 if (!(pyobj_dom = libvirt_virDomainPtrWrap(dom))) {
6127 virDomainFree(dom);
6128 goto cleanup;
6129 }
6130 Py_INCREF(pyobj_cbData);
6131
6132 /* Call the Callback Dispatcher */
6133 pyobj_ret = PyObject_CallMethod(pyobj_conn,
6134 (char*)"_dispatchDomainEventRTCChangeCallback",
6135 (char*)"OLO",
6136 pyobj_dom,
6137 (PY_LONG_LONG)utcoffset,
6138 pyobj_cbData);
6139
6140 Py_DECREF(pyobj_cbData);
6141 Py_DECREF(pyobj_dom);
6142
6143 cleanup:
6144 if (!pyobj_ret) {
6145 DEBUG("%s - ret:%p\n", __FUNCTION__, pyobj_ret);
6146 PyErr_Print();
6147 } else {
6148 Py_DECREF(pyobj_ret);
6149 ret = 0;
6150 }
6151
6152 LIBVIRT_RELEASE_THREAD_STATE;
6153 return ret;
6154 }
6155
6156 static int
6157 libvirt_virConnectDomainEventWatchdogCallback(virConnectPtr conn ATTRIBUTE_UNUSED,
6158 virDomainPtr dom,
6159 int action,
6160 void *opaque)
6161 {
6162 PyObject *pyobj_cbData = (PyObject*)opaque;
6163 PyObject *pyobj_dom;
6164 PyObject *pyobj_ret = NULL;
6165 PyObject *pyobj_conn;
6166 PyObject *dictKey;
6167 int ret = -1;
6168
6169 LIBVIRT_ENSURE_THREAD_STATE;
6170
6171 if (!(dictKey = libvirt_constcharPtrWrap("conn")))
6172 goto cleanup;
6173 pyobj_conn = PyDict_GetItem(pyobj_cbData, dictKey);
6174 Py_DECREF(dictKey);
6175
6176 /* Create a python instance of this virDomainPtr */
6177 virDomainRef(dom);
6178 if (!(pyobj_dom = libvirt_virDomainPtrWrap(dom))) {
6179 virDomainFree(dom);
6180 goto cleanup;
6181 }
6182 Py_INCREF(pyobj_cbData);
6183
6184 /* Call the Callback Dispatcher */
6185 pyobj_ret = PyObject_CallMethod(pyobj_conn,
6186 (char*)"_dispatchDomainEventWatchdogCallback",
6187 (char*)"OiO",
6188 pyobj_dom,
6189 action,
6190 pyobj_cbData);
6191
6192 Py_DECREF(pyobj_cbData);
6193 Py_DECREF(pyobj_dom);
6194
6195 cleanup:
6196 if (!pyobj_ret) {
6197 DEBUG("%s - ret:%p\n", __FUNCTION__, pyobj_ret);
6198 PyErr_Print();
6199 } else {
6200 Py_DECREF(pyobj_ret);
6201 ret = 0;
6202 }
6203
6204 LIBVIRT_RELEASE_THREAD_STATE;
6205 return ret;
6206 }
6207
6208 static int
6209 libvirt_virConnectDomainEventIOErrorCallback(virConnectPtr conn ATTRIBUTE_UNUSED,
6210 virDomainPtr dom,
6211 const char *srcPath,
6212 const char *devAlias,
6213 int action,
6214 void *opaque)
6215 {
6216 PyObject *pyobj_cbData = (PyObject*)opaque;
6217 PyObject *pyobj_dom;
6218 PyObject *pyobj_ret = NULL;
6219 PyObject *pyobj_conn;
6220 PyObject *dictKey;
6221 int ret = -1;
6222
6223 LIBVIRT_ENSURE_THREAD_STATE;
6224
6225 if (!(dictKey = libvirt_constcharPtrWrap("conn")))
6226 goto cleanup;
6227 pyobj_conn = PyDict_GetItem(pyobj_cbData, dictKey);
6228 Py_DECREF(dictKey);
6229
6230 /* Create a python instance of this virDomainPtr */
6231 virDomainRef(dom);
6232 if (!(pyobj_dom = libvirt_virDomainPtrWrap(dom))) {
6233 virDomainFree(dom);
6234 goto cleanup;
6235 }
6236 Py_INCREF(pyobj_cbData);
6237
6238 /* Call the Callback Dispatcher */
6239 pyobj_ret = PyObject_CallMethod(pyobj_conn,
6240 (char*)"_dispatchDomainEventIOErrorCallback",
6241 (char*)"OssiO",
6242 pyobj_dom,
6243 srcPath, devAlias, action,
6244 pyobj_cbData);
6245
6246 Py_DECREF(pyobj_cbData);
6247 Py_DECREF(pyobj_dom);
6248
6249 cleanup:
6250 if (!pyobj_ret) {
6251 DEBUG("%s - ret:%p\n", __FUNCTION__, pyobj_ret);
6252 PyErr_Print();
6253 } else {
6254 Py_DECREF(pyobj_ret);
6255 ret = 0;
6256 }
6257
6258 LIBVIRT_RELEASE_THREAD_STATE;
6259 return ret;
6260 }
6261
6262 static int
6263 libvirt_virConnectDomainEventIOErrorReasonCallback(virConnectPtr conn ATTRIBUTE_UNUSED,
6264 virDomainPtr dom,
6265 const char *srcPath,
6266 const char *devAlias,
6267 int action,
6268 const char *reason,
6269 void *opaque)
6270 {
6271 PyObject *pyobj_cbData = (PyObject*)opaque;
6272 PyObject *pyobj_dom;
6273 PyObject *pyobj_ret = NULL;
6274 PyObject *pyobj_conn;
6275 PyObject *dictKey;
6276 int ret = -1;
6277
6278 LIBVIRT_ENSURE_THREAD_STATE;
6279
6280 if (!(dictKey = libvirt_constcharPtrWrap("conn")))
6281 goto cleanup;
6282 pyobj_conn = PyDict_GetItem(pyobj_cbData, dictKey);
6283 Py_DECREF(dictKey);
6284
6285 /* Create a python instance of this virDomainPtr */
6286 virDomainRef(dom);
6287 if (!(pyobj_dom = libvirt_virDomainPtrWrap(dom))) {
6288 virDomainFree(dom);
6289 goto cleanup;
6290 }
6291 Py_INCREF(pyobj_cbData);
6292
6293 /* Call the Callback Dispatcher */
6294 pyobj_ret = PyObject_CallMethod(pyobj_conn,
6295 (char*)"_dispatchDomainEventIOErrorReasonCallback",
6296 (char*)"OssisO",
6297 pyobj_dom,
6298 srcPath, devAlias, action, reason,
6299 pyobj_cbData);
6300
6301 Py_DECREF(pyobj_cbData);
6302 Py_DECREF(pyobj_dom);
6303
6304 cleanup:
6305 if (!pyobj_ret) {
6306 DEBUG("%s - ret:%p\n", __FUNCTION__, pyobj_ret);
6307 PyErr_Print();
6308 } else {
6309 Py_DECREF(pyobj_ret);
6310 ret = 0;
6311 }
6312
6313 LIBVIRT_RELEASE_THREAD_STATE;
6314 return ret;
6315 }
6316
6317 static int
6318 libvirt_virConnectDomainEventGraphicsCallback(virConnectPtr conn ATTRIBUTE_UNUSED,
6319 virDomainPtr dom,
6320 int phase,
6321 virDomainEventGraphicsAddressPtr local,
6322 virDomainEventGraphicsAddressPtr remote,
6323 const char *authScheme,
6324 virDomainEventGraphicsSubjectPtr subject,
6325 void *opaque)
6326 {
6327 PyObject *pyobj_cbData = (PyObject*)opaque;
6328 PyObject *pyobj_dom = NULL;
6329 PyObject *pyobj_ret = NULL;
6330 PyObject *pyobj_conn;
6331 PyObject *dictKey;
6332 PyObject *pyobj_local = NULL;
6333 PyObject *pyobj_remote = NULL;
6334 PyObject *pyobj_subject = NULL;
6335 int ret = -1;
6336 ssize_t i;
6337
6338 LIBVIRT_ENSURE_THREAD_STATE;
6339
6340 if (!(dictKey = libvirt_constcharPtrWrap("conn")))
6341 goto cleanup;
6342 pyobj_conn = PyDict_GetItem(pyobj_cbData, dictKey);
6343 Py_DECREF(dictKey);
6344
6345 /* Create a python instance of this virDomainPtr */
6346 virDomainRef(dom);
6347 if (!(pyobj_dom = libvirt_virDomainPtrWrap(dom))) {
6348 virDomainFree(dom);
6349 goto cleanup;
6350 }
6351 Py_INCREF(pyobj_cbData);
6352
6353 if ((pyobj_local = PyDict_New()) == NULL)
6354 goto cleanup;
6355
6356 VIR_PY_DICT_SET_GOTO(pyobj_local,
6357 libvirt_constcharPtrWrap("family"),
6358 libvirt_intWrap(local->family),
6359 cleanup);
6360 VIR_PY_DICT_SET_GOTO(pyobj_local,
6361 libvirt_constcharPtrWrap("node"),
6362 libvirt_constcharPtrWrap(local->node),
6363 cleanup);
6364 VIR_PY_DICT_SET_GOTO(pyobj_local,
6365 libvirt_constcharPtrWrap("service"),
6366 libvirt_constcharPtrWrap(local->service),
6367 cleanup);
6368
6369 if ((pyobj_remote = PyDict_New()) == NULL)
6370 goto cleanup;
6371
6372 VIR_PY_DICT_SET_GOTO(pyobj_remote,
6373 libvirt_constcharPtrWrap("family"),
6374 libvirt_intWrap(remote->family),
6375 cleanup);
6376 VIR_PY_DICT_SET_GOTO(pyobj_remote,
6377 libvirt_constcharPtrWrap("node"),
6378 libvirt_constcharPtrWrap(remote->node),
6379 cleanup);
6380 VIR_PY_DICT_SET_GOTO(pyobj_remote,
6381 libvirt_constcharPtrWrap("service"),
6382 libvirt_constcharPtrWrap(remote->service),
6383 cleanup);
6384
6385 if ((pyobj_subject = PyList_New(subject->nidentity)) == NULL)
6386 goto cleanup;
6387
6388 for (i = 0; i < subject->nidentity; i++) {
6389 PyObject *pair = PyTuple_New(2);
6390 if (pair == NULL)
6391 goto cleanup;
6392
6393 VIR_PY_LIST_SET_GOTO(pyobj_subject, i, pair, cleanup);
6394
6395 VIR_PY_TUPLE_SET_GOTO(pair, 0,
6396 libvirt_constcharPtrWrap(subject->identities[i].type),
6397 cleanup);
6398 VIR_PY_TUPLE_SET_GOTO(pair, 1,
6399 libvirt_constcharPtrWrap(subject->identities[i].name),
6400 cleanup);
6401 }
6402
6403 /* Call the Callback Dispatcher */
6404 pyobj_ret = PyObject_CallMethod(pyobj_conn,
6405 (char*)"_dispatchDomainEventGraphicsCallback",
6406 (char*)"OiOOsOO",
6407 pyobj_dom,
6408 phase, pyobj_local, pyobj_remote,
6409 authScheme, pyobj_subject,
6410 pyobj_cbData);
6411
6412 cleanup:
6413 Py_DECREF(pyobj_cbData);
6414 Py_XDECREF(pyobj_dom);
6415
6416 if (!pyobj_ret) {
6417 Py_XDECREF(pyobj_local);
6418 Py_XDECREF(pyobj_remote);
6419 Py_XDECREF(pyobj_subject);
6420 DEBUG("%s - ret:%p\n", __FUNCTION__, pyobj_ret);
6421 PyErr_Print();
6422 } else {
6423 Py_DECREF(pyobj_ret);
6424 ret = 0;
6425 }
6426
6427 LIBVIRT_RELEASE_THREAD_STATE;
6428 return ret;
6429 }
6430
6431 static int
6432 libvirt_virConnectDomainEventBlockJobCallback(virConnectPtr conn ATTRIBUTE_UNUSED,
6433 virDomainPtr dom,
6434 const char *disk,
6435 int type,
6436 int status,
6437 void *opaque)
6438 {
6439 PyObject *pyobj_cbData = (PyObject*)opaque;
6440 PyObject *pyobj_dom;
6441 PyObject *pyobj_ret = NULL;
6442 PyObject *pyobj_conn;
6443 PyObject *dictKey;
6444 int ret = -1;
6445
6446 LIBVIRT_ENSURE_THREAD_STATE;
6447
6448 if (!(dictKey = libvirt_constcharPtrWrap("conn")))
6449 goto cleanup;
6450 pyobj_conn = PyDict_GetItem(pyobj_cbData, dictKey);
6451 Py_DECREF(dictKey);
6452
6453 /* Create a python instance of this virDomainPtr */
6454 virDomainRef(dom);
6455 if (!(pyobj_dom = libvirt_virDomainPtrWrap(dom))) {
6456 virDomainFree(dom);
6457 goto cleanup;
6458 }
6459 Py_INCREF(pyobj_cbData);
6460
6461 /* Call the Callback Dispatcher */
6462 pyobj_ret = PyObject_CallMethod(pyobj_conn,
6463 (char*)"_dispatchDomainEventBlockJobCallback",
6464 (char*)"OsiiO",
6465 pyobj_dom, disk, type, status, pyobj_cbData);
6466
6467 Py_DECREF(pyobj_cbData);
6468 Py_DECREF(pyobj_dom);
6469
6470 cleanup:
6471 if (!pyobj_ret) {
6472 DEBUG("%s - ret:%p\n", __FUNCTION__, pyobj_ret);
6473 PyErr_Print();
6474 } else {
6475 Py_DECREF(pyobj_ret);
6476 ret = 0;
6477 }
6478
6479 LIBVIRT_RELEASE_THREAD_STATE;
6480 return ret;
6481 }
6482
6483 static int
6484 libvirt_virConnectDomainEventDiskChangeCallback(virConnectPtr conn ATTRIBUTE_UNUSED,
6485 virDomainPtr dom,
6486 const char *oldSrcPath,
6487 const char *newSrcPath,
6488 const char *devAlias,
6489 int reason,
6490 void *opaque)
6491 {
6492 PyObject *pyobj_cbData = (PyObject*)opaque;
6493 PyObject *pyobj_dom;
6494 PyObject *pyobj_ret = NULL;
6495 PyObject *pyobj_conn;
6496 PyObject *dictKey;
6497 int ret = -1;
6498
6499 LIBVIRT_ENSURE_THREAD_STATE;
6500
6501 if (!(dictKey = libvirt_constcharPtrWrap("conn")))
6502 goto cleanup;
6503 pyobj_conn = PyDict_GetItem(pyobj_cbData, dictKey);
6504 Py_DECREF(dictKey);
6505
6506 /* Create a python instance of this virDomainPtr */
6507 virDomainRef(dom);
6508 if (!(pyobj_dom = libvirt_virDomainPtrWrap(dom))) {
6509 virDomainFree(dom);
6510 goto cleanup;
6511 }
6512 Py_INCREF(pyobj_cbData);
6513
6514 /* Call the Callback Dispatcher */
6515 pyobj_ret = PyObject_CallMethod(pyobj_conn,
6516 (char*)"_dispatchDomainEventDiskChangeCallback",
6517 (char*)"OsssiO",
6518 pyobj_dom,
6519 oldSrcPath, newSrcPath,
6520 devAlias, reason, pyobj_cbData);
6521
6522 Py_DECREF(pyobj_cbData);
6523 Py_DECREF(pyobj_dom);
6524
6525 cleanup:
6526 if (!pyobj_ret) {
6527 DEBUG("%s - ret:%p\n", __FUNCTION__, pyobj_ret);
6528 PyErr_Print();
6529 } else {
6530 Py_DECREF(pyobj_ret);
6531 ret = 0;
6532 }
6533
6534 LIBVIRT_RELEASE_THREAD_STATE;
6535 return ret;
6536 }
6537
6538 static int
6539 libvirt_virConnectDomainEventTrayChangeCallback(virConnectPtr conn ATTRIBUTE_UNUSED,
6540 virDomainPtr dom,
6541 const char *devAlias,
6542 int reason,
6543 void *opaque)
6544 {
6545 PyObject *pyobj_cbData = (PyObject*)opaque;
6546 PyObject *pyobj_dom;
6547 PyObject *pyobj_ret = NULL;
6548 PyObject *pyobj_conn;
6549 PyObject *dictKey;
6550 int ret = -1;
6551
6552 LIBVIRT_ENSURE_THREAD_STATE;
6553
6554 if (!(dictKey = libvirt_constcharPtrWrap("conn")))
6555 goto cleanup;
6556 pyobj_conn = PyDict_GetItem(pyobj_cbData, dictKey);
6557 Py_DECREF(dictKey);
6558
6559 /* Create a python instance of this virDomainPtr */
6560 virDomainRef(dom);
6561 if (!(pyobj_dom = libvirt_virDomainPtrWrap(dom))) {
6562 virDomainFree(dom);
6563 goto cleanup;
6564 }
6565 Py_INCREF(pyobj_cbData);
6566
6567 /* Call the Callback Dispatcher */
6568 pyobj_ret = PyObject_CallMethod(pyobj_conn,
6569 (char*)"_dispatchDomainEventTrayChangeCallback",
6570 (char*)"OsiO",
6571 pyobj_dom,
6572 devAlias, reason, pyobj_cbData);
6573
6574 Py_DECREF(pyobj_cbData);
6575 Py_DECREF(pyobj_dom);
6576
6577 cleanup:
6578 if (!pyobj_ret) {
6579 DEBUG("%s - ret:%p\n", __FUNCTION__, pyobj_ret);
6580 PyErr_Print();
6581 } else {
6582 Py_DECREF(pyobj_ret);
6583 ret = 0;
6584 }
6585
6586 LIBVIRT_RELEASE_THREAD_STATE;
6587 return ret;
6588 }
6589
6590 static int
6591 libvirt_virConnectDomainEventPMWakeupCallback(virConnectPtr conn ATTRIBUTE_UNUSED,
6592 virDomainPtr dom,
6593 int reason,
6594 void *opaque)
6595 {
6596 PyObject *pyobj_cbData = (PyObject*)opaque;
6597 PyObject *pyobj_dom;
6598 PyObject *pyobj_ret = NULL;
6599 PyObject *pyobj_conn;
6600 PyObject *dictKey;
6601 int ret = -1;
6602
6603 LIBVIRT_ENSURE_THREAD_STATE;
6604
6605 if (!(dictKey = libvirt_constcharPtrWrap("conn")))
6606 goto cleanup;
6607 pyobj_conn = PyDict_GetItem(pyobj_cbData, dictKey);
6608 Py_DECREF(dictKey);
6609
6610 /* Create a python instance of this virDomainPtr */
6611 virDomainRef(dom);
6612 if (!(pyobj_dom = libvirt_virDomainPtrWrap(dom))) {
6613 virDomainFree(dom);
6614 goto cleanup;
6615 }
6616 Py_INCREF(pyobj_cbData);
6617
6618 /* Call the Callback Dispatcher */
6619 pyobj_ret = PyObject_CallMethod(pyobj_conn,
6620 (char*)"_dispatchDomainEventPMWakeupCallback",
6621 (char*)"OiO",
6622 pyobj_dom,
6623 reason,
6624 pyobj_cbData);
6625
6626 Py_DECREF(pyobj_cbData);
6627 Py_DECREF(pyobj_dom);
6628
6629 cleanup:
6630 if (!pyobj_ret) {
6631 DEBUG("%s - ret:%p\n", __FUNCTION__, pyobj_ret);
6632 PyErr_Print();
6633 } else {
6634 Py_DECREF(pyobj_ret);
6635 ret = 0;
6636 }
6637
6638 LIBVIRT_RELEASE_THREAD_STATE;
6639 return ret;
6640 }
6641
6642 static int
6643 libvirt_virConnectDomainEventPMSuspendCallback(virConnectPtr conn ATTRIBUTE_UNUSED,
6644 virDomainPtr dom,
6645 int reason,
6646 void *opaque)
6647 {
6648 PyObject *pyobj_cbData = (PyObject*)opaque;
6649 PyObject *pyobj_dom;
6650 PyObject *pyobj_ret = NULL;
6651 PyObject *pyobj_conn;
6652 PyObject *dictKey;
6653 int ret = -1;
6654
6655 LIBVIRT_ENSURE_THREAD_STATE;
6656
6657 if (!(dictKey = libvirt_constcharPtrWrap("conn")))
6658 goto cleanup;
6659 pyobj_conn = PyDict_GetItem(pyobj_cbData, dictKey);
6660 Py_DECREF(dictKey);
6661
6662 /* Create a python instance of this virDomainPtr */
6663 virDomainRef(dom);
6664 if (!(pyobj_dom = libvirt_virDomainPtrWrap(dom))) {
6665 virDomainFree(dom);
6666 goto cleanup;
6667 }
6668 Py_INCREF(pyobj_cbData);
6669
6670 /* Call the Callback Dispatcher */
6671 pyobj_ret = PyObject_CallMethod(pyobj_conn,
6672 (char*)"_dispatchDomainEventPMSuspendCallback",
6673 (char*)"OiO",
6674 pyobj_dom,
6675 reason,
6676 pyobj_cbData);
6677
6678 Py_DECREF(pyobj_cbData);
6679 Py_DECREF(pyobj_dom);
6680
6681 cleanup:
6682 if (!pyobj_ret) {
6683 DEBUG("%s - ret:%p\n", __FUNCTION__, pyobj_ret);
6684 PyErr_Print();
6685 } else {
6686 Py_DECREF(pyobj_ret);
6687 ret = 0;
6688 }
6689
6690 LIBVIRT_RELEASE_THREAD_STATE;
6691 return ret;
6692 }
6693
6694
6695 #ifdef VIR_DOMAIN_EVENT_ID_BALLOON_CHANGE
6696 static int
6697 libvirt_virConnectDomainEventBalloonChangeCallback(virConnectPtr conn ATTRIBUTE_UNUSED,
6698 virDomainPtr dom,
6699 unsigned long long actual,
6700 void *opaque)
6701 {
6702 PyObject *pyobj_cbData = (PyObject*)opaque;
6703 PyObject *pyobj_dom;
6704 PyObject *pyobj_ret = NULL;
6705 PyObject *pyobj_conn;
6706 PyObject *dictKey;
6707 int ret = -1;
6708
6709 LIBVIRT_ENSURE_THREAD_STATE;
6710
6711 if (!(dictKey = libvirt_constcharPtrWrap("conn")))
6712 goto cleanup;
6713 pyobj_conn = PyDict_GetItem(pyobj_cbData, dictKey);
6714 Py_DECREF(dictKey);
6715
6716 /* Create a python instance of this virDomainPtr */
6717 virDomainRef(dom);
6718 if (!(pyobj_dom = libvirt_virDomainPtrWrap(dom))) {
6719 virDomainFree(dom);
6720 goto cleanup;
6721 }
6722 Py_INCREF(pyobj_cbData);
6723
6724 /* Call the Callback Dispatcher */
6725 pyobj_ret = PyObject_CallMethod(pyobj_conn,
6726 (char*)"_dispatchDomainEventBalloonChangeCallback",
6727 (char*)"OLO",
6728 pyobj_dom,
6729 (PY_LONG_LONG)actual,
6730 pyobj_cbData);
6731
6732 Py_DECREF(pyobj_cbData);
6733 Py_DECREF(pyobj_dom);
6734
6735 cleanup:
6736 if (!pyobj_ret) {
6737 DEBUG("%s - ret:%p\n", __FUNCTION__, pyobj_ret);
6738 PyErr_Print();
6739 } else {
6740 Py_DECREF(pyobj_ret);
6741 ret = 0;
6742 }
6743
6744 LIBVIRT_RELEASE_THREAD_STATE;
6745 return ret;
6746 }
6747 #endif /* VIR_DOMAIN_EVENT_ID_BALLOON_CHANGE */
6748
6749 #ifdef VIR_DOMAIN_EVENT_ID_PMSUSPEND_DISK
6750 static int
6751 libvirt_virConnectDomainEventPMSuspendDiskCallback(virConnectPtr conn ATTRIBUTE_UNUSED,
6752 virDomainPtr dom,
6753 int reason,
6754 void *opaque)
6755 {
6756 PyObject *pyobj_cbData = (PyObject*)opaque;
6757 PyObject *pyobj_dom;
6758 PyObject *pyobj_ret = NULL;
6759 PyObject *pyobj_conn;
6760 PyObject *dictKey;
6761 int ret = -1;
6762
6763 LIBVIRT_ENSURE_THREAD_STATE;
6764
6765 if (!(dictKey = libvirt_constcharPtrWrap("conn")))
6766 goto cleanup;
6767 pyobj_conn = PyDict_GetItem(pyobj_cbData, dictKey);
6768 Py_DECREF(dictKey);
6769
6770 /* Create a python instance of this virDomainPtr */
6771 virDomainRef(dom);
6772 if (!(pyobj_dom = libvirt_virDomainPtrWrap(dom))) {
6773 virDomainFree(dom);
6774 goto cleanup;
6775 }
6776 Py_INCREF(pyobj_cbData);
6777
6778 /* Call the Callback Dispatcher */
6779 pyobj_ret = PyObject_CallMethod(pyobj_conn,
6780 (char*)"_dispatchDomainEventPMSuspendDiskCallback",
6781 (char*)"OiO",
6782 pyobj_dom,
6783 reason,
6784 pyobj_cbData);
6785
6786 Py_DECREF(pyobj_cbData);
6787 Py_DECREF(pyobj_dom);
6788
6789 cleanup:
6790 if (!pyobj_ret) {
6791 DEBUG("%s - ret:%p\n", __FUNCTION__, pyobj_ret);
6792 PyErr_Print();
6793 } else {
6794 Py_DECREF(pyobj_ret);
6795 ret = 0;
6796 }
6797
6798 LIBVIRT_RELEASE_THREAD_STATE;
6799 return ret;
6800 }
6801 #endif /* VIR_DOMAIN_EVENT_ID_PMSUSPEND_DISK */
6802
6803 #ifdef VIR_DOMAIN_EVENT_ID_DEVICE_REMOVED
6804 static int
6805 libvirt_virConnectDomainEventDeviceRemovedCallback(virConnectPtr conn ATTRIBUTE_UNUSED,
6806 virDomainPtr dom,
6807 const char *devAlias,
6808 void *opaque)
6809 {
6810 PyObject *pyobj_cbData = (PyObject*)opaque;
6811 PyObject *pyobj_dom;
6812 PyObject *pyobj_ret = NULL;
6813 PyObject *pyobj_conn;
6814 PyObject *dictKey;
6815 int ret = -1;
6816
6817 LIBVIRT_ENSURE_THREAD_STATE;
6818
6819 if (!(dictKey = libvirt_constcharPtrWrap("conn")))
6820 goto cleanup;
6821 pyobj_conn = PyDict_GetItem(pyobj_cbData, dictKey);
6822 Py_DECREF(dictKey);
6823
6824 /* Create a python instance of this virDomainPtr */
6825 virDomainRef(dom);
6826 if (!(pyobj_dom = libvirt_virDomainPtrWrap(dom))) {
6827 virDomainFree(dom);
6828 goto cleanup;
6829 }
6830 Py_INCREF(pyobj_cbData);
6831
6832 /* Call the Callback Dispatcher */
6833 pyobj_ret = PyObject_CallMethod(pyobj_conn,
6834 (char*)"_dispatchDomainEventDeviceRemovedCallback",
6835 (char*)"OsO",
6836 pyobj_dom, devAlias, pyobj_cbData);
6837
6838 Py_DECREF(pyobj_cbData);
6839 Py_DECREF(pyobj_dom);
6840
6841 cleanup:
6842 if (!pyobj_ret) {
6843 DEBUG("%s - ret:%p\n", __FUNCTION__, pyobj_ret);
6844 PyErr_Print();
6845 } else {
6846 Py_DECREF(pyobj_ret);
6847 ret = 0;
6848 }
6849
6850 LIBVIRT_RELEASE_THREAD_STATE;
6851 return ret;
6852 }
6853 #endif /* VIR_DOMAIN_EVENT_ID_DEVICE_REMOVED */
6854
6855 #ifdef VIR_DOMAIN_EVENT_ID_TUNABLE
6856 static int
6857 libvirt_virConnectDomainEventTunableCallback(virConnectPtr conn ATTRIBUTE_UNUSED,
6858 virDomainPtr dom,
6859 virTypedParameterPtr params,
6860 int nparams,
6861 void *opaque)
6862 {
6863 PyObject *pyobj_cbData = (PyObject*)opaque;
6864 PyObject *pyobj_dom;
6865 PyObject *pyobj_ret = NULL;
6866 PyObject *pyobj_conn;
6867 PyObject *dictKey;
6868 PyObject *pyobj_dict = NULL;
6869 int ret = -1;
6870
6871 LIBVIRT_ENSURE_THREAD_STATE;
6872
6873 pyobj_dict = getPyVirTypedParameter(params, nparams);
6874 if (!pyobj_dict)
6875 goto cleanup;
6876
6877 if (!(dictKey = libvirt_constcharPtrWrap("conn")))
6878 goto cleanup;
6879 pyobj_conn = PyDict_GetItem(pyobj_cbData, dictKey);
6880 Py_DECREF(dictKey);
6881
6882 /* Create a python instance of this virDomainPtr */
6883 virDomainRef(dom);
6884 if (!(pyobj_dom = libvirt_virDomainPtrWrap(dom))) {
6885 virDomainFree(dom);
6886 goto cleanup;
6887 }
6888 Py_INCREF(pyobj_cbData);
6889
6890 /* Call the Callback Dispatcher */
6891 pyobj_ret = PyObject_CallMethod(pyobj_conn,
6892 (char*)"_dispatchDomainEventTunableCallback",
6893 (char*)"OOO",
6894 pyobj_dom, pyobj_dict, pyobj_cbData);
6895
6896 Py_DECREF(pyobj_cbData);
6897 Py_DECREF(pyobj_dom);
6898
6899 cleanup:
6900 if (!pyobj_ret) {
6901 DEBUG("%s - ret:%p\n", __FUNCTION__, pyobj_ret);
6902 PyErr_Print();
6903 } else {
6904 Py_DECREF(pyobj_ret);
6905 ret = 0;
6906 }
6907 Py_XDECREF(pyobj_dict);
6908
6909 LIBVIRT_RELEASE_THREAD_STATE;
6910 return ret;
6911
6912 }
6913 #endif /* VIR_DOMAIN_EVENT_ID_TUNABLE */
6914
6915 #ifdef VIR_DOMAIN_EVENT_ID_AGENT_LIFECYCLE
6916 static int
6917 libvirt_virConnectDomainEventAgentLifecycleCallback(virConnectPtr conn ATTRIBUTE_UNUSED,
6918 virDomainPtr dom,
6919 int state,
6920 int reason,
6921 void *opaque)
6922 {
6923 PyObject *pyobj_cbData = (PyObject*)opaque;
6924 PyObject *pyobj_dom;
6925 PyObject *pyobj_ret = NULL;
6926 PyObject *pyobj_conn;
6927 PyObject *dictKey;
6928 int ret = -1;
6929
6930 LIBVIRT_ENSURE_THREAD_STATE;
6931
6932 if (!(dictKey = libvirt_constcharPtrWrap("conn")))
6933 goto cleanup;
6934 pyobj_conn = PyDict_GetItem(pyobj_cbData, dictKey);
6935 Py_DECREF(dictKey);
6936
6937 /* Create a python instance of this virDomainPtr */
6938 virDomainRef(dom);
6939 if (!(pyobj_dom = libvirt_virDomainPtrWrap(dom))) {
6940 virDomainFree(dom);
6941 goto cleanup;
6942 }
6943 Py_INCREF(pyobj_cbData);
6944
6945 /* Call the Callback Dispatcher */
6946 pyobj_ret = PyObject_CallMethod(pyobj_conn,
6947 (char*)"_dispatchDomainEventAgentLifecycleCallback",
6948 (char*)"OiiO",
6949 pyobj_dom, state, reason, pyobj_cbData);
6950
6951 Py_DECREF(pyobj_cbData);
6952 Py_DECREF(pyobj_dom);
6953
6954 cleanup:
6955 if (!pyobj_ret) {
6956 DEBUG("%s - ret:%p\n", __FUNCTION__, pyobj_ret);
6957 PyErr_Print();
6958 } else {
6959 Py_DECREF(pyobj_ret);
6960 ret = 0;
6961 }
6962
6963 LIBVIRT_RELEASE_THREAD_STATE;
6964 return ret;
6965
6966 }
6967 #endif /* VIR_DOMAIN_EVENT_ID_AGENT_LIFECYCLE */
6968
6969 #ifdef VIR_DOMAIN_EVENT_ID_DEVICE_ADDED
6970 static int
6971 libvirt_virConnectDomainEventDeviceAddedCallback(virConnectPtr conn ATTRIBUTE_UNUSED,
6972 virDomainPtr dom,
6973 const char *devAlias,
6974 void *opaque)
6975 {
6976 PyObject *pyobj_cbData = (PyObject*)opaque;
6977 PyObject *pyobj_dom;
6978 PyObject *pyobj_ret = NULL;
6979 PyObject *pyobj_conn;
6980 PyObject *dictKey;
6981 int ret = -1;
6982
6983 LIBVIRT_ENSURE_THREAD_STATE;
6984
6985 if (!(dictKey = libvirt_constcharPtrWrap("conn")))
6986 goto cleanup;
6987 pyobj_conn = PyDict_GetItem(pyobj_cbData, dictKey);
6988 Py_DECREF(dictKey);
6989
6990 /* Create a python instance of this virDomainPtr */
6991 virDomainRef(dom);
6992 if (!(pyobj_dom = libvirt_virDomainPtrWrap(dom))) {
6993 virDomainFree(dom);
6994 goto cleanup;
6995 }
6996 Py_INCREF(pyobj_cbData);
6997
6998 /* Call the Callback Dispatcher */
6999 pyobj_ret = PyObject_CallMethod(pyobj_conn,
7000 (char*)"_dispatchDomainEventDeviceAddedCallback",
7001 (char*)"OsO",
7002 pyobj_dom, devAlias, pyobj_cbData);
7003
7004 Py_DECREF(pyobj_cbData);
7005 Py_DECREF(pyobj_dom);
7006
7007 cleanup:
7008 if (!pyobj_ret) {
7009 DEBUG("%s - ret:%p\n", __FUNCTION__, pyobj_ret);
7010 PyErr_Print();
7011 } else {
7012 Py_DECREF(pyobj_ret);
7013 ret = 0;
7014 }
7015
7016 LIBVIRT_RELEASE_THREAD_STATE;
7017 return ret;
7018
7019 }
7020 #endif /* VIR_DOMAIN_EVENT_ID_DEVICE_ADDED */
7021
7022 #ifdef VIR_DOMAIN_EVENT_ID_MIGRATION_ITERATION
7023 static int
7024 libvirt_virConnectDomainEventMigrationIterationCallback(virConnectPtr conn ATTRIBUTE_UNUSED,
7025 virDomainPtr dom,
7026 int iteration,
7027 void *opaque)
7028 {
7029 PyObject *pyobj_cbData = (PyObject*)opaque;
7030 PyObject *pyobj_dom;
7031 PyObject *pyobj_ret = NULL;
7032 PyObject *pyobj_conn;
7033 PyObject *dictKey;
7034 int ret = -1;
7035
7036 LIBVIRT_ENSURE_THREAD_STATE;
7037
7038 if (!(dictKey = libvirt_constcharPtrWrap("conn")))
7039 goto cleanup;
7040 pyobj_conn = PyDict_GetItem(pyobj_cbData, dictKey);
7041 Py_DECREF(dictKey);
7042
7043 /* Create a python instance of this virDomainPtr */
7044 virDomainRef(dom);
7045 if (!(pyobj_dom = libvirt_virDomainPtrWrap(dom))) {
7046 virDomainFree(dom);
7047 goto cleanup;
7048 }
7049 Py_INCREF(pyobj_cbData);
7050
7051 /* Call the Callback Dispatcher */
7052 pyobj_ret = PyObject_CallMethod(pyobj_conn,
7053 (char*)"_dispatchDomainEventMigrationIterationCallback",
7054 (char*)"OiO",
7055 pyobj_dom, iteration, pyobj_cbData);
7056
7057 Py_DECREF(pyobj_cbData);
7058 Py_DECREF(pyobj_dom);
7059
7060 cleanup:
7061 if (!pyobj_ret) {
7062 DEBUG("%s - ret:%p\n", __FUNCTION__, pyobj_ret);
7063 PyErr_Print();
7064 } else {
7065 Py_DECREF(pyobj_ret);
7066 ret = 0;
7067 }
7068
7069 LIBVIRT_RELEASE_THREAD_STATE;
7070 return ret;
7071 }
7072 #endif /* VIR_DOMAIN_EVENT_ID_MIGRATION_ITERATION */
7073
7074 #ifdef VIR_DOMAIN_EVENT_ID_JOB_COMPLETED
7075 static int
7076 libvirt_virConnectDomainEventJobCompletedCallback(virConnectPtr conn ATTRIBUTE_UNUSED,
7077 virDomainPtr dom,
7078 virTypedParameterPtr params,
7079 int nparams,
7080 void *opaque)
7081 {
7082 PyObject *pyobj_cbData = (PyObject*)opaque;
7083 PyObject *pyobj_dom;
7084 PyObject *pyobj_ret = NULL;
7085 PyObject *pyobj_conn;
7086 PyObject *dictKey;
7087 PyObject *pyobj_dict = NULL;
7088 int ret = -1;
7089
7090 LIBVIRT_ENSURE_THREAD_STATE;
7091
7092 pyobj_dict = getPyVirTypedParameter(params, nparams);
7093 if (!pyobj_dict)
7094 goto cleanup;
7095
7096 if (!(dictKey = libvirt_constcharPtrWrap("conn")))
7097 goto cleanup;
7098 pyobj_conn = PyDict_GetItem(pyobj_cbData, dictKey);
7099 Py_DECREF(dictKey);
7100
7101 /* Create a python instance of this virDomainPtr */
7102 virDomainRef(dom);
7103 if (!(pyobj_dom = libvirt_virDomainPtrWrap(dom))) {
7104 virDomainFree(dom);
7105 goto cleanup;
7106 }
7107 Py_INCREF(pyobj_cbData);
7108
7109 /* Call the Callback Dispatcher */
7110 pyobj_ret = PyObject_CallMethod(pyobj_conn,
7111 (char*)"_dispatchDomainEventJobCompletedCallback",
7112 (char*)"OOO",
7113 pyobj_dom, pyobj_dict, pyobj_cbData);
7114
7115 Py_DECREF(pyobj_cbData);
7116 Py_DECREF(pyobj_dom);
7117
7118 cleanup:
7119 if (!pyobj_ret) {
7120 DEBUG("%s - ret:%p\n", __FUNCTION__, pyobj_ret);
7121 PyErr_Print();
7122 Py_XDECREF(pyobj_dict);
7123 } else {
7124 Py_DECREF(pyobj_ret);
7125 ret = 0;
7126 }
7127
7128 LIBVIRT_RELEASE_THREAD_STATE;
7129 return ret;
7130 }
7131 #endif /* VIR_DOMAIN_EVENT_ID_JOB_COMPLETED */
7132
7133
7134 #ifdef VIR_DOMAIN_EVENT_ID_DEVICE_REMOVAL_FAILED
7135 static int
7136 libvirt_virConnectDomainEventDeviceRemovalFailedCallback(virConnectPtr conn ATTRIBUTE_UNUSED,
7137 virDomainPtr dom,
7138 const char *devAlias,
7139 void *opaque)
7140 {
7141 PyObject *pyobj_cbData = (PyObject*)opaque;
7142 PyObject *pyobj_dom;
7143 PyObject *pyobj_ret = NULL;
7144 PyObject *pyobj_conn;
7145 PyObject *dictKey;
7146 int ret = -1;
7147
7148 LIBVIRT_ENSURE_THREAD_STATE;
7149
7150 if (!(dictKey = libvirt_constcharPtrWrap("conn")))
7151 goto cleanup;
7152 pyobj_conn = PyDict_GetItem(pyobj_cbData, dictKey);
7153 Py_DECREF(dictKey);
7154
7155 /* Create a python instance of this virDomainPtr */
7156 virDomainRef(dom);
7157 if (!(pyobj_dom = libvirt_virDomainPtrWrap(dom))) {
7158 virDomainFree(dom);
7159 goto cleanup;
7160 }
7161 Py_INCREF(pyobj_cbData);
7162
7163 /* Call the Callback Dispatcher */
7164 pyobj_ret = PyObject_CallMethod(pyobj_conn,
7165 (char*)"_dispatchDomainEventDeviceRemovalFailedCallback",
7166 (char*)"OsO",
7167 pyobj_dom, devAlias, pyobj_cbData);
7168
7169 Py_DECREF(pyobj_cbData);
7170 Py_DECREF(pyobj_dom);
7171
7172 cleanup:
7173 if (!pyobj_ret) {
7174 DEBUG("%s - ret:%p\n", __FUNCTION__, pyobj_ret);
7175 PyErr_Print();
7176 } else {
7177 Py_DECREF(pyobj_ret);
7178 ret = 0;
7179 }
7180
7181 LIBVIRT_RELEASE_THREAD_STATE;
7182 return ret;
7183
7184 }
7185 #endif /* VIR_DOMAIN_EVENT_ID_DEVICE_REMOVAL_FAILED */
7186
7187 #ifdef VIR_DOMAIN_EVENT_ID_METADATA_CHANGE
7188 static int
7189 libvirt_virConnectDomainEventMetadataChangeCallback(virConnectPtr conn ATTRIBUTE_UNUSED,
7190 virDomainPtr dom,
7191 int type,
7192 const char *nsuri,
7193 void *opaque)
7194 {
7195 PyObject *pyobj_cbData = (PyObject*)opaque;
7196 PyObject *pyobj_dom;
7197 PyObject *pyobj_ret = NULL;
7198 PyObject *pyobj_conn;
7199 PyObject *dictKey;
7200 int ret = -1;
7201
7202 LIBVIRT_ENSURE_THREAD_STATE;
7203
7204 if (!(dictKey = libvirt_constcharPtrWrap("conn")))
7205 goto cleanup;
7206 pyobj_conn = PyDict_GetItem(pyobj_cbData, dictKey);
7207 Py_DECREF(dictKey);
7208
7209 /* Create a python instance of this virDomainPtr */
7210 virDomainRef(dom);
7211 if (!(pyobj_dom = libvirt_virDomainPtrWrap(dom))) {
7212 virDomainFree(dom);
7213 goto cleanup;
7214 }
7215 Py_INCREF(pyobj_cbData);
7216
7217 /* Call the Callback Dispatcher */
7218 pyobj_ret = PyObject_CallMethod(pyobj_conn,
7219 (char*)"_dispatchDomainEventMetadataChangeCallback",
7220 (char*)"OisO",
7221 pyobj_dom, type, nsuri, pyobj_cbData);
7222
7223 Py_DECREF(pyobj_cbData);
7224 Py_DECREF(pyobj_dom);
7225
7226 cleanup:
7227 if (!pyobj_ret) {
7228 DEBUG("%s - ret:%p\n", __FUNCTION__, pyobj_ret);
7229 PyErr_Print();
7230 } else {
7231 Py_DECREF(pyobj_ret);
7232 ret = 0;
7233 }
7234
7235 LIBVIRT_RELEASE_THREAD_STATE;
7236 return ret;
7237 }
7238 #endif /* VIR_DOMAIN_EVENT_ID_METADATA_CHANGE */
7239
7240 #ifdef VIR_DOMAIN_EVENT_ID_BLOCK_THRESHOLD
7241 static int
7242 libvirt_virConnectDomainEventBlockThresholdCallback(virConnectPtr conn ATTRIBUTE_UNUSED,
7243 virDomainPtr dom,
7244 const char *dev,
7245 const char *path,
7246 unsigned long long threshold,
7247 unsigned long long excess,
7248 void *opaque)
7249 {
7250 PyObject *pyobj_cbData = (PyObject*)opaque;
7251 PyObject *pyobj_dom;
7252 PyObject *pyobj_ret = NULL;
7253 PyObject *pyobj_conn;
7254 PyObject *dictKey;
7255 int ret = -1;
7256
7257 LIBVIRT_ENSURE_THREAD_STATE;
7258
7259 if (!(dictKey = libvirt_constcharPtrWrap("conn")))
7260 goto cleanup;
7261 pyobj_conn = PyDict_GetItem(pyobj_cbData, dictKey);
7262 Py_DECREF(dictKey);
7263
7264 /* Create a python instance of this virDomainPtr */
7265 virDomainRef(dom);
7266 if (!(pyobj_dom = libvirt_virDomainPtrWrap(dom))) {
7267 virDomainFree(dom);
7268 goto cleanup;
7269 }
7270 Py_INCREF(pyobj_cbData);
7271
7272 /* Call the Callback Dispatcher */
7273 pyobj_ret = PyObject_CallMethod(pyobj_conn,
7274 (char*)"_dispatchDomainEventBlockThresholdCallback",
7275 (char*)"OssKKO",
7276 pyobj_dom, dev, path, threshold, excess,
7277 pyobj_cbData);
7278
7279 Py_DECREF(pyobj_cbData);
7280 Py_DECREF(pyobj_dom);
7281
7282 cleanup:
7283 if (!pyobj_ret) {
7284 DEBUG("%s - ret:%p\n", __FUNCTION__, pyobj_ret);
7285 PyErr_Print();
7286 } else {
7287 Py_DECREF(pyobj_ret);
7288 ret = 0;
7289 }
7290
7291 LIBVIRT_RELEASE_THREAD_STATE;
7292 return ret;
7293 }
7294 #endif /* VIR_DOMAIN_EVENT_ID_BLOCK_THRESHOLD */
7295
7296
7297 #ifdef VIR_DOMAIN_EVENT_ID_MEMORY_FAILURE
7298 static int
7299 libvirt_virConnectDomainEventMemoryFailureCallback(virConnectPtr conn ATTRIBUTE_UNUSED,
7300 virDomainPtr dom,
7301 int recipient,
7302 int action,
7303 unsigned int flags,
7304 void *opaque)
7305 {
7306 PyObject *pyobj_cbData = (PyObject*)opaque;
7307 PyObject *pyobj_dom;
7308 PyObject *pyobj_ret = NULL;
7309 PyObject *pyobj_conn;
7310 PyObject *dictKey;
7311 int ret = -1;
7312
7313 LIBVIRT_ENSURE_THREAD_STATE;
7314
7315 if (!(dictKey = libvirt_constcharPtrWrap("conn")))
7316 goto cleanup;
7317 pyobj_conn = PyDict_GetItem(pyobj_cbData, dictKey);
7318 Py_DECREF(dictKey);
7319
7320 /* Create a python instance of this virDomainPtr */
7321 virDomainRef(dom);
7322 if (!(pyobj_dom = libvirt_virDomainPtrWrap(dom))) {
7323 virDomainFree(dom);
7324 goto cleanup;
7325 }
7326 Py_INCREF(pyobj_cbData);
7327
7328 /* Call the Callback Dispatcher */
7329 pyobj_ret = PyObject_CallMethod(pyobj_conn,
7330 (char*)"_dispatchDomainEventMemoryFailureCallback",
7331 (char*)"OiiiO",
7332 pyobj_dom, recipient, action, flags,
7333 pyobj_cbData);
7334
7335 Py_DECREF(pyobj_cbData);
7336 Py_DECREF(pyobj_dom);
7337
7338 cleanup:
7339 if (!pyobj_ret) {
7340 DEBUG("%s - ret:%p\n", __FUNCTION__, pyobj_ret);
7341 PyErr_Print();
7342 } else {
7343 Py_DECREF(pyobj_ret);
7344 ret = 0;
7345 }
7346
7347 LIBVIRT_RELEASE_THREAD_STATE;
7348 return ret;
7349 }
7350 #endif /* VIR_DOMAIN_EVENT_ID_MEMORY_FAILURE */
7351
7352
7353 #ifdef VIR_DOMAIN_EVENT_ID_MEMORY_DEVICE_SIZE_CHANGE
7354 static int
7355 libvirt_virConnectDomainEventMemoryDeviceSizeChangeCallback(virConnectPtr conn ATTRIBUTE_UNUSED,
7356 virDomainPtr dom,
7357 const char *alias,
7358 unsigned long long size,
7359 void *opaque)
7360 {
7361 PyObject *pyobj_cbData = (PyObject*)opaque;
7362 PyObject *pyobj_dom;
7363 PyObject *pyobj_ret = NULL;
7364 PyObject *pyobj_conn;
7365 PyObject *dictKey;
7366 int ret = -1;
7367
7368 LIBVIRT_ENSURE_THREAD_STATE;
7369
7370 if (!(dictKey = libvirt_constcharPtrWrap("conn")))
7371 goto cleanup;
7372 pyobj_conn = PyDict_GetItem(pyobj_cbData, dictKey);
7373 Py_DECREF(dictKey);
7374
7375 /* Create a python instance of this virDomainPtr */
7376 virDomainRef(dom);
7377 if (!(pyobj_dom = libvirt_virDomainPtrWrap(dom))) {
7378 virDomainFree(dom);
7379 goto cleanup;
7380 }
7381 Py_INCREF(pyobj_cbData);
7382
7383 /* Call the Callback Dispatcher */
7384 pyobj_ret = PyObject_CallMethod(pyobj_conn,
7385 (char*)"_dispatchDomainEventMemoryDeviceSizeChangeCallback",
7386 (char*)"OsKO",
7387 pyobj_dom, alias, size,
7388 pyobj_cbData);
7389
7390 Py_DECREF(pyobj_cbData);
7391 Py_DECREF(pyobj_dom);
7392
7393 cleanup:
7394 if (!pyobj_ret) {
7395 DEBUG("%s - ret:%p\n", __FUNCTION__, pyobj_ret);
7396 PyErr_Print();
7397 } else {
7398 Py_DECREF(pyobj_ret);
7399 ret = 0;
7400 }
7401
7402 LIBVIRT_RELEASE_THREAD_STATE;
7403 return ret;
7404 }
7405 #endif /* VIR_DOMAIN_EVENT_ID_MEMORY_DEVICE_SIZE_CHANGE */
7406
7407
7408 static PyObject *
7409 libvirt_virConnectDomainEventRegisterAny(PyObject *self ATTRIBUTE_UNUSED,
7410 PyObject *args)
7411 {
7412 PyObject *py_retval; /* return value */
7413 PyObject *pyobj_conn; /* virConnectPtr */
7414 PyObject *pyobj_dom;
7415 PyObject *pyobj_cbData; /* hash of callback data */
7416 int eventID;
7417 virConnectPtr conn;
7418 int ret = 0;
7419 virConnectDomainEventGenericCallback cb = NULL;
7420 virDomainPtr dom;
7421
7422 if (!PyArg_ParseTuple(args,
7423 (char *) "OOiO:virConnectDomainEventRegisterAny",
7424 &pyobj_conn, &pyobj_dom, &eventID, &pyobj_cbData))
7425 return NULL;
7426
7427 DEBUG("libvirt_virConnectDomainEventRegister(%p %p %d %p) called\n",
7428 pyobj_conn, pyobj_dom, eventID, pyobj_cbData);
7429 conn = PyvirConnect_Get(pyobj_conn);
7430 if (pyobj_dom == Py_None)
7431 dom = NULL;
7432 else
7433 dom = PyvirDomain_Get(pyobj_dom);
7434
7435 switch ((virDomainEventID) eventID) {
7436 case VIR_DOMAIN_EVENT_ID_LIFECYCLE:
7437 cb = VIR_DOMAIN_EVENT_CALLBACK(libvirt_virConnectDomainEventLifecycleCallback);
7438 break;
7439 case VIR_DOMAIN_EVENT_ID_REBOOT:
7440 cb = VIR_DOMAIN_EVENT_CALLBACK(libvirt_virConnectDomainEventGenericCallback);
7441 break;
7442 case VIR_DOMAIN_EVENT_ID_RTC_CHANGE:
7443 cb = VIR_DOMAIN_EVENT_CALLBACK(libvirt_virConnectDomainEventRTCChangeCallback);
7444 break;
7445 case VIR_DOMAIN_EVENT_ID_WATCHDOG:
7446 cb = VIR_DOMAIN_EVENT_CALLBACK(libvirt_virConnectDomainEventWatchdogCallback);
7447 break;
7448 case VIR_DOMAIN_EVENT_ID_IO_ERROR:
7449 cb = VIR_DOMAIN_EVENT_CALLBACK(libvirt_virConnectDomainEventIOErrorCallback);
7450 break;
7451 case VIR_DOMAIN_EVENT_ID_IO_ERROR_REASON:
7452 cb = VIR_DOMAIN_EVENT_CALLBACK(libvirt_virConnectDomainEventIOErrorReasonCallback);
7453 break;
7454 case VIR_DOMAIN_EVENT_ID_GRAPHICS:
7455 cb = VIR_DOMAIN_EVENT_CALLBACK(libvirt_virConnectDomainEventGraphicsCallback);
7456 break;
7457 case VIR_DOMAIN_EVENT_ID_CONTROL_ERROR:
7458 cb = VIR_DOMAIN_EVENT_CALLBACK(libvirt_virConnectDomainEventGenericCallback);
7459 break;
7460 case VIR_DOMAIN_EVENT_ID_BLOCK_JOB:
7461 #ifdef VIR_DOMAIN_EVENT_ID_BLOCK_JOB_2
7462 case VIR_DOMAIN_EVENT_ID_BLOCK_JOB_2:
7463 #endif /* VIR_DOMAIN_EVENT_ID_BLOCK_JOB_2 */
7464 cb = VIR_DOMAIN_EVENT_CALLBACK(libvirt_virConnectDomainEventBlockJobCallback);
7465 break;
7466 case VIR_DOMAIN_EVENT_ID_DISK_CHANGE:
7467 cb = VIR_DOMAIN_EVENT_CALLBACK(libvirt_virConnectDomainEventDiskChangeCallback);
7468 break;
7469 case VIR_DOMAIN_EVENT_ID_TRAY_CHANGE:
7470 cb = VIR_DOMAIN_EVENT_CALLBACK(libvirt_virConnectDomainEventTrayChangeCallback);
7471 break;
7472 case VIR_DOMAIN_EVENT_ID_PMWAKEUP:
7473 cb = VIR_DOMAIN_EVENT_CALLBACK(libvirt_virConnectDomainEventPMWakeupCallback);
7474 break;
7475 case VIR_DOMAIN_EVENT_ID_PMSUSPEND:
7476 cb = VIR_DOMAIN_EVENT_CALLBACK(libvirt_virConnectDomainEventPMSuspendCallback);
7477 break;
7478 #ifdef VIR_DOMAIN_EVENT_ID_BALLOON_CHANGE
7479 case VIR_DOMAIN_EVENT_ID_BALLOON_CHANGE:
7480 cb = VIR_DOMAIN_EVENT_CALLBACK(libvirt_virConnectDomainEventBalloonChangeCallback);
7481 break;
7482 #endif /* VIR_DOMAIN_EVENT_ID_BALLOON_CHANGE */
7483 #ifdef VIR_DOMAIN_EVENT_ID_PMSUSPEND_DISK
7484 case VIR_DOMAIN_EVENT_ID_PMSUSPEND_DISK:
7485 cb = VIR_DOMAIN_EVENT_CALLBACK(libvirt_virConnectDomainEventPMSuspendDiskCallback);
7486 break;
7487 #endif /* VIR_DOMAIN_EVENT_ID_PMSUSPEND_DISK */
7488 #ifdef VIR_DOMAIN_EVENT_ID_DEVICE_REMOVED
7489 case VIR_DOMAIN_EVENT_ID_DEVICE_REMOVED:
7490 cb = VIR_DOMAIN_EVENT_CALLBACK(libvirt_virConnectDomainEventDeviceRemovedCallback);
7491 break;
7492 #endif /* VIR_DOMAIN_EVENT_ID_DEVICE_REMOVED */
7493 #ifdef VIR_DOMAIN_EVENT_ID_TUNABLE
7494 case VIR_DOMAIN_EVENT_ID_TUNABLE:
7495 cb = VIR_DOMAIN_EVENT_CALLBACK(libvirt_virConnectDomainEventTunableCallback);
7496 break;
7497 #endif /* VIR_DOMAIN_EVENT_ID_TUNABLE */
7498 #ifdef VIR_DOMAIN_EVENT_ID_AGENT_LIFECYCLE
7499 case VIR_DOMAIN_EVENT_ID_AGENT_LIFECYCLE:
7500 cb = VIR_DOMAIN_EVENT_CALLBACK(libvirt_virConnectDomainEventAgentLifecycleCallback);
7501 break;
7502 #endif /* VIR_DOMAIN_EVENT_ID_AGENT_LIFECYCLE */
7503 #ifdef VIR_DOMAIN_EVENT_ID_DEVICE_ADDED
7504 case VIR_DOMAIN_EVENT_ID_DEVICE_ADDED:
7505 cb = VIR_DOMAIN_EVENT_CALLBACK(libvirt_virConnectDomainEventDeviceAddedCallback);
7506 break;
7507 #endif /* VIR_DOMAIN_EVENT_ID_DEVICE_ADDED */
7508 #ifdef VIR_DOMAIN_EVENT_ID_MIGRATION_ITERATION
7509 case VIR_DOMAIN_EVENT_ID_MIGRATION_ITERATION:
7510 cb = VIR_DOMAIN_EVENT_CALLBACK(libvirt_virConnectDomainEventMigrationIterationCallback);
7511 break;
7512 #endif /* VIR_DOMAIN_EVENT_ID_MIGRATION_ITERATION */
7513 #ifdef VIR_DOMAIN_EVENT_ID_JOB_COMPLETED
7514 case VIR_DOMAIN_EVENT_ID_JOB_COMPLETED:
7515 cb = VIR_DOMAIN_EVENT_CALLBACK(libvirt_virConnectDomainEventJobCompletedCallback);
7516 break;
7517 #endif /* VIR_DOMAIN_EVENT_ID_JOB_COMPLETED */
7518 #ifdef VIR_DOMAIN_EVENT_ID_DEVICE_REMOVAL_FAILED
7519 case VIR_DOMAIN_EVENT_ID_DEVICE_REMOVAL_FAILED:
7520 cb = VIR_DOMAIN_EVENT_CALLBACK(libvirt_virConnectDomainEventDeviceRemovalFailedCallback);
7521 break;
7522 #endif /* VIR_DOMAIN_EVENT_ID_DEVICE_REMOVAL_FAILED */
7523 #ifdef VIR_DOMAIN_EVENT_ID_METADATA_CHANGE
7524 case VIR_DOMAIN_EVENT_ID_METADATA_CHANGE:
7525 cb = VIR_DOMAIN_EVENT_CALLBACK(libvirt_virConnectDomainEventMetadataChangeCallback);
7526 break;
7527 #endif /* VIR_DOMAIN_EVENT_ID_METADATA_CHANGE */
7528 #ifdef VIR_DOMAIN_EVENT_ID_BLOCK_THRESHOLD
7529 case VIR_DOMAIN_EVENT_ID_BLOCK_THRESHOLD:
7530 cb = VIR_DOMAIN_EVENT_CALLBACK(libvirt_virConnectDomainEventBlockThresholdCallback);
7531 break;
7532 #endif /* VIR_DOMAIN_EVENT_ID_BLOCK_THRESHOLD */
7533 #ifdef VIR_DOMAIN_EVENT_ID_MEMORY_FAILURE
7534 case VIR_DOMAIN_EVENT_ID_MEMORY_FAILURE:
7535 cb = VIR_DOMAIN_EVENT_CALLBACK(libvirt_virConnectDomainEventMemoryFailureCallback);
7536 break;
7537 #endif /* VIR_DOMAIN_EVENT_ID_MEMORY_FAILURE */
7538 #ifdef VIR_DOMAIN_EVENT_ID_MEMORY_DEVICE_SIZE_CHANGE
7539 case VIR_DOMAIN_EVENT_ID_MEMORY_DEVICE_SIZE_CHANGE:
7540 cb = VIR_DOMAIN_EVENT_CALLBACK(libvirt_virConnectDomainEventMemoryDeviceSizeChangeCallback);
7541 break;
7542 #endif /* VIR_DOMAIN_EVENT_ID_MEMORY_DEVICE_SIZE_CHANGE */
7543 case VIR_DOMAIN_EVENT_ID_LAST:
7544 break;
7545 }
7546
7547 if (!cb) {
7548 return VIR_PY_INT_FAIL;
7549 }
7550
7551 Py_INCREF(pyobj_cbData);
7552
7553 LIBVIRT_BEGIN_ALLOW_THREADS;
7554 ret = virConnectDomainEventRegisterAny(conn, dom, eventID,
7555 cb, pyobj_cbData,
7556 libvirt_virConnectDomainEventFreeFunc);
7557 LIBVIRT_END_ALLOW_THREADS;
7558
7559 if (ret < 0) {
7560 Py_DECREF(pyobj_cbData);
7561 }
7562
7563 py_retval = libvirt_intWrap(ret);
7564 return py_retval;
7565 }
7566
7567 static PyObject *
7568 libvirt_virConnectDomainEventDeregisterAny(PyObject *self ATTRIBUTE_UNUSED,
7569 PyObject *args)
7570 {
7571 PyObject *pyobj_conn;
7572 int callbackID;
7573 virConnectPtr conn;
7574 int ret = 0;
7575
7576 if (!PyArg_ParseTuple(args, (char *) "Oi:virConnectDomainEventDeregister",
7577 &pyobj_conn, &callbackID))
7578 return NULL;
7579
7580 DEBUG("libvirt_virConnectDomainEventDeregister(%p) called\n", pyobj_conn);
7581
7582 conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
7583
7584 LIBVIRT_BEGIN_ALLOW_THREADS;
7585 ret = virConnectDomainEventDeregisterAny(conn, callbackID);
7586 LIBVIRT_END_ALLOW_THREADS;
7587
7588 return libvirt_intWrap(ret);
7589 }
7590
7591 #if LIBVIR_CHECK_VERSION(1, 2, 1)
7592 static void
7593 libvirt_virConnectNetworkEventFreeFunc(void *opaque)
7594 {
7595 PyObject *pyobj_conn = (PyObject*)opaque;
7596 LIBVIRT_ENSURE_THREAD_STATE;
7597 Py_DECREF(pyobj_conn);
7598 LIBVIRT_RELEASE_THREAD_STATE;
7599 }
7600
7601 static int
7602 libvirt_virConnectNetworkEventLifecycleCallback(virConnectPtr conn ATTRIBUTE_UNUSED,
7603 virNetworkPtr net,
7604 int event,
7605 int detail,
7606 void *opaque)
7607 {
7608 PyObject *pyobj_cbData = (PyObject*)opaque;
7609 PyObject *pyobj_net;
7610 PyObject *pyobj_ret = NULL;
7611 PyObject *pyobj_conn;
7612 PyObject *dictKey;
7613 int ret = -1;
7614
7615 LIBVIRT_ENSURE_THREAD_STATE;
7616
7617 if (!(dictKey = libvirt_constcharPtrWrap("conn")))
7618 goto cleanup;
7619 pyobj_conn = PyDict_GetItem(pyobj_cbData, dictKey);
7620 Py_DECREF(dictKey);
7621
7622 /* Create a python instance of this virNetworkPtr */
7623 virNetworkRef(net);
7624 if (!(pyobj_net = libvirt_virNetworkPtrWrap(net))) {
7625 virNetworkFree(net);
7626 goto cleanup;
7627 }
7628 Py_INCREF(pyobj_cbData);
7629
7630 /* Call the Callback Dispatcher */
7631 pyobj_ret = PyObject_CallMethod(pyobj_conn,
7632 (char*)"_dispatchNetworkEventLifecycleCallback",
7633 (char*)"OiiO",
7634 pyobj_net,
7635 event,
7636 detail,
7637 pyobj_cbData);
7638
7639 Py_DECREF(pyobj_cbData);
7640 Py_DECREF(pyobj_net);
7641
7642 cleanup:
7643 if (!pyobj_ret) {
7644 DEBUG("%s - ret:%p\n", __FUNCTION__, pyobj_ret);
7645 PyErr_Print();
7646 } else {
7647 Py_DECREF(pyobj_ret);
7648 ret = 0;
7649 }
7650
7651 LIBVIRT_RELEASE_THREAD_STATE;
7652 return ret;
7653 }
7654
7655 #ifdef VIR_NETWORK_EVENT_ID_METADATA_CHANGE
7656 static int
7657 libvirt_virConnectNetworkEventMetadataChangeCallback(virConnectPtr conn ATTRIBUTE_UNUSED,
7658 virNetworkPtr dom,
7659 int type,
7660 const char *nsuri,
7661 void *opaque)
7662 {
7663 PyObject *pyobj_cbData = (PyObject*)opaque;
7664 PyObject *pyobj_dom;
7665 PyObject *pyobj_ret = NULL;
7666 PyObject *pyobj_conn;
7667 PyObject *dictKey;
7668 int ret = -1;
7669
7670 LIBVIRT_ENSURE_THREAD_STATE;
7671
7672 if (!(dictKey = libvirt_constcharPtrWrap("conn")))
7673 goto cleanup;
7674 pyobj_conn = PyDict_GetItem(pyobj_cbData, dictKey);
7675 Py_DECREF(dictKey);
7676
7677 /* Create a python instance of this virNetworkPtr */
7678 virNetworkRef(dom);
7679 if (!(pyobj_dom = libvirt_virNetworkPtrWrap(dom))) {
7680 virNetworkFree(dom);
7681 goto cleanup;
7682 }
7683 Py_INCREF(pyobj_cbData);
7684
7685 /* Call the Callback Dispatcher */
7686 pyobj_ret = PyObject_CallMethod(pyobj_conn,
7687 (char*)"_dispatchNetworkEventMetadataChangeCallback",
7688 (char*)"OisO",
7689 pyobj_dom, type, nsuri, pyobj_cbData);
7690
7691 Py_DECREF(pyobj_cbData);
7692 Py_DECREF(pyobj_dom);
7693
7694 cleanup:
7695 if (!pyobj_ret) {
7696 DEBUG("%s - ret:%p\n", __FUNCTION__, pyobj_ret);
7697 PyErr_Print();
7698 } else {
7699 Py_DECREF(pyobj_ret);
7700 ret = 0;
7701 }
7702
7703 LIBVIRT_RELEASE_THREAD_STATE;
7704 return ret;
7705 }
7706 #endif /* VIR_NETWORK_EVENT_ID_METADATA_CHANGE */
7707
7708 static PyObject *
7709 libvirt_virConnectNetworkEventRegisterAny(PyObject *self ATTRIBUTE_UNUSED,
7710 PyObject *args)
7711 {
7712 PyObject *pyobj_conn; /* virConnectPtr */
7713 PyObject *pyobj_net;
7714 PyObject *pyobj_cbData; /* hash of callback data */
7715 int eventID;
7716 virConnectPtr conn;
7717 int ret = 0;
7718 virConnectNetworkEventGenericCallback cb = NULL;
7719 virNetworkPtr net;
7720
7721 if (!PyArg_ParseTuple(args,
7722 (char *) "OOiO:virConnectNetworkEventRegisterAny",
7723 &pyobj_conn, &pyobj_net, &eventID, &pyobj_cbData))
7724 return NULL;
7725
7726 DEBUG("libvirt_virConnectNetworkEventRegister(%p %p %d %p) called\n",
7727 pyobj_conn, pyobj_net, eventID, pyobj_cbData);
7728 conn = PyvirConnect_Get(pyobj_conn);
7729 if (pyobj_net == Py_None)
7730 net = NULL;
7731 else
7732 net = PyvirNetwork_Get(pyobj_net);
7733
7734 switch ((virNetworkEventID) eventID) {
7735 case VIR_NETWORK_EVENT_ID_LIFECYCLE:
7736 cb = VIR_NETWORK_EVENT_CALLBACK(libvirt_virConnectNetworkEventLifecycleCallback);
7737 break;
7738
7739 #ifdef VIR_NETWORK_EVENT_ID_METADATA_CHANGE
7740 case VIR_NETWORK_EVENT_ID_METADATA_CHANGE:
7741 cb = VIR_NETWORK_EVENT_CALLBACK(libvirt_virConnectNetworkEventMetadataChangeCallback);
7742 break;
7743 #endif /* VIR_NETWORK_EVENT_ID_METADATA_CHANGE */
7744
7745 case VIR_NETWORK_EVENT_ID_LAST:
7746 break;
7747 }
7748
7749 if (!cb) {
7750 return VIR_PY_INT_FAIL;
7751 }
7752
7753 Py_INCREF(pyobj_cbData);
7754
7755 LIBVIRT_BEGIN_ALLOW_THREADS;
7756 ret = virConnectNetworkEventRegisterAny(conn, net, eventID,
7757 cb, pyobj_cbData,
7758 libvirt_virConnectNetworkEventFreeFunc);
7759 LIBVIRT_END_ALLOW_THREADS;
7760
7761 if (ret < 0) {
7762 Py_DECREF(pyobj_cbData);
7763 }
7764
7765 return libvirt_intWrap(ret);
7766 }
7767
7768 static PyObject *
7769 libvirt_virConnectNetworkEventDeregisterAny(PyObject *self ATTRIBUTE_UNUSED,
7770 PyObject *args)
7771 {
7772 PyObject *pyobj_conn;
7773 int callbackID;
7774 virConnectPtr conn;
7775 int ret = 0;
7776
7777 if (!PyArg_ParseTuple(args, (char *) "Oi:virConnectNetworkEventDeregister",
7778 &pyobj_conn, &callbackID))
7779 return NULL;
7780
7781 DEBUG("libvirt_virConnectNetworkEventDeregister(%p) called\n", pyobj_conn);
7782
7783 conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
7784
7785 LIBVIRT_BEGIN_ALLOW_THREADS;
7786 ret = virConnectNetworkEventDeregisterAny(conn, callbackID);
7787 LIBVIRT_END_ALLOW_THREADS;
7788
7789 return libvirt_intWrap(ret);
7790 }
7791 #endif /* LIBVIR_CHECK_VERSION(1, 2, 1)*/
7792
7793 #if LIBVIR_CHECK_VERSION(0, 10, 0)
7794 static void
7795 libvirt_virConnectCloseCallbackDispatch(virConnectPtr conn ATTRIBUTE_UNUSED,
7796 int reason,
7797 void *opaque)
7798 {
7799 PyObject *pyobj_cbData = (PyObject*)opaque;
7800 PyObject *pyobj_ret;
7801 PyObject *pyobj_conn;
7802 PyObject *dictKey;
7803
7804 LIBVIRT_ENSURE_THREAD_STATE;
7805
7806 Py_INCREF(pyobj_cbData);
7807
7808 dictKey = libvirt_constcharPtrWrap("conn");
7809 pyobj_conn = PyDict_GetItem(pyobj_cbData, dictKey);
7810 Py_DECREF(dictKey);
7811
7812 /* Call the Callback Dispatcher */
7813 pyobj_ret = PyObject_CallMethod(pyobj_conn,
7814 (char*)"_dispatchCloseCallback",
7815 (char*)"iO",
7816 reason,
7817 pyobj_cbData);
7818
7819 Py_DECREF(pyobj_cbData);
7820
7821 if (!pyobj_ret) {
7822 DEBUG("%s - ret:%p\n", __FUNCTION__, pyobj_ret);
7823 PyErr_Print();
7824 } else {
7825 Py_DECREF(pyobj_ret);
7826 }
7827
7828 LIBVIRT_RELEASE_THREAD_STATE;
7829 }
7830
7831 static PyObject *
7832 libvirt_virConnectRegisterCloseCallback(PyObject *self ATTRIBUTE_UNUSED,
7833 PyObject *args)
7834 {
7835 PyObject *pyobj_conn; /* virConnectPtr */
7836 PyObject *pyobj_cbData; /* hash of callback data */
7837 virConnectPtr conn;
7838 int ret = 0;
7839
7840 if (!PyArg_ParseTuple(args, (char *) "OO:virConnectRegisterCloseCallback",
7841 &pyobj_conn, &pyobj_cbData))
7842 return NULL;
7843
7844 DEBUG("libvirt_virConnectRegisterCloseCallback(%p %p) called\n",
7845 pyobj_conn, pyobj_cbData);
7846 conn = PyvirConnect_Get(pyobj_conn);
7847
7848 Py_INCREF(pyobj_cbData);
7849
7850 LIBVIRT_BEGIN_ALLOW_THREADS;
7851 ret = virConnectRegisterCloseCallback(conn,
7852 libvirt_virConnectCloseCallbackDispatch,
7853 pyobj_cbData,
7854 libvirt_virConnectDomainEventFreeFunc);
7855 LIBVIRT_END_ALLOW_THREADS;
7856
7857 if (ret < 0) {
7858 Py_DECREF(pyobj_cbData);
7859 }
7860
7861 return libvirt_intWrap(ret);
7862 }
7863
7864 static PyObject *
7865 libvirt_virConnectUnregisterCloseCallback(PyObject * self ATTRIBUTE_UNUSED,
7866 PyObject * args)
7867 {
7868 PyObject *pyobj_conn;
7869 virConnectPtr conn;
7870 int ret = 0;
7871
7872 if (!PyArg_ParseTuple(args, (char *) "O:virConnectUnregisterCloseCallback",
7873 &pyobj_conn))
7874 return NULL;
7875
7876 DEBUG("libvirt_virConnectDomainEventUnregister(%p) called\n",
7877 pyobj_conn);
7878
7879 conn = PyvirConnect_Get(pyobj_conn);
7880
7881 LIBVIRT_BEGIN_ALLOW_THREADS;
7882 ret = virConnectUnregisterCloseCallback(conn,
7883 libvirt_virConnectCloseCallbackDispatch);
7884 LIBVIRT_END_ALLOW_THREADS;
7885
7886 return libvirt_intWrap(ret);
7887 }
7888 #endif /* LIBVIR_CHECK_VERSION(0, 10, 0) */
7889
7890 static void
7891 libvirt_virStreamEventFreeFunc(void *opaque)
7892 {
7893 PyObject *pyobj_stream = (PyObject*)opaque;
7894 LIBVIRT_ENSURE_THREAD_STATE;
7895 Py_DECREF(pyobj_stream);
7896 LIBVIRT_RELEASE_THREAD_STATE;
7897 }
7898
7899 static void
7900 libvirt_virStreamEventCallback(virStreamPtr st ATTRIBUTE_UNUSED,
7901 int events,
7902 void *opaque)
7903 {
7904 PyObject *pyobj_cbData = (PyObject *)opaque;
7905 PyObject *pyobj_stream;
7906 PyObject *pyobj_ret;
7907 PyObject *dictKey;
7908
7909 LIBVIRT_ENSURE_THREAD_STATE;
7910
7911 Py_INCREF(pyobj_cbData);
7912 dictKey = libvirt_constcharPtrWrap("stream");
7913 pyobj_stream = PyDict_GetItem(pyobj_cbData, dictKey);
7914 Py_DECREF(dictKey);
7915
7916 /* Call the pure python dispatcher */
7917 pyobj_ret = PyObject_CallMethod(pyobj_stream,
7918 (char *)"_dispatchStreamEventCallback",
7919 (char *)"iO",
7920 events, pyobj_cbData);
7921
7922 Py_DECREF(pyobj_cbData);
7923
7924 if (!pyobj_ret) {
7925 DEBUG("%s - ret:%p\n", __FUNCTION__, pyobj_ret);
7926 PyErr_Print();
7927 } else {
7928 Py_DECREF(pyobj_ret);
7929 }
7930
7931 LIBVIRT_RELEASE_THREAD_STATE;
7932 }
7933
7934 static PyObject *
7935 libvirt_virStreamEventAddCallback(PyObject *self ATTRIBUTE_UNUSED,
7936 PyObject *args)
7937 {
7938 PyObject *pyobj_stream;
7939 PyObject *pyobj_cbData;
7940 virStreamPtr stream;
7941 virStreamEventCallback cb = libvirt_virStreamEventCallback;
7942 int ret;
7943 int events;
7944
7945 if (!PyArg_ParseTuple(args, (char *) "OiO:virStreamEventAddCallback",
7946 &pyobj_stream, &events, &pyobj_cbData))
7947 return NULL;
7948
7949 DEBUG("libvirt_virStreamEventAddCallback(%p, %d, %p) called\n",
7950 pyobj_stream, events, pyobj_cbData);
7951 stream = PyvirStream_Get(pyobj_stream);
7952
7953 Py_INCREF(pyobj_cbData);
7954
7955 LIBVIRT_BEGIN_ALLOW_THREADS;
7956 ret = virStreamEventAddCallback(stream, events, cb, pyobj_cbData,
7957 libvirt_virStreamEventFreeFunc);
7958 LIBVIRT_END_ALLOW_THREADS;
7959
7960 if (ret < 0) {
7961 Py_DECREF(pyobj_cbData);
7962 }
7963
7964 return libvirt_intWrap(ret);
7965 }
7966
7967 static PyObject *
7968 libvirt_virStreamRecv(PyObject *self ATTRIBUTE_UNUSED,
7969 PyObject *args)
7970 {
7971 PyObject *pyobj_stream;
7972 PyObject *rv;
7973 virStreamPtr stream;
7974 char *buf = NULL;
7975 int ret;
7976 int nbytes;
7977
7978 if (!PyArg_ParseTuple(args, (char *) "Oi:virStreamRecv",
7979 &pyobj_stream, &nbytes)) {
7980 return NULL;
7981 }
7982 stream = PyvirStream_Get(pyobj_stream);
7983
7984 if (VIR_ALLOC_N(buf, nbytes+1 > 0 ? nbytes+1 : 1) < 0)
7985 return PyErr_NoMemory();
7986
7987 LIBVIRT_BEGIN_ALLOW_THREADS;
7988 ret = virStreamRecv(stream, buf, nbytes);
7989 LIBVIRT_END_ALLOW_THREADS;
7990
7991 buf[ret > -1 ? ret : 0] = '\0';
7992 DEBUG("StreamRecv ret=%d strlen=%zu\n", ret, strlen(buf));
7993
7994 if (ret == -2) {
7995 VIR_FREE(buf);
7996 return libvirt_intWrap(ret);
7997 }
7998 if (ret < 0) {
7999 VIR_FREE(buf);
8000 return VIR_PY_NONE;
8001 }
8002 rv = libvirt_charPtrSizeWrap((char *) buf, (Py_ssize_t) ret);
8003 VIR_FREE(buf);
8004 return rv;
8005 }
8006
8007 static PyObject *
8008 libvirt_virStreamSend(PyObject *self ATTRIBUTE_UNUSED,
8009 PyObject *args)
8010 {
8011 PyObject *pyobj_stream;
8012 PyObject *pyobj_data;
8013 virStreamPtr stream;
8014 char *data;
8015 Py_ssize_t datalen;
8016 int ret;
8017
8018 if (!PyArg_ParseTuple(args, (char *) "OO:virStreamSend",
8019 &pyobj_stream, &pyobj_data))
8020 return NULL;
8021
8022 stream = PyvirStream_Get(pyobj_stream);
8023 libvirt_charPtrSizeUnwrap(pyobj_data, &data, &datalen);
8024
8025 LIBVIRT_BEGIN_ALLOW_THREADS;
8026 ret = virStreamSend(stream, data, datalen);
8027 LIBVIRT_END_ALLOW_THREADS;
8028
8029 DEBUG("StreamSend ret=%d\n", ret);
8030
8031 return libvirt_intWrap(ret);
8032 }
8033
8034 static PyObject *
8035 libvirt_virDomainSendKey(PyObject *self ATTRIBUTE_UNUSED,
8036 PyObject *args)
8037 {
8038 virDomainPtr domain;
8039 PyObject *pyobj_domain;
8040 PyObject *pyobj_list;
8041 int codeset;
8042 int holdtime;
8043 unsigned int flags;
8044 int ret;
8045 ssize_t i;
8046 unsigned int keycodes[VIR_DOMAIN_SEND_KEY_MAX_KEYS];
8047 int nkeycodes;
8048
8049 if (!PyArg_ParseTuple(args, (char *)"OiiOII:virDomainSendKey",
8050 &pyobj_domain, &codeset, &holdtime, &pyobj_list,
8051 &nkeycodes, &flags))
8052 return NULL;
8053
8054 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
8055
8056 if (!PyList_Check(pyobj_list)) {
8057 return VIR_PY_INT_FAIL;
8058 }
8059
8060 if (nkeycodes != PyList_Size(pyobj_list) ||
8061 nkeycodes > VIR_DOMAIN_SEND_KEY_MAX_KEYS) {
8062 return VIR_PY_INT_FAIL;
8063 }
8064
8065 for (i = 0; i < nkeycodes; i++) {
8066 if (libvirt_uintUnwrap(PyList_GetItem(pyobj_list, i), &keycodes[i]) < 0)
8067 return NULL;
8068 }
8069
8070 LIBVIRT_BEGIN_ALLOW_THREADS;
8071 ret = virDomainSendKey(domain, codeset, holdtime, keycodes, nkeycodes, flags);
8072 LIBVIRT_END_ALLOW_THREADS;
8073
8074 DEBUG("virDomainSendKey ret=%d\n", ret);
8075
8076 return libvirt_intWrap(ret);
8077 }
8078
8079 #if LIBVIR_CHECK_VERSION(1, 0, 3)
8080 static PyObject *
8081 libvirt_virDomainMigrateGetCompressionCache(PyObject *self ATTRIBUTE_UNUSED,
8082 PyObject *args)
8083 {
8084 PyObject *pyobj_domain;
8085 virDomainPtr domain;
8086 unsigned int flags;
8087 unsigned long long cacheSize;
8088 int rc;
8089
8090 if (!PyArg_ParseTuple(args,
8091 (char *) "OI:virDomainMigrateGetCompressionCache",
8092 &pyobj_domain, &flags))
8093 return NULL;
8094
8095 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
8096
8097 LIBVIRT_BEGIN_ALLOW_THREADS;
8098 rc = virDomainMigrateGetCompressionCache(domain, &cacheSize, flags);
8099 LIBVIRT_END_ALLOW_THREADS;
8100
8101 if (rc < 0)
8102 return VIR_PY_NONE;
8103
8104 return libvirt_ulonglongWrap(cacheSize);
8105 }
8106 #endif /* LIBVIR_CHECK_VERSION(1, 0, 3) */
8107
8108 static PyObject *
8109 libvirt_virDomainMigrateGetMaxSpeed(PyObject *self ATTRIBUTE_UNUSED,
8110 PyObject *args)
8111 {
8112 int c_retval;
8113 unsigned long bandwidth;
8114 virDomainPtr domain;
8115 PyObject *pyobj_domain;
8116 unsigned int flags = 0;
8117
8118 if (!PyArg_ParseTuple(args, (char *)"OI:virDomainMigrateGetMaxSpeed",
8119 &pyobj_domain, &flags))
8120 return NULL;
8121
8122 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
8123
8124 LIBVIRT_BEGIN_ALLOW_THREADS;
8125 c_retval = virDomainMigrateGetMaxSpeed(domain, &bandwidth, flags);
8126 LIBVIRT_END_ALLOW_THREADS;
8127
8128 if (c_retval < 0)
8129 return VIR_PY_INT_FAIL;
8130
8131 return libvirt_ulongWrap(bandwidth);
8132 }
8133
8134 #if LIBVIR_CHECK_VERSION(3, 7, 0)
8135 static PyObject *
8136 libvirt_virDomainMigrateGetMaxDowntime(PyObject *self ATTRIBUTE_UNUSED,
8137 PyObject *args)
8138 {
8139 PyObject *pyobj_domain;
8140 virDomainPtr domain;
8141 unsigned int flags;
8142 unsigned long long downtime;
8143 int rc;
8144
8145 if (!PyArg_ParseTuple(args,
8146 (char *) "OI:virDomainMigrateGetMaxDowntime",
8147 &pyobj_domain, &flags))
8148 return NULL;
8149
8150 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
8151
8152 LIBVIRT_BEGIN_ALLOW_THREADS;
8153 rc = virDomainMigrateGetMaxDowntime(domain, &downtime, flags);
8154 LIBVIRT_END_ALLOW_THREADS;
8155
8156 if (rc < 0)
8157 return VIR_PY_NONE;
8158
8159 return libvirt_ulonglongWrap(downtime);
8160 }
8161 #endif /* LIBVIR_CHECK_VERSION(3, 7, 0) */
8162
8163 #if LIBVIR_CHECK_VERSION(1, 1, 0)
8164 static virPyTypedParamsHint virPyDomainMigrate3Params[] = {
8165 # ifdef VIR_MIGRATE_PARAM_URI
8166 { VIR_MIGRATE_PARAM_URI, VIR_TYPED_PARAM_STRING },
8167 # endif
8168 # ifdef VIR_MIGRATE_PARAM_DEST_NAME
8169 { VIR_MIGRATE_PARAM_DEST_NAME, VIR_TYPED_PARAM_STRING },
8170 # endif
8171 # ifdef VIR_MIGRATE_PARAM_DEST_XML
8172 { VIR_MIGRATE_PARAM_DEST_XML, VIR_TYPED_PARAM_STRING },
8173 # endif
8174 # ifdef VIR_MIGRATE_PARAM_PERSIST_XML
8175 { VIR_MIGRATE_PARAM_PERSIST_XML, VIR_TYPED_PARAM_STRING },
8176 # endif
8177 # ifdef VIR_MIGRATE_PARAM_BANDWIDTH
8178 { VIR_MIGRATE_PARAM_BANDWIDTH, VIR_TYPED_PARAM_ULLONG },
8179 # endif
8180 # ifdef VIR_MIGRATE_PARAM_GRAPHICS_URI
8181 { VIR_MIGRATE_PARAM_GRAPHICS_URI, VIR_TYPED_PARAM_STRING },
8182 # endif
8183 # ifdef VIR_MIGRATE_PARAM_LISTEN_ADDRESS
8184 { VIR_MIGRATE_PARAM_LISTEN_ADDRESS, VIR_TYPED_PARAM_STRING },
8185 # endif
8186 # ifdef VIR_MIGRATE_PARAM_MIGRATE_DISKS
8187 { VIR_MIGRATE_PARAM_MIGRATE_DISKS, VIR_TYPED_PARAM_STRING },
8188 # endif
8189 # ifdef VIR_MIGRATE_PARAM_DISKS_PORT
8190 { VIR_MIGRATE_PARAM_DISKS_PORT, VIR_TYPED_PARAM_INT },
8191 # endif
8192 # ifdef VIR_MIGRATE_PARAM_COMPRESSION
8193 { VIR_MIGRATE_PARAM_COMPRESSION, VIR_TYPED_PARAM_STRING },
8194 # endif
8195 # ifdef VIR_MIGRATE_PARAM_COMPRESSION_MT_LEVEL
8196 { VIR_MIGRATE_PARAM_COMPRESSION_MT_LEVEL, VIR_TYPED_PARAM_INT },
8197 # endif
8198 # ifdef VIR_MIGRATE_PARAM_COMPRESSION_MT_THREADS
8199 { VIR_MIGRATE_PARAM_COMPRESSION_MT_THREADS, VIR_TYPED_PARAM_INT },
8200 # endif
8201 # ifdef VIR_MIGRATE_PARAM_COMPRESSION_MT_DTHREADS
8202 { VIR_MIGRATE_PARAM_COMPRESSION_MT_DTHREADS, VIR_TYPED_PARAM_INT },
8203 # endif
8204 # ifdef VIR_MIGRATE_PARAM_COMPRESSION_XBZRLE_CACHE
8205 { VIR_MIGRATE_PARAM_COMPRESSION_XBZRLE_CACHE, VIR_TYPED_PARAM_ULLONG },
8206 # endif
8207 # ifdef VIR_MIGRATE_PARAM_AUTO_CONVERGE_INITIAL
8208 { VIR_MIGRATE_PARAM_AUTO_CONVERGE_INITIAL, VIR_TYPED_PARAM_INT },
8209 # endif
8210 # ifdef VIR_MIGRATE_PARAM_AUTO_CONVERGE_INCREMENT
8211 { VIR_MIGRATE_PARAM_AUTO_CONVERGE_INCREMENT, VIR_TYPED_PARAM_INT },
8212 # endif
8213 # ifdef VIR_MIGRATE_PARAM_BANDWIDTH_POSTCOPY
8214 { VIR_MIGRATE_PARAM_BANDWIDTH_POSTCOPY, VIR_TYPED_PARAM_ULLONG },
8215 # endif
8216 # ifdef VIR_MIGRATE_PARAM_PARALLEL_CONNECTIONS
8217 { VIR_MIGRATE_PARAM_PARALLEL_CONNECTIONS, VIR_TYPED_PARAM_INT },
8218 # endif
8219 # ifdef VIR_MIGRATE_PARAM_DISKS_URI
8220 { VIR_MIGRATE_PARAM_DISKS_URI, VIR_TYPED_PARAM_STRING },
8221 #endif
8222 #ifdef VIR_MIGRATE_PARAM_TLS_DESTINATION
8223 { VIR_MIGRATE_PARAM_TLS_DESTINATION, VIR_TYPED_PARAM_STRING },
8224 #endif
8225 #ifdef VIR_MIGRATE_PARAM_COMPRESSION_ZLIB_LEVEL
8226 { VIR_MIGRATE_PARAM_COMPRESSION_ZLIB_LEVEL, VIR_TYPED_PARAM_INT },
8227 #endif
8228 #ifdef VIR_MIGRATE_PARAM_COMPRESSION_ZSTD_LEVEL
8229 { VIR_MIGRATE_PARAM_COMPRESSION_ZSTD_LEVEL, VIR_TYPED_PARAM_INT },
8230 #endif
8231 };
8232
8233
8234 static PyObject *
8235 libvirt_virDomainMigrate3(PyObject *self ATTRIBUTE_UNUSED,
8236 PyObject *args)
8237 {
8238 PyObject *pyobj_domain;
8239 virDomainPtr domain;
8240 PyObject *pyobj_dconn;
8241 virConnectPtr dconn;
8242 PyObject *dict;
8243 unsigned int flags;
8244 virTypedParameterPtr params;
8245 int nparams = 0;
8246 virDomainPtr ddom = NULL;
8247
8248 if (!PyArg_ParseTuple(args, (char *) "OOOI:virDomainMigrate3",
8249 &pyobj_domain, &pyobj_dconn, &dict, &flags))
8250 return NULL;
8251
8252 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
8253 dconn = (virConnectPtr) PyvirConnect_Get(pyobj_dconn);
8254
8255 if (!PyDict_Check(dict)) {
8256 PyErr_Format(PyExc_TypeError, "migration params must be a dictionary");
8257 return NULL;
8258 }
8259
8260 if (virPyDictToTypedParams(dict, &params, &nparams,
8261 virPyDomainMigrate3Params,
8262 VIR_N_ELEMENTS(virPyDomainMigrate3Params)) < 0) {
8263 return NULL;
8264 }
8265
8266 LIBVIRT_BEGIN_ALLOW_THREADS;
8267 ddom = virDomainMigrate3(domain, dconn, params, nparams, flags);
8268 LIBVIRT_END_ALLOW_THREADS;
8269
8270 virTypedParamsFree(params, nparams);
8271 return libvirt_virDomainPtrWrap(ddom);
8272 }
8273
8274 static PyObject *
8275 libvirt_virDomainMigrateToURI3(PyObject *self ATTRIBUTE_UNUSED,
8276 PyObject *args)
8277 {
8278 PyObject *pyobj_domain;
8279 virDomainPtr domain;
8280 char *dconnuri;
8281 PyObject *dict;
8282 unsigned int flags;
8283 virTypedParameterPtr params;
8284 int nparams;
8285 int ret = -1;
8286
8287 if (!PyArg_ParseTuple(args, (char *) "OzOI:virDomainMigrate3",
8288 &pyobj_domain, &dconnuri, &dict, &flags))
8289 return NULL;
8290
8291 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
8292
8293 if (!PyDict_Check(dict)) {
8294 PyErr_Format(PyExc_TypeError, "migration params must be a dictionary");
8295 return NULL;
8296 }
8297
8298 if (virPyDictToTypedParams(dict, &params, &nparams,
8299 virPyDomainMigrate3Params,
8300 VIR_N_ELEMENTS(virPyDomainMigrate3Params)) < 0) {
8301 return NULL;
8302 }
8303
8304 LIBVIRT_BEGIN_ALLOW_THREADS;
8305 ret = virDomainMigrateToURI3(domain, dconnuri, params, nparams, flags);
8306 LIBVIRT_END_ALLOW_THREADS;
8307
8308 virTypedParamsFree(params, nparams);
8309 return libvirt_intWrap(ret);
8310 }
8311 #endif /* LIBVIR_CHECK_VERSION(1, 1, 0) */
8312
8313 static PyObject *
8314 libvirt_virDomainBlockPeek(PyObject *self ATTRIBUTE_UNUSED,
8315 PyObject *args)
8316 {
8317 PyObject *py_retval = NULL;
8318 int c_retval;
8319 virDomainPtr domain;
8320 PyObject *pyobj_domain;
8321 const char *disk;
8322 unsigned long long offset;
8323 size_t size;
8324 char *buf;
8325 unsigned int flags;
8326
8327 if (!PyArg_ParseTuple(args, (char *)"OzKkI:virDomainBlockPeek",
8328 &pyobj_domain, &disk, &offset, &size, &flags))
8329 return NULL;
8330
8331 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
8332
8333 if (VIR_ALLOC_N(buf, size) < 0)
8334 return PyErr_NoMemory();
8335
8336 LIBVIRT_BEGIN_ALLOW_THREADS;
8337 c_retval = virDomainBlockPeek(domain, disk, offset, size, buf, flags);
8338 LIBVIRT_END_ALLOW_THREADS;
8339
8340 if (c_retval < 0) {
8341 py_retval = VIR_PY_NONE;
8342 goto cleanup;
8343 }
8344
8345 py_retval = libvirt_charPtrSizeWrap(buf, size);
8346
8347 cleanup:
8348 VIR_FREE(buf);
8349 return py_retval;
8350 }
8351
8352 static PyObject *
8353 libvirt_virDomainMemoryPeek(PyObject *self ATTRIBUTE_UNUSED,
8354 PyObject *args)
8355 {
8356 PyObject *py_retval = NULL;
8357 int c_retval;
8358 virDomainPtr domain;
8359 PyObject *pyobj_domain;
8360 unsigned long long start;
8361 size_t size;
8362 char *buf;
8363 unsigned int flags;
8364
8365 if (!PyArg_ParseTuple(args, (char *)"OKkI:virDomainMemoryPeek",
8366 &pyobj_domain, &start, &size, &flags))
8367 return NULL;
8368
8369 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
8370
8371 if (VIR_ALLOC_N(buf, size) < 0)
8372 return PyErr_NoMemory();
8373
8374 LIBVIRT_BEGIN_ALLOW_THREADS;
8375 c_retval = virDomainMemoryPeek(domain, start, size, buf, flags);
8376 LIBVIRT_END_ALLOW_THREADS;
8377
8378 if (c_retval < 0) {
8379 py_retval = VIR_PY_NONE;
8380 goto cleanup;
8381 }
8382
8383 py_retval = libvirt_charPtrSizeWrap(buf, size);
8384
8385 cleanup:
8386 VIR_FREE(buf);
8387 return py_retval;
8388 }
8389
8390 #if LIBVIR_CHECK_VERSION(0, 10, 2)
8391 static PyObject *
8392 libvirt_virNodeSetMemoryParameters(PyObject *self ATTRIBUTE_UNUSED,
8393 PyObject *args)
8394 {
8395 virConnectPtr conn;
8396 PyObject *pyobj_conn, *info;
8397 PyObject *ret = NULL;
8398 int i_retval;
8399 int nparams = 0;
8400 Py_ssize_t size = 0;
8401 unsigned int flags;
8402 virTypedParameterPtr params = NULL, new_params = NULL;
8403
8404 if (!PyArg_ParseTuple(args,
8405 (char *)"OOI:virNodeSetMemoryParameters",
8406 &pyobj_conn, &info, &flags))
8407 return NULL;
8408 conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
8409
8410 if ((size = PyDict_Size(info)) < 0)
8411 return NULL;
8412
8413 if (size == 0) {
8414 PyErr_Format(PyExc_LookupError,
8415 "Need non-empty dictionary to set attributes");
8416 return NULL;
8417 }
8418
8419 LIBVIRT_BEGIN_ALLOW_THREADS;
8420 i_retval = virNodeGetMemoryParameters(conn, NULL, &nparams, flags);
8421 LIBVIRT_END_ALLOW_THREADS;
8422
8423 if (i_retval < 0)
8424 return VIR_PY_INT_FAIL;
8425
8426 if (nparams == 0) {
8427 PyErr_Format(PyExc_LookupError,
8428 "no settable attributes");
8429 return NULL;
8430 }
8431
8432 if (VIR_ALLOC_N(params, nparams) < 0)
8433 return PyErr_NoMemory();
8434
8435 LIBVIRT_BEGIN_ALLOW_THREADS;
8436 i_retval = virNodeGetMemoryParameters(conn, params, &nparams, flags);
8437 LIBVIRT_END_ALLOW_THREADS;
8438
8439 if (i_retval < 0) {
8440 ret = VIR_PY_INT_FAIL;
8441 goto cleanup;
8442 }
8443
8444 new_params = setPyVirTypedParameter(info, params, nparams);
8445 if (!new_params)
8446 goto cleanup;
8447
8448 LIBVIRT_BEGIN_ALLOW_THREADS;
8449 i_retval = virNodeSetMemoryParameters(conn, new_params, size, flags);
8450 LIBVIRT_END_ALLOW_THREADS;
8451
8452 if (i_retval < 0) {
8453 ret = VIR_PY_INT_FAIL;
8454 goto cleanup;
8455 }
8456
8457 ret = VIR_PY_INT_SUCCESS;
8458
8459 cleanup:
8460 virTypedParamsFree(params, nparams);
8461 virTypedParamsFree(new_params, size);
8462 return ret;
8463 }
8464
8465 static PyObject *
8466 libvirt_virNodeGetMemoryParameters(PyObject *self ATTRIBUTE_UNUSED,
8467 PyObject *args)
8468 {
8469 virConnectPtr conn;
8470 PyObject *pyobj_conn;
8471 PyObject *ret = NULL;
8472 int i_retval;
8473 int nparams = 0;
8474 unsigned int flags;
8475 virTypedParameterPtr params;
8476
8477 if (!PyArg_ParseTuple(args, (char *)"OI:virNodeGetMemoryParameters",
8478 &pyobj_conn, &flags))
8479 return NULL;
8480 conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
8481
8482 LIBVIRT_BEGIN_ALLOW_THREADS;
8483 i_retval = virNodeGetMemoryParameters(conn, NULL, &nparams, flags);
8484 LIBVIRT_END_ALLOW_THREADS;
8485
8486 if (i_retval < 0)
8487 return VIR_PY_NONE;
8488
8489 if (!nparams)
8490 return PyDict_New();
8491
8492 if (VIR_ALLOC_N(params, nparams) < 0)
8493 return PyErr_NoMemory();
8494
8495 LIBVIRT_BEGIN_ALLOW_THREADS;
8496 i_retval = virNodeGetMemoryParameters(conn, params, &nparams, flags);
8497 LIBVIRT_END_ALLOW_THREADS;
8498
8499 if (i_retval < 0) {
8500 ret = VIR_PY_NONE;
8501 goto cleanup;
8502 }
8503
8504 ret = getPyVirTypedParameter(params, nparams);
8505
8506 cleanup:
8507 virTypedParamsFree(params, nparams);
8508 return ret;
8509 }
8510 #endif /* LIBVIR_CHECK_VERSION(0, 10, 2) */
8511
8512 #if LIBVIR_CHECK_VERSION(1, 0, 0)
8513 static PyObject *
8514 libvirt_virNodeGetCPUMap(PyObject *self ATTRIBUTE_UNUSED,
8515 PyObject *args)
8516 {
8517 virConnectPtr conn;
8518 PyObject *pyobj_conn;
8519 PyObject *ret = NULL;
8520 PyObject *pycpumap = NULL;
8521 int i_retval;
8522 unsigned char *cpumap = NULL;
8523 unsigned int online = 0;
8524 unsigned int flags;
8525 ssize_t i;
8526
8527 if (!PyArg_ParseTuple(args, (char *)"OI:virNodeGetCPUMap",
8528 &pyobj_conn, &flags))
8529 return NULL;
8530 conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
8531
8532 LIBVIRT_BEGIN_ALLOW_THREADS;
8533 i_retval = virNodeGetCPUMap(conn, &cpumap, &online, flags);
8534 LIBVIRT_END_ALLOW_THREADS;
8535
8536 if (i_retval < 0)
8537 return VIR_PY_NONE;
8538
8539 if ((ret = PyTuple_New(3)) == NULL)
8540 goto error;
8541
8542 /* 0: number of CPUs */
8543 VIR_PY_TUPLE_SET_GOTO(ret, 0, libvirt_intWrap(i_retval), error);
8544
8545 /* 1: CPU map */
8546 if ((pycpumap = PyList_New(i_retval)) == NULL)
8547 goto error;
8548
8549 VIR_PY_TUPLE_SET_GOTO(ret, 1, pycpumap, error);
8550
8551 for (i = 0; i < i_retval; i++)
8552 VIR_PY_LIST_SET_GOTO(pycpumap, i,
8553 PyBool_FromLong(VIR_CPU_USED(cpumap, i)), error);
8554
8555 /* 2: number of online CPUs */
8556 VIR_PY_TUPLE_SET_GOTO(ret, 2, libvirt_uintWrap(online), error);
8557
8558 cleanup:
8559 VIR_FREE(cpumap);
8560 return ret;
8561
8562 error:
8563 Py_CLEAR(ret);
8564 goto cleanup;
8565 }
8566 #endif /* LIBVIR_CHECK_VERSION(1, 0, 0) */
8567
8568
8569 #if LIBVIR_CHECK_VERSION(1, 1, 1)
8570 static PyObject *
8571 libvirt_virDomainCreateWithFiles(PyObject *self ATTRIBUTE_UNUSED,
8572 PyObject *args)
8573 {
8574 PyObject *py_retval = NULL;
8575 int c_retval;
8576 virDomainPtr domain;
8577 PyObject *pyobj_domain;
8578 PyObject *pyobj_files;
8579 unsigned int flags;
8580 unsigned int nfiles;
8581 int *files = NULL;
8582 size_t i;
8583
8584 if (!PyArg_ParseTuple(args, (char *)"OOI:virDomainCreateWithFiles",
8585 &pyobj_domain, &pyobj_files, &flags))
8586 return NULL;
8587 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
8588
8589 nfiles = PyList_Size(pyobj_files);
8590
8591 if (VIR_ALLOC_N(files, nfiles) < 0)
8592 return PyErr_NoMemory();
8593
8594 for (i = 0; i < nfiles; i++) {
8595 PyObject *pyfd;
8596 int fd;
8597
8598 pyfd = PyList_GetItem(pyobj_files, i);
8599
8600 if (libvirt_intUnwrap(pyfd, &fd) < 0)
8601 goto cleanup;
8602
8603 files[i] = fd;
8604 }
8605
8606 LIBVIRT_BEGIN_ALLOW_THREADS;
8607 c_retval = virDomainCreateWithFiles(domain, nfiles, files, flags);
8608 LIBVIRT_END_ALLOW_THREADS;
8609
8610 py_retval = libvirt_intWrap(c_retval);
8611
8612 cleanup:
8613 VIR_FREE(files);
8614 return py_retval;
8615 }
8616
8617
8618 static PyObject *
8619 libvirt_virDomainCreateXMLWithFiles(PyObject *self ATTRIBUTE_UNUSED,
8620 PyObject *args)
8621 {
8622 PyObject *py_retval = NULL;
8623 virDomainPtr c_retval;
8624 virConnectPtr conn;
8625 PyObject *pyobj_conn;
8626 char * xmlDesc;
8627 PyObject *pyobj_files;
8628 unsigned int flags;
8629 unsigned int nfiles;
8630 int *files = NULL;
8631 size_t i;
8632
8633 if (!PyArg_ParseTuple(args, (char *)"OzOI:virDomainCreateXMLWithFiles",
8634 &pyobj_conn, &xmlDesc, &pyobj_files, &flags))
8635 return NULL;
8636 conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
8637
8638 nfiles = PyList_Size(pyobj_files);
8639
8640 if (VIR_ALLOC_N(files, nfiles) < 0)
8641 return PyErr_NoMemory();
8642
8643 for (i = 0; i < nfiles; i++) {
8644 PyObject *pyfd;
8645 int fd;
8646
8647 pyfd = PyList_GetItem(pyobj_files, i);
8648
8649 if (libvirt_intUnwrap(pyfd, &fd) < 0)
8650 goto cleanup;
8651
8652 files[i] = fd;
8653 }
8654
8655 LIBVIRT_BEGIN_ALLOW_THREADS;
8656 c_retval = virDomainCreateXMLWithFiles(conn, xmlDesc, nfiles, files, flags);
8657 LIBVIRT_END_ALLOW_THREADS;
8658
8659 py_retval = libvirt_virDomainPtrWrap((virDomainPtr) c_retval);
8660
8661 cleanup:
8662 VIR_FREE(files);
8663 return py_retval;
8664 }
8665 #endif /* LIBVIR_CHECK_VERSION(1, 1, 1) */
8666
8667
8668 #if LIBVIR_CHECK_VERSION(1, 2, 5)
8669 static PyObject *
8670 libvirt_virDomainFSFreeze(PyObject *self ATTRIBUTE_UNUSED,
8671 PyObject *args)
8672 {
8673 PyObject *py_retval = NULL;
8674 int c_retval;
8675 virDomainPtr domain;
8676 PyObject *pyobj_domain;
8677 PyObject *pyobj_list;
8678 unsigned int flags;
8679 unsigned int nmountpoints = 0;
8680 char **mountpoints = NULL;
8681 size_t i = 0;
8682 size_t j = 0;
8683
8684 if (!PyArg_ParseTuple(args, (char *)"OOI:virDomainFSFreeze",
8685 &pyobj_domain, &pyobj_list, &flags))
8686 return NULL;
8687 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
8688
8689 if (PyList_Check(pyobj_list)) {
8690 nmountpoints = PyList_Size(pyobj_list);
8691
8692 if (VIR_ALLOC_N(mountpoints, nmountpoints) < 0)
8693 return PyErr_NoMemory();
8694
8695 for (i = 0; i < nmountpoints; i++) {
8696 if (libvirt_charPtrUnwrap(PyList_GetItem(pyobj_list, i),
8697 mountpoints+i) < 0)
8698 goto cleanup;
8699 }
8700 }
8701
8702 LIBVIRT_BEGIN_ALLOW_THREADS;
8703 c_retval = virDomainFSFreeze(domain, (const char **) mountpoints,
8704 nmountpoints, flags);
8705 LIBVIRT_END_ALLOW_THREADS;
8706
8707 py_retval = libvirt_intWrap(c_retval);
8708
8709 cleanup:
8710 for (j = 0 ; j < i ; j++)
8711 VIR_FREE(mountpoints[j]);
8712 VIR_FREE(mountpoints);
8713 return py_retval;
8714 }
8715
8716
8717 static PyObject *
8718 libvirt_virDomainFSThaw(PyObject *self ATTRIBUTE_UNUSED,
8719 PyObject *args)
8720 {
8721 PyObject *py_retval = NULL;
8722 int c_retval;
8723 virDomainPtr domain;
8724 PyObject *pyobj_domain;
8725 PyObject *pyobj_list;
8726 unsigned int flags;
8727 unsigned int nmountpoints = 0;
8728 char **mountpoints = NULL;
8729 size_t i = 0;
8730 size_t j = 0;
8731
8732 if (!PyArg_ParseTuple(args, (char *)"OOI:virDomainFSThaw",
8733 &pyobj_domain, &pyobj_list, &flags))
8734 return NULL;
8735 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
8736
8737 if (PyList_Check(pyobj_list)) {
8738 nmountpoints = PyList_Size(pyobj_list);
8739
8740 if (VIR_ALLOC_N(mountpoints, nmountpoints) < 0)
8741 return PyErr_NoMemory();
8742
8743 for (i = 0; i < nmountpoints; i++) {
8744 if (libvirt_charPtrUnwrap(PyList_GetItem(pyobj_list, i),
8745 mountpoints+i) < 0)
8746 goto cleanup;
8747 }
8748 }
8749
8750 LIBVIRT_BEGIN_ALLOW_THREADS;
8751 c_retval = virDomainFSThaw(domain, (const char **) mountpoints,
8752 nmountpoints, flags);
8753 LIBVIRT_END_ALLOW_THREADS;
8754
8755 py_retval = libvirt_intWrap(c_retval);
8756
8757 cleanup:
8758 for (j = 0 ; j < i ; j++)
8759 VIR_FREE(mountpoints[j]);
8760 VIR_FREE(mountpoints);
8761 return py_retval;
8762 }
8763
8764 static PyObject *
8765 libvirt_virDomainGetTime(PyObject *self ATTRIBUTE_UNUSED,
8766 PyObject *args)
8767 {
8768 PyObject *py_retval = NULL;
8769 PyObject *dict = NULL;
8770 PyObject *pyobj_domain;
8771 virDomainPtr domain;
8772 long long seconds;
8773 unsigned int nseconds;
8774 unsigned int flags;
8775 int c_retval;
8776
8777 if (!PyArg_ParseTuple(args, (char*)"OI:virDomainGetTime",
8778 &pyobj_domain, &flags))
8779 return NULL;
8780 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
8781
8782 if (!(dict = PyDict_New()))
8783 goto cleanup;
8784
8785 LIBVIRT_BEGIN_ALLOW_THREADS;
8786 c_retval = virDomainGetTime(domain, &seconds, &nseconds, flags);
8787 LIBVIRT_END_ALLOW_THREADS;
8788
8789 if (c_retval < 0) {
8790 py_retval = VIR_PY_NONE;
8791 goto cleanup;
8792 }
8793
8794 VIR_PY_DICT_SET_GOTO(dict, libvirt_constcharPtrWrap("seconds"),
8795 libvirt_longlongWrap(seconds), cleanup);
8796 VIR_PY_DICT_SET_GOTO(dict, libvirt_constcharPtrWrap("nseconds"),
8797 libvirt_longlongWrap(nseconds), cleanup);
8798
8799 py_retval = dict;
8800 dict = NULL;
8801 cleanup:
8802 Py_XDECREF(dict);
8803 return py_retval;
8804 }
8805
8806
8807 static PyObject *
8808 libvirt_virDomainSetTime(PyObject *self ATTRIBUTE_UNUSED,
8809 PyObject *args)
8810 {
8811 PyObject *pyobj_domain;
8812 PyObject *pyobj_seconds;
8813 PyObject *pyobj_nseconds;
8814 PyObject *py_dict;
8815 virDomainPtr domain;
8816 long long seconds = 0;
8817 unsigned int nseconds = 0;
8818 unsigned int flags;
8819 ssize_t py_dict_size = 0;
8820 int c_retval;
8821
8822 if (!PyArg_ParseTuple(args, (char*)"OOI:virDomainSetTime",
8823 &pyobj_domain, &py_dict, &flags))
8824 return NULL;
8825 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
8826
8827 if (PyDict_Check(py_dict)) {
8828 py_dict_size = PyDict_Size(py_dict);
8829 if ((pyobj_seconds = PyDict_GetItemString(py_dict, "seconds"))) {
8830 if (libvirt_longlongUnwrap(pyobj_seconds, &seconds) < 0)
8831 return NULL;
8832 } else {
8833 PyErr_Format(PyExc_LookupError, "Dictionary must contains 'seconds'");
8834 return NULL;
8835 }
8836
8837 if ((pyobj_nseconds = PyDict_GetItemString(py_dict, "nseconds"))) {
8838 if (libvirt_uintUnwrap(pyobj_nseconds, &nseconds) < 0)
8839 return NULL;
8840 } else if (py_dict_size > 1) {
8841 PyErr_Format(PyExc_LookupError, "Dictionary contains unknown key");
8842 return NULL;
8843 }
8844 } else if (py_dict != Py_None || !flags) {
8845 PyErr_Format(PyExc_TypeError, "time must be a dictionary "
8846 "or None with flags set");
8847 return NULL;
8848 }
8849
8850 LIBVIRT_BEGIN_ALLOW_THREADS;
8851 c_retval = virDomainSetTime(domain, seconds, nseconds, flags);
8852 LIBVIRT_END_ALLOW_THREADS;
8853
8854 return libvirt_intWrap(c_retval);
8855 }
8856 #endif /* LIBVIR_CHECK_VERSION(1, 2, 5) */
8857
8858
8859 #if LIBVIR_CHECK_VERSION(1, 2, 6)
8860 static PyObject *
8861 libvirt_virNodeGetFreePages(PyObject *self ATTRIBUTE_UNUSED,
8862 PyObject *args)
8863 {
8864 PyObject *py_retval = NULL;
8865 PyObject *pyobj_conn;
8866 PyObject *pyobj_pagesize;
8867 PyObject *pyobj_counts = NULL;
8868 virConnectPtr conn;
8869 unsigned int *pages = NULL;
8870 int startCell;
8871 unsigned int cellCount;
8872 unsigned int flags;
8873 unsigned long long *counts = NULL;
8874 int c_retval;
8875 ssize_t pyobj_pagesize_size, i, j;
8876
8877 if (!PyArg_ParseTuple(args, (char *)"OOiII:virNodeGetFreePages",
8878 &pyobj_conn, &pyobj_pagesize, &startCell,
8879 &cellCount, &flags))
8880 return NULL;
8881
8882 if (!PyList_Check(pyobj_pagesize)) {
8883 PyErr_Format(PyExc_TypeError, "pagesize must be list");
8884 return NULL;
8885 }
8886
8887 if (cellCount == 0) {
8888 PyErr_Format(PyExc_LookupError, "cellCount must not be zero");
8889 return NULL;
8890 }
8891
8892 conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
8893
8894 pyobj_pagesize_size = PyList_Size(pyobj_pagesize);
8895 if (VIR_ALLOC_N(pages, pyobj_pagesize_size) < 0 ||
8896 VIR_ALLOC_N(counts, pyobj_pagesize_size * cellCount) < 0) {
8897 PyErr_NoMemory();
8898 goto cleanup;
8899 }
8900
8901 if (!(pyobj_counts = PyDict_New()))
8902 goto cleanup;
8903
8904 for (i = 0; i < pyobj_pagesize_size; i++) {
8905 PyObject *tmp = PyList_GetItem(pyobj_pagesize, i);
8906
8907 if (libvirt_uintUnwrap(tmp, &pages[i]) < 0)
8908 goto cleanup;
8909 }
8910
8911 LIBVIRT_BEGIN_ALLOW_THREADS;
8912 c_retval = virNodeGetFreePages(conn,
8913 pyobj_pagesize_size, pages,
8914 startCell, cellCount,
8915 counts, flags);
8916 LIBVIRT_END_ALLOW_THREADS;
8917
8918 if (c_retval < 0) {
8919 py_retval = VIR_PY_NONE;
8920 goto cleanup;
8921 }
8922
8923 for (i = 0; i < c_retval;) {
8924 PyObject *per_node = NULL;
8925
8926 if (!(per_node = PyDict_New()))
8927 goto cleanup;
8928
8929 VIR_PY_DICT_SET_GOTO(pyobj_counts,
8930 libvirt_intWrap(startCell + i/pyobj_pagesize_size),
8931 per_node, cleanup);
8932
8933 for (j = 0; j < pyobj_pagesize_size; j ++)
8934 VIR_PY_DICT_SET_GOTO(per_node, libvirt_intWrap(pages[j]),
8935 libvirt_intWrap(counts[i + j]), cleanup);
8936
8937 i += pyobj_pagesize_size;
8938 }
8939
8940 py_retval = pyobj_counts;
8941 pyobj_counts = NULL;
8942 cleanup:
8943 Py_XDECREF(pyobj_counts);
8944 VIR_FREE(pages);
8945 VIR_FREE(counts);
8946 return py_retval;
8947 }
8948
8949
8950 static PyObject *
8951 libvirt_virNetworkGetDHCPLeases(PyObject *self ATTRIBUTE_UNUSED,
8952 PyObject *args)
8953 {
8954 PyObject *py_retval = NULL;
8955 PyObject *py_lease = NULL;
8956 virNetworkPtr network;
8957 PyObject *pyobj_network;
8958 unsigned int flags;
8959 virNetworkDHCPLeasePtr *leases = NULL;
8960 int leases_count;
8961 char *mac = NULL;
8962 ssize_t i;
8963
8964 if (!PyArg_ParseTuple(args, (char *) "OzI:virNetworkGetDHCPLeases",
8965 &pyobj_network, &mac, &flags))
8966 return NULL;
8967
8968 network = (virNetworkPtr) PyvirNetwork_Get(pyobj_network);
8969
8970 LIBVIRT_BEGIN_ALLOW_THREADS;
8971 leases_count = virNetworkGetDHCPLeases(network, mac, &leases, flags);
8972 LIBVIRT_END_ALLOW_THREADS;
8973
8974 if (leases_count < 0) {
8975 py_retval = VIR_PY_NONE;
8976 goto cleanup;
8977 }
8978
8979 if (!(py_retval = PyList_New(leases_count)))
8980 goto error;
8981
8982 for (i = 0; i < leases_count; i++) {
8983 virNetworkDHCPLeasePtr lease = leases[i];
8984
8985 if ((py_lease = PyDict_New()) == NULL)
8986 goto error;
8987
8988 VIR_PY_LIST_SET_GOTO(py_retval, i, py_lease, error);
8989
8990 VIR_PY_DICT_SET_GOTO(py_lease, libvirt_constcharPtrWrap("iface"),
8991 libvirt_charPtrWrap(lease->iface), error);
8992 VIR_PY_DICT_SET_GOTO(py_lease, libvirt_constcharPtrWrap("expirytime"),
8993 libvirt_longlongWrap(lease->expirytime), error);
8994 VIR_PY_DICT_SET_GOTO(py_lease, libvirt_constcharPtrWrap("type"),
8995 libvirt_intWrap(lease->type), error);
8996 VIR_PY_DICT_SET_GOTO(py_lease, libvirt_constcharPtrWrap("mac"),
8997 libvirt_charPtrWrap(lease->mac), error);
8998 VIR_PY_DICT_SET_GOTO(py_lease, libvirt_constcharPtrWrap("ipaddr"),
8999 libvirt_charPtrWrap(lease->ipaddr), error);
9000 VIR_PY_DICT_SET_GOTO(py_lease, libvirt_constcharPtrWrap("prefix"),
9001 libvirt_uintWrap(lease->prefix), error);
9002 VIR_PY_DICT_SET_GOTO(py_lease, libvirt_constcharPtrWrap("hostname"),
9003 libvirt_charPtrWrap(lease->hostname), error);
9004 VIR_PY_DICT_SET_GOTO(py_lease, libvirt_constcharPtrWrap("clientid"),
9005 libvirt_charPtrWrap(lease->clientid), error);
9006 VIR_PY_DICT_SET_GOTO(py_lease, libvirt_constcharPtrWrap("iaid"),
9007 libvirt_charPtrWrap(lease->iaid), error);
9008 }
9009
9010 cleanup:
9011 if (leases_count > 0)
9012 for (i = 0; i < leases_count; i++)
9013 virNetworkDHCPLeaseFree(leases[i]);
9014 VIR_FREE(leases);
9015
9016 return py_retval;
9017
9018 error:
9019 Py_CLEAR(py_retval);
9020 goto cleanup;
9021 }
9022
9023 #endif /* LIBVIR_CHECK_VERSION(1, 2, 6) */
9024
9025 #if LIBVIR_CHECK_VERSION(1, 2, 8)
9026
9027 static PyObject *
9028 convertDomainStatsRecord(virDomainStatsRecordPtr *records,
9029 int nrecords)
9030 {
9031 PyObject *py_retval;
9032 PyObject *py_record;
9033 PyObject *py_record_stats = NULL;
9034 virDomainPtr dom = NULL;
9035 ssize_t i;
9036
9037 if (!(py_retval = PyList_New(nrecords)))
9038 return NULL;
9039
9040 for (i = 0; i < nrecords; i++) {
9041 if (!(py_record = PyTuple_New(2)))
9042 goto error;
9043
9044 VIR_PY_LIST_SET_GOTO(py_retval, i, py_record, error);
9045
9046 dom = records[i]->dom;
9047 virDomainRef(dom);
9048 VIR_PY_TUPLE_SET_GOTO(py_record, 0,
9049 libvirt_virDomainPtrWrap(dom),
9050 error);
9051 dom = NULL;
9052
9053 if (!(py_record_stats = getPyVirTypedParameter(records[i]->params,
9054 records[i]->nparams)))
9055 goto error;
9056 VIR_PY_TUPLE_SET_GOTO(py_record, 1, py_record_stats, error);
9057
9058 }
9059
9060 return py_retval;
9061
9062 error:
9063 if (dom)
9064 virDomainFree(dom);
9065 Py_XDECREF(py_retval);
9066 return NULL;
9067 }
9068
9069
9070 static PyObject *
9071 libvirt_virConnectGetAllDomainStats(PyObject *self ATTRIBUTE_UNUSED,
9072 PyObject *args)
9073 {
9074 PyObject *pyobj_conn;
9075 PyObject *py_retval;
9076 virConnectPtr conn;
9077 virDomainStatsRecordPtr *records;
9078 int nrecords;
9079 unsigned int flags;
9080 unsigned int stats;
9081
9082 if (!PyArg_ParseTuple(args, (char *)"OII:virConnectGetAllDomainStats",
9083 &pyobj_conn, &stats, &flags))
9084 return NULL;
9085 conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
9086
9087 LIBVIRT_BEGIN_ALLOW_THREADS;
9088 nrecords = virConnectGetAllDomainStats(conn, stats, &records, flags);
9089 LIBVIRT_END_ALLOW_THREADS;
9090
9091 if (nrecords < 0)
9092 return VIR_PY_NONE;
9093
9094 py_retval = convertDomainStatsRecord(records, nrecords);
9095
9096 virDomainStatsRecordListFree(records);
9097
9098 return py_retval;
9099 }
9100
9101
9102 static PyObject *
9103 libvirt_virDomainListGetStats(PyObject *self ATTRIBUTE_UNUSED,
9104 PyObject *args)
9105 {
9106 PyObject *pyobj_conn;
9107 PyObject *py_retval;
9108 PyObject *py_domlist;
9109 virDomainStatsRecordPtr *records = NULL;
9110 virDomainPtr *doms = NULL;
9111 int nrecords;
9112 int ndoms;
9113 ssize_t i;
9114 unsigned int flags;
9115 unsigned int stats;
9116
9117 if (!PyArg_ParseTuple(args, (char *)"OOII:virDomainListGetStats",
9118 &pyobj_conn, &py_domlist, &stats, &flags))
9119 return NULL;
9120
9121 if (PyList_Check(py_domlist)) {
9122 ndoms = PyList_Size(py_domlist);
9123
9124 if (VIR_ALLOC_N(doms, ndoms + 1) < 0)
9125 return PyErr_NoMemory();
9126
9127 for (i = 0; i < ndoms; i++)
9128 doms[i] = PyvirDomain_Get(PyList_GetItem(py_domlist, i));
9129 }
9130
9131 LIBVIRT_BEGIN_ALLOW_THREADS;
9132 nrecords = virDomainListGetStats(doms, stats, &records, flags);
9133 LIBVIRT_END_ALLOW_THREADS;
9134
9135 if (nrecords < 0) {
9136 py_retval = VIR_PY_NONE;
9137 goto cleanup;
9138 }
9139
9140 py_retval = convertDomainStatsRecord(records, nrecords);
9141
9142 cleanup:
9143 virDomainStatsRecordListFree(records);
9144 VIR_FREE(doms);
9145
9146 return py_retval;
9147 }
9148
9149
9150 static virPyTypedParamsHint virPyDomainBlockCopyParams[] = {
9151 { VIR_DOMAIN_BLOCK_COPY_BANDWIDTH, VIR_TYPED_PARAM_ULLONG },
9152 { VIR_DOMAIN_BLOCK_COPY_GRANULARITY, VIR_TYPED_PARAM_UINT },
9153 { VIR_DOMAIN_BLOCK_COPY_BUF_SIZE, VIR_TYPED_PARAM_ULLONG },
9154 };
9155
9156
9157 static PyObject *
9158 libvirt_virDomainBlockCopy(PyObject *self ATTRIBUTE_UNUSED,
9159 PyObject *args)
9160 {
9161 PyObject *pyobj_dom = NULL;
9162 PyObject *pyobj_dict = NULL;
9163
9164 virDomainPtr dom;
9165 char *disk = NULL;
9166 char *destxml = NULL;
9167 virTypedParameterPtr params = NULL;
9168 int nparams = 0;
9169 unsigned int flags = 0;
9170 int c_retval;
9171
9172 if (!PyArg_ParseTuple(args, (char *) "Ozz|OI:virDomainBlockCopy",
9173 &pyobj_dom, &disk, &destxml, &pyobj_dict, &flags))
9174 return NULL;
9175
9176 if (PyDict_Check(pyobj_dict)) {
9177 if (virPyDictToTypedParams(pyobj_dict, &params, &nparams,
9178 virPyDomainBlockCopyParams,
9179 VIR_N_ELEMENTS(virPyDomainBlockCopyParams)) < 0) {
9180 return NULL;
9181 }
9182 } else if (pyobj_dict != Py_None) {
9183 PyErr_Format(PyExc_TypeError, "block params must be a dictionary");
9184 return NULL;
9185 }
9186
9187 dom = (virDomainPtr) PyvirDomain_Get(pyobj_dom);
9188
9189 LIBVIRT_BEGIN_ALLOW_THREADS;
9190 c_retval = virDomainBlockCopy(dom, disk, destxml, params, nparams, flags);
9191 LIBVIRT_END_ALLOW_THREADS;
9192
9193 virTypedParamsFree(params, nparams);
9194 return libvirt_intWrap(c_retval);
9195 }
9196
9197 #endif /* LIBVIR_CHECK_VERSION(1, 2, 8) */
9198
9199 #if LIBVIR_CHECK_VERSION(1, 2, 9)
9200 static PyObject *
9201 libvirt_virNodeAllocPages(PyObject *self ATTRIBUTE_UNUSED,
9202 PyObject *args)
9203 {
9204 PyObject *pyobj_conn;
9205 PyObject *pyobj_pages;
9206 Py_ssize_t size = 0;
9207 Py_ssize_t pos = 0;
9208 PyObject *key, *value;
9209 virConnectPtr conn;
9210 unsigned int npages = 0;
9211 unsigned int *pageSizes = NULL;
9212 unsigned long long *pageCounts = NULL;
9213 int startCell = -1;
9214 unsigned int cellCount = 1;
9215 unsigned int flags = VIR_NODE_ALLOC_PAGES_ADD;
9216 int c_retval;
9217
9218 if (!PyArg_ParseTuple(args, (char *)"OOiII:virNodeAllocPages",
9219 &pyobj_conn, &pyobj_pages,
9220 &startCell, &cellCount, &flags))
9221 return NULL;
9222 conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
9223
9224 if ((size = PyDict_Size(pyobj_pages)) < 0)
9225 return NULL;
9226
9227 if (size == 0) {
9228 PyErr_Format(PyExc_LookupError,
9229 "Need non-empty dictionary to pages attribute");
9230 return NULL;
9231 }
9232
9233 if (VIR_ALLOC_N(pageSizes, size) < 0 ||
9234 VIR_ALLOC_N(pageCounts, size) < 0) {
9235 PyErr_NoMemory();
9236 goto error;
9237 }
9238
9239 while (PyDict_Next(pyobj_pages, &pos, &key, &value)) {
9240 if (libvirt_uintUnwrap(key, &pageSizes[npages]) < 0 ||
9241 libvirt_ulonglongUnwrap(value, &pageCounts[npages]) < 0)
9242 goto error;
9243 npages++;
9244 }
9245
9246 LIBVIRT_BEGIN_ALLOW_THREADS;
9247 c_retval = virNodeAllocPages(conn, npages, pageSizes,
9248 pageCounts, startCell, cellCount, flags);
9249 LIBVIRT_END_ALLOW_THREADS;
9250
9251 VIR_FREE(pageSizes);
9252 VIR_FREE(pageCounts);
9253
9254 return libvirt_intWrap(c_retval);
9255
9256 error:
9257 VIR_FREE(pageSizes);
9258 VIR_FREE(pageCounts);
9259 return NULL;
9260 }
9261 #endif /* LIBVIR_CHECK_VERSION(1, 2, 8) */
9262
9263 #if LIBVIR_CHECK_VERSION(1, 2, 11)
9264
9265 static PyObject *
9266 libvirt_virDomainGetFSInfo(PyObject *self ATTRIBUTE_UNUSED,
9267 PyObject *args)
9268 {
9269 virDomainPtr domain;
9270 PyObject *pyobj_domain;
9271 unsigned int flags;
9272 virDomainFSInfoPtr *fsinfo = NULL;
9273 int c_retval, i;
9274 size_t j;
9275 PyObject *py_retval = NULL;
9276
9277 if (!PyArg_ParseTuple(args, (char *)"OI:virDomainGetFSInfo",
9278 &pyobj_domain, &flags))
9279 return NULL;
9280 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
9281
9282 LIBVIRT_BEGIN_ALLOW_THREADS;
9283 c_retval = virDomainGetFSInfo(domain, &fsinfo, flags);
9284 LIBVIRT_END_ALLOW_THREADS;
9285
9286 if (c_retval < 0) {
9287 py_retval = VIR_PY_NONE;
9288 goto cleanup;
9289 }
9290
9291 /* convert to a Python list */
9292 if ((py_retval = PyList_New(c_retval)) == NULL)
9293 goto error;
9294
9295 for (i = 0; i < c_retval; i++) {
9296 virDomainFSInfoPtr fs = fsinfo[i];
9297 PyObject *info, *alias;
9298
9299 if (fs == NULL)
9300 goto error;
9301
9302 info = PyTuple_New(4);
9303 if (info == NULL)
9304 goto error;
9305
9306 VIR_PY_LIST_SET_GOTO(py_retval, i, info, error);
9307
9308 VIR_PY_TUPLE_SET_GOTO(info, 0,
9309 libvirt_constcharPtrWrap(fs->mountpoint), error);
9310 VIR_PY_TUPLE_SET_GOTO(info, 1,
9311 libvirt_constcharPtrWrap(fs->name), error);
9312 VIR_PY_TUPLE_SET_GOTO(info, 2,
9313 libvirt_constcharPtrWrap(fs->fstype), error);
9314
9315 alias = PyList_New(0);
9316 if (alias == NULL)
9317 goto error;
9318 VIR_PY_TUPLE_SET_GOTO(info, 3, alias, error);
9319
9320 for (j = 0; j < fs->ndevAlias; j++)
9321 VIR_PY_LIST_APPEND_GOTO(alias,
9322 libvirt_constcharPtrWrap(fs->devAlias[j]),
9323 error);
9324 }
9325
9326 cleanup:
9327 if (c_retval > 0)
9328 for (i = 0; i < c_retval; i++)
9329 virDomainFSInfoFree(fsinfo[i]);
9330 VIR_FREE(fsinfo);
9331 return py_retval;
9332
9333 error:
9334 Py_CLEAR(py_retval);
9335 goto cleanup;
9336 }
9337
9338 #endif /* LIBVIR_CHECK_VERSION(1, 2, 11) */
9339
9340 #if LIBVIR_CHECK_VERSION(1, 3, 3)
9341 static PyObject *
9342 libvirt_virDomainGetPerfEvents(PyObject *self ATTRIBUTE_UNUSED,
9343 PyObject *args)
9344 {
9345 PyObject *pyobj_domain;
9346 virDomainPtr domain;
9347 virTypedParameterPtr params = NULL;
9348 int nparams = 0;
9349 PyObject *dict = NULL;
9350 unsigned int flags;
9351 int rc;
9352
9353 if (!PyArg_ParseTuple(args, (char *) "OI:virDomainGetPerfEvents",
9354 &pyobj_domain, &flags))
9355 return NULL;
9356 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
9357
9358 LIBVIRT_BEGIN_ALLOW_THREADS;
9359 rc = virDomainGetPerfEvents(domain, &params, &nparams, flags);
9360 LIBVIRT_END_ALLOW_THREADS;
9361
9362 if (rc < 0)
9363 return VIR_PY_NONE;
9364
9365 if (!(dict = getPyVirTypedParameter(params, nparams)))
9366 goto cleanup;
9367
9368 cleanup:
9369 virTypedParamsFree(params, nparams);
9370 return dict;
9371 }
9372
9373 static PyObject *
9374 libvirt_virDomainSetPerfEvents(PyObject *self ATTRIBUTE_UNUSED,
9375 PyObject *args)
9376 {
9377 virDomainPtr domain;
9378 PyObject *pyobj_domain, *info;
9379 PyObject *ret = NULL;
9380 int i_retval;
9381 int nparams = 0;
9382 Py_ssize_t size = 0;
9383 unsigned int flags;
9384 virTypedParameterPtr params = NULL, new_params = NULL;
9385
9386 if (!PyArg_ParseTuple(args,
9387 (char *)"OOI:virDomainSetPerfEvents",
9388 &pyobj_domain, &info, &flags))
9389 return NULL;
9390 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
9391
9392 if ((size = PyDict_Size(info)) < 0)
9393 return NULL;
9394
9395 if (size == 0) {
9396 PyErr_Format(PyExc_LookupError,
9397 "Need non-empty dictionary to set attributes");
9398 return NULL;
9399 }
9400
9401 LIBVIRT_BEGIN_ALLOW_THREADS;
9402 i_retval = virDomainGetPerfEvents(domain, &params, &nparams, flags);
9403 LIBVIRT_END_ALLOW_THREADS;
9404
9405 if (i_retval < 0)
9406 return VIR_PY_INT_FAIL;
9407
9408 if (nparams == 0) {
9409 PyErr_Format(PyExc_LookupError,
9410 "Domain has no settable attributes");
9411 return NULL;
9412 }
9413
9414 new_params = setPyVirTypedParameter(info, params, nparams);
9415 if (!new_params)
9416 goto cleanup;
9417
9418 LIBVIRT_BEGIN_ALLOW_THREADS;
9419 i_retval = virDomainSetPerfEvents(domain, new_params, size, flags);
9420 LIBVIRT_END_ALLOW_THREADS;
9421
9422 if (i_retval < 0) {
9423 ret = VIR_PY_INT_FAIL;
9424 goto cleanup;
9425 }
9426
9427 ret = VIR_PY_INT_SUCCESS;
9428
9429 cleanup:
9430 virTypedParamsFree(params, nparams);
9431 virTypedParamsFree(new_params, size);
9432 return ret;
9433 }
9434 #endif /* LIBVIR_CHECK_VERSION(1, 3, 3) */
9435
9436 #if LIBVIR_CHECK_VERSION(2, 0, 0)
9437 static void
9438 libvirt_virConnectStoragePoolEventFreeFunc(void *opaque)
9439 {
9440 PyObject *pyobj_conn = (PyObject*)opaque;
9441 LIBVIRT_ENSURE_THREAD_STATE;
9442 Py_DECREF(pyobj_conn);
9443 LIBVIRT_RELEASE_THREAD_STATE;
9444 }
9445
9446 static int
9447 libvirt_virConnectStoragePoolEventLifecycleCallback(virConnectPtr conn ATTRIBUTE_UNUSED,
9448 virStoragePoolPtr pool,
9449 int event,
9450 int detail,
9451 void *opaque)
9452 {
9453 PyObject *pyobj_cbData = (PyObject*)opaque;
9454 PyObject *pyobj_pool;
9455 PyObject *pyobj_ret = NULL;
9456 PyObject *pyobj_conn;
9457 PyObject *dictKey;
9458 int ret = -1;
9459
9460 LIBVIRT_ENSURE_THREAD_STATE;
9461
9462 if (!(dictKey = libvirt_constcharPtrWrap("conn")))
9463 goto cleanup;
9464 pyobj_conn = PyDict_GetItem(pyobj_cbData, dictKey);
9465 Py_DECREF(dictKey);
9466
9467 /* Create a python instance of this virStoragePoolPtr */
9468 virStoragePoolRef(pool);
9469 if (!(pyobj_pool = libvirt_virStoragePoolPtrWrap(pool))) {
9470 virStoragePoolFree(pool);
9471 goto cleanup;
9472 }
9473 Py_INCREF(pyobj_cbData);
9474
9475 /* Call the Callback Dispatcher */
9476 pyobj_ret = PyObject_CallMethod(pyobj_conn,
9477 (char*)"_dispatchStoragePoolEventLifecycleCallback",
9478 (char*)"OiiO",
9479 pyobj_pool,
9480 event,
9481 detail,
9482 pyobj_cbData);
9483
9484 Py_DECREF(pyobj_cbData);
9485 Py_DECREF(pyobj_pool);
9486
9487 cleanup:
9488 if (!pyobj_ret) {
9489 DEBUG("%s - ret:%p\n", __FUNCTION__, pyobj_ret);
9490 PyErr_Print();
9491 } else {
9492 Py_DECREF(pyobj_ret);
9493 ret = 0;
9494 }
9495
9496 LIBVIRT_RELEASE_THREAD_STATE;
9497 return ret;
9498 }
9499
9500 static int
9501 libvirt_virConnectStoragePoolEventGenericCallback(virConnectPtr conn ATTRIBUTE_UNUSED,
9502 virStoragePoolPtr pool,
9503 void *opaque)
9504 {
9505 PyObject *pyobj_cbData = (PyObject*)opaque;
9506 PyObject *pyobj_pool;
9507 PyObject *pyobj_ret = NULL;
9508 PyObject *pyobj_conn;
9509 PyObject *dictKey;
9510 int ret = -1;
9511
9512 LIBVIRT_ENSURE_THREAD_STATE;
9513
9514 if (!(dictKey = libvirt_constcharPtrWrap("conn")))
9515 goto cleanup;
9516 pyobj_conn = PyDict_GetItem(pyobj_cbData, dictKey);
9517 Py_DECREF(dictKey);
9518
9519 /* Create a python instance of this virStoragePoolPtr */
9520 virStoragePoolRef(pool);
9521 if (!(pyobj_pool = libvirt_virStoragePoolPtrWrap(pool))) {
9522 virStoragePoolFree(pool);
9523 goto cleanup;
9524 }
9525 Py_INCREF(pyobj_cbData);
9526
9527 /* Call the Callback Dispatcher */
9528 pyobj_ret = PyObject_CallMethod(pyobj_conn,
9529 (char*)"_dispatchStoragePoolEventGenericCallback",
9530 (char*)"OO",
9531 pyobj_pool,
9532 pyobj_cbData);
9533
9534 Py_DECREF(pyobj_cbData);
9535 Py_DECREF(pyobj_pool);
9536
9537 cleanup:
9538 if (!pyobj_ret) {
9539 DEBUG("%s - ret:%p\n", __FUNCTION__, pyobj_ret);
9540 PyErr_Print();
9541 } else {
9542 Py_DECREF(pyobj_ret);
9543 ret = 0;
9544 }
9545
9546 LIBVIRT_RELEASE_THREAD_STATE;
9547 return ret;
9548 }
9549
9550 static PyObject *
9551 libvirt_virConnectStoragePoolEventRegisterAny(PyObject *self ATTRIBUTE_UNUSED,
9552 PyObject *args)
9553 {
9554 PyObject *pyobj_conn; /* virConnectPtr */
9555 PyObject *pyobj_pool;
9556 PyObject *pyobj_cbData; /* hash of callback data */
9557 int eventID;
9558 virConnectPtr conn;
9559 int ret = 0;
9560 virConnectStoragePoolEventGenericCallback cb = NULL;
9561 virStoragePoolPtr pool;
9562
9563 if (!PyArg_ParseTuple(args,
9564 (char *) "OOiO:virConnectStoragePoolEventRegisterAny",
9565 &pyobj_conn, &pyobj_pool, &eventID, &pyobj_cbData))
9566 return NULL;
9567
9568 DEBUG("libvirt_virConnectStoragePoolEventRegister(%p %p %d %p) called\n",
9569 pyobj_conn, pyobj_pool, eventID, pyobj_cbData);
9570 conn = PyvirConnect_Get(pyobj_conn);
9571 if (pyobj_pool == Py_None)
9572 pool = NULL;
9573 else
9574 pool = PyvirStoragePool_Get(pyobj_pool);
9575
9576 switch ((virStoragePoolEventID) eventID) {
9577 case VIR_STORAGE_POOL_EVENT_ID_LIFECYCLE:
9578 cb = VIR_STORAGE_POOL_EVENT_CALLBACK(libvirt_virConnectStoragePoolEventLifecycleCallback);
9579 break;
9580
9581 case VIR_STORAGE_POOL_EVENT_ID_REFRESH:
9582 cb = VIR_STORAGE_POOL_EVENT_CALLBACK(libvirt_virConnectStoragePoolEventGenericCallback);
9583 break;
9584
9585 case VIR_STORAGE_POOL_EVENT_ID_LAST:
9586 break;
9587 }
9588
9589 if (!cb) {
9590 return VIR_PY_INT_FAIL;
9591 }
9592
9593 Py_INCREF(pyobj_cbData);
9594
9595 LIBVIRT_BEGIN_ALLOW_THREADS;
9596 ret = virConnectStoragePoolEventRegisterAny(conn,
9597 pool,
9598 eventID,
9599 cb,
9600 pyobj_cbData,
9601 libvirt_virConnectStoragePoolEventFreeFunc);
9602 LIBVIRT_END_ALLOW_THREADS;
9603
9604 if (ret < 0) {
9605 Py_DECREF(pyobj_cbData);
9606 }
9607
9608 return libvirt_intWrap(ret);
9609 }
9610
9611 static PyObject *
9612 libvirt_virConnectStoragePoolEventDeregisterAny(PyObject *self ATTRIBUTE_UNUSED,
9613 PyObject *args)
9614 {
9615 PyObject *pyobj_conn;
9616 int callbackID;
9617 virConnectPtr conn;
9618 int ret = 0;
9619
9620 if (!PyArg_ParseTuple(args, (char *) "Oi:virConnectStoragePoolEventDeregisterAny",
9621 &pyobj_conn, &callbackID))
9622 return NULL;
9623
9624 DEBUG("libvirt_virConnectStoragePoolEventDeregister(%p) called\n",
9625 pyobj_conn);
9626
9627 conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
9628
9629 LIBVIRT_BEGIN_ALLOW_THREADS;
9630 ret = virConnectStoragePoolEventDeregisterAny(conn, callbackID);
9631 LIBVIRT_END_ALLOW_THREADS;
9632
9633 return libvirt_intWrap(ret);
9634 }
9635
9636 static PyObject *
9637 libvirt_virDomainGetGuestVcpus(PyObject *self ATTRIBUTE_UNUSED,
9638 PyObject *args)
9639 {
9640 PyObject *pyobj_domain;
9641 virDomainPtr domain;
9642 virTypedParameterPtr params = NULL;
9643 unsigned int nparams = 0;
9644 unsigned int flags;
9645 int i_retval;
9646 PyObject *ret = NULL;
9647
9648 if (!PyArg_ParseTuple(args, (char *)"OI:virDomainGetGuestVcpus",
9649 &pyobj_domain, &flags))
9650 return NULL;
9651 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
9652
9653 LIBVIRT_BEGIN_ALLOW_THREADS;
9654 i_retval = virDomainGetGuestVcpus(domain, &params, &nparams, flags);
9655 LIBVIRT_END_ALLOW_THREADS;
9656
9657 if (i_retval < 0) {
9658 ret = VIR_PY_NONE;
9659 goto cleanup;
9660 }
9661
9662 ret = getPyVirTypedParameter(params, nparams);
9663 cleanup:
9664 virTypedParamsFree(params, nparams);
9665 return ret;
9666 }
9667 #endif /* LIBVIR_CHECK_VERSION(2, 0, 0)*/
9668
9669 #if LIBVIR_CHECK_VERSION(2, 2, 0)
9670 static void
9671 libvirt_virConnectNodeDeviceEventFreeFunc(void *opaque)
9672 {
9673 PyObject *pyobj_conn = (PyObject*)opaque;
9674 LIBVIRT_ENSURE_THREAD_STATE;
9675 Py_DECREF(pyobj_conn);
9676 LIBVIRT_RELEASE_THREAD_STATE;
9677 }
9678
9679 static int
9680 libvirt_virConnectNodeDeviceEventLifecycleCallback(virConnectPtr conn ATTRIBUTE_UNUSED,
9681 virNodeDevicePtr dev,
9682 int event,
9683 int detail,
9684 void *opaque)
9685 {
9686 PyObject *pyobj_cbData = (PyObject*)opaque;
9687 PyObject *pyobj_dev;
9688 PyObject *pyobj_ret = NULL;
9689 PyObject *pyobj_conn;
9690 PyObject *dictKey;
9691 int ret = -1;
9692
9693 LIBVIRT_ENSURE_THREAD_STATE;
9694
9695 if (!(dictKey = libvirt_constcharPtrWrap("conn")))
9696 goto cleanup;
9697 pyobj_conn = PyDict_GetItem(pyobj_cbData, dictKey);
9698 Py_DECREF(dictKey);
9699
9700 /* Create a python instance of this virNodeDevicePtr */
9701 virNodeDeviceRef(dev);
9702 if (!(pyobj_dev = libvirt_virNodeDevicePtrWrap(dev))) {
9703 virNodeDeviceFree(dev);
9704 goto cleanup;
9705 }
9706 Py_INCREF(pyobj_cbData);
9707
9708 /* Call the Callback Dispatcher */
9709 pyobj_ret = PyObject_CallMethod(pyobj_conn,
9710 (char*)"_dispatchNodeDeviceEventLifecycleCallback",
9711 (char*)"OiiO",
9712 pyobj_dev,
9713 event,
9714 detail,
9715 pyobj_cbData);
9716
9717 Py_DECREF(pyobj_cbData);
9718 Py_DECREF(pyobj_dev);
9719
9720 cleanup:
9721 if (!pyobj_ret) {
9722 DEBUG("%s - ret:%p\n", __FUNCTION__, pyobj_ret);
9723 PyErr_Print();
9724 } else {
9725 Py_DECREF(pyobj_ret);
9726 ret = 0;
9727 }
9728
9729 LIBVIRT_RELEASE_THREAD_STATE;
9730 return ret;
9731 }
9732
9733 static int
9734 libvirt_virConnectNodeDeviceEventGenericCallback(virConnectPtr conn ATTRIBUTE_UNUSED,
9735 virNodeDevicePtr dev,
9736 void *opaque)
9737 {
9738 PyObject *pyobj_cbData = (PyObject*)opaque;
9739 PyObject *pyobj_dev;
9740 PyObject *pyobj_ret = NULL;
9741 PyObject *pyobj_conn;
9742 PyObject *dictKey;
9743 int ret = -1;
9744
9745 LIBVIRT_ENSURE_THREAD_STATE;
9746
9747 if (!(dictKey = libvirt_constcharPtrWrap("conn")))
9748 goto cleanup;
9749 pyobj_conn = PyDict_GetItem(pyobj_cbData, dictKey);
9750 Py_DECREF(dictKey);
9751
9752 /* Create a python instance of this virNodeDevicePtr */
9753 virNodeDeviceRef(dev);
9754 if (!(pyobj_dev = libvirt_virNodeDevicePtrWrap(dev))) {
9755 virNodeDeviceFree(dev);
9756 goto cleanup;
9757 }
9758 Py_INCREF(pyobj_cbData);
9759
9760 /* Call the Callback Dispatcher */
9761 pyobj_ret = PyObject_CallMethod(pyobj_conn,
9762 (char*)"_dispatchNodeDeviceEventGenericCallback",
9763 (char*)"OO",
9764 pyobj_dev,
9765 pyobj_cbData);
9766
9767 Py_DECREF(pyobj_cbData);
9768 Py_DECREF(pyobj_dev);
9769
9770 cleanup:
9771 if (!pyobj_ret) {
9772 DEBUG("%s - ret:%p\n", __FUNCTION__, pyobj_ret);
9773 PyErr_Print();
9774 } else {
9775 Py_DECREF(pyobj_ret);
9776 ret = 0;
9777 }
9778
9779 LIBVIRT_RELEASE_THREAD_STATE;
9780 return ret;
9781 }
9782
9783 static PyObject *
9784 libvirt_virConnectNodeDeviceEventRegisterAny(PyObject *self ATTRIBUTE_UNUSED,
9785 PyObject *args)
9786 {
9787 PyObject *pyobj_conn; /* virConnectPtr */
9788 PyObject *pyobj_dev;
9789 PyObject *pyobj_cbData; /* hash of callback data */
9790 int eventID;
9791 virConnectPtr conn;
9792 int ret = 0;
9793 virConnectNodeDeviceEventGenericCallback cb = NULL;
9794 virNodeDevicePtr dev;
9795
9796 if (!PyArg_ParseTuple(args,
9797 (char *) "OOiO:virConnectNodeDeviceEventRegisterAny",
9798 &pyobj_conn, &pyobj_dev, &eventID, &pyobj_cbData))
9799 return NULL;
9800
9801 DEBUG("libvirt_virConnectNodeDeviceEventRegister(%p %p %d %p) called\n",
9802 pyobj_conn, pyobj_dev, eventID, pyobj_cbData);
9803 conn = PyvirConnect_Get(pyobj_conn);
9804 if (pyobj_dev == Py_None)
9805 dev = NULL;
9806 else
9807 dev = PyvirNodeDevice_Get(pyobj_dev);
9808
9809 switch ((virNodeDeviceEventID) eventID) {
9810 case VIR_NODE_DEVICE_EVENT_ID_LIFECYCLE:
9811 cb = VIR_NODE_DEVICE_EVENT_CALLBACK(libvirt_virConnectNodeDeviceEventLifecycleCallback);
9812 break;
9813
9814 case VIR_NODE_DEVICE_EVENT_ID_UPDATE:
9815 cb = VIR_NODE_DEVICE_EVENT_CALLBACK(libvirt_virConnectNodeDeviceEventGenericCallback);
9816 break;
9817
9818 case VIR_NODE_DEVICE_EVENT_ID_LAST:
9819 break;
9820 }
9821
9822 if (!cb) {
9823 return VIR_PY_INT_FAIL;
9824 }
9825
9826 Py_INCREF(pyobj_cbData);
9827
9828 LIBVIRT_BEGIN_ALLOW_THREADS;
9829 ret = virConnectNodeDeviceEventRegisterAny(conn,
9830 dev,
9831 eventID,
9832 cb,
9833 pyobj_cbData,
9834 libvirt_virConnectNodeDeviceEventFreeFunc);
9835 LIBVIRT_END_ALLOW_THREADS;
9836
9837 if (ret < 0) {
9838 Py_DECREF(pyobj_cbData);
9839 }
9840
9841 return libvirt_intWrap(ret);
9842 }
9843
9844 static PyObject *
9845 libvirt_virConnectNodeDeviceEventDeregisterAny(PyObject *self ATTRIBUTE_UNUSED,
9846 PyObject *args)
9847 {
9848 PyObject *pyobj_conn;
9849 int callbackID;
9850 virConnectPtr conn;
9851 int ret = 0;
9852
9853 if (!PyArg_ParseTuple(args, (char *) "Oi:virConnectNodeDeviceEventDeregister",
9854 &pyobj_conn, &callbackID))
9855 return NULL;
9856
9857 DEBUG("libvirt_virConnectNodeDeviceEventDeregister(%p) called\n",
9858 pyobj_conn);
9859
9860 conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
9861
9862 LIBVIRT_BEGIN_ALLOW_THREADS;
9863 ret = virConnectNodeDeviceEventDeregisterAny(conn, callbackID);
9864 LIBVIRT_END_ALLOW_THREADS;
9865
9866 return libvirt_intWrap(ret);
9867 }
9868
9869 #endif /* LIBVIR_CHECK_VERSION(2, 2, 0)*/
9870
9871 #if LIBVIR_CHECK_VERSION(3, 0, 0)
9872 static void
9873 libvirt_virConnectSecretEventFreeFunc(void *opaque)
9874 {
9875 PyObject *pyobj_conn = (PyObject*)opaque;
9876 LIBVIRT_ENSURE_THREAD_STATE;
9877 Py_DECREF(pyobj_conn);
9878 LIBVIRT_RELEASE_THREAD_STATE;
9879 }
9880
9881 static int
9882 libvirt_virConnectSecretEventLifecycleCallback(virConnectPtr conn ATTRIBUTE_UNUSED,
9883 virSecretPtr secret,
9884 int event,
9885 int detail,
9886 void *opaque)
9887 {
9888 PyObject *pyobj_cbData = (PyObject*)opaque;
9889 PyObject *pyobj_secret;
9890 PyObject *pyobj_ret = NULL;
9891 PyObject *pyobj_conn;
9892 PyObject *dictKey;
9893 int ret = -1;
9894
9895 LIBVIRT_ENSURE_THREAD_STATE;
9896
9897 if (!(dictKey = libvirt_constcharPtrWrap("conn")))
9898 goto cleanup;
9899 pyobj_conn = PyDict_GetItem(pyobj_cbData, dictKey);
9900 Py_DECREF(dictKey);
9901
9902 /* Create a python instance of this virSecretPtr */
9903 virSecretRef(secret);
9904 if (!(pyobj_secret = libvirt_virSecretPtrWrap(secret))) {
9905 virSecretFree(secret);
9906 goto cleanup;
9907 }
9908 Py_INCREF(pyobj_cbData);
9909
9910 /* Call the Callback Dispatcher */
9911 pyobj_ret = PyObject_CallMethod(pyobj_conn,
9912 (char*)"_dispatchSecretEventLifecycleCallback",
9913 (char*)"OiiO",
9914 pyobj_secret,
9915 event,
9916 detail,
9917 pyobj_cbData);
9918
9919 Py_DECREF(pyobj_cbData);
9920 Py_DECREF(pyobj_secret);
9921
9922 cleanup:
9923 if (!pyobj_ret) {
9924 DEBUG("%s - ret:%p\n", __FUNCTION__, pyobj_ret);
9925 PyErr_Print();
9926 } else {
9927 Py_DECREF(pyobj_ret);
9928 ret = 0;
9929 }
9930
9931 LIBVIRT_RELEASE_THREAD_STATE;
9932 return ret;
9933 }
9934
9935 static int
9936 libvirt_virConnectSecretEventGenericCallback(virConnectPtr conn ATTRIBUTE_UNUSED,
9937 virSecretPtr secret,
9938 void *opaque)
9939 {
9940 PyObject *pyobj_cbData = (PyObject*)opaque;
9941 PyObject *pyobj_secret;
9942 PyObject *pyobj_ret = NULL;
9943 PyObject *pyobj_conn;
9944 PyObject *dictKey;
9945 int ret = -1;
9946
9947 LIBVIRT_ENSURE_THREAD_STATE;
9948
9949 if (!(dictKey = libvirt_constcharPtrWrap("conn")))
9950 goto cleanup;
9951 pyobj_conn = PyDict_GetItem(pyobj_cbData, dictKey);
9952 Py_DECREF(dictKey);
9953
9954 /* Create a python instance of this virSecretPtr */
9955 virSecretRef(secret);
9956 if (!(pyobj_secret = libvirt_virSecretPtrWrap(secret))) {
9957 virSecretFree(secret);
9958 goto cleanup;
9959 }
9960 Py_INCREF(pyobj_cbData);
9961
9962 /* Call the Callback Dispatcher */
9963 pyobj_ret = PyObject_CallMethod(pyobj_conn,
9964 (char*)"_dispatchSecretEventGenericCallback",
9965 (char*)"OO",
9966 pyobj_secret,
9967 pyobj_cbData);
9968
9969 Py_DECREF(pyobj_cbData);
9970 Py_DECREF(pyobj_secret);
9971
9972 cleanup:
9973 if (!pyobj_ret) {
9974 DEBUG("%s - ret:%p\n", __FUNCTION__, pyobj_ret);
9975 PyErr_Print();
9976 } else {
9977 Py_DECREF(pyobj_ret);
9978 ret = 0;
9979 }
9980
9981 LIBVIRT_RELEASE_THREAD_STATE;
9982 return ret;
9983 }
9984
9985 static PyObject *
9986 libvirt_virConnectSecretEventRegisterAny(PyObject *self ATTRIBUTE_UNUSED,
9987 PyObject *args)
9988 {
9989 PyObject *pyobj_conn; /* virConnectPtr */
9990 PyObject *pyobj_secret;
9991 PyObject *pyobj_cbData; /* hash of callback data */
9992 int eventID;
9993 virConnectPtr conn;
9994 int ret = 0;
9995 virConnectSecretEventGenericCallback cb = NULL;
9996 virSecretPtr secret;
9997
9998 if (!PyArg_ParseTuple(args,
9999 (char *) "OOiO:virConnectSecretEventRegisterAny",
10000 &pyobj_conn, &pyobj_secret, &eventID, &pyobj_cbData))
10001 return NULL;
10002
10003 DEBUG("libvirt_virConnectSecretEventRegister(%p %p %d %p) called\n",
10004 pyobj_conn, pyobj_secret, eventID, pyobj_cbData);
10005 conn = PyvirConnect_Get(pyobj_conn);
10006 if (pyobj_secret == Py_None)
10007 secret = NULL;
10008 else
10009 secret = PyvirSecret_Get(pyobj_secret);
10010
10011 switch ((virSecretEventID) eventID) {
10012 case VIR_SECRET_EVENT_ID_LIFECYCLE:
10013 cb = VIR_SECRET_EVENT_CALLBACK(libvirt_virConnectSecretEventLifecycleCallback);
10014 break;
10015
10016 case VIR_SECRET_EVENT_ID_VALUE_CHANGED:
10017 cb = VIR_SECRET_EVENT_CALLBACK(libvirt_virConnectSecretEventGenericCallback);
10018 break;
10019
10020 case VIR_SECRET_EVENT_ID_LAST:
10021 break;
10022 }
10023
10024 if (!cb) {
10025 return VIR_PY_INT_FAIL;
10026 }
10027
10028 Py_INCREF(pyobj_cbData);
10029
10030 LIBVIRT_BEGIN_ALLOW_THREADS;
10031 ret = virConnectSecretEventRegisterAny(conn, secret, eventID,
10032 cb, pyobj_cbData,
10033 libvirt_virConnectSecretEventFreeFunc);
10034 LIBVIRT_END_ALLOW_THREADS;
10035
10036 if (ret < 0) {
10037 Py_DECREF(pyobj_cbData);
10038 }
10039
10040 return libvirt_intWrap(ret);
10041 }
10042
10043 static PyObject *
10044 libvirt_virConnectSecretEventDeregisterAny(PyObject *self ATTRIBUTE_UNUSED,
10045 PyObject *args)
10046 {
10047 PyObject *pyobj_conn;
10048 int callbackID;
10049 virConnectPtr conn;
10050 int ret = 0;
10051
10052 if (!PyArg_ParseTuple(args, (char *) "Oi:virConnectSecretEventDeregister",
10053 &pyobj_conn, &callbackID))
10054 return NULL;
10055
10056 DEBUG("libvirt_virConnectSecretEventDeregister(%p) called\n", pyobj_conn);
10057
10058 conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
10059
10060 LIBVIRT_BEGIN_ALLOW_THREADS;
10061 ret = virConnectSecretEventDeregisterAny(conn, callbackID);
10062 LIBVIRT_END_ALLOW_THREADS;
10063
10064 return libvirt_intWrap(ret);
10065 }
10066 #endif /* LIBVIR_CHECK_VERSION(3, 0, 0)*/
10067
10068
10069 #if LIBVIR_CHECK_VERSION(3, 4, 0)
10070 static PyObject *
10071 libvirt_virStreamRecvHole(PyObject *self ATTRIBUTE_UNUSED,
10072 PyObject *args)
10073 {
10074 PyObject *pyobj_stream;
10075 virStreamPtr stream;
10076 long long length = -1;
10077 unsigned int flags;
10078 int ret;
10079
10080 if (!PyArg_ParseTuple(args, (char *) "OI:virStreamRecvHole",
10081 &pyobj_stream, &flags))
10082 return NULL;
10083
10084 stream = PyvirStream_Get(pyobj_stream);
10085
10086 LIBVIRT_BEGIN_ALLOW_THREADS;
10087 ret = virStreamRecvHole(stream, &length, flags);
10088 LIBVIRT_END_ALLOW_THREADS;
10089
10090 DEBUG("StreamRecvHole ret=%d length=%lld\n", ret, length);
10091
10092 if (ret < 0)
10093 return VIR_PY_NONE;
10094
10095 return libvirt_longlongWrap(length);
10096 }
10097
10098
10099 static PyObject *
10100 libvirt_virStreamSendHole(PyObject *self ATTRIBUTE_UNUSED,
10101 PyObject *args)
10102 {
10103 PyObject *pyobj_stream;
10104 virStreamPtr stream;
10105 long long length;
10106 unsigned int flags;
10107 int ret;
10108
10109 if (!PyArg_ParseTuple(args, (char *) "OLI:virStreamSendHole",
10110 &pyobj_stream, &length, &flags))
10111 return NULL;
10112
10113 stream = PyvirStream_Get(pyobj_stream);
10114
10115 LIBVIRT_BEGIN_ALLOW_THREADS;
10116 ret = virStreamSendHole(stream, length, flags);
10117 LIBVIRT_END_ALLOW_THREADS;
10118
10119 DEBUG("StreamSendHole ret=%d\n", ret);
10120
10121 return libvirt_intWrap(ret);
10122 }
10123
10124
10125 static PyObject *
10126 libvirt_virStreamRecvFlags(PyObject *self ATTRIBUTE_UNUSED,
10127 PyObject *args)
10128 {
10129 PyObject *pyobj_stream;
10130 PyObject *rv;
10131 virStreamPtr stream;
10132 char *buf = NULL;
10133 size_t nbytes;
10134 unsigned int flags;
10135 int ret;
10136
10137 if (!PyArg_ParseTuple(args, (char *) "OkI:virStreamRecvFlags",
10138 &pyobj_stream, &nbytes, &flags))
10139 return NULL;
10140
10141 stream = PyvirStream_Get(pyobj_stream);
10142
10143 if (VIR_ALLOC_N(buf, nbytes + 1) < 0)
10144 return PyErr_NoMemory();
10145
10146 LIBVIRT_BEGIN_ALLOW_THREADS;
10147 ret = virStreamRecvFlags(stream, buf, nbytes, flags);
10148 LIBVIRT_END_ALLOW_THREADS;
10149
10150 buf[ret > -1 ? ret : 0] = '\0';
10151 DEBUG("StreamRecvFlags ret=%d strlen=%zu\n", ret, strlen(buf));
10152
10153 if (ret == -2 || ret == -3)
10154 return libvirt_intWrap(ret);
10155 if (ret < 0)
10156 return VIR_PY_NONE;
10157 rv = libvirt_charPtrSizeWrap((char *) buf, (Py_ssize_t) ret);
10158 VIR_FREE(buf);
10159 return rv;
10160 }
10161
10162 #endif /* LIBVIR_CHECK_VERSION(3, 4, 0) */
10163
10164
10165 #if LIBVIR_CHECK_VERSION(4, 4, 0)
10166 static PyObject *
10167 libvirt_virConnectBaselineHypervisorCPU(PyObject *self ATTRIBUTE_UNUSED,
10168 PyObject *args)
10169 {
10170 virConnectPtr conn;
10171 PyObject *pyobj_conn;
10172 char *emulator;
10173 char *arch;
10174 char *machine;
10175 char *virttype;
10176 PyObject *list;
10177 unsigned int flags;
10178 char **xmlCPUs = NULL;
10179 int ncpus = 0;
10180 ssize_t i;
10181 char *cpu;
10182 PyObject *ret = NULL;
10183
10184 if (!PyArg_ParseTuple(args, (char *)"OzzzzOI:virConnectBaselineHypervisorCPU",
10185 &pyobj_conn, &emulator, &arch, &machine, &virttype,
10186 &list, &flags))
10187 return NULL;
10188
10189 conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
10190
10191 if (PyList_Check(list)) {
10192 ncpus = PyList_Size(list);
10193 if (VIR_ALLOC_N(xmlCPUs, ncpus) < 0)
10194 return PyErr_NoMemory();
10195
10196 for (i = 0; i < ncpus; i++) {
10197 if (libvirt_charPtrUnwrap(PyList_GetItem(list, i),
10198 &(xmlCPUs[i])) < 0)
10199 goto cleanup;
10200 }
10201 }
10202
10203 LIBVIRT_BEGIN_ALLOW_THREADS;
10204 cpu = virConnectBaselineHypervisorCPU(conn, emulator, arch, machine, virttype,
10205 (const char **)xmlCPUs, ncpus, flags);
10206 LIBVIRT_END_ALLOW_THREADS;
10207
10208 ret = libvirt_constcharPtrWrap(cpu);
10209
10210 cleanup:
10211 for (i = 0; i < ncpus; i++)
10212 VIR_FREE(xmlCPUs[i]);
10213 VIR_FREE(xmlCPUs);
10214 VIR_FREE(cpu);
10215
10216 return ret;
10217 }
10218 #endif /* LIBVIR_CHECK_VERSION(4, 4, 0) */
10219
10220
10221 #if LIBVIR_CHECK_VERSION(4, 5, 0)
10222 static PyObject *
10223 libvirt_virDomainGetLaunchSecurityInfo(PyObject *self ATTRIBUTE_UNUSED,
10224 PyObject *args)
10225 {
10226 PyObject *pyobj_dom = NULL;
10227 PyObject *ret = NULL;
10228
10229 virDomainPtr dom = NULL;
10230 virTypedParameterPtr params = NULL;
10231 int nparams = 0;
10232 unsigned int flags = 0;
10233 int i_retval;
10234
10235 if (!PyArg_ParseTuple(args, (char *)"OI:virDomainGetLaunchSecurityInfo",
10236 &pyobj_dom, &flags))
10237 return NULL;
10238 dom = (virDomainPtr) PyvirDomain_Get(pyobj_dom);
10239
10240 LIBVIRT_BEGIN_ALLOW_THREADS;
10241 i_retval = virDomainGetLaunchSecurityInfo(dom, &params, &nparams, flags);
10242 LIBVIRT_END_ALLOW_THREADS;
10243
10244 if (i_retval < 0) {
10245 ret = VIR_PY_NONE;
10246 goto cleanup;
10247 }
10248
10249 ret = getPyVirTypedParameter(params, nparams);
10250 cleanup:
10251 virTypedParamsFree(params, nparams);
10252 return ret;
10253 }
10254
10255
10256 static PyObject *
10257 libvirt_virNodeGetSEVInfo(PyObject *self ATTRIBUTE_UNUSED,
10258 PyObject *args)
10259 {
10260 PyObject *pyobj_conn = NULL;
10261 PyObject *ret = NULL;
10262
10263 virConnectPtr conn = NULL;
10264 virTypedParameterPtr params = NULL;
10265 int nparams = 0;
10266 unsigned int flags = 0;
10267 int i_retval;
10268
10269 if (!PyArg_ParseTuple(args, (char *)"OI:virNodeGetSEVInfo",
10270 &pyobj_conn, &flags))
10271 return NULL;
10272 conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
10273
10274 LIBVIRT_BEGIN_ALLOW_THREADS;
10275 i_retval = virNodeGetSEVInfo(conn, &params, &nparams, flags);
10276 LIBVIRT_END_ALLOW_THREADS;
10277
10278 if (i_retval < 0) {
10279 ret = VIR_PY_NONE;
10280 goto cleanup;
10281 }
10282
10283 ret = getPyVirTypedParameter(params, nparams);
10284 cleanup:
10285 virTypedParamsFree(params, nparams);
10286 return ret;
10287 }
10288 #endif /* LIBVIR_CHECK_VERSION(4, 5, 0) */
10289
10290 #if LIBVIR_CHECK_VERSION(5, 5, 0)
10291 static PyObject *
10292 libvirt_virNetworkListAllPorts(PyObject *self ATTRIBUTE_UNUSED,
10293 PyObject *args)
10294 {
10295 PyObject *pyobj_conn;
10296 PyObject *py_retval = NULL;
10297 virNetworkPtr conn;
10298 virNetworkPortPtr *doms = NULL;
10299 int c_retval = 0;
10300 ssize_t i;
10301 unsigned int flags;
10302
10303 if (!PyArg_ParseTuple(args, (char *)"OI:virNetworkListAllPorts",
10304 &pyobj_conn, &flags))
10305 return NULL;
10306 conn = (virNetworkPtr) PyvirNetwork_Get(pyobj_conn);
10307
10308 LIBVIRT_BEGIN_ALLOW_THREADS;
10309 c_retval = virNetworkListAllPorts(conn, &doms, flags);
10310 LIBVIRT_END_ALLOW_THREADS;
10311
10312 if (c_retval < 0)
10313 return VIR_PY_NONE;
10314
10315 if (!(py_retval = PyList_New(c_retval)))
10316 goto cleanup;
10317
10318 for (i = 0; i < c_retval; i++) {
10319 VIR_PY_LIST_SET_GOTO(py_retval, i, libvirt_virNetworkPortPtrWrap(doms[i]), error);
10320 /* python steals the pointer */
10321 doms[i] = NULL;
10322 }
10323
10324 cleanup:
10325 for (i = 0; i < c_retval; i++)
10326 if (doms[i])
10327 virNetworkPortFree(doms[i]);
10328 VIR_FREE(doms);
10329 return py_retval;
10330
10331 error:
10332 Py_CLEAR(py_retval);
10333 goto cleanup;
10334 }
10335
10336 static PyObject *
10337 libvirt_virNetworkPortSetParameters(PyObject *self ATTRIBUTE_UNUSED,
10338 PyObject *args)
10339 {
10340 virNetworkPortPtr port;
10341 PyObject *pyobj_port, *info;
10342 PyObject *ret = NULL;
10343 int i_retval;
10344 int nparams = 0;
10345 Py_ssize_t size = 0;
10346 unsigned int flags;
10347 virTypedParameterPtr params = NULL, new_params = NULL;
10348
10349 if (!PyArg_ParseTuple(args,
10350 (char *)"OOI:virNetworkPortSetParameters",
10351 &pyobj_port, &info, &flags))
10352 return NULL;
10353 port = (virNetworkPortPtr) PyvirNetworkPort_Get(pyobj_port);
10354
10355 if ((size = PyDict_Size(info)) < 0)
10356 return NULL;
10357
10358 if (size == 0) {
10359 PyErr_Format(PyExc_LookupError,
10360 "Need non-empty dictionary to set attributes");
10361 return NULL;
10362 }
10363
10364 LIBVIRT_BEGIN_ALLOW_THREADS;
10365 i_retval = virNetworkPortGetParameters(port, &params, &nparams, flags);
10366 LIBVIRT_END_ALLOW_THREADS;
10367
10368 if (i_retval < 0)
10369 return VIR_PY_INT_FAIL;
10370
10371 if (nparams == 0) {
10372 PyErr_Format(PyExc_LookupError,
10373 "Port has no settable attributes");
10374 return NULL;
10375 }
10376
10377 new_params = setPyVirTypedParameter(info, params, nparams);
10378 if (!new_params)
10379 goto cleanup;
10380
10381 LIBVIRT_BEGIN_ALLOW_THREADS;
10382 i_retval = virNetworkPortSetParameters(port, new_params, size, flags);
10383 LIBVIRT_END_ALLOW_THREADS;
10384
10385 if (i_retval < 0) {
10386 ret = VIR_PY_INT_FAIL;
10387 goto cleanup;
10388 }
10389
10390 ret = VIR_PY_INT_SUCCESS;
10391
10392 cleanup:
10393 virTypedParamsFree(params, nparams);
10394 virTypedParamsFree(new_params, size);
10395 return ret;
10396 }
10397
10398 static PyObject *
10399 libvirt_virNetworkPortGetParameters(PyObject *self ATTRIBUTE_UNUSED,
10400 PyObject *args)
10401 {
10402 PyObject *pyobj_port;
10403 virNetworkPortPtr port;
10404 virTypedParameterPtr params = NULL;
10405 int nparams = 0;
10406 PyObject *dict = NULL;
10407 unsigned int flags;
10408 int rc;
10409
10410 if (!PyArg_ParseTuple(args, (char *) "OI:virNetworkPortGetParameters",
10411 &pyobj_port, &flags))
10412 return NULL;
10413 port = (virNetworkPortPtr) PyvirNetworkPort_Get(pyobj_port);
10414
10415 LIBVIRT_BEGIN_ALLOW_THREADS;
10416 rc = virNetworkPortGetParameters(port, &params, &nparams, flags);
10417 LIBVIRT_END_ALLOW_THREADS;
10418
10419 if (rc < 0)
10420 return VIR_PY_NONE;
10421
10422 dict = getPyVirTypedParameter(params, nparams);
10423
10424 virTypedParamsFree(params, nparams);
10425 return dict;
10426 }
10427
10428 static PyObject *
10429 libvirt_virNetworkPortGetUUID(PyObject *self ATTRIBUTE_UNUSED,
10430 PyObject *args)
10431 {
10432 unsigned char uuid[VIR_UUID_BUFLEN];
10433 virNetworkPortPtr port;
10434 PyObject *pyobj_port;
10435 int c_retval;
10436
10437 if (!PyArg_ParseTuple(args, (char *)"O:virNetworkPortGetUUID", &pyobj_port))
10438 return NULL;
10439 port = (virNetworkPortPtr) PyvirNetworkPort_Get(pyobj_port);
10440
10441 if (port == NULL)
10442 return VIR_PY_NONE;
10443
10444 LIBVIRT_BEGIN_ALLOW_THREADS;
10445 c_retval = virNetworkPortGetUUID(port, &uuid[0]);
10446 LIBVIRT_END_ALLOW_THREADS;
10447
10448 if (c_retval < 0)
10449 return VIR_PY_NONE;
10450
10451 return libvirt_charPtrSizeWrap((char *) &uuid[0], VIR_UUID_BUFLEN);
10452 }
10453
10454 static PyObject *
10455 libvirt_virNetworkPortGetUUIDString(PyObject *self ATTRIBUTE_UNUSED,
10456 PyObject *args)
10457 {
10458 char uuidstr[VIR_UUID_STRING_BUFLEN];
10459 virNetworkPortPtr port;
10460 PyObject *pyobj_port;
10461 int c_retval;
10462
10463 if (!PyArg_ParseTuple(args, (char *)"O:virNetworkPortGetUUIDString",
10464 &pyobj_port))
10465 return NULL;
10466 port = (virNetworkPortPtr) PyvirNetworkPort_Get(pyobj_port);
10467
10468 if (port == NULL)
10469 return VIR_PY_NONE;
10470
10471 LIBVIRT_BEGIN_ALLOW_THREADS;
10472 c_retval = virNetworkPortGetUUIDString(port, &uuidstr[0]);
10473 LIBVIRT_END_ALLOW_THREADS;
10474
10475 if (c_retval < 0)
10476 return VIR_PY_NONE;
10477
10478 return libvirt_constcharPtrWrap((char *) &uuidstr[0]);
10479 }
10480
10481 static PyObject *
10482 libvirt_virNetworkPortLookupByUUID(PyObject *self ATTRIBUTE_UNUSED,
10483 PyObject *args)
10484 {
10485 virNetworkPortPtr c_retval;
10486 virNetworkPtr net;
10487 PyObject *pyobj_net;
10488 unsigned char *uuid;
10489 Py_ssize_t len;
10490
10491 if (!PyArg_ParseTuple(args, (char *)"Oz#:virNetworkPortLookupByUUID",
10492 &pyobj_net, &uuid, &len))
10493 return NULL;
10494 net = (virNetworkPtr) PyvirNetwork_Get(pyobj_net);
10495
10496 if ((uuid == NULL) || (len != VIR_UUID_BUFLEN))
10497 return VIR_PY_NONE;
10498
10499 LIBVIRT_BEGIN_ALLOW_THREADS;
10500 c_retval = virNetworkPortLookupByUUID(net, uuid);
10501 LIBVIRT_END_ALLOW_THREADS;
10502
10503 return libvirt_virNetworkPortPtrWrap((virNetworkPortPtr) c_retval);
10504 }
10505
10506
10507 #endif /* LIBVIR_CHECK_VERSION(5, 5, 0) */
10508
10509 #if LIBVIR_CHECK_VERSION(5, 7, 0)
10510 static PyObject *
10511 libvirt_virDomainGetGuestInfo(PyObject *self ATTRIBUTE_UNUSED,
10512 PyObject *args)
10513 {
10514 PyObject *pyobj_dom = NULL;
10515 PyObject *dict = NULL;
10516 virDomainPtr dom = NULL;
10517 virTypedParameterPtr params = NULL;
10518 int nparams = 0;
10519 unsigned int types;
10520 unsigned int flags;
10521 int rc;
10522
10523 if (!PyArg_ParseTuple(args, (char *) "OII:virDomainGetGuestInfo",
10524 &pyobj_dom, &types, &flags))
10525 return NULL;
10526 dom = (virDomainPtr) PyvirDomain_Get(pyobj_dom);
10527
10528 LIBVIRT_BEGIN_ALLOW_THREADS;
10529 rc = virDomainGetGuestInfo(dom, types, &params, &nparams, flags);
10530 LIBVIRT_END_ALLOW_THREADS;
10531
10532 if (rc < 0)
10533 return VIR_PY_NONE;
10534
10535 dict = getPyVirTypedParameter(params, nparams);
10536
10537 virTypedParamsFree(params, nparams);
10538 return dict;
10539 }
10540 #endif /* LIBVIR_CHECK_VERSION(5, 7, 0) */
10541
10542
10543 #if LIBVIR_CHECK_VERSION(5, 8, 0)
10544 static virPyTypedParamsHint virPyConnectSetIdentityParams[] = {
10545 { VIR_CONNECT_IDENTITY_USER_NAME, VIR_TYPED_PARAM_STRING },
10546 { VIR_CONNECT_IDENTITY_UNIX_USER_ID, VIR_TYPED_PARAM_ULLONG },
10547 { VIR_CONNECT_IDENTITY_GROUP_NAME, VIR_TYPED_PARAM_STRING },
10548 { VIR_CONNECT_IDENTITY_UNIX_GROUP_ID, VIR_TYPED_PARAM_ULLONG },
10549 { VIR_CONNECT_IDENTITY_PROCESS_ID, VIR_TYPED_PARAM_LLONG },
10550 { VIR_CONNECT_IDENTITY_PROCESS_TIME, VIR_TYPED_PARAM_ULLONG },
10551 { VIR_CONNECT_IDENTITY_SASL_USER_NAME, VIR_TYPED_PARAM_STRING },
10552 { VIR_CONNECT_IDENTITY_X509_DISTINGUISHED_NAME, VIR_TYPED_PARAM_STRING },
10553 { VIR_CONNECT_IDENTITY_SELINUX_CONTEXT, VIR_TYPED_PARAM_STRING },
10554 };
10555
10556 static PyObject *
10557 libvirt_virConnectSetIdentity(PyObject *self ATTRIBUTE_UNUSED,
10558 PyObject *args)
10559 {
10560 virConnectPtr conn;
10561 PyObject *pyobj_conn, *dict;
10562 PyObject *ret = NULL;
10563 int i_retval;
10564 int nparams = 0;
10565 unsigned int flags;
10566 virTypedParameterPtr params = NULL;
10567
10568 if (!PyArg_ParseTuple(args,
10569 (char *)"OOI:virConnectSetIdentity",
10570 &pyobj_conn, &dict, &flags))
10571 return NULL;
10572 conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
10573
10574 if (!PyDict_Check(dict)) {
10575 PyErr_Format(PyExc_TypeError, "migration params must be a dictionary");
10576 return NULL;
10577 }
10578
10579 if (virPyDictToTypedParams(dict, &params, &nparams,
10580 virPyConnectSetIdentityParams,
10581 VIR_N_ELEMENTS(virPyConnectSetIdentityParams)) < 0) {
10582 return NULL;
10583 }
10584
10585 LIBVIRT_BEGIN_ALLOW_THREADS;
10586 i_retval = virConnectSetIdentity(conn, params, nparams, flags);
10587 LIBVIRT_END_ALLOW_THREADS;
10588
10589 if (i_retval < 0) {
10590 ret = VIR_PY_INT_FAIL;
10591 goto cleanup;
10592 }
10593
10594 ret = VIR_PY_INT_SUCCESS;
10595
10596 cleanup:
10597 virTypedParamsFree(params, nparams);
10598 return ret;
10599 }
10600 #endif /* LIBVIR_CHECK_VERSION(5, 8, 0) */
10601
10602
10603 #if LIBVIR_CHECK_VERSION(6, 10, 0)
10604 static PyObject *
10605 libvirt_virDomainAuthorizedSSHKeysGet(PyObject *self ATTRIBUTE_UNUSED,
10606 PyObject *args)
10607 {
10608 PyObject *pyobj_dom = NULL;
10609 virDomainPtr dom = NULL;
10610 const char *user = NULL;
10611 char **keys = NULL;
10612 int nkeys;
10613 int i;
10614 unsigned int flags;
10615 PyObject *ret = NULL;
10616
10617 if (!PyArg_ParseTuple(args, (char *)"OsI:virDomainAuthorizedSSHKeysGet",
10618 &pyobj_dom, &user, &flags))
10619 return NULL;
10620 dom = (virDomainPtr) PyvirDomain_Get(pyobj_dom);
10621
10622 LIBVIRT_BEGIN_ALLOW_THREADS;
10623 nkeys = virDomainAuthorizedSSHKeysGet(dom, user, &keys, flags);
10624 LIBVIRT_END_ALLOW_THREADS;
10625
10626 if (nkeys < 0)
10627 return VIR_PY_NONE;
10628
10629 if ((ret = PyList_New(nkeys)) == NULL)
10630 goto error;
10631
10632 for (i = 0; i < nkeys; i++)
10633 VIR_PY_LIST_SET_GOTO(ret, i, libvirt_constcharPtrWrap(keys[i]), error);
10634
10635 done:
10636 for (i = 0; i < nkeys; i++)
10637 VIR_FREE(keys[i]);
10638 VIR_FREE(keys);
10639 return ret;
10640
10641 error:
10642 Py_CLEAR(ret);
10643 goto done;
10644 }
10645
10646
10647 static PyObject *
10648 libvirt_virDomainAuthorizedSSHKeysSet(PyObject *self ATTRIBUTE_UNUSED,
10649 PyObject *args)
10650 {
10651 PyObject *pyobj_dom = NULL;
10652 virDomainPtr dom = NULL;
10653 const char *user = NULL;
10654 PyObject *pyobj_keys = NULL;
10655 char **keys = NULL;
10656 int nkeys = 0;
10657 int i;
10658 unsigned int flags;
10659 int c_retval;
10660 PyObject *py_retval = NULL;
10661
10662 if (!PyArg_ParseTuple(args, (char *)"OsOI:virDomainAuthorizedSSHKeysSet",
10663 &pyobj_dom, &user, &pyobj_keys, &flags))
10664 return NULL;
10665 dom = (virDomainPtr) PyvirDomain_Get(pyobj_dom);
10666
10667 if (PyList_Check(pyobj_keys)) {
10668 nkeys = PyList_Size(pyobj_keys);
10669
10670 if (VIR_ALLOC_N(keys, nkeys) < 0)
10671 return PyErr_NoMemory();
10672
10673 for (i = 0; i < nkeys; i++) {
10674 if (libvirt_charPtrUnwrap(PyList_GetItem(pyobj_keys, i),
10675 &(keys[i])) < 0)
10676 goto cleanup;
10677 }
10678 }
10679
10680 LIBVIRT_BEGIN_ALLOW_THREADS;
10681 c_retval = virDomainAuthorizedSSHKeysSet(dom, user, (const char **)keys, nkeys, flags);
10682 LIBVIRT_END_ALLOW_THREADS;
10683
10684 py_retval = libvirt_intWrap(c_retval);
10685 cleanup:
10686 for (i = 0 ; i < nkeys ; i++)
10687 VIR_FREE(keys[i]);
10688 VIR_FREE(keys);
10689
10690 return py_retval;
10691 }
10692 #endif /* LIBVIR_CHECK_VERSION(6, 10, 0) */
10693
10694 #if LIBVIR_CHECK_VERSION(7, 1, 0)
10695 static PyObject *
10696 libvirt_virDomainGetMessages(PyObject *self ATTRIBUTE_UNUSED,
10697 PyObject *args)
10698 {
10699 PyObject *pyobj_dom = NULL;
10700 virDomainPtr dom = NULL;
10701 char **msgs = NULL;
10702 int nmsgs;
10703 int i;
10704 unsigned int flags;
10705 PyObject *ret = NULL;
10706
10707 if (!PyArg_ParseTuple(args, (char *)"OI:virDomainGetMessages",
10708 &pyobj_dom, &flags))
10709 return NULL;
10710 dom = (virDomainPtr) PyvirDomain_Get(pyobj_dom);
10711
10712 LIBVIRT_BEGIN_ALLOW_THREADS;
10713 nmsgs = virDomainGetMessages(dom, &msgs, flags);
10714 LIBVIRT_END_ALLOW_THREADS;
10715
10716 if (nmsgs < 0)
10717 return VIR_PY_NONE;
10718
10719 if ((ret = PyList_New(nmsgs)) == NULL)
10720 goto error;
10721
10722 for (i = 0; i < nmsgs; i++)
10723 VIR_PY_LIST_SET_GOTO(ret, i, libvirt_constcharPtrWrap(msgs[i]), error);
10724
10725 done:
10726 for (i = 0; i < nmsgs; i++)
10727 VIR_FREE(msgs[i]);
10728 VIR_FREE(msgs);
10729 return ret;
10730
10731 error:
10732 Py_CLEAR(ret);
10733 goto done;
10734 }
10735 #endif /* LIBVIR_CHECK_VERSION(7, 1, 0) */
10736
10737 #if LIBVIR_CHECK_VERSION(8, 0, 0)
10738
10739 static virPyTypedParamsHint virPyDomainSetLaunchSecurityStateParams[] = {
10740 { VIR_DOMAIN_LAUNCH_SECURITY_SEV_SECRET, VIR_TYPED_PARAM_STRING },
10741 { VIR_DOMAIN_LAUNCH_SECURITY_SEV_SECRET_HEADER, VIR_TYPED_PARAM_STRING },
10742 { VIR_DOMAIN_LAUNCH_SECURITY_SEV_SECRET_SET_ADDRESS, VIR_TYPED_PARAM_ULLONG },
10743 };
10744
10745 static PyObject *
10746 libvirt_virDomainSetLaunchSecurityState(PyObject *self ATTRIBUTE_UNUSED,
10747 PyObject *args)
10748 {
10749 PyObject *pyobj_dom = NULL;
10750 PyObject *pyobj_dict = NULL;
10751
10752 virDomainPtr dom;
10753 virTypedParameterPtr params = NULL;
10754 int nparams = 0;
10755 unsigned int flags;
10756 int c_retval;
10757
10758 if (!PyArg_ParseTuple(args, (char *)"OOI:virDomainSetLaunchSecurityState",
10759 &pyobj_dom, &pyobj_dict, &flags))
10760 return NULL;
10761
10762 if (PyDict_Check(pyobj_dict)) {
10763 if (virPyDictToTypedParams(pyobj_dict, &params, &nparams,
10764 virPyDomainSetLaunchSecurityStateParams,
10765 VIR_N_ELEMENTS(virPyDomainSetLaunchSecurityStateParams)) < 0) {
10766 return NULL;
10767 }
10768 } else {
10769 PyErr_Format(PyExc_TypeError, "Launch security state params must be "
10770 "a dictionary");
10771 return NULL;
10772 }
10773
10774 dom = (virDomainPtr) PyvirDomain_Get(pyobj_dom);
10775
10776 LIBVIRT_BEGIN_ALLOW_THREADS;
10777 c_retval = virDomainSetLaunchSecurityState(dom, params, nparams, flags);
10778 LIBVIRT_END_ALLOW_THREADS;
10779
10780 virTypedParamsFree(params, nparams);
10781
10782 return libvirt_intWrap(c_retval);
10783 }
10784 #endif /* LIBVIR_CHECK_VERSION(8, 0, 0) */
10785
10786
10787 #if LIBVIR_CHECK_VERSION(8, 4, 0)
10788 static virPyTypedParamsHint virPyDomainSaveParams[] = {
10789 { VIR_DOMAIN_SAVE_PARAM_FILE, VIR_TYPED_PARAM_STRING },
10790 { VIR_DOMAIN_SAVE_PARAM_DXML, VIR_TYPED_PARAM_STRING },
10791 };
10792
10793
10794 static PyObject *
10795 libvirt_virDomainSaveParams(PyObject *self ATTRIBUTE_UNUSED,
10796 PyObject *args)
10797 {
10798 PyObject *pyobj_dom = NULL;
10799 PyObject *pyobj_dict = NULL;
10800 virDomainPtr dom;
10801 virTypedParameterPtr params = NULL;
10802 int nparams = 0;
10803 unsigned int flags = 0;
10804 int c_retval;
10805
10806 if (!PyArg_ParseTuple(args, (char *)"OO|I:virDomainSaveParams",
10807 &pyobj_dom, &pyobj_dict, &flags))
10808 return NULL;
10809
10810 if (PyDict_Check(pyobj_dict)) {
10811 if (virPyDictToTypedParams(pyobj_dict, &params, &nparams,
10812 virPyDomainSaveParams,
10813 VIR_N_ELEMENTS(virPyDomainSaveParams)) < 0) {
10814 return NULL;
10815 }
10816 } else {
10817 PyErr_Format(PyExc_TypeError, "Save params must be a dictionary");
10818 return NULL;
10819 }
10820
10821 dom = (virDomainPtr) PyvirDomain_Get(pyobj_dom);
10822
10823 LIBVIRT_BEGIN_ALLOW_THREADS;
10824 c_retval = virDomainSaveParams(dom, params, nparams, flags);
10825 LIBVIRT_END_ALLOW_THREADS;
10826
10827 virTypedParamsFree(params, nparams);
10828
10829 return libvirt_intWrap(c_retval);
10830 }
10831
10832 static PyObject *
10833 libvirt_virDomainRestoreParams(PyObject *self ATTRIBUTE_UNUSED,
10834 PyObject *args)
10835 {
10836 PyObject *pyobj_conn = NULL;
10837 PyObject *pyobj_dict = NULL;
10838 virConnectPtr conn;
10839 virTypedParameterPtr params = NULL;
10840 int nparams = 0;
10841 unsigned int flags = 0;
10842 int c_retval;
10843
10844 if (!PyArg_ParseTuple(args, (char *)"OO|I:virDomainRestoreParams",
10845 &pyobj_conn, &pyobj_dict, &flags))
10846 return NULL;
10847
10848 if (PyDict_Check(pyobj_dict)) {
10849 if (virPyDictToTypedParams(pyobj_dict, &params, &nparams,
10850 virPyDomainSaveParams,
10851 VIR_N_ELEMENTS(virPyDomainSaveParams)) < 0) {
10852 return NULL;
10853 }
10854 } else {
10855 PyErr_Format(PyExc_TypeError, "Restore params must be a dictionary");
10856 return NULL;
10857 }
10858
10859 conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
10860
10861 LIBVIRT_BEGIN_ALLOW_THREADS;
10862 c_retval = virDomainRestoreParams(conn, params, nparams, flags);
10863 LIBVIRT_END_ALLOW_THREADS;
10864
10865 virTypedParamsFree(params, nparams);
10866
10867 return libvirt_intWrap(c_retval);
10868 }
10869 #endif /* LIBVIR_CHECK_VERSION(8, 4, 0) */
10870
10871
10872 #if LIBVIR_CHECK_VERSION(9, 0, 0)
10873 static PyObject *
10874 libvirt_virDomainFDAssociate(PyObject *self ATTRIBUTE_UNUSED,
10875 PyObject *args)
10876 {
10877 PyObject *py_retval = NULL;
10878 int c_retval;
10879 virDomainPtr domain;
10880 PyObject *pyobj_domain;
10881 PyObject *pyobj_files;
10882 const char *name = NULL;
10883 unsigned int flags;
10884 unsigned int nfiles;
10885 int *files = NULL;
10886 size_t i;
10887
10888 if (!PyArg_ParseTuple(args, (char *)"OsOI:virDomainFDAssociate",
10889 &pyobj_domain, &name, &pyobj_files, &flags))
10890 return NULL;
10891 domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
10892
10893 nfiles = PyList_Size(pyobj_files);
10894
10895 if (VIR_ALLOC_N(files, nfiles) < 0)
10896 return PyErr_NoMemory();
10897
10898 for (i = 0; i < nfiles; i++) {
10899 PyObject *pyfd;
10900 int fd;
10901
10902 pyfd = PyList_GetItem(pyobj_files, i);
10903
10904 if (libvirt_intUnwrap(pyfd, &fd) < 0)
10905 goto cleanup;
10906
10907 files[i] = fd;
10908 }
10909
10910 LIBVIRT_BEGIN_ALLOW_THREADS;
10911 c_retval = virDomainFDAssociate(domain, name, nfiles, files, flags);
10912 LIBVIRT_END_ALLOW_THREADS;
10913
10914 py_retval = libvirt_intWrap(c_retval);
10915
10916 cleanup:
10917 VIR_FREE(files);
10918 return py_retval;
10919 }
10920 #endif /* LIBVIR_CHECK_VERSION(9, 0, 0) */
10921
10922
10923
10924 /************************************************************************
10925 * *
10926 * The registration stuff *
10927 * *
10928 ************************************************************************/
10929 static PyMethodDef libvirtMethods[] = {
10930 #include "build/libvirt-export.c"
10931 {(char *) "virGetVersion", libvirt_virGetVersion, METH_VARARGS, NULL},
10932 {(char *) "virConnectGetVersion", libvirt_virConnectGetVersion, METH_VARARGS, NULL},
10933 #if LIBVIR_CHECK_VERSION(1, 1, 3)
10934 {(char *) "virConnectGetCPUModelNames", libvirt_virConnectGetCPUModelNames, METH_VARARGS, NULL},
10935 #endif /* LIBVIR_CHECK_VERSION(1, 1, 3) */
10936 {(char *) "virConnectGetLibVersion", libvirt_virConnectGetLibVersion, METH_VARARGS, NULL},
10937 {(char *) "virConnectOpenAuth", libvirt_virConnectOpenAuth, METH_VARARGS, NULL},
10938 {(char *) "virConnectListDomainsID", libvirt_virConnectListDomainsID, METH_VARARGS, NULL},
10939 {(char *) "virConnectListDefinedDomains", libvirt_virConnectListDefinedDomains, METH_VARARGS, NULL},
10940 #if LIBVIR_CHECK_VERSION(0, 9, 13)
10941 {(char *) "virConnectListAllDomains", libvirt_virConnectListAllDomains, METH_VARARGS, NULL},
10942 #endif /* LIBVIR_CHECK_VERSION(0, 9, 13) */
10943 {(char *) "virConnectDomainEventRegister", libvirt_virConnectDomainEventRegister, METH_VARARGS, NULL},
10944 {(char *) "virConnectDomainEventDeregister", libvirt_virConnectDomainEventDeregister, METH_VARARGS, NULL},
10945 {(char *) "virConnectDomainEventRegisterAny", libvirt_virConnectDomainEventRegisterAny, METH_VARARGS, NULL},
10946 {(char *) "virConnectDomainEventDeregisterAny", libvirt_virConnectDomainEventDeregisterAny, METH_VARARGS, NULL},
10947 #if LIBVIR_CHECK_VERSION(1, 2, 1)
10948 {(char *) "virConnectNetworkEventRegisterAny", libvirt_virConnectNetworkEventRegisterAny, METH_VARARGS, NULL},
10949 {(char *) "virConnectNetworkEventDeregisterAny", libvirt_virConnectNetworkEventDeregisterAny, METH_VARARGS, NULL},
10950 #endif /* LIBVIR_CHECK_VERSION(1, 2, 1) */
10951 #if LIBVIR_CHECK_VERSION(0, 10, 0)
10952 {(char *) "virConnectRegisterCloseCallback", libvirt_virConnectRegisterCloseCallback, METH_VARARGS, NULL},
10953 {(char *) "virConnectUnregisterCloseCallback", libvirt_virConnectUnregisterCloseCallback, METH_VARARGS, NULL},
10954 #endif /* LIBVIR_CHECK_VERSION(0, 10, 0) */
10955 {(char *) "virStreamEventAddCallback", libvirt_virStreamEventAddCallback, METH_VARARGS, NULL},
10956 {(char *) "virStreamRecv", libvirt_virStreamRecv, METH_VARARGS, NULL},
10957 {(char *) "virStreamSend", libvirt_virStreamSend, METH_VARARGS, NULL},
10958 {(char *) "virDomainGetInfo", libvirt_virDomainGetInfo, METH_VARARGS, NULL},
10959 {(char *) "virDomainGetState", libvirt_virDomainGetState, METH_VARARGS, NULL},
10960 {(char *) "virDomainGetControlInfo", libvirt_virDomainGetControlInfo, METH_VARARGS, NULL},
10961 {(char *) "virDomainGetBlockInfo", libvirt_virDomainGetBlockInfo, METH_VARARGS, NULL},
10962 {(char *) "virNodeGetInfo", libvirt_virNodeGetInfo, METH_VARARGS, NULL},
10963 {(char *) "virNodeGetSecurityModel", libvirt_virNodeGetSecurityModel, METH_VARARGS, NULL},
10964 {(char *) "virDomainGetSecurityLabel", libvirt_virDomainGetSecurityLabel, METH_VARARGS, NULL},
10965 #if LIBVIR_CHECK_VERSION(0, 10, 0)
10966 {(char *) "virDomainGetSecurityLabelList", libvirt_virDomainGetSecurityLabelList, METH_VARARGS, NULL},
10967 #endif /* LIBVIR_CHECK_VERSION(0, 10, 0) */
10968 {(char *) "virNodeGetCPUStats", libvirt_virNodeGetCPUStats, METH_VARARGS, NULL},
10969 {(char *) "virNodeGetMemoryStats", libvirt_virNodeGetMemoryStats, METH_VARARGS, NULL},
10970 {(char *) "virDomainGetUUID", libvirt_virDomainGetUUID, METH_VARARGS, NULL},
10971 {(char *) "virDomainGetUUIDString", libvirt_virDomainGetUUIDString, METH_VARARGS, NULL},
10972 {(char *) "virDomainLookupByUUID", libvirt_virDomainLookupByUUID, METH_VARARGS, NULL},
10973 {(char *) "virRegisterErrorHandler", libvirt_virRegisterErrorHandler, METH_VARARGS, NULL},
10974 {(char *) "virGetLastError", libvirt_virGetLastError, METH_VARARGS, NULL},
10975 {(char *) "virConnGetLastError", libvirt_virConnGetLastError, METH_VARARGS, NULL},
10976 {(char *) "virConnectListNetworks", libvirt_virConnectListNetworks, METH_VARARGS, NULL},
10977 {(char *) "virConnectListDefinedNetworks", libvirt_virConnectListDefinedNetworks, METH_VARARGS, NULL},
10978 #if LIBVIR_CHECK_VERSION(0, 10, 2)
10979 {(char *) "virConnectListAllNetworks", libvirt_virConnectListAllNetworks, METH_VARARGS, NULL},
10980 #endif /* LIBVIR_CHECK_VERSION(0, 10, 2) */
10981 {(char *) "virNetworkGetUUID", libvirt_virNetworkGetUUID, METH_VARARGS, NULL},
10982 {(char *) "virNetworkGetUUIDString", libvirt_virNetworkGetUUIDString, METH_VARARGS, NULL},
10983 {(char *) "virNetworkLookupByUUID", libvirt_virNetworkLookupByUUID, METH_VARARGS, NULL},
10984 {(char *) "virDomainGetAutostart", libvirt_virDomainGetAutostart, METH_VARARGS, NULL},
10985 {(char *) "virNetworkGetAutostart", libvirt_virNetworkGetAutostart, METH_VARARGS, NULL},
10986 {(char *) "virDomainBlockStats", libvirt_virDomainBlockStats, METH_VARARGS, NULL},
10987 {(char *) "virDomainBlockStatsFlags", libvirt_virDomainBlockStatsFlags, METH_VARARGS, NULL},
10988 {(char *) "virDomainGetCPUStats", libvirt_virDomainGetCPUStats, METH_VARARGS, NULL},
10989 {(char *) "virDomainInterfaceStats", libvirt_virDomainInterfaceStats, METH_VARARGS, NULL},
10990 {(char *) "virDomainMemoryStats", libvirt_virDomainMemoryStats, METH_VARARGS, NULL},
10991 {(char *) "virNodeGetCellsFreeMemory", libvirt_virNodeGetCellsFreeMemory, METH_VARARGS, NULL},
10992 {(char *) "virDomainGetSchedulerType", libvirt_virDomainGetSchedulerType, METH_VARARGS, NULL},
10993 {(char *) "virDomainGetSchedulerParameters", libvirt_virDomainGetSchedulerParameters, METH_VARARGS, NULL},
10994 {(char *) "virDomainGetSchedulerParametersFlags", libvirt_virDomainGetSchedulerParametersFlags, METH_VARARGS, NULL},
10995 {(char *) "virDomainSetSchedulerParameters", libvirt_virDomainSetSchedulerParameters, METH_VARARGS, NULL},
10996 {(char *) "virDomainSetSchedulerParametersFlags", libvirt_virDomainSetSchedulerParametersFlags, METH_VARARGS, NULL},
10997 {(char *) "virDomainSetBlkioParameters", libvirt_virDomainSetBlkioParameters, METH_VARARGS, NULL},
10998 {(char *) "virDomainGetBlkioParameters", libvirt_virDomainGetBlkioParameters, METH_VARARGS, NULL},
10999 {(char *) "virDomainSetMemoryParameters", libvirt_virDomainSetMemoryParameters, METH_VARARGS, NULL},
11000 {(char *) "virDomainGetMemoryParameters", libvirt_virDomainGetMemoryParameters, METH_VARARGS, NULL},
11001 {(char *) "virDomainSetNumaParameters", libvirt_virDomainSetNumaParameters, METH_VARARGS, NULL},
11002 {(char *) "virDomainGetNumaParameters", libvirt_virDomainGetNumaParameters, METH_VARARGS, NULL},
11003 {(char *) "virDomainSetInterfaceParameters", libvirt_virDomainSetInterfaceParameters, METH_VARARGS, NULL},
11004 {(char *) "virDomainGetInterfaceParameters", libvirt_virDomainGetInterfaceParameters, METH_VARARGS, NULL},
11005 {(char *) "virDomainGetVcpus", libvirt_virDomainGetVcpus, METH_VARARGS, NULL},
11006 {(char *) "virDomainPinVcpu", libvirt_virDomainPinVcpu, METH_VARARGS, NULL},
11007 {(char *) "virDomainPinVcpuFlags", libvirt_virDomainPinVcpuFlags, METH_VARARGS, NULL},
11008 {(char *) "virDomainGetVcpuPinInfo", libvirt_virDomainGetVcpuPinInfo, METH_VARARGS, NULL},
11009 #if LIBVIR_CHECK_VERSION(0, 10, 0)
11010 {(char *) "virDomainGetEmulatorPinInfo", libvirt_virDomainGetEmulatorPinInfo, METH_VARARGS, NULL},
11011 {(char *) "virDomainPinEmulator", libvirt_virDomainPinEmulator, METH_VARARGS, NULL},
11012 #endif /* LIBVIR_CHECK_VERSION(0, 10, 0) */
11013 #if LIBVIR_CHECK_VERSION(1, 2, 14)
11014 {(char *) "virDomainGetIOThreadInfo", libvirt_virDomainGetIOThreadInfo, METH_VARARGS, NULL},
11015 {(char *) "virDomainPinIOThread", libvirt_virDomainPinIOThread, METH_VARARGS, NULL},
11016 #endif /* LIBVIR_CHECK_VERSION(1, 2, 14) */
11017 #if LIBVIR_CHECK_VERSION(4, 10, 0)
11018 {(char *) "virDomainSetIOThreadParams", libvirt_virDomainSetIOThreadParams, METH_VARARGS, NULL},
11019 #endif /* LIBVIR_CHECK_VERSION(4, 10, 0) */
11020 {(char *) "virConnectListStoragePools", libvirt_virConnectListStoragePools, METH_VARARGS, NULL},
11021 {(char *) "virConnectListDefinedStoragePools", libvirt_virConnectListDefinedStoragePools, METH_VARARGS, NULL},
11022 #if LIBVIR_CHECK_VERSION(0, 10, 2)
11023 {(char *) "virConnectListAllStoragePools", libvirt_virConnectListAllStoragePools, METH_VARARGS, NULL},
11024 #endif /* LIBVIR_CHECK_VERSION(0, 10, 2) */
11025 {(char *) "virStoragePoolGetAutostart", libvirt_virStoragePoolGetAutostart, METH_VARARGS, NULL},
11026 {(char *) "virStoragePoolListVolumes", libvirt_virStoragePoolListVolumes, METH_VARARGS, NULL},
11027 #if LIBVIR_CHECK_VERSION(0, 10, 2)
11028 {(char *) "virStoragePoolListAllVolumes", libvirt_virStoragePoolListAllVolumes, METH_VARARGS, NULL},
11029 #endif /* LIBVIR_CHECK_VERSION(0, 10, 2) */
11030 {(char *) "virStoragePoolGetInfo", libvirt_virStoragePoolGetInfo, METH_VARARGS, NULL},
11031 {(char *) "virStorageVolGetInfo", libvirt_virStorageVolGetInfo, METH_VARARGS, NULL},
11032 #if LIBVIR_CHECK_VERSION(3, 0, 0)
11033 {(char *) "virStorageVolGetInfoFlags", libvirt_virStorageVolGetInfoFlags, METH_VARARGS, NULL},
11034 #endif /* LIBVIR_CHECK_VERSION(3, 0, 0) */
11035 {(char *) "virStoragePoolGetUUID", libvirt_virStoragePoolGetUUID, METH_VARARGS, NULL},
11036 {(char *) "virStoragePoolGetUUIDString", libvirt_virStoragePoolGetUUIDString, METH_VARARGS, NULL},
11037 {(char *) "virStoragePoolLookupByUUID", libvirt_virStoragePoolLookupByUUID, METH_VARARGS, NULL},
11038 {(char *) "virEventRegisterImpl", libvirt_virEventRegisterImpl, METH_VARARGS, NULL},
11039 {(char *) "virEventAddHandle", libvirt_virEventAddHandle, METH_VARARGS, NULL},
11040 {(char *) "virEventAddTimeout", libvirt_virEventAddTimeout, METH_VARARGS, NULL},
11041 {(char *) "virEventInvokeHandleCallback", libvirt_virEventInvokeHandleCallback, METH_VARARGS, NULL},
11042 {(char *) "virEventInvokeTimeoutCallback", libvirt_virEventInvokeTimeoutCallback, METH_VARARGS, NULL},
11043 {(char *) "virEventInvokeFreeCallback", libvirt_virEventInvokeFreeCallback, METH_VARARGS, NULL},
11044 {(char *) "virNodeListDevices", libvirt_virNodeListDevices, METH_VARARGS, NULL},
11045 #if LIBVIR_CHECK_VERSION(0, 10, 2)
11046 {(char *) "virConnectListAllNodeDevices", libvirt_virConnectListAllNodeDevices, METH_VARARGS, NULL},
11047 #endif /* LIBVIR_CHECK_VERSION(0, 10, 2) */
11048 {(char *) "virNodeDeviceListCaps", libvirt_virNodeDeviceListCaps, METH_VARARGS, NULL},
11049 {(char *) "virSecretGetUUID", libvirt_virSecretGetUUID, METH_VARARGS, NULL},
11050 {(char *) "virSecretGetUUIDString", libvirt_virSecretGetUUIDString, METH_VARARGS, NULL},
11051 {(char *) "virSecretLookupByUUID", libvirt_virSecretLookupByUUID, METH_VARARGS, NULL},
11052 {(char *) "virConnectListSecrets", libvirt_virConnectListSecrets, METH_VARARGS, NULL},
11053 #if LIBVIR_CHECK_VERSION(0, 10, 2)
11054 {(char *) "virConnectListAllSecrets", libvirt_virConnectListAllSecrets, METH_VARARGS, NULL},
11055 #endif /* LIBVIR_CHECK_VERSION(0, 10, 2) */
11056 {(char *) "virSecretGetValue", libvirt_virSecretGetValue, METH_VARARGS, NULL},
11057 {(char *) "virSecretSetValue", libvirt_virSecretSetValue, METH_VARARGS, NULL},
11058 {(char *) "virNWFilterGetUUID", libvirt_virNWFilterGetUUID, METH_VARARGS, NULL},
11059 {(char *) "virNWFilterGetUUIDString", libvirt_virNWFilterGetUUIDString, METH_VARARGS, NULL},
11060 {(char *) "virNWFilterLookupByUUID", libvirt_virNWFilterLookupByUUID, METH_VARARGS, NULL},
11061 {(char *) "virConnectListNWFilters", libvirt_virConnectListNWFilters, METH_VARARGS, NULL},
11062 #if LIBVIR_CHECK_VERSION(0, 10, 2)
11063 {(char *) "virConnectListAllNWFilters", libvirt_virConnectListAllNWFilters, METH_VARARGS, NULL},
11064 #endif /* LIBVIR_CHECK_VERSION(0, 10, 2) */
11065 #if LIBVIR_CHECK_VERSION(4, 5, 0)
11066 {(char *) "virConnectListAllNWFilterBindings", libvirt_virConnectListAllNWFilterBindings, METH_VARARGS, NULL},
11067 #endif /* LIBVIR_CHECK_VERSION(4, 5, 0) */
11068 {(char *) "virConnectListInterfaces", libvirt_virConnectListInterfaces, METH_VARARGS, NULL},
11069 {(char *) "virConnectListDefinedInterfaces", libvirt_virConnectListDefinedInterfaces, METH_VARARGS, NULL},
11070 #if LIBVIR_CHECK_VERSION(0, 10, 2)
11071 {(char *) "virConnectListAllInterfaces", libvirt_virConnectListAllInterfaces, METH_VARARGS, NULL},
11072 #endif /* LIBVIR_CHECK_VERSION(0, 10, 2) */
11073 {(char *) "virConnectBaselineCPU", libvirt_virConnectBaselineCPU, METH_VARARGS, NULL},
11074 {(char *) "virDomainGetJobInfo", libvirt_virDomainGetJobInfo, METH_VARARGS, NULL},
11075 #if LIBVIR_CHECK_VERSION(1, 0, 3)
11076 {(char *) "virDomainGetJobStats", libvirt_virDomainGetJobStats, METH_VARARGS, NULL},
11077 #endif /* LIBVIR_CHECK_VERSION(1, 0, 3) */
11078 #if LIBVIR_CHECK_VERSION(5, 6, 0)
11079 {(char *) "virDomainListAllCheckpoints", libvirt_virDomainListAllCheckpoints, METH_VARARGS, NULL},
11080 {(char *) "virDomainCheckpointListAllChildren", libvirt_virDomainCheckpointListAllChildren, METH_VARARGS, NULL},
11081 #endif /* LIBVIR_CHECK_VERSION(5, 6, 0) */
11082 {(char *) "virDomainSnapshotListNames", libvirt_virDomainSnapshotListNames, METH_VARARGS, NULL},
11083 #if LIBVIR_CHECK_VERSION(0, 9, 13)
11084 {(char *) "virDomainListAllSnapshots", libvirt_virDomainListAllSnapshots, METH_VARARGS, NULL},
11085 #endif /* LIBVIR_CHECK_VERSION(0, 9, 13) */
11086 {(char *) "virDomainSnapshotListChildrenNames", libvirt_virDomainSnapshotListChildrenNames, METH_VARARGS, NULL},
11087 #if LIBVIR_CHECK_VERSION(0, 9, 13)
11088 {(char *) "virDomainSnapshotListAllChildren", libvirt_virDomainSnapshotListAllChildren, METH_VARARGS, NULL},
11089 #endif /* LIBVIR_CHECK_VERSION(0, 9, 13) */
11090 {(char *) "virDomainRevertToSnapshot", libvirt_virDomainRevertToSnapshot, METH_VARARGS, NULL},
11091 {(char *) "virDomainGetBlockJobInfo", libvirt_virDomainGetBlockJobInfo, METH_VARARGS, NULL},
11092 {(char *) "virDomainSetBlockIoTune", libvirt_virDomainSetBlockIoTune, METH_VARARGS, NULL},
11093 {(char *) "virDomainGetBlockIoTune", libvirt_virDomainGetBlockIoTune, METH_VARARGS, NULL},
11094 {(char *) "virDomainSendKey", libvirt_virDomainSendKey, METH_VARARGS, NULL},
11095 #if LIBVIR_CHECK_VERSION(1, 0, 3)
11096 {(char *) "virDomainMigrateGetCompressionCache", libvirt_virDomainMigrateGetCompressionCache, METH_VARARGS, NULL},
11097 #endif /* LIBVIR_CHECK_VERSION(1, 0, 3) */
11098 {(char *) "virDomainMigrateGetMaxSpeed", libvirt_virDomainMigrateGetMaxSpeed, METH_VARARGS, NULL},
11099 #if LIBVIR_CHECK_VERSION(3, 7, 0)
11100 {(char *) "virDomainMigrateGetMaxDowntime", libvirt_virDomainMigrateGetMaxDowntime, METH_VARARGS, NULL},
11101 #endif /* LIBVIR_CHECK_VERSION(3, 7, 0) */
11102 {(char *) "virDomainMigrateGetMaxSpeed", libvirt_virDomainMigrateGetMaxSpeed, METH_VARARGS, NULL},
11103 #if LIBVIR_CHECK_VERSION(1, 1, 0)
11104 {(char *) "virDomainMigrate3", libvirt_virDomainMigrate3, METH_VARARGS, NULL},
11105 {(char *) "virDomainMigrateToURI3", libvirt_virDomainMigrateToURI3, METH_VARARGS, NULL},
11106 #endif /* LIBVIR_CHECK_VERSION(1, 1, 0) */
11107 {(char *) "virDomainBlockPeek", libvirt_virDomainBlockPeek, METH_VARARGS, NULL},
11108 {(char *) "virDomainMemoryPeek", libvirt_virDomainMemoryPeek, METH_VARARGS, NULL},
11109 {(char *) "virDomainGetDiskErrors", libvirt_virDomainGetDiskErrors, METH_VARARGS, NULL},
11110 #if LIBVIR_CHECK_VERSION(0, 10, 2)
11111 {(char *) "virNodeGetMemoryParameters", libvirt_virNodeGetMemoryParameters, METH_VARARGS, NULL},
11112 {(char *) "virNodeSetMemoryParameters", libvirt_virNodeSetMemoryParameters, METH_VARARGS, NULL},
11113 #endif /* LIBVIR_CHECK_VERSION(0, 10, 2) */
11114 #if LIBVIR_CHECK_VERSION(1, 0, 0)
11115 {(char *) "virNodeGetCPUMap", libvirt_virNodeGetCPUMap, METH_VARARGS, NULL},
11116 #endif /* LIBVIR_CHECK_VERSION(1, 0, 0) */
11117 #if LIBVIR_CHECK_VERSION(1, 1, 1)
11118 {(char *) "virDomainCreateXMLWithFiles", libvirt_virDomainCreateXMLWithFiles, METH_VARARGS, NULL},
11119 {(char *) "virDomainCreateWithFiles", libvirt_virDomainCreateWithFiles, METH_VARARGS, NULL},
11120 #endif /* LIBVIR_CHECK_VERSION(1, 1, 1) */
11121 #if LIBVIR_CHECK_VERSION(1, 2, 5)
11122 {(char *) "virDomainFSFreeze", libvirt_virDomainFSFreeze, METH_VARARGS, NULL},
11123 {(char *) "virDomainFSThaw", libvirt_virDomainFSThaw, METH_VARARGS, NULL},
11124 {(char *) "virDomainGetTime", libvirt_virDomainGetTime, METH_VARARGS, NULL},
11125 {(char *) "virDomainSetTime", libvirt_virDomainSetTime, METH_VARARGS, NULL},
11126 #endif /* LIBVIR_CHECK_VERSION(1, 2, 5) */
11127 #if LIBVIR_CHECK_VERSION(1, 2, 6)
11128 {(char *) "virNodeGetFreePages", libvirt_virNodeGetFreePages, METH_VARARGS, NULL},
11129 {(char *) "virNetworkGetDHCPLeases", libvirt_virNetworkGetDHCPLeases, METH_VARARGS, NULL},
11130 #endif /* LIBVIR_CHECK_VERSION(1, 2, 6) */
11131 #if LIBVIR_CHECK_VERSION(1, 2, 8)
11132 {(char *) "virConnectGetAllDomainStats", libvirt_virConnectGetAllDomainStats, METH_VARARGS, NULL},
11133 {(char *) "virDomainListGetStats", libvirt_virDomainListGetStats, METH_VARARGS, NULL},
11134 {(char *) "virDomainBlockCopy", libvirt_virDomainBlockCopy, METH_VARARGS, NULL},
11135 #endif /* LIBVIR_CHECK_VERSION(1, 2, 8) */
11136 #if LIBVIR_CHECK_VERSION(1, 2, 9)
11137 {(char *) "virNodeAllocPages", libvirt_virNodeAllocPages, METH_VARARGS, NULL},
11138 #endif /* LIBVIR_CHECK_VERSION(1, 2, 9) */
11139 #if LIBVIR_CHECK_VERSION(1, 2, 11)
11140 {(char *) "virDomainGetFSInfo", libvirt_virDomainGetFSInfo, METH_VARARGS, NULL},
11141 #endif /* LIBVIR_CHECK_VERSION(1, 2, 11) */
11142 #if LIBVIR_CHECK_VERSION(1, 2, 14)
11143 {(char *) "virDomainInterfaceAddresses", libvirt_virDomainInterfaceAddresses, METH_VARARGS, NULL},
11144 #endif /* LIBVIR_CHECK_VERSION(1, 2, 14) */
11145 #if LIBVIR_CHECK_VERSION(1, 3, 3)
11146 {(char *) "virDomainGetPerfEvents", libvirt_virDomainGetPerfEvents, METH_VARARGS, NULL},
11147 {(char *) "virDomainSetPerfEvents", libvirt_virDomainSetPerfEvents, METH_VARARGS, NULL},
11148 #endif /* LIBVIR_CHECK_VERSION(1, 3, 3) */
11149 #if LIBVIR_CHECK_VERSION(2, 0, 0)
11150 {(char *) "virConnectStoragePoolEventRegisterAny", libvirt_virConnectStoragePoolEventRegisterAny, METH_VARARGS, NULL},
11151 {(char *) "virConnectStoragePoolEventDeregisterAny", libvirt_virConnectStoragePoolEventDeregisterAny, METH_VARARGS, NULL},
11152 {(char *) "virDomainGetGuestVcpus", libvirt_virDomainGetGuestVcpus, METH_VARARGS, NULL},
11153 #endif /* LIBVIR_CHECK_VERSION(2, 0, 0) */
11154 #if LIBVIR_CHECK_VERSION(2, 2, 0)
11155 {(char *) "virConnectNodeDeviceEventRegisterAny", libvirt_virConnectNodeDeviceEventRegisterAny, METH_VARARGS, NULL},
11156 {(char *) "virConnectNodeDeviceEventDeregisterAny", libvirt_virConnectNodeDeviceEventDeregisterAny, METH_VARARGS, NULL},
11157 #endif /* LIBVIR_CHECK_VERSION(2, 2, 0) */
11158 #if LIBVIR_CHECK_VERSION(3, 0, 0)
11159 {(char *) "virConnectSecretEventRegisterAny", libvirt_virConnectSecretEventRegisterAny, METH_VARARGS, NULL},
11160 {(char *) "virConnectSecretEventDeregisterAny", libvirt_virConnectSecretEventDeregisterAny, METH_VARARGS, NULL},
11161 #endif /* LIBVIR_CHECK_VERSION(3, 0, 0) */
11162 #if LIBVIR_CHECK_VERSION(3, 4, 0)
11163 {(char *) "virStreamRecvHole", libvirt_virStreamRecvHole, METH_VARARGS, NULL},
11164 {(char *) "virStreamSendHole", libvirt_virStreamSendHole, METH_VARARGS, NULL},
11165 {(char *) "virStreamRecvFlags", libvirt_virStreamRecvFlags, METH_VARARGS, NULL},
11166 #endif /* LIBVIR_CHECK_VERSION(3, 4, 0) */
11167 #if LIBVIR_CHECK_VERSION(4, 4, 0)
11168 {(char *) "virConnectBaselineHypervisorCPU", libvirt_virConnectBaselineHypervisorCPU, METH_VARARGS, NULL},
11169 #endif /* LIBVIR_CHECK_VERSION(4, 4, 0) */
11170 #if LIBVIR_CHECK_VERSION(4, 5, 0)
11171 {(char *) "virDomainGetLaunchSecurityInfo", libvirt_virDomainGetLaunchSecurityInfo, METH_VARARGS, NULL},
11172 {(char *) "virNodeGetSEVInfo", libvirt_virNodeGetSEVInfo, METH_VARARGS, NULL},
11173 #endif /* LIBVIR_CHECK_VERSION(4, 5, 0) */
11174 #if LIBVIR_CHECK_VERSION(5, 5, 0)
11175 {(char *) "virNetworkListAllPorts", libvirt_virNetworkListAllPorts, METH_VARARGS, NULL},
11176 {(char *) "virNetworkPortSetParameters", libvirt_virNetworkPortSetParameters, METH_VARARGS, NULL},
11177 {(char *) "virNetworkPortGetParameters", libvirt_virNetworkPortGetParameters, METH_VARARGS, NULL},
11178 {(char *) "virNetworkPortGetUUID", libvirt_virNetworkPortGetUUID, METH_VARARGS, NULL},
11179 {(char *) "virNetworkPortGetUUIDString", libvirt_virNetworkPortGetUUIDString, METH_VARARGS, NULL},
11180 {(char *) "virNetworkPortLookupByUUID", libvirt_virNetworkPortLookupByUUID, METH_VARARGS, NULL},
11181 #endif /* LIBVIR_CHECK_VERSION(5, 5, 0) */
11182 #if LIBVIR_CHECK_VERSION(5, 7, 0)
11183 {(char *) "virDomainGetGuestInfo", libvirt_virDomainGetGuestInfo, METH_VARARGS, NULL},
11184 #endif /* LIBVIR_CHECK_VERSION(5, 7, 0) */
11185 #if LIBVIR_CHECK_VERSION(5, 8, 0)
11186 {(char *) "virConnectSetIdentity", libvirt_virConnectSetIdentity, METH_VARARGS, NULL},
11187 #endif /* LIBVIR_CHECK_VERSION(5, 8, 0) */
11188 #if LIBVIR_CHECK_VERSION(6, 10, 0)
11189 {(char *) "virDomainAuthorizedSSHKeysGet", libvirt_virDomainAuthorizedSSHKeysGet, METH_VARARGS, NULL},
11190 {(char *) "virDomainAuthorizedSSHKeysSet", libvirt_virDomainAuthorizedSSHKeysSet, METH_VARARGS, NULL},
11191 #endif /* LIBVIR_CHECK_VERSION(6, 10, 0) */
11192 #if LIBVIR_CHECK_VERSION(7, 1, 0)
11193 {(char *) "virDomainGetMessages", libvirt_virDomainGetMessages, METH_VARARGS, NULL},
11194 #endif /* LIBVIR_CHECK_VERSION(7, 1, 0) */
11195 #if LIBVIR_CHECK_VERSION(7, 8, 0)
11196 {(char *) "virNodeDeviceGetAutostart", libvirt_virNodeDeviceGetAutostart, METH_VARARGS, NULL},
11197 #endif /* LIBVIR_CHECK_VERSION(7, 8, 0) */
11198 #if LIBVIR_CHECK_VERSION(8, 0, 0)
11199 {(char *) "virDomainSetLaunchSecurityState", libvirt_virDomainSetLaunchSecurityState, METH_VARARGS, NULL},
11200 #endif /* LIBVIR_CHECK_VERSION(8, 0, 0) */
11201 #if LIBVIR_CHECK_VERSION(8, 4, 0)
11202 {(char *) "virDomainSaveParams", libvirt_virDomainSaveParams, METH_VARARGS, NULL},
11203 {(char *) "virDomainRestoreParams", libvirt_virDomainRestoreParams, METH_VARARGS, NULL},
11204 #endif /* LIBVIR_CHECK_VERSION(8, 4, 0) */
11205 #if LIBVIR_CHECK_VERSION(9, 0, 0)
11206 {(char *) "virDomainFDAssociate", libvirt_virDomainFDAssociate, METH_VARARGS, NULL},
11207 #endif /* LIBVIR_CHECK_VERSION(9, 0, 0) */
11208 {NULL, NULL, 0, NULL}
11209 };
11210
11211 static struct PyModuleDef moduledef = {
11212 PyModuleDef_HEAD_INIT,
11213 #ifndef __CYGWIN__
11214 "libvirtmod",
11215 #else
11216 "cygvirtmod",
11217 #endif
11218 NULL,
11219 -1,
11220 libvirtMethods,
11221 NULL,
11222 NULL,
11223 NULL,
11224 NULL
11225 };
11226
11227 PyObject *
11228 #ifndef __CYGWIN__
11229 PyInit_libvirtmod
11230 #else
11231 PyInit_cygvirtmod
11232 #endif
11233 (void)
11234 {
11235 PyObject *module;
11236
11237 if (virInitialize() < 0)
11238 return NULL;
11239
11240 module = PyModule_Create(&moduledef);
11241
11242 return module;
11243 }
Python bindings for libvirt