qapi/qapi-forward-visitor.c

   1 /*
   2  * Forward Visitor
   3  *
   4  * Copyright (C) 2021 Red Hat, Inc.
   5  *
   6  * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
   7  * See the COPYING.LIB file in the top-level directory.
   8  *
   9  */
  10
  11 #include "qemu/osdep.h"
  12 #include "qapi/compat-policy.h"
  13 #include "qapi/error.h"
  14 #include "qapi/forward-visitor.h"
  15 #include "qapi/visitor-impl.h"
  16 #include "qemu/queue.h"
  17 #include "qapi/qmp/qjson.h"
  18 #include "qapi/qmp/qbool.h"
  19 #include "qapi/qmp/qdict.h"
  20 #include "qapi/qmp/qerror.h"
  21 #include "qapi/qmp/qlist.h"
  22 #include "qapi/qmp/qnull.h"
  23 #include "qapi/qmp/qnum.h"
  24 #include "qapi/qmp/qstring.h"
  25 #include "qemu/cutils.h"
  26
  27 struct ForwardFieldVisitor {
  28     Visitor visitor;
  29
  30     Visitor *target;
  31     char *from;
  32     char *to;
  33
  34     int depth;
  35 };
  36
  37 static ForwardFieldVisitor *to_ffv(Visitor *v)
  38 {
  39     return container_of(v, ForwardFieldVisitor, visitor);
  40 }
  41
  42 static bool forward_field_translate_name(ForwardFieldVisitor *v, const char **name,
  43                                          Error **errp)
  44 {
  45     if (v->depth) {
  46         return true;
  47     }
  48     if (g_str_equal(*name, v->from)) {
  49         *name = v->to;
  50         return true;
  51     }
  52     error_setg(errp, QERR_MISSING_PARAMETER, *name);
  53     return false;
  54 }
  55
  56 static bool forward_field_check_struct(Visitor *v, Error **errp)
  57 {
  58     ForwardFieldVisitor *ffv = to_ffv(v);
  59
  60     return visit_check_struct(ffv->target, errp);
  61 }
  62
  63 static bool forward_field_start_struct(Visitor *v, const char *name, void **obj,
  64                                        size_t size, Error **errp)
  65 {
  66     ForwardFieldVisitor *ffv = to_ffv(v);
  67
  68     if (!forward_field_translate_name(ffv, &name, errp)) {
  69         return false;
  70     }
  71     if (!visit_start_struct(ffv->target, name, obj, size, errp)) {
  72         return false;
  73     }
  74     ffv->depth++;
  75     return true;
  76 }
  77
  78 static void forward_field_end_struct(Visitor *v, void **obj)
  79 {
  80     ForwardFieldVisitor *ffv = to_ffv(v);
  81
  82     assert(ffv->depth);
  83     ffv->depth--;
  84     visit_end_struct(ffv->target, obj);
  85 }
  86
  87 static bool forward_field_start_list(Visitor *v, const char *name,
  88                                      GenericList **list, size_t size,
  89                                      Error **errp)
  90 {
  91     ForwardFieldVisitor *ffv = to_ffv(v);
  92
  93     if (!forward_field_translate_name(ffv, &name, errp)) {
  94         return false;
  95     }
  96     ffv->depth++;
  97     return visit_start_list(ffv->target, name, list, size, errp);
  98 }
  99
 100 static GenericList *forward_field_next_list(Visitor *v, GenericList *tail,
 101                                             size_t size)
 102 {
 103     ForwardFieldVisitor *ffv = to_ffv(v);
 104
 105     assert(ffv->depth);
 106     return visit_next_list(ffv->target, tail, size);
 107 }
 108
 109 static bool forward_field_check_list(Visitor *v, Error **errp)
 110 {
 111     ForwardFieldVisitor *ffv = to_ffv(v);
 112
 113     assert(ffv->depth);
 114     return visit_check_list(ffv->target, errp);
 115 }
 116
 117 static void forward_field_end_list(Visitor *v, void **obj)
 118 {
 119     ForwardFieldVisitor *ffv = to_ffv(v);
 120
 121     assert(ffv->depth);
 122     ffv->depth--;
 123     visit_end_list(ffv->target, obj);
 124 }
 125
 126 static bool forward_field_start_alternate(Visitor *v, const char *name,
 127                                           GenericAlternate **obj, size_t size,
 128                                           Error **errp)
 129 {
 130     ForwardFieldVisitor *ffv = to_ffv(v);
 131
 132     if (!forward_field_translate_name(ffv, &name, errp)) {
 133         return false;
 134     }
 135     /*
 136      * The name passed to start_alternate is used also in the visit_type_* calls
 137      * that retrieve the alternate's content; so, do not increase depth here.
 138      */
 139     return visit_start_alternate(ffv->target, name, obj, size, errp);
 140 }
 141
 142 static void forward_field_end_alternate(Visitor *v, void **obj)
 143 {
 144     ForwardFieldVisitor *ffv = to_ffv(v);
 145
 146     visit_end_alternate(ffv->target, obj);
 147 }
 148
 149 static bool forward_field_type_int64(Visitor *v, const char *name, int64_t *obj,
 150                                      Error **errp)
 151 {
 152     ForwardFieldVisitor *ffv = to_ffv(v);
 153
 154     if (!forward_field_translate_name(ffv, &name, errp)) {
 155         return false;
 156     }
 157     return visit_type_int64(ffv->target, name, obj, errp);
 158 }
 159
 160 static bool forward_field_type_uint64(Visitor *v, const char *name,
 161                                       uint64_t *obj, Error **errp)
 162 {
 163     ForwardFieldVisitor *ffv = to_ffv(v);
 164
 165     if (!forward_field_translate_name(ffv, &name, errp)) {
 166         return false;
 167     }
 168     return visit_type_uint64(ffv->target, name, obj, errp);
 169 }
 170
 171 static bool forward_field_type_bool(Visitor *v, const char *name, bool *obj,
 172                                     Error **errp)
 173 {
 174     ForwardFieldVisitor *ffv = to_ffv(v);
 175
 176     if (!forward_field_translate_name(ffv, &name, errp)) {
 177         return false;
 178     }
 179     return visit_type_bool(ffv->target, name, obj, errp);
 180 }
 181
 182 static bool forward_field_type_str(Visitor *v, const char *name, char **obj,
 183                                    Error **errp)
 184 {
 185     ForwardFieldVisitor *ffv = to_ffv(v);
 186
 187     if (!forward_field_translate_name(ffv, &name, errp)) {
 188         return false;
 189     }
 190     return visit_type_str(ffv->target, name, obj, errp);
 191 }
 192
 193 static bool forward_field_type_size(Visitor *v, const char *name, uint64_t *obj,
 194                                     Error **errp)
 195 {
 196     ForwardFieldVisitor *ffv = to_ffv(v);
 197
 198     if (!forward_field_translate_name(ffv, &name, errp)) {
 199         return false;
 200     }
 201     return visit_type_size(ffv->target, name, obj, errp);
 202 }
 203
 204 static bool forward_field_type_number(Visitor *v, const char *name, double *obj,
 205                                       Error **errp)
 206 {
 207     ForwardFieldVisitor *ffv = to_ffv(v);
 208
 209     if (!forward_field_translate_name(ffv, &name, errp)) {
 210         return false;
 211     }
 212     return visit_type_number(ffv->target, name, obj, errp);
 213 }
 214
 215 static bool forward_field_type_any(Visitor *v, const char *name, QObject **obj,
 216                                    Error **errp)
 217 {
 218     ForwardFieldVisitor *ffv = to_ffv(v);
 219
 220     if (!forward_field_translate_name(ffv, &name, errp)) {
 221         return false;
 222     }
 223     return visit_type_any(ffv->target, name, obj, errp);
 224 }
 225
 226 static bool forward_field_type_null(Visitor *v, const char *name,
 227                                     QNull **obj, Error **errp)
 228 {
 229     ForwardFieldVisitor *ffv = to_ffv(v);
 230
 231     if (!forward_field_translate_name(ffv, &name, errp)) {
 232         return false;
 233     }
 234     return visit_type_null(ffv->target, name, obj, errp);
 235 }
 236
 237 static void forward_field_optional(Visitor *v, const char *name, bool *present)
 238 {
 239     ForwardFieldVisitor *ffv = to_ffv(v);
 240
 241     if (!forward_field_translate_name(ffv, &name, NULL)) {
 242         *present = false;
 243         return;
 244     }
 245     visit_optional(ffv->target, name, present);
 246 }
 247
 248 static bool forward_field_policy_reject(Visitor *v, const char *name,
 249                                         unsigned special_features,
 250                                         Error **errp)
 251 {
 252     ForwardFieldVisitor *ffv = to_ffv(v);
 253
 254     if (!forward_field_translate_name(ffv, &name, errp)) {
 255         return true;
 256     }
 257     return visit_policy_reject(ffv->target, name, special_features, errp);
 258 }
 259
 260 static bool forward_field_policy_skip(Visitor *v, const char *name,
 261                                       unsigned special_features)
 262 {
 263     ForwardFieldVisitor *ffv = to_ffv(v);
 264
 265     if (!forward_field_translate_name(ffv, &name, NULL)) {
 266         return true;
 267     }
 268     return visit_policy_skip(ffv->target, name, special_features);
 269 }
 270
 271 static void forward_field_complete(Visitor *v, void *opaque)
 272 {
 273     /*
 274      * Do nothing, the complete method will be called in due time
 275      * on the target visitor.
 276      */
 277 }
 278
 279 static void forward_field_free(Visitor *v)
 280 {
 281     ForwardFieldVisitor *ffv = to_ffv(v);
 282
 283     g_free(ffv->from);
 284     g_free(ffv->to);
 285     g_free(ffv);
 286 }
 287
 288 Visitor *visitor_forward_field(Visitor *target, const char *from, const char *to)
 289 {
 290     ForwardFieldVisitor *v = g_new0(ForwardFieldVisitor, 1);
 291
 292     /*
 293      * Clone and dealloc visitors don't use a name for the toplevel
 294      * visit, so they make no sense here.
 295      */
 296     assert(target->type == VISITOR_OUTPUT || target->type == VISITOR_INPUT);
 297
 298     v->visitor.type = target->type;
 299     v->visitor.start_struct = forward_field_start_struct;
 300     v->visitor.check_struct = forward_field_check_struct;
 301     v->visitor.end_struct = forward_field_end_struct;
 302     v->visitor.start_list = forward_field_start_list;
 303     v->visitor.next_list = forward_field_next_list;
 304     v->visitor.check_list = forward_field_check_list;
 305     v->visitor.end_list = forward_field_end_list;
 306     v->visitor.start_alternate = forward_field_start_alternate;
 307     v->visitor.end_alternate = forward_field_end_alternate;
 308     v->visitor.type_int64 = forward_field_type_int64;
 309     v->visitor.type_uint64 = forward_field_type_uint64;
 310     v->visitor.type_size = forward_field_type_size;
 311     v->visitor.type_bool = forward_field_type_bool;
 312     v->visitor.type_str = forward_field_type_str;
 313     v->visitor.type_number = forward_field_type_number;
 314     v->visitor.type_any = forward_field_type_any;
 315     v->visitor.type_null = forward_field_type_null;
 316     v->visitor.optional = forward_field_optional;
 317     v->visitor.policy_reject = forward_field_policy_reject;
 318     v->visitor.policy_skip = forward_field_policy_skip;
 319     v->visitor.complete = forward_field_complete;
 320     v->visitor.free = forward_field_free;
 321
 322     v->target = target;
 323     v->from = g_strdup(from);
 324     v->to = g_strdup(to);
 325
 326     return &v->visitor;
 327 }