qapi/string-input-visitor.c

   1 /*
   2  * String parsing visitor
   3  *
   4  * Copyright Red Hat, Inc. 2012
   5  *
   6  * Author: Paolo Bonzini <[email protected]>
   7  *
   8  * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
   9  * See the COPYING.LIB file in the top-level directory.
  10  *
  11  */
  12
  13 #include "qemu/osdep.h"
  14 #include "qemu-common.h"
  15 #include "qapi/string-input-visitor.h"
  16 #include "qapi/visitor-impl.h"
  17 #include "qapi/qmp/qerror.h"
  18 #include "qemu/option.h"
  19 #include "qemu/queue.h"
  20 #include "qemu/range.h"
  21
  22
  23 struct StringInputVisitor
  24 {
  25     Visitor visitor;
  26
  27     bool head;
  28
  29     GList *ranges;
  30     GList *cur_range;
  31     int64_t cur;
  32
  33     const char *string;
  34 };
  35
  36 static StringInputVisitor *to_siv(Visitor *v)
  37 {
  38     return container_of(v, StringInputVisitor, visitor);
  39 }
  40
  41 static void free_range(void *range, void *dummy)
  42 {
  43     g_free(range);
  44 }
  45
  46 static void parse_str(StringInputVisitor *siv, Error **errp)
  47 {
  48     char *str = (char *) siv->string;
  49     long long start, end;
  50     Range *cur;
  51     char *endptr;
  52
  53     if (siv->ranges) {
  54         return;
  55     }
  56
  57     do {
  58         errno = 0;
  59         start = strtoll(str, &endptr, 0);
  60         if (errno == 0 && endptr > str) {
  61             if (*endptr == '\0') {
  62                 cur = g_malloc0(sizeof(*cur));
  63                 cur->begin = start;
  64                 cur->end = start + 1;
  65                 siv->ranges = g_list_insert_sorted_merged(siv->ranges, cur,
  66                                                           range_compare);
  67                 cur = NULL;
  68                 str = NULL;
  69             } else if (*endptr == '-') {
  70                 str = endptr + 1;
  71                 errno = 0;
  72                 end = strtoll(str, &endptr, 0);
  73                 if (errno == 0 && endptr > str && start <= end &&
  74                     (start > INT64_MAX - 65536 ||
  75                      end < start + 65536)) {
  76                     if (*endptr == '\0') {
  77                         cur = g_malloc0(sizeof(*cur));
  78                         cur->begin = start;
  79                         cur->end = end + 1;
  80                         siv->ranges =
  81                             g_list_insert_sorted_merged(siv->ranges,
  82                                                         cur,
  83                                                         range_compare);
  84                         cur = NULL;
  85                         str = NULL;
  86                     } else if (*endptr == ',') {
  87                         str = endptr + 1;
  88                         cur = g_malloc0(sizeof(*cur));
  89                         cur->begin = start;
  90                         cur->end = end + 1;
  91                         siv->ranges =
  92                             g_list_insert_sorted_merged(siv->ranges,
  93                                                         cur,
  94                                                         range_compare);
  95                         cur = NULL;
  96                     } else {
  97                         goto error;
  98                     }
  99                 } else {
 100                     goto error;
 101                 }
 102             } else if (*endptr == ',') {
 103                 str = endptr + 1;
 104                 cur = g_malloc0(sizeof(*cur));
 105                 cur->begin = start;
 106                 cur->end = start + 1;
 107                 siv->ranges = g_list_insert_sorted_merged(siv->ranges,
 108                                                           cur,
 109                                                           range_compare);
 110                 cur = NULL;
 111             } else {
 112                 goto error;
 113             }
 114         } else {
 115             goto error;
 116         }
 117     } while (str);
 118
 119     return;
 120 error:
 121     g_list_foreach(siv->ranges, free_range, NULL);
 122     g_list_free(siv->ranges);
 123     siv->ranges = NULL;
 124 }
 125
 126 static void
 127 start_list(Visitor *v, const char *name, Error **errp)
 128 {
 129     StringInputVisitor *siv = to_siv(v);
 130
 131     parse_str(siv, errp);
 132
 133     siv->cur_range = g_list_first(siv->ranges);
 134     if (siv->cur_range) {
 135         Range *r = siv->cur_range->data;
 136         if (r) {
 137             siv->cur = r->begin;
 138         }
 139     }
 140 }
 141
 142 static GenericList *
 143 next_list(Visitor *v, GenericList **list, Error **errp)
 144 {
 145     StringInputVisitor *siv = to_siv(v);
 146     GenericList **link;
 147     Range *r;
 148
 149     if (!siv->ranges || !siv->cur_range) {
 150         return NULL;
 151     }
 152
 153     r = siv->cur_range->data;
 154     if (!r) {
 155         return NULL;
 156     }
 157
 158     if (siv->cur < r->begin || siv->cur >= r->end) {
 159         siv->cur_range = g_list_next(siv->cur_range);
 160         if (!siv->cur_range) {
 161             return NULL;
 162         }
 163         r = siv->cur_range->data;
 164         if (!r) {
 165             return NULL;
 166         }
 167         siv->cur = r->begin;
 168     }
 169
 170     if (siv->head) {
 171         link = list;
 172         siv->head = false;
 173     } else {
 174         link = &(*list)->next;
 175     }
 176
 177     *link = g_malloc0(sizeof **link);
 178     return *link;
 179 }
 180
 181 static void
 182 end_list(Visitor *v, Error **errp)
 183 {
 184     StringInputVisitor *siv = to_siv(v);
 185     siv->head = true;
 186 }
 187
 188 static void parse_type_int64(Visitor *v, int64_t *obj, const char *name,
 189                              Error **errp)
 190 {
 191     StringInputVisitor *siv = to_siv(v);
 192
 193     if (!siv->string) {
 194         error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
 195                    "integer");
 196         return;
 197     }
 198
 199     parse_str(siv, errp);
 200
 201     if (!siv->ranges) {
 202         goto error;
 203     }
 204
 205     if (!siv->cur_range) {
 206         Range *r;
 207
 208         siv->cur_range = g_list_first(siv->ranges);
 209         if (!siv->cur_range) {
 210             goto error;
 211         }
 212
 213         r = siv->cur_range->data;
 214         if (!r) {
 215             goto error;
 216         }
 217
 218         siv->cur = r->begin;
 219     }
 220
 221     *obj = siv->cur;
 222     siv->cur++;
 223     return;
 224
 225 error:
 226     error_setg(errp, QERR_INVALID_PARAMETER_VALUE, name,
 227                "an int64 value or range");
 228 }
 229
 230 static void parse_type_uint64(Visitor *v, uint64_t *obj, const char *name,
 231                               Error **errp)
 232 {
 233     /* FIXME: parse_type_int64 mishandles values over INT64_MAX */
 234     int64_t i;
 235     Error *err = NULL;
 236     parse_type_int64(v, &i, name, &err);
 237     if (err) {
 238         error_propagate(errp, err);
 239     } else {
 240         *obj = i;
 241     }
 242 }
 243
 244 static void parse_type_size(Visitor *v, uint64_t *obj, const char *name,
 245                             Error **errp)
 246 {
 247     StringInputVisitor *siv = to_siv(v);
 248     Error *err = NULL;
 249     uint64_t val;
 250
 251     if (siv->string) {
 252         parse_option_size(name, siv->string, &val, &err);
 253     } else {
 254         error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
 255                    "size");
 256         return;
 257     }
 258     if (err) {
 259         error_propagate(errp, err);
 260         return;
 261     }
 262
 263     *obj = val;
 264 }
 265
 266 static void parse_type_bool(Visitor *v, bool *obj, const char *name,
 267                             Error **errp)
 268 {
 269     StringInputVisitor *siv = to_siv(v);
 270
 271     if (siv->string) {
 272         if (!strcasecmp(siv->string, "on") ||
 273             !strcasecmp(siv->string, "yes") ||
 274             !strcasecmp(siv->string, "true")) {
 275             *obj = true;
 276             return;
 277         }
 278         if (!strcasecmp(siv->string, "off") ||
 279             !strcasecmp(siv->string, "no") ||
 280             !strcasecmp(siv->string, "false")) {
 281             *obj = false;
 282             return;
 283         }
 284     }
 285
 286     error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
 287                "boolean");
 288 }
 289
 290 static void parse_type_str(Visitor *v, char **obj, const char *name,
 291                            Error **errp)
 292 {
 293     StringInputVisitor *siv = to_siv(v);
 294     if (siv->string) {
 295         *obj = g_strdup(siv->string);
 296     } else {
 297         error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
 298                    "string");
 299     }
 300 }
 301
 302 static void parse_type_number(Visitor *v, double *obj, const char *name,
 303                               Error **errp)
 304 {
 305     StringInputVisitor *siv = to_siv(v);
 306     char *endp = (char *) siv->string;
 307     double val;
 308
 309     errno = 0;
 310     if (siv->string) {
 311         val = strtod(siv->string, &endp);
 312     }
 313     if (!siv->string || errno || endp == siv->string || *endp) {
 314         error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
 315                    "number");
 316         return;
 317     }
 318
 319     *obj = val;
 320 }
 321
 322 static void parse_optional(Visitor *v, bool *present, const char *name)
 323 {
 324     StringInputVisitor *siv = to_siv(v);
 325
 326     if (!siv->string) {
 327         *present = false;
 328         return;
 329     }
 330
 331     *present = true;
 332 }
 333
 334 Visitor *string_input_get_visitor(StringInputVisitor *v)
 335 {
 336     return &v->visitor;
 337 }
 338
 339 void string_input_visitor_cleanup(StringInputVisitor *v)
 340 {
 341     g_list_foreach(v->ranges, free_range, NULL);
 342     g_list_free(v->ranges);
 343     g_free(v);
 344 }
 345
 346 StringInputVisitor *string_input_visitor_new(const char *str)
 347 {
 348     StringInputVisitor *v;
 349
 350     v = g_malloc0(sizeof(*v));
 351
 352     v->visitor.type_enum = input_type_enum;
 353     v->visitor.type_int64 = parse_type_int64;
 354     v->visitor.type_uint64 = parse_type_uint64;
 355     v->visitor.type_size = parse_type_size;
 356     v->visitor.type_bool = parse_type_bool;
 357     v->visitor.type_str = parse_type_str;
 358     v->visitor.type_number = parse_type_number;
 359     v->visitor.start_list = start_list;
 360     v->visitor.next_list = next_list;
 361     v->visitor.end_list = end_list;
 362     v->visitor.optional = parse_optional;
 363
 364     v->string = str;
 365     v->head = true;
 366     return v;
 367 }