1/* AUTOMATICALLY GENERATED, DO NOT MODIFY */
2
3/*
4 * Schema-defined QAPI visitors
5 *
6 * Copyright IBM, Corp. 2011
7 * Copyright (C) 2014-2018 Red Hat, Inc.
8 *
9 * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
10 * See the COPYING.LIB file in the top-level directory.
11 */
12
13#include "qemu/osdep.h"
14#include "qapi/error.h"
15#include "qapi/qmp/qerror.h"
16#include "qapi-visit-crypto.h"
17
18void visit_type_QCryptoTLSCredsEndpoint(Visitor *v, const char *name, QCryptoTLSCredsEndpoint *obj, Error **errp)
19{
20 int value = *obj;
21 visit_type_enum(v, name, &value, &QCryptoTLSCredsEndpoint_lookup, errp);
22 *obj = value;
23}
24
25void visit_type_QCryptoSecretFormat(Visitor *v, const char *name, QCryptoSecretFormat *obj, Error **errp)
26{
27 int value = *obj;
28 visit_type_enum(v, name, &value, &QCryptoSecretFormat_lookup, errp);
29 *obj = value;
30}
31
32void visit_type_QCryptoHashAlgorithm(Visitor *v, const char *name, QCryptoHashAlgorithm *obj, Error **errp)
33{
34 int value = *obj;
35 visit_type_enum(v, name, &value, &QCryptoHashAlgorithm_lookup, errp);
36 *obj = value;
37}
38
39void visit_type_QCryptoCipherAlgorithm(Visitor *v, const char *name, QCryptoCipherAlgorithm *obj, Error **errp)
40{
41 int value = *obj;
42 visit_type_enum(v, name, &value, &QCryptoCipherAlgorithm_lookup, errp);
43 *obj = value;
44}
45
46void visit_type_QCryptoCipherMode(Visitor *v, const char *name, QCryptoCipherMode *obj, Error **errp)
47{
48 int value = *obj;
49 visit_type_enum(v, name, &value, &QCryptoCipherMode_lookup, errp);
50 *obj = value;
51}
52
53void visit_type_QCryptoIVGenAlgorithm(Visitor *v, const char *name, QCryptoIVGenAlgorithm *obj, Error **errp)
54{
55 int value = *obj;
56 visit_type_enum(v, name, &value, &QCryptoIVGenAlgorithm_lookup, errp);
57 *obj = value;
58}
59
60void visit_type_QCryptoBlockFormat(Visitor *v, const char *name, QCryptoBlockFormat *obj, Error **errp)
61{
62 int value = *obj;
63 visit_type_enum(v, name, &value, &QCryptoBlockFormat_lookup, errp);
64 *obj = value;
65}
66
67void visit_type_QCryptoBlockOptionsBase_members(Visitor *v, QCryptoBlockOptionsBase *obj, Error **errp)
68{
69 Error *err = NULL;
70
71 visit_type_QCryptoBlockFormat(v, "format", &obj->format, &err);
72 if (err) {
73 goto out;
74 }
75
76out:
77 error_propagate(errp, err);
78}
79
80void visit_type_QCryptoBlockOptionsBase(Visitor *v, const char *name, QCryptoBlockOptionsBase **obj, Error **errp)
81{
82 Error *err = NULL;
83
84 visit_start_struct(v, name, (void **)obj, sizeof(QCryptoBlockOptionsBase), &err);
85 if (err) {
86 goto out;
87 }
88 if (!*obj) {
89 goto out_obj;
90 }
91 visit_type_QCryptoBlockOptionsBase_members(v, *obj, &err);
92 if (err) {
93 goto out_obj;
94 }
95 visit_check_struct(v, &err);
96out_obj:
97 visit_end_struct(v, (void **)obj);
98 if (err && visit_is_input(v)) {
99 qapi_free_QCryptoBlockOptionsBase(*obj);
100 *obj = NULL;
101 }
102out:
103 error_propagate(errp, err);
104}
105
106void visit_type_QCryptoBlockOptionsQCow_members(Visitor *v, QCryptoBlockOptionsQCow *obj, Error **errp)
107{
108 Error *err = NULL;
109
110 if (visit_optional(v, "key-secret", &obj->has_key_secret)) {
111 visit_type_str(v, "key-secret", &obj->key_secret, &err);
112 if (err) {
113 goto out;
114 }
115 }
116
117out:
118 error_propagate(errp, err);
119}
120
121void visit_type_QCryptoBlockOptionsQCow(Visitor *v, const char *name, QCryptoBlockOptionsQCow **obj, Error **errp)
122{
123 Error *err = NULL;
124
125 visit_start_struct(v, name, (void **)obj, sizeof(QCryptoBlockOptionsQCow), &err);
126 if (err) {
127 goto out;
128 }
129 if (!*obj) {
130 goto out_obj;
131 }
132 visit_type_QCryptoBlockOptionsQCow_members(v, *obj, &err);
133 if (err) {
134 goto out_obj;
135 }
136 visit_check_struct(v, &err);
137out_obj:
138 visit_end_struct(v, (void **)obj);
139 if (err && visit_is_input(v)) {
140 qapi_free_QCryptoBlockOptionsQCow(*obj);
141 *obj = NULL;
142 }
143out:
144 error_propagate(errp, err);
145}
146
147void visit_type_QCryptoBlockOptionsLUKS_members(Visitor *v, QCryptoBlockOptionsLUKS *obj, Error **errp)
148{
149 Error *err = NULL;
150
151 if (visit_optional(v, "key-secret", &obj->has_key_secret)) {
152 visit_type_str(v, "key-secret", &obj->key_secret, &err);
153 if (err) {
154 goto out;
155 }
156 }
157
158out:
159 error_propagate(errp, err);
160}
161
162void visit_type_QCryptoBlockOptionsLUKS(Visitor *v, const char *name, QCryptoBlockOptionsLUKS **obj, Error **errp)
163{
164 Error *err = NULL;
165
166 visit_start_struct(v, name, (void **)obj, sizeof(QCryptoBlockOptionsLUKS), &err);
167 if (err) {
168 goto out;
169 }
170 if (!*obj) {
171 goto out_obj;
172 }
173 visit_type_QCryptoBlockOptionsLUKS_members(v, *obj, &err);
174 if (err) {
175 goto out_obj;
176 }
177 visit_check_struct(v, &err);
178out_obj:
179 visit_end_struct(v, (void **)obj);
180 if (err && visit_is_input(v)) {
181 qapi_free_QCryptoBlockOptionsLUKS(*obj);
182 *obj = NULL;
183 }
184out:
185 error_propagate(errp, err);
186}
187
188void visit_type_QCryptoBlockCreateOptionsLUKS_members(Visitor *v, QCryptoBlockCreateOptionsLUKS *obj, Error **errp)
189{
190 Error *err = NULL;
191
192 visit_type_QCryptoBlockOptionsLUKS_members(v, (QCryptoBlockOptionsLUKS *)obj, &err);
193 if (err) {
194 goto out;
195 }
196 if (visit_optional(v, "cipher-alg", &obj->has_cipher_alg)) {
197 visit_type_QCryptoCipherAlgorithm(v, "cipher-alg", &obj->cipher_alg, &err);
198 if (err) {
199 goto out;
200 }
201 }
202 if (visit_optional(v, "cipher-mode", &obj->has_cipher_mode)) {
203 visit_type_QCryptoCipherMode(v, "cipher-mode", &obj->cipher_mode, &err);
204 if (err) {
205 goto out;
206 }
207 }
208 if (visit_optional(v, "ivgen-alg", &obj->has_ivgen_alg)) {
209 visit_type_QCryptoIVGenAlgorithm(v, "ivgen-alg", &obj->ivgen_alg, &err);
210 if (err) {
211 goto out;
212 }
213 }
214 if (visit_optional(v, "ivgen-hash-alg", &obj->has_ivgen_hash_alg)) {
215 visit_type_QCryptoHashAlgorithm(v, "ivgen-hash-alg", &obj->ivgen_hash_alg, &err);
216 if (err) {
217 goto out;
218 }
219 }
220 if (visit_optional(v, "hash-alg", &obj->has_hash_alg)) {
221 visit_type_QCryptoHashAlgorithm(v, "hash-alg", &obj->hash_alg, &err);
222 if (err) {
223 goto out;
224 }
225 }
226 if (visit_optional(v, "iter-time", &obj->has_iter_time)) {
227 visit_type_int(v, "iter-time", &obj->iter_time, &err);
228 if (err) {
229 goto out;
230 }
231 }
232
233out:
234 error_propagate(errp, err);
235}
236
237void visit_type_QCryptoBlockCreateOptionsLUKS(Visitor *v, const char *name, QCryptoBlockCreateOptionsLUKS **obj, Error **errp)
238{
239 Error *err = NULL;
240
241 visit_start_struct(v, name, (void **)obj, sizeof(QCryptoBlockCreateOptionsLUKS), &err);
242 if (err) {
243 goto out;
244 }
245 if (!*obj) {
246 goto out_obj;
247 }
248 visit_type_QCryptoBlockCreateOptionsLUKS_members(v, *obj, &err);
249 if (err) {
250 goto out_obj;
251 }
252 visit_check_struct(v, &err);
253out_obj:
254 visit_end_struct(v, (void **)obj);
255 if (err && visit_is_input(v)) {
256 qapi_free_QCryptoBlockCreateOptionsLUKS(*obj);
257 *obj = NULL;
258 }
259out:
260 error_propagate(errp, err);
261}
262
263void visit_type_QCryptoBlockOpenOptions_members(Visitor *v, QCryptoBlockOpenOptions *obj, Error **errp)
264{
265 Error *err = NULL;
266
267 visit_type_QCryptoBlockOptionsBase_members(v, (QCryptoBlockOptionsBase *)obj, &err);
268 if (err) {
269 goto out;
270 }
271 switch (obj->format) {
272 case Q_CRYPTO_BLOCK_FORMAT_QCOW:
273 visit_type_QCryptoBlockOptionsQCow_members(v, &obj->u.qcow, &err);
274 break;
275 case Q_CRYPTO_BLOCK_FORMAT_LUKS:
276 visit_type_QCryptoBlockOptionsLUKS_members(v, &obj->u.luks, &err);
277 break;
278 default:
279 abort();
280 }
281
282out:
283 error_propagate(errp, err);
284}
285
286void visit_type_QCryptoBlockOpenOptions(Visitor *v, const char *name, QCryptoBlockOpenOptions **obj, Error **errp)
287{
288 Error *err = NULL;
289
290 visit_start_struct(v, name, (void **)obj, sizeof(QCryptoBlockOpenOptions), &err);
291 if (err) {
292 goto out;
293 }
294 if (!*obj) {
295 goto out_obj;
296 }
297 visit_type_QCryptoBlockOpenOptions_members(v, *obj, &err);
298 if (err) {
299 goto out_obj;
300 }
301 visit_check_struct(v, &err);
302out_obj:
303 visit_end_struct(v, (void **)obj);
304 if (err && visit_is_input(v)) {
305 qapi_free_QCryptoBlockOpenOptions(*obj);
306 *obj = NULL;
307 }
308out:
309 error_propagate(errp, err);
310}
311
312void visit_type_QCryptoBlockCreateOptions_members(Visitor *v, QCryptoBlockCreateOptions *obj, Error **errp)
313{
314 Error *err = NULL;
315
316 visit_type_QCryptoBlockOptionsBase_members(v, (QCryptoBlockOptionsBase *)obj, &err);
317 if (err) {
318 goto out;
319 }
320 switch (obj->format) {
321 case Q_CRYPTO_BLOCK_FORMAT_QCOW:
322 visit_type_QCryptoBlockOptionsQCow_members(v, &obj->u.qcow, &err);
323 break;
324 case Q_CRYPTO_BLOCK_FORMAT_LUKS:
325 visit_type_QCryptoBlockCreateOptionsLUKS_members(v, &obj->u.luks, &err);
326 break;
327 default:
328 abort();
329 }
330
331out:
332 error_propagate(errp, err);
333}
334
335void visit_type_QCryptoBlockCreateOptions(Visitor *v, const char *name, QCryptoBlockCreateOptions **obj, Error **errp)
336{
337 Error *err = NULL;
338
339 visit_start_struct(v, name, (void **)obj, sizeof(QCryptoBlockCreateOptions), &err);
340 if (err) {
341 goto out;
342 }
343 if (!*obj) {
344 goto out_obj;
345 }
346 visit_type_QCryptoBlockCreateOptions_members(v, *obj, &err);
347 if (err) {
348 goto out_obj;
349 }
350 visit_check_struct(v, &err);
351out_obj:
352 visit_end_struct(v, (void **)obj);
353 if (err && visit_is_input(v)) {
354 qapi_free_QCryptoBlockCreateOptions(*obj);
355 *obj = NULL;
356 }
357out:
358 error_propagate(errp, err);
359}
360
361void visit_type_QCryptoBlockInfoBase_members(Visitor *v, QCryptoBlockInfoBase *obj, Error **errp)
362{
363 Error *err = NULL;
364
365 visit_type_QCryptoBlockFormat(v, "format", &obj->format, &err);
366 if (err) {
367 goto out;
368 }
369
370out:
371 error_propagate(errp, err);
372}
373
374void visit_type_QCryptoBlockInfoBase(Visitor *v, const char *name, QCryptoBlockInfoBase **obj, Error **errp)
375{
376 Error *err = NULL;
377
378 visit_start_struct(v, name, (void **)obj, sizeof(QCryptoBlockInfoBase), &err);
379 if (err) {
380 goto out;
381 }
382 if (!*obj) {
383 goto out_obj;
384 }
385 visit_type_QCryptoBlockInfoBase_members(v, *obj, &err);
386 if (err) {
387 goto out_obj;
388 }
389 visit_check_struct(v, &err);
390out_obj:
391 visit_end_struct(v, (void **)obj);
392 if (err && visit_is_input(v)) {
393 qapi_free_QCryptoBlockInfoBase(*obj);
394 *obj = NULL;
395 }
396out:
397 error_propagate(errp, err);
398}
399
400void visit_type_QCryptoBlockInfoLUKSSlot_members(Visitor *v, QCryptoBlockInfoLUKSSlot *obj, Error **errp)
401{
402 Error *err = NULL;
403
404 visit_type_bool(v, "active", &obj->active, &err);
405 if (err) {
406 goto out;
407 }
408 if (visit_optional(v, "iters", &obj->has_iters)) {
409 visit_type_int(v, "iters", &obj->iters, &err);
410 if (err) {
411 goto out;
412 }
413 }
414 if (visit_optional(v, "stripes", &obj->has_stripes)) {
415 visit_type_int(v, "stripes", &obj->stripes, &err);
416 if (err) {
417 goto out;
418 }
419 }
420 visit_type_int(v, "key-offset", &obj->key_offset, &err);
421 if (err) {
422 goto out;
423 }
424
425out:
426 error_propagate(errp, err);
427}
428
429void visit_type_QCryptoBlockInfoLUKSSlot(Visitor *v, const char *name, QCryptoBlockInfoLUKSSlot **obj, Error **errp)
430{
431 Error *err = NULL;
432
433 visit_start_struct(v, name, (void **)obj, sizeof(QCryptoBlockInfoLUKSSlot), &err);
434 if (err) {
435 goto out;
436 }
437 if (!*obj) {
438 goto out_obj;
439 }
440 visit_type_QCryptoBlockInfoLUKSSlot_members(v, *obj, &err);
441 if (err) {
442 goto out_obj;
443 }
444 visit_check_struct(v, &err);
445out_obj:
446 visit_end_struct(v, (void **)obj);
447 if (err && visit_is_input(v)) {
448 qapi_free_QCryptoBlockInfoLUKSSlot(*obj);
449 *obj = NULL;
450 }
451out:
452 error_propagate(errp, err);
453}
454
455void visit_type_QCryptoBlockInfoLUKSSlotList(Visitor *v, const char *name, QCryptoBlockInfoLUKSSlotList **obj, Error **errp)
456{
457 Error *err = NULL;
458 QCryptoBlockInfoLUKSSlotList *tail;
459 size_t size = sizeof(**obj);
460
461 visit_start_list(v, name, (GenericList **)obj, size, &err);
462 if (err) {
463 goto out;
464 }
465
466 for (tail = *obj; tail;
467 tail = (QCryptoBlockInfoLUKSSlotList *)visit_next_list(v, (GenericList *)tail, size)) {
468 visit_type_QCryptoBlockInfoLUKSSlot(v, NULL, &tail->value, &err);
469 if (err) {
470 break;
471 }
472 }
473
474 if (!err) {
475 visit_check_list(v, &err);
476 }
477 visit_end_list(v, (void **)obj);
478 if (err && visit_is_input(v)) {
479 qapi_free_QCryptoBlockInfoLUKSSlotList(*obj);
480 *obj = NULL;
481 }
482out:
483 error_propagate(errp, err);
484}
485
486void visit_type_QCryptoBlockInfoLUKS_members(Visitor *v, QCryptoBlockInfoLUKS *obj, Error **errp)
487{
488 Error *err = NULL;
489
490 visit_type_QCryptoCipherAlgorithm(v, "cipher-alg", &obj->cipher_alg, &err);
491 if (err) {
492 goto out;
493 }
494 visit_type_QCryptoCipherMode(v, "cipher-mode", &obj->cipher_mode, &err);
495 if (err) {
496 goto out;
497 }
498 visit_type_QCryptoIVGenAlgorithm(v, "ivgen-alg", &obj->ivgen_alg, &err);
499 if (err) {
500 goto out;
501 }
502 if (visit_optional(v, "ivgen-hash-alg", &obj->has_ivgen_hash_alg)) {
503 visit_type_QCryptoHashAlgorithm(v, "ivgen-hash-alg", &obj->ivgen_hash_alg, &err);
504 if (err) {
505 goto out;
506 }
507 }
508 visit_type_QCryptoHashAlgorithm(v, "hash-alg", &obj->hash_alg, &err);
509 if (err) {
510 goto out;
511 }
512 visit_type_int(v, "payload-offset", &obj->payload_offset, &err);
513 if (err) {
514 goto out;
515 }
516 visit_type_int(v, "master-key-iters", &obj->master_key_iters, &err);
517 if (err) {
518 goto out;
519 }
520 visit_type_str(v, "uuid", &obj->uuid, &err);
521 if (err) {
522 goto out;
523 }
524 visit_type_QCryptoBlockInfoLUKSSlotList(v, "slots", &obj->slots, &err);
525 if (err) {
526 goto out;
527 }
528
529out:
530 error_propagate(errp, err);
531}
532
533void visit_type_QCryptoBlockInfoLUKS(Visitor *v, const char *name, QCryptoBlockInfoLUKS **obj, Error **errp)
534{
535 Error *err = NULL;
536
537 visit_start_struct(v, name, (void **)obj, sizeof(QCryptoBlockInfoLUKS), &err);
538 if (err) {
539 goto out;
540 }
541 if (!*obj) {
542 goto out_obj;
543 }
544 visit_type_QCryptoBlockInfoLUKS_members(v, *obj, &err);
545 if (err) {
546 goto out_obj;
547 }
548 visit_check_struct(v, &err);
549out_obj:
550 visit_end_struct(v, (void **)obj);
551 if (err && visit_is_input(v)) {
552 qapi_free_QCryptoBlockInfoLUKS(*obj);
553 *obj = NULL;
554 }
555out:
556 error_propagate(errp, err);
557}
558
559void visit_type_QCryptoBlockInfo_members(Visitor *v, QCryptoBlockInfo *obj, Error **errp)
560{
561 Error *err = NULL;
562
563 visit_type_QCryptoBlockInfoBase_members(v, (QCryptoBlockInfoBase *)obj, &err);
564 if (err) {
565 goto out;
566 }
567 switch (obj->format) {
568 case Q_CRYPTO_BLOCK_FORMAT_LUKS:
569 visit_type_QCryptoBlockInfoLUKS_members(v, &obj->u.luks, &err);
570 break;
571 case Q_CRYPTO_BLOCK_FORMAT_QCOW:
572 break;
573 default:
574 abort();
575 }
576
577out:
578 error_propagate(errp, err);
579}
580
581void visit_type_QCryptoBlockInfo(Visitor *v, const char *name, QCryptoBlockInfo **obj, Error **errp)
582{
583 Error *err = NULL;
584
585 visit_start_struct(v, name, (void **)obj, sizeof(QCryptoBlockInfo), &err);
586 if (err) {
587 goto out;
588 }
589 if (!*obj) {
590 goto out_obj;
591 }
592 visit_type_QCryptoBlockInfo_members(v, *obj, &err);
593 if (err) {
594 goto out_obj;
595 }
596 visit_check_struct(v, &err);
597out_obj:
598 visit_end_struct(v, (void **)obj);
599 if (err && visit_is_input(v)) {
600 qapi_free_QCryptoBlockInfo(*obj);
601 *obj = NULL;
602 }
603out:
604 error_propagate(errp, err);
605}
606
607/* Dummy declaration to prevent empty .o file */
608char qapi_dummy_qapi_visit_crypto_c;
609