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.re = NULL;
 138         base->u.string.reMatch = NULL;
 139         base->u.string.reComment = NULL;
 140         base->u.string.minLen = 0;
 141         base->u.string.maxLen = UINT_MAX;
 142         break;
 143
 144     case OVSDB_TYPE_UUID:
 145         base->u.uuid.refTableName = NULL;
 146         base->u.uuid.refTable = NULL;
 147         break;
 148
 149     case OVSDB_N_TYPES:
 150         NOT_REACHED();
 151
 152     default:
 153         NOT_REACHED();
 154     }
 155 }
 156
 157 void
 158 ovsdb_base_type_clone(struct ovsdb_base_type *dst,
 159                       const struct ovsdb_base_type *src)
 160 {
 161     *dst = *src;
 162
 163     switch (dst->type) {
 164     case OVSDB_TYPE_VOID:
 165     case OVSDB_TYPE_INTEGER:
 166     case OVSDB_TYPE_REAL:
 167     case OVSDB_TYPE_BOOLEAN:
 168         break;
 169
 170     case OVSDB_TYPE_STRING:
 171         if (dst->u.string.re) {
 172             pcre_refcount(dst->u.string.re, 1);
 173         }
 174         break;
 175
 176     case OVSDB_TYPE_UUID:
 177         if (dst->u.uuid.refTableName) {
 178             dst->u.uuid.refTableName = xstrdup(dst->u.uuid.refTableName);
 179         }
 180         break;
 181
 182     case OVSDB_N_TYPES:
 183     default:
 184         NOT_REACHED();
 185     }
 186 }
 187
 188 void
 189 ovsdb_base_type_destroy(struct ovsdb_base_type *base)
 190 {
 191     if (base) {
 192         switch (base->type) {
 193         case OVSDB_TYPE_VOID:
 194         case OVSDB_TYPE_INTEGER:
 195         case OVSDB_TYPE_REAL:
 196         case OVSDB_TYPE_BOOLEAN:
 197             break;
 198
 199         case OVSDB_TYPE_STRING:
 200             if (base->u.string.re && !pcre_refcount(base->u.string.re, -1)) {
 201                 pcre_free(base->u.string.re);
 202                 free(base->u.string.reMatch);
 203                 free(base->u.string.reComment);
 204             }
 205             break;
 206
 207         case OVSDB_TYPE_UUID:
 208             free(base->u.uuid.refTableName);
 209             break;
 210
 211         case OVSDB_N_TYPES:
 212             NOT_REACHED();
 213
 214         default:
 215             NOT_REACHED();
 216         }
 217     }
 218 }
 219
 220 bool
 221 ovsdb_base_type_is_valid(const struct ovsdb_base_type *base)
 222 {
 223     switch (base->type) {
 224     case OVSDB_TYPE_VOID:
 225         return true;
 226
 227     case OVSDB_TYPE_INTEGER:
 228         return base->u.integer.min <= base->u.integer.max;
 229
 230     case OVSDB_TYPE_REAL:
 231         return base->u.real.min <= base->u.real.max;
 232
 233     case OVSDB_TYPE_BOOLEAN:
 234         return true;
 235
 236     case OVSDB_TYPE_STRING:
 237         return base->u.string.minLen <= base->u.string.maxLen;
 238
 239     case OVSDB_TYPE_UUID:
 240         return true;
 241
 242     case OVSDB_N_TYPES:
 243     default:
 244         return false;
 245     }
 246 }
 247
 248 bool
 249 ovsdb_base_type_has_constraints(const struct ovsdb_base_type *base)
 250 {
 251     switch (base->type) {
 252     case OVSDB_TYPE_VOID:
 253         NOT_REACHED();
 254
 255     case OVSDB_TYPE_INTEGER:
 256         return (base->u.integer.min != INT64_MIN
 257                 || base->u.integer.max != INT64_MAX);
 258
 259     case OVSDB_TYPE_REAL:
 260         return (base->u.real.min != -DBL_MAX
 261                 || base->u.real.max != DBL_MAX);
 262
 263     case OVSDB_TYPE_BOOLEAN:
 264         return false;
 265
 266     case OVSDB_TYPE_STRING:
 267         return (base->u.string.reMatch != NULL
 268                 || base->u.string.minLen != 0
 269                 || base->u.string.maxLen != UINT_MAX);
 270
 271     case OVSDB_TYPE_UUID:
 272         return base->u.uuid.refTableName != NULL;
 273
 274     case OVSDB_N_TYPES:
 275         NOT_REACHED();
 276
 277     default:
 278         NOT_REACHED();
 279     }
 280 }
 281
 282 void
 283 ovsdb_base_type_clear_constraints(struct ovsdb_base_type *base)
 284 {
 285     enum ovsdb_atomic_type type = base->type;
 286     ovsdb_base_type_destroy(base);
 287     ovsdb_base_type_init(base, type);
 288 }
 289
 290 struct ovsdb_error *
 291 ovsdb_base_type_set_regex(struct ovsdb_base_type *base,
 292                           const char *reMatch, const char *reComment)
 293 {
 294     const char *errorString;
 295     const char *pattern;
 296     int errorOffset;
 297
 298     /* Compile pattern, anchoring it at both ends. */
 299     pattern = reMatch;
 300     if (pattern[0] == '\0' || strchr(pattern, '\0')[-1] != '$') {
 301         pattern = xasprintf("%s$", pattern);
 302     }
 303     base->u.string.re = pcre_compile(pattern, (PCRE_ANCHORED | PCRE_UTF8
 304                                                | PCRE_JAVASCRIPT_COMPAT),
 305                                      &errorString, &errorOffset, NULL);
 306     if (pattern != reMatch) {
 307         free((char *) pattern);
 308     }
 309     if (!base->u.string.re) {
 310         return ovsdb_syntax_error(NULL, "invalid regular expression",
 311                                   "\"%s\" is not a valid regular "
 312                                   "expression: %s", reMatch, errorString);
 313     }
 314
 315     /* Save regular expression. */
 316     pcre_refcount(base->u.string.re, 1);
 317     base->u.string.reMatch = xstrdup(reMatch);
 318     base->u.string.reComment = reComment ? xstrdup(reComment) : NULL;
 319     return NULL;
 320 }
 321
 322 static struct ovsdb_error *
 323 parse_optional_uint(struct ovsdb_parser *parser, const char *member,
 324                     unsigned int *uint)
 325 {
 326     const struct json *json;
 327
 328     json = ovsdb_parser_member(parser, member, OP_INTEGER | OP_OPTIONAL);
 329     if (json) {
 330         if (json->u.integer < 0 || json->u.integer > UINT_MAX) {
 331             return ovsdb_syntax_error(json, NULL,
 332                                       "%s out of valid range 0 to %u",
 333                                       member, UINT_MAX);
 334         }
 335         *uint = json->u.integer;
 336     }
 337     return NULL;
 338 }
 339
 340 struct ovsdb_error *
 341 ovsdb_base_type_from_json(struct ovsdb_base_type *base,
 342                           const struct json *json)
 343 {
 344     struct ovsdb_parser parser;
 345     struct ovsdb_error *error;
 346     const struct json *type;
 347
 348     if (json->type == JSON_STRING) {
 349         error = ovsdb_atomic_type_from_json(&base->type, json);
 350         if (error) {
 351             return error;
 352         }
 353         ovsdb_base_type_init(base, base->type);
 354         return NULL;
 355     }
 356
 357     ovsdb_parser_init(&parser, json, "ovsdb type");
 358     type = ovsdb_parser_member(&parser, "type", OP_STRING);
 359     if (ovsdb_parser_has_error(&parser)) {
 360         base->type = OVSDB_TYPE_VOID;
 361         return ovsdb_parser_finish(&parser);
 362     }
 363
 364     error = ovsdb_atomic_type_from_json(&base->type, type);
 365     if (error) {
 366         return error;
 367     }
 368
 369     ovsdb_base_type_init(base, base->type);
 370     if (base->type == OVSDB_TYPE_INTEGER) {
 371         const struct json *min, *max;
 372
 373         min = ovsdb_parser_member(&parser, "minInteger",
 374                                   OP_INTEGER | OP_OPTIONAL);
 375         max = ovsdb_parser_member(&parser, "maxInteger",
 376                                   OP_INTEGER | OP_OPTIONAL);
 377         base->u.integer.min = min ? min->u.integer : INT64_MIN;
 378         base->u.integer.max = max ? max->u.integer : INT64_MAX;
 379         if (base->u.integer.min > base->u.integer.max) {
 380             error = ovsdb_syntax_error(json, NULL,
 381                                        "minInteger exceeds maxInteger");
 382         }
 383     } else if (base->type == OVSDB_TYPE_REAL) {
 384         const struct json *min, *max;
 385
 386         min = ovsdb_parser_member(&parser, "minReal", OP_NUMBER | OP_OPTIONAL);
 387         max = ovsdb_parser_member(&parser, "maxReal", OP_NUMBER | OP_OPTIONAL);
 388         base->u.real.min = min ? json_real(min) : -DBL_MAX;
 389         base->u.real.max = max ? json_real(max) : DBL_MAX;
 390         if (base->u.real.min > base->u.real.max) {
 391             error = ovsdb_syntax_error(json, NULL, "minReal exceeds maxReal");
 392         }
 393     } else if (base->type == OVSDB_TYPE_STRING) {
 394         const struct json *reMatch;
 395
 396         reMatch = ovsdb_parser_member(&parser, "reMatch",
 397                                       OP_STRING | OP_OPTIONAL);
 398         if (reMatch) {
 399             const struct json *reComment;
 400
 401             reComment = ovsdb_parser_member(&parser, "reComment",
 402                                             OP_STRING | OP_OPTIONAL);
 403             error = ovsdb_base_type_set_regex(
 404                 base, json_string(reMatch),
 405                 reComment ? json_string(reComment) : NULL);
 406         }
 407
 408         if (!error) {
 409             error = parse_optional_uint(&parser, "minLength",
 410                                         &base->u.string.minLen);
 411         }
 412         if (!error) {
 413             error = parse_optional_uint(&parser, "maxLength",
 414                                         &base->u.string.maxLen);
 415         }
 416         if (!error && base->u.string.minLen > base->u.string.maxLen) {
 417             error = ovsdb_syntax_error(json, NULL,
 418                                        "minLength exceeds maxLength");
 419         }
 420     } else if (base->type == OVSDB_TYPE_UUID) {
 421         const struct json *refTable;
 422
 423         refTable = ovsdb_parser_member(&parser, "refTable",
 424                                        OP_ID | OP_OPTIONAL);
 425         if (refTable) {
 426             base->u.uuid.refTableName = xstrdup(refTable->u.string);
 427             /* We can't set base->u.uuid.refTable here because we don't have
 428              * enough context (we might not even be running in ovsdb-server).
 429              * ovsdb_create() will set refTable later. */
 430         }
 431     }
 432
 433     if (error) {
 434         ovsdb_error_destroy(ovsdb_parser_finish(&parser));
 435     } else {
 436         error = ovsdb_parser_finish(&parser);
 437     }
 438     if (error) {
 439         ovsdb_base_type_destroy(base);
 440         base->type = OVSDB_TYPE_VOID;
 441     }
 442     return error;
 443 }
 444
 445 struct json *
 446 ovsdb_base_type_to_json(const struct ovsdb_base_type *base)
 447 {
 448     struct json *json;
 449
 450     if (!ovsdb_base_type_has_constraints(base)) {
 451         return json_string_create(ovsdb_atomic_type_to_string(base->type));
 452     }
 453
 454     json = json_object_create();
 455     json_object_put_string(json, "type",
 456                            ovsdb_atomic_type_to_string(base->type));
 457     switch (base->type) {
 458     case OVSDB_TYPE_VOID:
 459         NOT_REACHED();
 460
 461     case OVSDB_TYPE_INTEGER:
 462         if (base->u.integer.min != INT64_MIN) {
 463             json_object_put(json, "minInteger",
 464                             json_integer_create(base->u.integer.min));
 465         }
 466         if (base->u.integer.max != INT64_MAX) {
 467             json_object_put(json, "maxInteger",
 468                             json_integer_create(base->u.integer.max));
 469         }
 470         break;
 471
 472     case OVSDB_TYPE_REAL:
 473         if (base->u.real.min != -DBL_MAX) {
 474             json_object_put(json, "minReal",
 475                             json_real_create(base->u.real.min));
 476         }
 477         if (base->u.real.max != DBL_MAX) {
 478             json_object_put(json, "maxReal",
 479                             json_real_create(base->u.real.max));
 480         }
 481         break;
 482
 483     case OVSDB_TYPE_BOOLEAN:
 484         break;
 485
 486     case OVSDB_TYPE_STRING:
 487         if (base->u.string.reMatch) {
 488             json_object_put_string(json, "reMatch", base->u.string.reMatch);
 489             if (base->u.string.reComment) {
 490                 json_object_put_string(json, "reComment",
 491                                        base->u.string.reComment);
 492             }
 493         }
 494         if (base->u.string.minLen != 0) {
 495             json_object_put(json, "minLength",
 496                             json_integer_create(base->u.string.minLen));
 497         }
 498         if (base->u.string.maxLen != UINT_MAX) {
 499             json_object_put(json, "maxLength",
 500                             json_integer_create(base->u.string.maxLen));
 501         }
 502         break;
 503
 504     case OVSDB_TYPE_UUID:
 505         if (base->u.uuid.refTableName) {
 506             json_object_put_string(json, "refTable",
 507                                    base->u.uuid.refTableName);
 508         }
 509         break;
 510
 511     case OVSDB_N_TYPES:
 512         NOT_REACHED();
 513
 514     default:
 515         NOT_REACHED();
 516     }
 517
 518     return json;
 519 }
 520 \f
 521 /* ovsdb_type */
 522
 523 void
 524 ovsdb_type_clone(struct ovsdb_type *dst, const struct ovsdb_type *src)
 525 {
 526     ovsdb_base_type_clone(&dst->key, &src->key);
 527     ovsdb_base_type_clone(&dst->value, &src->value);
 528     dst->n_min = src->n_min;
 529     dst->n_max = src->n_max;
 530 }
 531
 532 void
 533 ovsdb_type_destroy(struct ovsdb_type *type)
 534 {
 535     ovsdb_base_type_destroy(&type->key);
 536     ovsdb_base_type_destroy(&type->value);
 537 }
 538
 539 bool
 540 ovsdb_type_is_valid(const struct ovsdb_type *type)
 541 {
 542     return (type->key.type != OVSDB_TYPE_VOID
 543             && ovsdb_base_type_is_valid(&type->key)
 544             && ovsdb_base_type_is_valid(&type->value)
 545             && type->n_min <= 1
 546             && type->n_min <= type->n_max);
 547 }
 548
 549 static struct ovsdb_error *
 550 n_from_json(const struct json *json, unsigned int *n)
 551 {
 552     if (!json) {
 553         return NULL;
 554     } else if (json->type == JSON_INTEGER
 555                && json->u.integer >= 0 && json->u.integer < UINT_MAX) {
 556         *n = json->u.integer;
 557         return NULL;
 558     } else {
 559         return ovsdb_syntax_error(json, NULL, "bad min or max value");
 560     }
 561 }
 562
 563 char *
 564 ovsdb_type_to_english(const struct ovsdb_type *type)
 565 {
 566     const char *key = ovsdb_atomic_type_to_string(type->key.type);
 567     const char *value = ovsdb_atomic_type_to_string(type->value.type);
 568     if (ovsdb_type_is_scalar(type)) {
 569         return xstrdup(key);
 570     } else {
 571         struct ds s = DS_EMPTY_INITIALIZER;
 572         ds_put_cstr(&s, ovsdb_type_is_set(type) ? "set" : "map");
 573         if (type->n_max == UINT_MAX) {
 574             if (type->n_min) {
 575                 ds_put_format(&s, " of %u or more", type->n_min);
 576             } else {
 577                 ds_put_cstr(&s, " of");
 578             }
 579         } else if (type->n_min) {
 580             ds_put_format(&s, " of %u to %u", type->n_min, type->n_max);
 581         } else {
 582             ds_put_format(&s, " of up to %u", type->n_max);
 583         }
 584         if (ovsdb_type_is_set(type)) {
 585             ds_put_format(&s, " %ss", key);
 586         } else {
 587             ds_put_format(&s, " (%s, %s) pairs", key, value);
 588         }
 589         return ds_cstr(&s);
 590     }
 591 }
 592
 593 struct ovsdb_error *
 594 ovsdb_type_from_json(struct ovsdb_type *type, const struct json *json)
 595 {
 596     type->value.type = OVSDB_TYPE_VOID;
 597     type->n_min = 1;
 598     type->n_max = 1;
 599
 600     if (json->type == JSON_STRING) {
 601         return ovsdb_base_type_from_json(&type->key, json);
 602     } else if (json->type == JSON_OBJECT) {
 603         const struct json *key, *value, *min, *max;
 604         struct ovsdb_error *error;
 605         struct ovsdb_parser parser;
 606
 607         ovsdb_parser_init(&parser, json, "ovsdb type");
 608         key = ovsdb_parser_member(&parser, "key", OP_STRING | OP_OBJECT);
 609         value = ovsdb_parser_member(&parser, "value",
 610                                     OP_STRING | OP_OBJECT | OP_OPTIONAL);
 611         min = ovsdb_parser_member(&parser, "min", OP_INTEGER | OP_OPTIONAL);
 612         max = ovsdb_parser_member(&parser, "max",
 613                                   OP_INTEGER | OP_STRING | OP_OPTIONAL);
 614         error = ovsdb_parser_finish(&parser);
 615         if (error) {
 616             return error;
 617         }
 618
 619         error = ovsdb_base_type_from_json(&type->key, key);
 620         if (error) {
 621             return error;
 622         }
 623
 624         if (value) {
 625             error = ovsdb_base_type_from_json(&type->value, value);
 626             if (error) {
 627                 return error;
 628             }
 629         }
 630
 631         error = n_from_json(min, &type->n_min);
 632         if (error) {
 633             return error;
 634         }
 635
 636         if (max && max->type == JSON_STRING
 637             && !strcmp(max->u.string, "unlimited")) {
 638             type->n_max = UINT_MAX;
 639         } else {
 640             error = n_from_json(max, &type->n_max);
 641             if (error) {
 642                 return error;
 643             }
 644         }
 645
 646         if (!ovsdb_type_is_valid(type)) {
 647             return ovsdb_syntax_error(json, NULL,
 648                                       "ovsdb type fails constraint checks");
 649         }
 650
 651         return NULL;
 652     } else {
 653         return ovsdb_syntax_error(json, NULL, "ovsdb type expected");
 654     }
 655 }
 656
 657 struct json *
 658 ovsdb_type_to_json(const struct ovsdb_type *type)
 659 {
 660     if (ovsdb_type_is_scalar(type)
 661         && !ovsdb_base_type_has_constraints(&type->key)) {
 662         return ovsdb_base_type_to_json(&type->key);
 663     } else {
 664         struct json *json = json_object_create();
 665         json_object_put(json, "key", ovsdb_base_type_to_json(&type->key));
 666         if (type->value.type != OVSDB_TYPE_VOID) {
 667             json_object_put(json, "value",
 668                             ovsdb_base_type_to_json(&type->value));
 669         }
 670         if (type->n_min != 1) {
 671             json_object_put(json, "min", json_integer_create(type->n_min));
 672         }
 673         if (type->n_max == UINT_MAX) {
 674             json_object_put_string(json, "max", "unlimited");
 675         } else if (type->n_max != 1) {
 676             json_object_put(json, "max", json_integer_create(type->n_max));
 677         }
 678         return json;
 679     }
 680 }