Diff for /qemu/qemu-option.c between versions 1.1.1.2 and 1.1.1.3

version 1.1.1.2, 2018/04/24 17:33:36 version 1.1.1.3, 2018/04/24 18:22:58
Line 27 Line 27
 #include <string.h>  #include <string.h>
   
 #include "qemu-common.h"  #include "qemu-common.h"
   #include "qemu-error.h"
   #include "qemu-objects.h"
 #include "qemu-option.h"  #include "qemu-option.h"
   #include "qerror.h"
   
 /*  /*
  * Extracts the name of an option from the parameter string (p points at the   * Extracts the name of an option from the parameter string (p points at the
Line 173  static int parse_option_bool(const char  Line 176  static int parse_option_bool(const char 
         } else if (!strcmp(value, "off")) {          } else if (!strcmp(value, "off")) {
             *ret = 0;              *ret = 0;
         } else {          } else {
             fprintf(stderr, "Option '%s': Use 'on' or 'off'\n", name);              qerror_report(QERR_INVALID_PARAMETER_VALUE, name, "'on' or 'off'");
             return -1;              return -1;
         }          }
     } else {      } else {
Line 190  static int parse_option_number(const cha Line 193  static int parse_option_number(const cha
     if (value != NULL) {      if (value != NULL) {
         number = strtoull(value, &postfix, 0);          number = strtoull(value, &postfix, 0);
         if (*postfix != '\0') {          if (*postfix != '\0') {
             fprintf(stderr, "Option '%s' needs a number as parameter\n", name);              qerror_report(QERR_INVALID_PARAMETER_VALUE, name, "a number");
             return -1;              return -1;
         }          }
         *ret = number;          *ret = number;
     } else {      } else {
         fprintf(stderr, "Option '%s' needs a parameter\n", name);          qerror_report(QERR_INVALID_PARAMETER_VALUE, name, "a number");
         return -1;          return -1;
     }      }
     return 0;      return 0;
Line 223  static int parse_option_size(const char  Line 226  static int parse_option_size(const char 
             *ret = (uint64_t) sizef;              *ret = (uint64_t) sizef;
             break;              break;
         default:          default:
             fprintf(stderr, "Option '%s' needs size as parameter\n", name);              qerror_report(QERR_INVALID_PARAMETER_VALUE, name, "a size");
             fprintf(stderr, "You may use k, M, G or T suffixes for "              error_printf_unless_qmp("You may use k, M, G or T suffixes for "
                     "kilobytes, megabytes, gigabytes and terabytes.\n");                      "kilobytes, megabytes, gigabytes and terabytes.\n");
             return -1;              return -1;
         }          }
     } else {      } else {
         fprintf(stderr, "Option '%s' needs a parameter\n", name);          qerror_report(QERR_INVALID_PARAMETER_VALUE, name, "a size");
         return -1;          return -1;
     }      }
     return 0;      return 0;
Line 343  void free_option_parameters(QEMUOptionPa Line 346  void free_option_parameters(QEMUOptionPa
 }  }
   
 /*  /*
    * Count valid options in list
    */
   static size_t count_option_parameters(QEMUOptionParameter *list)
   {
       size_t num_options = 0;
   
       while (list && list->name) {
           num_options++;
           list++;
       }
   
       return num_options;
   }
   
   /*
    * Append an option list (list) to an option list (dest).
    *
    * If dest is NULL, a new copy of list is created.
    *
    * Returns a pointer to the first element of dest (or the newly allocated copy)
    */
   QEMUOptionParameter *append_option_parameters(QEMUOptionParameter *dest,
       QEMUOptionParameter *list)
   {
       size_t num_options, num_dest_options;
   
       num_options = count_option_parameters(dest);
       num_dest_options = num_options;
   
       num_options += count_option_parameters(list);
   
       dest = qemu_realloc(dest, (num_options + 1) * sizeof(QEMUOptionParameter));
       dest[num_dest_options].name = NULL;
   
       while (list && list->name) {
           if (get_option_parameter(dest, list->name) == NULL) {
               dest[num_dest_options++] = *list;
               dest[num_dest_options].name = NULL;
           }
           list++;
       }
   
       return dest;
   }
   
   /*
  * Parses a parameter string (param) into an option list (dest).   * Parses a parameter string (param) into an option list (dest).
  *   *
  * list is the templace is. If dest is NULL, a new copy of list is created for   * list is the templace is. If dest is NULL, a new copy of list is created for
Line 362  void free_option_parameters(QEMUOptionPa Line 411  void free_option_parameters(QEMUOptionPa
 QEMUOptionParameter *parse_option_parameters(const char *param,  QEMUOptionParameter *parse_option_parameters(const char *param,
     QEMUOptionParameter *list, QEMUOptionParameter *dest)      QEMUOptionParameter *list, QEMUOptionParameter *dest)
 {  {
     QEMUOptionParameter *cur;  
     QEMUOptionParameter *allocated = NULL;      QEMUOptionParameter *allocated = NULL;
     char name[256];      char name[256];
     char value[256];      char value[256];
Line 376  QEMUOptionParameter *parse_option_parame Line 424  QEMUOptionParameter *parse_option_parame
   
     if (dest == NULL) {      if (dest == NULL) {
         // Count valid options          // Count valid options
         num_options = 0;          num_options = count_option_parameters(list);
         cur = list;  
         while (cur->name) {  
             num_options++;  
             cur++;  
         }  
   
         // Create a copy of the option list to fill in values          // Create a copy of the option list to fill in values
         dest = qemu_mallocz((num_options + 1) * sizeof(QEMUOptionParameter));          dest = qemu_mallocz((num_options + 1) * sizeof(QEMUOptionParameter));
Line 470  struct QemuOpt { Line 513  struct QemuOpt {
     const char   *name;      const char   *name;
     const char   *str;      const char   *str;
   
     QemuOptDesc  *desc;      const QemuOptDesc *desc;
     union {      union {
         int      boolean;          int      boolean;
         uint64_t uint;          uint64_t uint;
Line 483  struct QemuOpt { Line 526  struct QemuOpt {
 struct QemuOpts {  struct QemuOpts {
     char *id;      char *id;
     QemuOptsList *list;      QemuOptsList *list;
       Location loc;
     QTAILQ_HEAD(QemuOptHead, QemuOpt) head;      QTAILQ_HEAD(QemuOptHead, QemuOpt) head;
     QTAILQ_ENTRY(QemuOpts) next;      QTAILQ_ENTRY(QemuOpts) next;
 };  };
Line 565  static void qemu_opt_del(QemuOpt *opt) Line 609  static void qemu_opt_del(QemuOpt *opt)
 int qemu_opt_set(QemuOpts *opts, const char *name, const char *value)  int qemu_opt_set(QemuOpts *opts, const char *name, const char *value)
 {  {
     QemuOpt *opt;      QemuOpt *opt;
     QemuOptDesc *desc = opts->list->desc;      const QemuOptDesc *desc = opts->list->desc;
     int i;      int i;
   
     for (i = 0; desc[i].name != NULL; i++) {      for (i = 0; desc[i].name != NULL; i++) {
Line 577  int qemu_opt_set(QemuOpts *opts, const c Line 621  int qemu_opt_set(QemuOpts *opts, const c
         if (i == 0) {          if (i == 0) {
             /* empty list -> allow any */;              /* empty list -> allow any */;
         } else {          } else {
             fprintf(stderr, "option \"%s\" is not valid for %s\n",              qerror_report(QERR_INVALID_PARAMETER, name);
                     name, opts->list->name);  
             return -1;              return -1;
         }          }
     }      }
Line 594  int qemu_opt_set(QemuOpts *opts, const c Line 637  int qemu_opt_set(QemuOpts *opts, const c
         opt->str = qemu_strdup(value);          opt->str = qemu_strdup(value);
     }      }
     if (qemu_opt_parse(opt) < 0) {      if (qemu_opt_parse(opt) < 0) {
         fprintf(stderr, "Failed to parse \"%s\" for \"%s.%s\"\n", opt->str,  
                 opts->list->name, opt->name);  
         qemu_opt_del(opt);          qemu_opt_del(opt);
         return -1;          return -1;
     }      }
Line 632  QemuOpts *qemu_opts_find(QemuOptsList *l Line 673  QemuOpts *qemu_opts_find(QemuOptsList *l
     return NULL;      return NULL;
 }  }
   
   static int id_wellformed(const char *id)
   {
       int i;
   
       if (!qemu_isalpha(id[0])) {
           return 0;
       }
       for (i = 1; id[i]; i++) {
           if (!qemu_isalnum(id[i]) && !strchr("-._", id[i])) {
               return 0;
           }
       }
       return 1;
   }
   
 QemuOpts *qemu_opts_create(QemuOptsList *list, const char *id, int fail_if_exists)  QemuOpts *qemu_opts_create(QemuOptsList *list, const char *id, int fail_if_exists)
 {  {
     QemuOpts *opts = NULL;      QemuOpts *opts = NULL;
   
     if (id) {      if (id) {
           if (!id_wellformed(id)) {
               qerror_report(QERR_INVALID_PARAMETER_VALUE, "id", "an identifier");
               error_printf_unless_qmp("Identifiers consist of letters, digits, '-', '.', '_', starting with a letter.\n");
               return NULL;
           }
         opts = qemu_opts_find(list, id);          opts = qemu_opts_find(list, id);
         if (opts != NULL) {          if (opts != NULL) {
             if (fail_if_exists) {              if (fail_if_exists) {
                 fprintf(stderr, "tried to create id \"%s\" twice for \"%s\"\n",                  qerror_report(QERR_DUPLICATE_ID, id, list->name);
                         id, list->name);  
                 return NULL;                  return NULL;
             } else {              } else {
                 return opts;                  return opts;
Line 653  QemuOpts *qemu_opts_create(QemuOptsList  Line 713  QemuOpts *qemu_opts_create(QemuOptsList 
         opts->id = qemu_strdup(id);          opts->id = qemu_strdup(id);
     }      }
     opts->list = list;      opts->list = list;
       loc_save(&opts->loc);
     QTAILQ_INIT(&opts->head);      QTAILQ_INIT(&opts->head);
     QTAILQ_INSERT_TAIL(&list->head, opts, next);      QTAILQ_INSERT_TAIL(&list->head, opts, next);
     return opts;      return opts;
 }  }
   
   void qemu_opts_reset(QemuOptsList *list)
   {
       QemuOpts *opts, *next_opts;
   
       QTAILQ_FOREACH_SAFE(opts, &list->head, next, next_opts) {
           qemu_opts_del(opts);
       }
   }
   
   void qemu_opts_loc_restore(QemuOpts *opts)
   {
       loc_restore(&opts->loc);
   }
   
 int qemu_opts_set(QemuOptsList *list, const char *id,  int qemu_opts_set(QemuOptsList *list, const char *id,
                   const char *name, const char *value)                    const char *name, const char *value)
 {  {
Line 749  int qemu_opts_do_parse(QemuOpts *opts, c Line 824  int qemu_opts_do_parse(QemuOpts *opts, c
     return 0;      return 0;
 }  }
   
 QemuOpts *qemu_opts_parse(QemuOptsList *list, const char *params, const char *firstname)  QemuOpts *qemu_opts_parse(QemuOptsList *list, const char *params,
                             int permit_abbrev)
 {  {
       const char *firstname;
     char value[1024], *id = NULL;      char value[1024], *id = NULL;
     const char *p;      const char *p;
     QemuOpts *opts;      QemuOpts *opts;
   
       assert(!permit_abbrev || list->implied_opt_name);
       firstname = permit_abbrev ? list->implied_opt_name : NULL;
   
     if (strncmp(params, "id=", 3) == 0) {      if (strncmp(params, "id=", 3) == 0) {
         get_opt_value(value, sizeof(value), params+3);          get_opt_value(value, sizeof(value), params+3);
         id = qemu_strdup(value);          id = value;
     } else if ((p = strstr(params, ",id=")) != NULL) {      } else if ((p = strstr(params, ",id=")) != NULL) {
         get_opt_value(value, sizeof(value), p+4);          get_opt_value(value, sizeof(value), p+4);
         id = qemu_strdup(value);          id = value;
     }      }
     opts = qemu_opts_create(list, id, 1);      opts = qemu_opts_create(list, id, 1);
     if (opts == NULL)      if (opts == NULL)
Line 774  QemuOpts *qemu_opts_parse(QemuOptsList * Line 854  QemuOpts *qemu_opts_parse(QemuOptsList *
     return opts;      return opts;
 }  }
   
   static void qemu_opts_from_qdict_1(const char *key, QObject *obj, void *opaque)
   {
       char buf[32];
       const char *value;
       int n;
   
       if (!strcmp(key, "id")) {
           return;
       }
   
       switch (qobject_type(obj)) {
       case QTYPE_QSTRING:
           value = qstring_get_str(qobject_to_qstring(obj));
           break;
       case QTYPE_QINT:
           n = snprintf(buf, sizeof(buf), "%" PRId64,
                        qint_get_int(qobject_to_qint(obj)));
           assert(n < sizeof(buf));
           value = buf;
           break;
       case QTYPE_QFLOAT:
           n = snprintf(buf, sizeof(buf), "%.17g",
                        qfloat_get_double(qobject_to_qfloat(obj)));
           assert(n < sizeof(buf));
           value = buf;
           break;
       case QTYPE_QBOOL:
           pstrcpy(buf, sizeof(buf),
                   qbool_get_int(qobject_to_qbool(obj)) ? "on" : "off");
           value = buf;
           break;
       default:
           return;
       }
       qemu_opt_set(opaque, key, value);
   }
   
   /*
    * Create QemuOpts from a QDict.
    * Use value of key "id" as ID if it exists and is a QString.
    * Only QStrings, QInts, QFloats and QBools are copied.  Entries with
    * other types are silently ignored.
    */
   QemuOpts *qemu_opts_from_qdict(QemuOptsList *list, const QDict *qdict)
   {
       QemuOpts *opts;
   
       opts = qemu_opts_create(list, qdict_get_try_str(qdict, "id"), 1);
       if (opts == NULL)
           return NULL;
   
       qdict_iter(qdict, qemu_opts_from_qdict_1, opts);
       return opts;
   }
   
   /*
    * Convert from QemuOpts to QDict.
    * The QDict values are of type QString.
    * TODO We'll want to use types appropriate for opt->desc->type, but
    * this is enough for now.
    */
   QDict *qemu_opts_to_qdict(QemuOpts *opts, QDict *qdict)
   {
       QemuOpt *opt;
       QObject *val;
   
       if (!qdict) {
           qdict = qdict_new();
       }
       if (opts->id) {
           qdict_put(qdict, "id", qstring_from_str(opts->id));
       }
       QTAILQ_FOREACH(opt, &opts->head, next) {
           val = QOBJECT(qstring_from_str(opt->str));
           qdict_put_obj(qdict, opt->name, val);
       }
       return qdict;
   }
   
 /* Validate parsed opts against descriptions where no  /* Validate parsed opts against descriptions where no
  * descriptions were provided in the QemuOptsList.   * descriptions were provided in the QemuOptsList.
  */   */
 int qemu_opts_validate(QemuOpts *opts, QemuOptDesc *desc)  int qemu_opts_validate(QemuOpts *opts, const QemuOptDesc *desc)
 {  {
     QemuOpt *opt;      QemuOpt *opt;
   
Line 792  int qemu_opts_validate(QemuOpts *opts, Q Line 951  int qemu_opts_validate(QemuOpts *opts, Q
             }              }
         }          }
         if (desc[i].name == NULL) {          if (desc[i].name == NULL) {
             fprintf(stderr, "option \"%s\" is not valid for %s\n",              qerror_report(QERR_INVALID_PARAMETER, opt->name);
                     opt->name, opts->list->name);  
             return -1;              return -1;
         }          }
   
Line 810  int qemu_opts_validate(QemuOpts *opts, Q Line 968  int qemu_opts_validate(QemuOpts *opts, Q
 int qemu_opts_foreach(QemuOptsList *list, qemu_opts_loopfunc func, void *opaque,  int qemu_opts_foreach(QemuOptsList *list, qemu_opts_loopfunc func, void *opaque,
                       int abort_on_failure)                        int abort_on_failure)
 {  {
       Location loc;
     QemuOpts *opts;      QemuOpts *opts;
     int rc = 0;      int rc = 0;
   
       loc_push_none(&loc);
     QTAILQ_FOREACH(opts, &list->head, next) {      QTAILQ_FOREACH(opts, &list->head, next) {
         rc = func(opts, opaque);          loc_restore(&opts->loc);
           rc |= func(opts, opaque);
         if (abort_on_failure  &&  rc != 0)          if (abort_on_failure  &&  rc != 0)
             break;              break;
     }      }
       loc_pop(&loc);
     return rc;      return rc;
 }  }

Removed from v.1.1.1.2  
changed lines
  Added in v.1.1.1.3


unix.superglobalmegacorp.com