1 /* 2 * Copy one QAPI object to another 3 * 4 * Copyright (C) 2016 Red Hat, Inc. 5 * 6 * This work is licensed under the terms of the GNU GPL, version 2 or later. 7 * See the COPYING file in the top-level directory. 8 * 9 */ 10 11 #include "qemu/osdep.h" 12 #include "qapi/clone-visitor.h" 13 #include "qapi/visitor-impl.h" 14 #include "qapi/error.h" 15 #include "qapi/qmp/qnull.h" 16 17 struct QapiCloneVisitor { 18 Visitor visitor; 19 size_t depth; 20 }; 21 22 static QapiCloneVisitor *to_qcv(Visitor *v) 23 { 24 return container_of(v, QapiCloneVisitor, visitor); 25 } 26 27 static bool qapi_clone_start_struct(Visitor *v, const char *name, void **obj, 28 size_t size, Error **errp) 29 { 30 QapiCloneVisitor *qcv = to_qcv(v); 31 32 if (!obj) { 33 assert(qcv->depth); 34 /* Only possible when visiting an alternate's object 35 * branch. Nothing further to do here, since the earlier 36 * visit_start_alternate() already copied memory. */ 37 return true; 38 } 39 40 *obj = g_memdup(*obj, size); 41 qcv->depth++; 42 return true; 43 } 44 45 static void qapi_clone_end(Visitor *v, void **obj) 46 { 47 QapiCloneVisitor *qcv = to_qcv(v); 48 49 assert(qcv->depth); 50 if (obj) { 51 qcv->depth--; 52 } 53 } 54 55 static bool qapi_clone_start_list(Visitor *v, const char *name, 56 GenericList **listp, size_t size, 57 Error **errp) 58 { 59 return qapi_clone_start_struct(v, name, (void **)listp, size, errp); 60 } 61 62 static GenericList *qapi_clone_next_list(Visitor *v, GenericList *tail, 63 size_t size) 64 { 65 QapiCloneVisitor *qcv = to_qcv(v); 66 67 assert(qcv->depth); 68 /* Unshare the tail of the list cloned by g_memdup() */ 69 tail->next = g_memdup(tail->next, size); 70 return tail->next; 71 } 72 73 static bool qapi_clone_start_alternate(Visitor *v, const char *name, 74 GenericAlternate **obj, size_t size, 75 Error **errp) 76 { 77 return qapi_clone_start_struct(v, name, (void **)obj, size, errp); 78 } 79 80 static bool qapi_clone_type_int64(Visitor *v, const char *name, int64_t *obj, 81 Error **errp) 82 { 83 QapiCloneVisitor *qcv = to_qcv(v); 84 85 assert(qcv->depth); 86 /* Value was already cloned by g_memdup() */ 87 return true; 88 } 89 90 static bool qapi_clone_type_uint64(Visitor *v, const char *name, 91 uint64_t *obj, Error **errp) 92 { 93 QapiCloneVisitor *qcv = to_qcv(v); 94 95 assert(qcv->depth); 96 /* Value was already cloned by g_memdup() */ 97 return true; 98 } 99 100 static bool qapi_clone_type_bool(Visitor *v, const char *name, bool *obj, 101 Error **errp) 102 { 103 QapiCloneVisitor *qcv = to_qcv(v); 104 105 assert(qcv->depth); 106 /* Value was already cloned by g_memdup() */ 107 return true; 108 } 109 110 static bool qapi_clone_type_str(Visitor *v, const char *name, char **obj, 111 Error **errp) 112 { 113 QapiCloneVisitor *qcv = to_qcv(v); 114 115 assert(qcv->depth); 116 /* 117 * Pointer was already cloned by g_memdup; create fresh copy. 118 * Note that as long as qobject-output-visitor accepts NULL instead of 119 * "", then we must do likewise. However, we want to obey the 120 * input visitor semantics of never producing NULL when the empty 121 * string is intended. 122 */ 123 *obj = g_strdup(*obj ?: ""); 124 return true; 125 } 126 127 static bool qapi_clone_type_number(Visitor *v, const char *name, double *obj, 128 Error **errp) 129 { 130 QapiCloneVisitor *qcv = to_qcv(v); 131 132 assert(qcv->depth); 133 /* Value was already cloned by g_memdup() */ 134 return true; 135 } 136 137 static bool qapi_clone_type_null(Visitor *v, const char *name, QNull **obj, 138 Error **errp) 139 { 140 QapiCloneVisitor *qcv = to_qcv(v); 141 142 assert(qcv->depth); 143 *obj = qnull(); 144 return true; 145 } 146 147 static void qapi_clone_free(Visitor *v) 148 { 149 g_free(v); 150 } 151 152 Visitor *qapi_clone_visitor_new(void) 153 { 154 QapiCloneVisitor *v; 155 156 v = g_malloc0(sizeof(*v)); 157 158 v->visitor.type = VISITOR_CLONE; 159 v->visitor.start_struct = qapi_clone_start_struct; 160 v->visitor.end_struct = qapi_clone_end; 161 v->visitor.start_list = qapi_clone_start_list; 162 v->visitor.next_list = qapi_clone_next_list; 163 v->visitor.end_list = qapi_clone_end; 164 v->visitor.start_alternate = qapi_clone_start_alternate; 165 v->visitor.end_alternate = qapi_clone_end; 166 v->visitor.type_int64 = qapi_clone_type_int64; 167 v->visitor.type_uint64 = qapi_clone_type_uint64; 168 v->visitor.type_bool = qapi_clone_type_bool; 169 v->visitor.type_str = qapi_clone_type_str; 170 v->visitor.type_number = qapi_clone_type_number; 171 v->visitor.type_null = qapi_clone_type_null; 172 v->visitor.free = qapi_clone_free; 173 174 return &v->visitor; 175 } 176 177 Visitor *qapi_clone_members_visitor_new(void) 178 { 179 Visitor *v = qapi_clone_visitor_new(); 180 to_qcv(v)->depth++; 181 return v; 182 } 183