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 | |
18 | void 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 | |
25 | void 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 | |
32 | void 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 | |
39 | void 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 | |
46 | void 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 | |
53 | void 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 | |
60 | void 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 | |
67 | void 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 | |
76 | out: |
77 | error_propagate(errp, err); |
78 | } |
79 | |
80 | void 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); |
96 | out_obj: |
97 | visit_end_struct(v, (void **)obj); |
98 | if (err && visit_is_input(v)) { |
99 | qapi_free_QCryptoBlockOptionsBase(*obj); |
100 | *obj = NULL; |
101 | } |
102 | out: |
103 | error_propagate(errp, err); |
104 | } |
105 | |
106 | void 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 | |
117 | out: |
118 | error_propagate(errp, err); |
119 | } |
120 | |
121 | void 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); |
137 | out_obj: |
138 | visit_end_struct(v, (void **)obj); |
139 | if (err && visit_is_input(v)) { |
140 | qapi_free_QCryptoBlockOptionsQCow(*obj); |
141 | *obj = NULL; |
142 | } |
143 | out: |
144 | error_propagate(errp, err); |
145 | } |
146 | |
147 | void 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 | |
158 | out: |
159 | error_propagate(errp, err); |
160 | } |
161 | |
162 | void 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); |
178 | out_obj: |
179 | visit_end_struct(v, (void **)obj); |
180 | if (err && visit_is_input(v)) { |
181 | qapi_free_QCryptoBlockOptionsLUKS(*obj); |
182 | *obj = NULL; |
183 | } |
184 | out: |
185 | error_propagate(errp, err); |
186 | } |
187 | |
188 | void 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 | |
233 | out: |
234 | error_propagate(errp, err); |
235 | } |
236 | |
237 | void 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); |
253 | out_obj: |
254 | visit_end_struct(v, (void **)obj); |
255 | if (err && visit_is_input(v)) { |
256 | qapi_free_QCryptoBlockCreateOptionsLUKS(*obj); |
257 | *obj = NULL; |
258 | } |
259 | out: |
260 | error_propagate(errp, err); |
261 | } |
262 | |
263 | void 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 | |
282 | out: |
283 | error_propagate(errp, err); |
284 | } |
285 | |
286 | void 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); |
302 | out_obj: |
303 | visit_end_struct(v, (void **)obj); |
304 | if (err && visit_is_input(v)) { |
305 | qapi_free_QCryptoBlockOpenOptions(*obj); |
306 | *obj = NULL; |
307 | } |
308 | out: |
309 | error_propagate(errp, err); |
310 | } |
311 | |
312 | void 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 | |
331 | out: |
332 | error_propagate(errp, err); |
333 | } |
334 | |
335 | void 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); |
351 | out_obj: |
352 | visit_end_struct(v, (void **)obj); |
353 | if (err && visit_is_input(v)) { |
354 | qapi_free_QCryptoBlockCreateOptions(*obj); |
355 | *obj = NULL; |
356 | } |
357 | out: |
358 | error_propagate(errp, err); |
359 | } |
360 | |
361 | void 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 | |
370 | out: |
371 | error_propagate(errp, err); |
372 | } |
373 | |
374 | void 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); |
390 | out_obj: |
391 | visit_end_struct(v, (void **)obj); |
392 | if (err && visit_is_input(v)) { |
393 | qapi_free_QCryptoBlockInfoBase(*obj); |
394 | *obj = NULL; |
395 | } |
396 | out: |
397 | error_propagate(errp, err); |
398 | } |
399 | |
400 | void 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 | |
425 | out: |
426 | error_propagate(errp, err); |
427 | } |
428 | |
429 | void 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); |
445 | out_obj: |
446 | visit_end_struct(v, (void **)obj); |
447 | if (err && visit_is_input(v)) { |
448 | qapi_free_QCryptoBlockInfoLUKSSlot(*obj); |
449 | *obj = NULL; |
450 | } |
451 | out: |
452 | error_propagate(errp, err); |
453 | } |
454 | |
455 | void 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 | } |
482 | out: |
483 | error_propagate(errp, err); |
484 | } |
485 | |
486 | void 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 | |
529 | out: |
530 | error_propagate(errp, err); |
531 | } |
532 | |
533 | void 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); |
549 | out_obj: |
550 | visit_end_struct(v, (void **)obj); |
551 | if (err && visit_is_input(v)) { |
552 | qapi_free_QCryptoBlockInfoLUKS(*obj); |
553 | *obj = NULL; |
554 | } |
555 | out: |
556 | error_propagate(errp, err); |
557 | } |
558 | |
559 | void 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 | |
577 | out: |
578 | error_propagate(errp, err); |
579 | } |
580 | |
581 | void 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); |
597 | out_obj: |
598 | visit_end_struct(v, (void **)obj); |
599 | if (err && visit_is_input(v)) { |
600 | qapi_free_QCryptoBlockInfo(*obj); |
601 | *obj = NULL; |
602 | } |
603 | out: |
604 | error_propagate(errp, err); |
605 | } |
606 | |
607 | /* Dummy declaration to prevent empty .o file */ |
608 | char qapi_dummy_qapi_visit_crypto_c; |
609 | |