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