qapi/string-input-visitor.c

   1 /*
   2  * String parsing visitor
   3  *
   4  * Copyright Red Hat, Inc. 2012-2016
   5  *
   6  * Author: Paolo Bonzini <pbonzini@redhat.com>
   7  *         David Hildenbrand <david@redhat.com>
   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/string-input-visitor.h"
  16 #include "qapi/visitor-impl.h"
  17 #include "qapi/qmp/qerror.h"
  18 #include "qapi/qmp/qnull.h"
  19 #include "qemu/option.h"
  20 #include "qemu/cutils.h"
  21
  22 typedef enum ListMode {
  23     /* no list parsing active / no list expected */
  24     LM_NONE,
  25     /* we have an unparsed string remaining */
  26     LM_UNPARSED,
  27     /* we have an unfinished int64 range */
  28     LM_INT64_RANGE,
  29     /* we have an unfinished uint64 range */
  30     LM_UINT64_RANGE,
  31     /* we have parsed the string completely and no range is remaining */
  32     LM_END,
  33 } ListMode;
  34
  35 /* protect against DOS attacks, limit the amount of elements per range */
  36 #define RANGE_MAX_ELEMENTS 65536
  37
  38 typedef union RangeElement {
  39     int64_t i64;
  40     uint64_t u64;
  41 } RangeElement;
  42
  43 struct StringInputVisitor
  44 {
  45     Visitor visitor;
  46
  47     /* List parsing state */
  48     ListMode lm;
  49     RangeElement rangeNext;
  50     RangeElement rangeEnd;
  51     const char *unparsed_string;
  52     void *list;
  53
  54     /* The original string to parse */
  55     const char *string;
  56 };
  57
  58 static StringInputVisitor *to_siv(Visitor *v)
  59 {
  60     return container_of(v, StringInputVisitor, visitor);
  61 }
  62
  63 static void start_list(Visitor *v, const char *name, GenericList **list,
  64                        size_t size, Error **errp)
  65 {
  66     StringInputVisitor *siv = to_siv(v);
  67
  68     assert(siv->lm == LM_NONE);
  69     siv->list = list;
  70     siv->unparsed_string = siv->string;
  71
  72     if (!siv->string[0]) {
  73         if (list) {
  74             *list = NULL;
  75         }
  76         siv->lm = LM_END;
  77     } else {
  78         if (list) {
  79             *list = g_malloc0(size);
  80         }
  81         siv->lm = LM_UNPARSED;
  82     }
  83 }
  84
  85 static GenericList *next_list(Visitor *v, GenericList *tail, size_t size)
  86 {
  87     StringInputVisitor *siv = to_siv(v);
  88
  89     switch (siv->lm) {
  90     case LM_END:
  91         return NULL;
  92     case LM_INT64_RANGE:
  93     case LM_UINT64_RANGE:
  94     case LM_UNPARSED:
  95         /* we have an unparsed string or something left in a range */
  96         break;
  97     default:
  98         abort();
  99     }
 100
 101     tail->next = g_malloc0(size);
 102     return tail->next;
 103 }
 104
 105 static void check_list(Visitor *v, Error **errp)
 106 {
 107     const StringInputVisitor *siv = to_siv(v);
 108
 109     switch (siv->lm) {
 110     case LM_INT64_RANGE:
 111     case LM_UINT64_RANGE:
 112     case LM_UNPARSED:
 113         error_setg(errp, "Fewer list elements expected");
 114         return;
 115     case LM_END:
 116         return;
 117     default:
 118         abort();
 119     }
 120 }
 121
 122 static void end_list(Visitor *v, void **obj)
 123 {
 124     StringInputVisitor *siv = to_siv(v);
 125
 126     assert(siv->lm != LM_NONE);
 127     assert(siv->list == obj);
 128     siv->list = NULL;
 129     siv->unparsed_string = NULL;
 130     siv->lm = LM_NONE;
 131 }
 132
 133 static int try_parse_int64_list_entry(StringInputVisitor *siv, int64_t *obj)
 134 {
 135     const char *endptr;
 136     int64_t start, end;
 137
 138     /* parse a simple int64 or range */
 139     if (qemu_strtoi64(siv->unparsed_string, &endptr, 0, &start)) {
 140         return -EINVAL;
 141     }
 142     end = start;
 143
 144     switch (endptr[0]) {
 145     case '\0':
 146         siv->unparsed_string = endptr;
 147         break;
 148     case ',':
 149         siv->unparsed_string = endptr + 1;
 150         break;
 151     case '-':
 152         /* parse the end of the range */
 153         if (qemu_strtoi64(endptr + 1, &endptr, 0, &end)) {
 154             return -EINVAL;
 155         }
 156         if (start > end || end - start >= RANGE_MAX_ELEMENTS) {
 157             return -EINVAL;
 158         }
 159         switch (endptr[0]) {
 160         case '\0':
 161             siv->unparsed_string = endptr;
 162             break;
 163         case ',':
 164             siv->unparsed_string = endptr + 1;
 165             break;
 166         default:
 167             return -EINVAL;
 168         }
 169         break;
 170     default:
 171         return -EINVAL;
 172     }
 173
 174     /* we have a proper range (with maybe only one element) */
 175     siv->lm = LM_INT64_RANGE;
 176     siv->rangeNext.i64 = start;
 177     siv->rangeEnd.i64 = end;
 178     return 0;
 179 }
 180
 181 static void parse_type_int64(Visitor *v, const char *name, int64_t *obj,
 182                              Error **errp)
 183 {
 184     StringInputVisitor *siv = to_siv(v);
 185     int64_t val;
 186
 187     switch (siv->lm) {
 188     case LM_NONE:
 189         /* just parse a simple int64, bail out if not completely consumed */
 190         if (qemu_strtoi64(siv->string, NULL, 0, &val)) {
 191                 error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
 192                            name ? name : "null", "int64");
 193             return;
 194         }
 195         *obj = val;
 196         return;
 197     case LM_UNPARSED:
 198         if (try_parse_int64_list_entry(siv, obj)) {
 199             error_setg(errp, QERR_INVALID_PARAMETER_VALUE, name ? name : "null",
 200                        "list of int64 values or ranges");
 201             return;
 202         }
 203         assert(siv->lm == LM_INT64_RANGE);
 204         /* fall through */
 205     case LM_INT64_RANGE:
 206         /* return the next element in the range */
 207         assert(siv->rangeNext.i64 <= siv->rangeEnd.i64);
 208         *obj = siv->rangeNext.i64++;
 209
 210         if (siv->rangeNext.i64 > siv->rangeEnd.i64 || *obj == INT64_MAX) {
 211             /* end of range, check if there is more to parse */
 212             siv->lm = siv->unparsed_string[0] ? LM_UNPARSED : LM_END;
 213         }
 214         return;
 215     case LM_END:
 216         error_setg(errp, "Fewer list elements expected");
 217         return;
 218     default:
 219         abort();
 220     }
 221 }
 222
 223 static int try_parse_uint64_list_entry(StringInputVisitor *siv, uint64_t *obj)
 224 {
 225     const char *endptr;
 226     uint64_t start, end;
 227
 228     /* parse a simple uint64 or range */
 229     if (qemu_strtou64(siv->unparsed_string, &endptr, 0, &start)) {
 230         return -EINVAL;
 231     }
 232     end = start;
 233
 234     switch (endptr[0]) {
 235     case '\0':
 236         siv->unparsed_string = endptr;
 237         break;
 238     case ',':
 239         siv->unparsed_string = endptr + 1;
 240         break;
 241     case '-':
 242         /* parse the end of the range */
 243         if (qemu_strtou64(endptr + 1, &endptr, 0, &end)) {
 244             return -EINVAL;
 245         }
 246         if (start > end || end - start >= RANGE_MAX_ELEMENTS) {
 247             return -EINVAL;
 248         }
 249         switch (endptr[0]) {
 250         case '\0':
 251             siv->unparsed_string = endptr;
 252             break;
 253         case ',':
 254             siv->unparsed_string = endptr + 1;
 255             break;
 256         default:
 257             return -EINVAL;
 258         }
 259         break;
 260     default:
 261         return -EINVAL;
 262     }
 263
 264     /* we have a proper range (with maybe only one element) */
 265     siv->lm = LM_UINT64_RANGE;
 266     siv->rangeNext.u64 = start;
 267     siv->rangeEnd.u64 = end;
 268     return 0;
 269 }
 270
 271 static void parse_type_uint64(Visitor *v, const char *name, uint64_t *obj,
 272                               Error **errp)
 273 {
 274     StringInputVisitor *siv = to_siv(v);
 275     uint64_t val;
 276
 277     switch (siv->lm) {
 278     case LM_NONE:
 279         /* just parse a simple uint64, bail out if not completely consumed */
 280         if (qemu_strtou64(siv->string, NULL, 0, &val)) {
 281             error_setg(errp, QERR_INVALID_PARAMETER_VALUE, name ? name : "null",
 282                        "uint64");
 283             return;
 284         }
 285         *obj = val;
 286         return;
 287     case LM_UNPARSED:
 288         if (try_parse_uint64_list_entry(siv, obj)) {
 289             error_setg(errp, QERR_INVALID_PARAMETER_VALUE, name ? name : "null",
 290                        "list of uint64 values or ranges");
 291             return;
 292         }
 293         assert(siv->lm == LM_UINT64_RANGE);
 294         /* fall through */
 295     case LM_UINT64_RANGE:
 296         /* return the next element in the range */
 297         assert(siv->rangeNext.u64 <= siv->rangeEnd.u64);
 298         *obj = siv->rangeNext.u64++;
 299
 300         if (siv->rangeNext.u64 > siv->rangeEnd.u64 || *obj == UINT64_MAX) {
 301             /* end of range, check if there is more to parse */
 302             siv->lm = siv->unparsed_string[0] ? LM_UNPARSED : LM_END;
 303         }
 304         return;
 305     case LM_END:
 306         error_setg(errp, "Fewer list elements expected");
 307         return;
 308     default:
 309         abort();
 310     }
 311 }
 312
 313 static void parse_type_size(Visitor *v, const char *name, uint64_t *obj,
 314                             Error **errp)
 315 {
 316     StringInputVisitor *siv = to_siv(v);
 317     Error *err = NULL;
 318     uint64_t val;
 319
 320     assert(siv->lm == LM_NONE);
 321     parse_option_size(name, siv->string, &val, &err);
 322     if (err) {
 323         error_propagate(errp, err);
 324         return;
 325     }
 326
 327     *obj = val;
 328 }
 329
 330 static void parse_type_bool(Visitor *v, const char *name, bool *obj,
 331                             Error **errp)
 332 {
 333     StringInputVisitor *siv = to_siv(v);
 334
 335     assert(siv->lm == LM_NONE);
 336     if (!strcasecmp(siv->string, "on") ||
 337         !strcasecmp(siv->string, "yes") ||
 338         !strcasecmp(siv->string, "true")) {
 339         *obj = true;
 340         return;
 341     }
 342     if (!strcasecmp(siv->string, "off") ||
 343         !strcasecmp(siv->string, "no") ||
 344         !strcasecmp(siv->string, "false")) {
 345         *obj = false;
 346         return;
 347     }
 348
 349     error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
 350                "boolean");
 351 }
 352
 353 static void parse_type_str(Visitor *v, const char *name, char **obj,
 354                            Error **errp)
 355 {
 356     StringInputVisitor *siv = to_siv(v);
 357
 358     assert(siv->lm == LM_NONE);
 359     *obj = g_strdup(siv->string);
 360 }
 361
 362 static void parse_type_number(Visitor *v, const char *name, double *obj,
 363                               Error **errp)
 364 {
 365     StringInputVisitor *siv = to_siv(v);
 366     double val;
 367
 368     assert(siv->lm == LM_NONE);
 369     if (qemu_strtod_finite(siv->string, NULL, &val)) {
 370         error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
 371                    "number");
 372         return;
 373     }
 374
 375     *obj = val;
 376 }
 377
 378 static void parse_type_null(Visitor *v, const char *name, QNull **obj,
 379                             Error **errp)
 380 {
 381     StringInputVisitor *siv = to_siv(v);
 382
 383     assert(siv->lm == LM_NONE);
 384     *obj = NULL;
 385
 386     if (siv->string[0]) {
 387         error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
 388                    "null");
 389         return;
 390     }
 391
 392     *obj = qnull();
 393 }
 394
 395 static void string_input_free(Visitor *v)
 396 {
 397     StringInputVisitor *siv = to_siv(v);
 398
 399     g_free(siv);
 400 }
 401
 402 Visitor *string_input_visitor_new(const char *str)
 403 {
 404     StringInputVisitor *v;
 405
 406     assert(str);
 407     v = g_malloc0(sizeof(*v));
 408
 409     v->visitor.type = VISITOR_INPUT;
 410     v->visitor.type_int64 = parse_type_int64;
 411     v->visitor.type_uint64 = parse_type_uint64;
 412     v->visitor.type_size = parse_type_size;
 413     v->visitor.type_bool = parse_type_bool;
 414     v->visitor.type_str = parse_type_str;
 415     v->visitor.type_number = parse_type_number;
 416     v->visitor.type_null = parse_type_null;
 417     v->visitor.start_list = start_list;
 418     v->visitor.next_list = next_list;
 419     v->visitor.check_list = check_list;
 420     v->visitor.end_list = end_list;
 421     v->visitor.free = string_input_free;
 422
 423     v->string = str;
 424     v->lm = LM_NONE;
 425     return &v->visitor;
 426 }