lib/ovsdb-types.c

   1 /* Copyright (c) 2009, 2010 Nicira Networks
   2  *
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15
  16 #include <config.h>
  17
  18 #include "ovsdb-types.h"
  19
  20 #include <float.h>
  21 #include <limits.h>
  22
  23 #include "dynamic-string.h"
  24 #include "json.h"
  25 #include "ovsdb-error.h"
  26 #include "ovsdb-parser.h"
  27
  28 const struct ovsdb_type ovsdb_type_integer =
  29     OVSDB_TYPE_SCALAR_INITIALIZER(OVSDB_BASE_INTEGER_INIT);
  30 const struct ovsdb_type ovsdb_type_real =
  31     OVSDB_TYPE_SCALAR_INITIALIZER(OVSDB_BASE_REAL_INIT);
  32 const struct ovsdb_type ovsdb_type_boolean =
  33     OVSDB_TYPE_SCALAR_INITIALIZER(OVSDB_BASE_BOOLEAN_INIT);
  34 const struct ovsdb_type ovsdb_type_string =
  35     OVSDB_TYPE_SCALAR_INITIALIZER(OVSDB_BASE_STRING_INIT);
  36 const struct ovsdb_type ovsdb_type_uuid =
  37     OVSDB_TYPE_SCALAR_INITIALIZER(OVSDB_BASE_UUID_INIT);
  38 \f
  39 /* ovsdb_atomic_type */
  40 const char *
  41 ovsdb_atomic_type_to_string(enum ovsdb_atomic_type type)
  42 {
  43     switch (type) {
  44     case OVSDB_TYPE_VOID:
  45         return "void";
  46
  47     case OVSDB_TYPE_INTEGER:
  48         return "integer";
  49
  50     case OVSDB_TYPE_REAL:
  51         return "real";
  52
  53     case OVSDB_TYPE_BOOLEAN:
  54         return "boolean";
  55
  56     case OVSDB_TYPE_STRING:
  57         return "string";
  58
  59     case OVSDB_TYPE_UUID:
  60         return "uuid";
  61
  62     case OVSDB_N_TYPES:
  63     default:
  64         return "<invalid>";
  65     }
  66 }
  67
  68 struct json *
  69 ovsdb_atomic_type_to_json(enum ovsdb_atomic_type type)
  70 {
  71     return json_string_create(ovsdb_atomic_type_to_string(type));
  72 }
  73
  74 bool
  75 ovsdb_atomic_type_from_string(const char *string, enum ovsdb_atomic_type *type)
  76 {
  77     if (!strcmp(string, "integer")) {
  78         *type = OVSDB_TYPE_INTEGER;
  79     } else if (!strcmp(string, "real")) {
  80         *type = OVSDB_TYPE_REAL;
  81     } else if (!strcmp(string, "boolean")) {
  82         *type = OVSDB_TYPE_BOOLEAN;
  83     } else if (!strcmp(string, "string")) {
  84         *type = OVSDB_TYPE_STRING;
  85     } else if (!strcmp(string, "uuid")) {
  86         *type = OVSDB_TYPE_UUID;
  87     } else {
  88         return false;
  89     }
  90     return true;
  91 }
  92
  93 struct ovsdb_error *
  94 ovsdb_atomic_type_from_json(enum ovsdb_atomic_type *type,
  95                             const struct json *json)
  96 {
  97     if (json->type == JSON_STRING) {
  98         if (ovsdb_atomic_type_from_string(json_string(json), type)) {
  99             return NULL;
 100         } else {
 101             *type = OVSDB_TYPE_VOID;
 102             return ovsdb_syntax_error(json, NULL,
 103                                       "\"%s\" is not an atomic-type",
 104                                       json_string(json));
 105         }
 106     } else {
 107         *type = OVSDB_TYPE_VOID;
 108         return ovsdb_syntax_error(json, NULL, "atomic-type expected");
 109     }
 110 }
 111 \f
 112 /* ovsdb_base_type */
 113
 114 void
 115 ovsdb_base_type_init(struct ovsdb_base_type *base, enum ovsdb_atomic_type type)
 116 {
 117     base->type = type;
 118
 119     switch (base->type) {
 120     case OVSDB_TYPE_VOID:
 121         break;
 122
 123     case OVSDB_TYPE_INTEGER:
 124         base->u.integer.min = INT64_MIN;
 125         base->u.integer.max = INT64_MAX;
 126         break;
 127
 128     case OVSDB_TYPE_REAL:
 129         base->u.real.min = -DBL_MAX;
 130         base->u.real.max = DBL_MAX;
 131         break;
 132
 133     case OVSDB_TYPE_BOOLEAN:
 134         break;
 135
 136     case OVSDB_TYPE_STRING:
 137         base->u.string.minLen = 0;
 138         base->u.string.maxLen = UINT_MAX;
 139         break;
 140
 141     case OVSDB_TYPE_UUID:
 142         base->u.uuid.refTableName = NULL;
 143         base->u.uuid.refTable = NULL;
 144         break;
 145
 146     case OVSDB_N_TYPES:
 147         NOT_REACHED();
 148
 149     default:
 150         NOT_REACHED();
 151     }
 152 }
 153
 154 void
 155 ovsdb_base_type_clone(struct ovsdb_base_type *dst,
 156                       const struct ovsdb_base_type *src)
 157 {
 158     *dst = *src;
 159
 160     switch (dst->type) {
 161     case OVSDB_TYPE_VOID:
 162     case OVSDB_TYPE_INTEGER:
 163     case OVSDB_TYPE_REAL:
 164     case OVSDB_TYPE_BOOLEAN:
 165         break;
 166
 167     case OVSDB_TYPE_STRING:
 168         break;
 169
 170     case OVSDB_TYPE_UUID:
 171         if (dst->u.uuid.refTableName) {
 172             dst->u.uuid.refTableName = xstrdup(dst->u.uuid.refTableName);
 173         }
 174         break;
 175
 176     case OVSDB_N_TYPES:
 177     default:
 178         NOT_REACHED();
 179     }
 180 }
 181
 182 void
 183 ovsdb_base_type_destroy(struct ovsdb_base_type *base)
 184 {
 185     if (base) {
 186         switch (base->type) {
 187         case OVSDB_TYPE_VOID:
 188         case OVSDB_TYPE_INTEGER:
 189         case OVSDB_TYPE_REAL:
 190         case OVSDB_TYPE_BOOLEAN:
 191             break;
 192
 193         case OVSDB_TYPE_STRING:
 194             break;
 195
 196         case OVSDB_TYPE_UUID:
 197             free(base->u.uuid.refTableName);
 198             break;
 199
 200         case OVSDB_N_TYPES:
 201             NOT_REACHED();
 202
 203         default:
 204             NOT_REACHED();
 205         }
 206     }
 207 }
 208
 209 bool
 210 ovsdb_base_type_is_valid(const struct ovsdb_base_type *base)
 211 {
 212     switch (base->type) {
 213     case OVSDB_TYPE_VOID:
 214         return true;
 215
 216     case OVSDB_TYPE_INTEGER:
 217         return base->u.integer.min <= base->u.integer.max;
 218
 219     case OVSDB_TYPE_REAL:
 220         return base->u.real.min <= base->u.real.max;
 221
 222     case OVSDB_TYPE_BOOLEAN:
 223         return true;
 224
 225     case OVSDB_TYPE_STRING:
 226         return base->u.string.minLen <= base->u.string.maxLen;
 227
 228     case OVSDB_TYPE_UUID:
 229         return true;
 230
 231     case OVSDB_N_TYPES:
 232     default:
 233         return false;
 234     }
 235 }
 236
 237 bool
 238 ovsdb_base_type_has_constraints(const struct ovsdb_base_type *base)
 239 {
 240     switch (base->type) {
 241     case OVSDB_TYPE_VOID:
 242         NOT_REACHED();
 243
 244     case OVSDB_TYPE_INTEGER:
 245         return (base->u.integer.min != INT64_MIN
 246                 || base->u.integer.max != INT64_MAX);
 247
 248     case OVSDB_TYPE_REAL:
 249         return (base->u.real.min != -DBL_MAX
 250                 || base->u.real.max != DBL_MAX);
 251
 252     case OVSDB_TYPE_BOOLEAN:
 253         return false;
 254
 255     case OVSDB_TYPE_STRING:
 256         return base->u.string.minLen != 0 || base->u.string.maxLen != UINT_MAX;
 257
 258     case OVSDB_TYPE_UUID:
 259         return base->u.uuid.refTableName != NULL;
 260
 261     case OVSDB_N_TYPES:
 262         NOT_REACHED();
 263
 264     default:
 265         NOT_REACHED();
 266     }
 267 }
 268
 269 void
 270 ovsdb_base_type_clear_constraints(struct ovsdb_base_type *base)
 271 {
 272     enum ovsdb_atomic_type type = base->type;
 273     ovsdb_base_type_destroy(base);
 274     ovsdb_base_type_init(base, type);
 275 }
 276
 277 static struct ovsdb_error *
 278 parse_optional_uint(struct ovsdb_parser *parser, const char *member,
 279                     unsigned int *uint)
 280 {
 281     const struct json *json;
 282
 283     json = ovsdb_parser_member(parser, member, OP_INTEGER | OP_OPTIONAL);
 284     if (json) {
 285         if (json->u.integer < 0 || json->u.integer > UINT_MAX) {
 286             return ovsdb_syntax_error(json, NULL,
 287                                       "%s out of valid range 0 to %u",
 288                                       member, UINT_MAX);
 289         }
 290         *uint = json->u.integer;
 291     }
 292     return NULL;
 293 }
 294
 295 struct ovsdb_error *
 296 ovsdb_base_type_from_json(struct ovsdb_base_type *base,
 297                           const struct json *json)
 298 {
 299     struct ovsdb_parser parser;
 300     struct ovsdb_error *error;
 301     const struct json *type;
 302
 303     if (json->type == JSON_STRING) {
 304         error = ovsdb_atomic_type_from_json(&base->type, json);
 305         if (error) {
 306             return error;
 307         }
 308         ovsdb_base_type_init(base, base->type);
 309         return NULL;
 310     }
 311
 312     ovsdb_parser_init(&parser, json, "ovsdb type");
 313     type = ovsdb_parser_member(&parser, "type", OP_STRING);
 314     if (ovsdb_parser_has_error(&parser)) {
 315         base->type = OVSDB_TYPE_VOID;
 316         return ovsdb_parser_finish(&parser);
 317     }
 318
 319     error = ovsdb_atomic_type_from_json(&base->type, type);
 320     if (error) {
 321         return error;
 322     }
 323
 324     ovsdb_base_type_init(base, base->type);
 325     if (base->type == OVSDB_TYPE_INTEGER) {
 326         const struct json *min, *max;
 327
 328         min = ovsdb_parser_member(&parser, "minInteger",
 329                                   OP_INTEGER | OP_OPTIONAL);
 330         max = ovsdb_parser_member(&parser, "maxInteger",
 331                                   OP_INTEGER | OP_OPTIONAL);
 332         base->u.integer.min = min ? min->u.integer : INT64_MIN;
 333         base->u.integer.max = max ? max->u.integer : INT64_MAX;
 334         if (base->u.integer.min > base->u.integer.max) {
 335             error = ovsdb_syntax_error(json, NULL,
 336                                        "minInteger exceeds maxInteger");
 337         }
 338     } else if (base->type == OVSDB_TYPE_REAL) {
 339         const struct json *min, *max;
 340
 341         min = ovsdb_parser_member(&parser, "minReal", OP_NUMBER | OP_OPTIONAL);
 342         max = ovsdb_parser_member(&parser, "maxReal", OP_NUMBER | OP_OPTIONAL);
 343         base->u.real.min = min ? json_real(min) : -DBL_MAX;
 344         base->u.real.max = max ? json_real(max) : DBL_MAX;
 345         if (base->u.real.min > base->u.real.max) {
 346             error = ovsdb_syntax_error(json, NULL, "minReal exceeds maxReal");
 347         }
 348     } else if (base->type == OVSDB_TYPE_STRING) {
 349         if (!error) {
 350             error = parse_optional_uint(&parser, "minLength",
 351                                         &base->u.string.minLen);
 352         }
 353         if (!error) {
 354             error = parse_optional_uint(&parser, "maxLength",
 355                                         &base->u.string.maxLen);
 356         }
 357         if (!error && base->u.string.minLen > base->u.string.maxLen) {
 358             error = ovsdb_syntax_error(json, NULL,
 359                                        "minLength exceeds maxLength");
 360         }
 361     } else if (base->type == OVSDB_TYPE_UUID) {
 362         const struct json *refTable;
 363
 364         refTable = ovsdb_parser_member(&parser, "refTable",
 365                                        OP_ID | OP_OPTIONAL);
 366         if (refTable) {
 367             base->u.uuid.refTableName = xstrdup(refTable->u.string);
 368             /* We can't set base->u.uuid.refTable here because we don't have
 369              * enough context (we might not even be running in ovsdb-server).
 370              * ovsdb_create() will set refTable later. */
 371         }
 372     }
 373
 374     if (error) {
 375         ovsdb_error_destroy(ovsdb_parser_finish(&parser));
 376     } else {
 377         error = ovsdb_parser_finish(&parser);
 378     }
 379     if (error) {
 380         ovsdb_base_type_destroy(base);
 381         base->type = OVSDB_TYPE_VOID;
 382     }
 383     return error;
 384 }
 385
 386 struct json *
 387 ovsdb_base_type_to_json(const struct ovsdb_base_type *base)
 388 {
 389     struct json *json;
 390
 391     if (!ovsdb_base_type_has_constraints(base)) {
 392         return json_string_create(ovsdb_atomic_type_to_string(base->type));
 393     }
 394
 395     json = json_object_create();
 396     json_object_put_string(json, "type",
 397                            ovsdb_atomic_type_to_string(base->type));
 398     switch (base->type) {
 399     case OVSDB_TYPE_VOID:
 400         NOT_REACHED();
 401
 402     case OVSDB_TYPE_INTEGER:
 403         if (base->u.integer.min != INT64_MIN) {
 404             json_object_put(json, "minInteger",
 405                             json_integer_create(base->u.integer.min));
 406         }
 407         if (base->u.integer.max != INT64_MAX) {
 408             json_object_put(json, "maxInteger",
 409                             json_integer_create(base->u.integer.max));
 410         }
 411         break;
 412
 413     case OVSDB_TYPE_REAL:
 414         if (base->u.real.min != -DBL_MAX) {
 415             json_object_put(json, "minReal",
 416                             json_real_create(base->u.real.min));
 417         }
 418         if (base->u.real.max != DBL_MAX) {
 419             json_object_put(json, "maxReal",
 420                             json_real_create(base->u.real.max));
 421         }
 422         break;
 423
 424     case OVSDB_TYPE_BOOLEAN:
 425         break;
 426
 427     case OVSDB_TYPE_STRING:
 428         if (base->u.string.minLen != 0) {
 429             json_object_put(json, "minLength",
 430                             json_integer_create(base->u.string.minLen));
 431         }
 432         if (base->u.string.maxLen != UINT_MAX) {
 433             json_object_put(json, "maxLength",
 434                             json_integer_create(base->u.string.maxLen));
 435         }
 436         break;
 437
 438     case OVSDB_TYPE_UUID:
 439         if (base->u.uuid.refTableName) {
 440             json_object_put_string(json, "refTable",
 441                                    base->u.uuid.refTableName);
 442         }
 443         break;
 444
 445     case OVSDB_N_TYPES:
 446         NOT_REACHED();
 447
 448     default:
 449         NOT_REACHED();
 450     }
 451
 452     return json;
 453 }
 454 \f
 455 /* ovsdb_type */
 456
 457 void
 458 ovsdb_type_clone(struct ovsdb_type *dst, const struct ovsdb_type *src)
 459 {
 460     ovsdb_base_type_clone(&dst->key, &src->key);
 461     ovsdb_base_type_clone(&dst->value, &src->value);
 462     dst->n_min = src->n_min;
 463     dst->n_max = src->n_max;
 464 }
 465
 466 void
 467 ovsdb_type_destroy(struct ovsdb_type *type)
 468 {
 469     ovsdb_base_type_destroy(&type->key);
 470     ovsdb_base_type_destroy(&type->value);
 471 }
 472
 473 bool
 474 ovsdb_type_is_valid(const struct ovsdb_type *type)
 475 {
 476     return (type->key.type != OVSDB_TYPE_VOID
 477             && ovsdb_base_type_is_valid(&type->key)
 478             && ovsdb_base_type_is_valid(&type->value)
 479             && type->n_min <= 1
 480             && type->n_min <= type->n_max
 481             && type->n_max >= 1);
 482 }
 483
 484 static struct ovsdb_error *
 485 n_from_json(const struct json *json, unsigned int *n)
 486 {
 487     if (!json) {
 488         return NULL;
 489     } else if (json->type == JSON_INTEGER
 490                && json->u.integer >= 0 && json->u.integer < UINT_MAX) {
 491         *n = json->u.integer;
 492         return NULL;
 493     } else {
 494         return ovsdb_syntax_error(json, NULL, "bad min or max value");
 495     }
 496 }
 497
 498 char *
 499 ovsdb_type_to_english(const struct ovsdb_type *type)
 500 {
 501     const char *key = ovsdb_atomic_type_to_string(type->key.type);
 502     const char *value = ovsdb_atomic_type_to_string(type->value.type);
 503     if (ovsdb_type_is_scalar(type)) {
 504         return xstrdup(key);
 505     } else {
 506         struct ds s = DS_EMPTY_INITIALIZER;
 507         ds_put_cstr(&s, ovsdb_type_is_set(type) ? "set" : "map");
 508         if (type->n_max == UINT_MAX) {
 509             if (type->n_min) {
 510                 ds_put_format(&s, " of %u or more", type->n_min);
 511             } else {
 512                 ds_put_cstr(&s, " of");
 513             }
 514         } else if (type->n_min) {
 515             ds_put_format(&s, " of %u to %u", type->n_min, type->n_max);
 516         } else {
 517             ds_put_format(&s, " of up to %u", type->n_max);
 518         }
 519         if (ovsdb_type_is_set(type)) {
 520             ds_put_format(&s, " %ss", key);
 521         } else {
 522             ds_put_format(&s, " (%s, %s) pairs", key, value);
 523         }
 524         return ds_cstr(&s);
 525     }
 526 }
 527
 528 struct ovsdb_error *
 529 ovsdb_type_from_json(struct ovsdb_type *type, const struct json *json)
 530 {
 531     type->value.type = OVSDB_TYPE_VOID;
 532     type->n_min = 1;
 533     type->n_max = 1;
 534
 535     if (json->type == JSON_STRING) {
 536         return ovsdb_base_type_from_json(&type->key, json);
 537     } else if (json->type == JSON_OBJECT) {
 538         const struct json *key, *value, *min, *max;
 539         struct ovsdb_error *error;
 540         struct ovsdb_parser parser;
 541
 542         ovsdb_parser_init(&parser, json, "ovsdb type");
 543         key = ovsdb_parser_member(&parser, "key", OP_STRING | OP_OBJECT);
 544         value = ovsdb_parser_member(&parser, "value",
 545                                     OP_STRING | OP_OBJECT | OP_OPTIONAL);
 546         min = ovsdb_parser_member(&parser, "min", OP_INTEGER | OP_OPTIONAL);
 547         max = ovsdb_parser_member(&parser, "max",
 548                                   OP_INTEGER | OP_STRING | OP_OPTIONAL);
 549         error = ovsdb_parser_finish(&parser);
 550         if (error) {
 551             return error;
 552         }
 553
 554         error = ovsdb_base_type_from_json(&type->key, key);
 555         if (error) {
 556             return error;
 557         }
 558
 559         if (value) {
 560             error = ovsdb_base_type_from_json(&type->value, value);
 561             if (error) {
 562                 return error;
 563             }
 564         }
 565
 566         error = n_from_json(min, &type->n_min);
 567         if (error) {
 568             return error;
 569         }
 570
 571         if (max && max->type == JSON_STRING
 572             && !strcmp(max->u.string, "unlimited")) {
 573             type->n_max = UINT_MAX;
 574         } else {
 575             error = n_from_json(max, &type->n_max);
 576             if (error) {
 577                 return error;
 578             }
 579         }
 580
 581         if (!ovsdb_type_is_valid(type)) {
 582             return ovsdb_syntax_error(json, NULL,
 583                                       "ovsdb type fails constraint checks");
 584         }
 585
 586         return NULL;
 587     } else {
 588         return ovsdb_syntax_error(json, NULL, "ovsdb type expected");
 589     }
 590 }
 591
 592 struct json *
 593 ovsdb_type_to_json(const struct ovsdb_type *type)
 594 {
 595     if (ovsdb_type_is_scalar(type)
 596         && !ovsdb_base_type_has_constraints(&type->key)) {
 597         return ovsdb_base_type_to_json(&type->key);
 598     } else {
 599         struct json *json = json_object_create();
 600         json_object_put(json, "key", ovsdb_base_type_to_json(&type->key));
 601         if (type->value.type != OVSDB_TYPE_VOID) {
 602             json_object_put(json, "value",
 603                             ovsdb_base_type_to_json(&type->value));
 604         }
 605         if (type->n_min != 1) {
 606             json_object_put(json, "min", json_integer_create(type->n_min));
 607         }
 608         if (type->n_max == UINT_MAX) {
 609             json_object_put_string(json, "max", "unlimited");
 610         } else if (type->n_max != 1) {
 611             json_object_put(json, "max", json_integer_create(type->n_max));
 612         }
 613         return json;
 614     }
 615 }