1 /* Copyright (c) 2009, 2010 Nicira Networks
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:
7 * http://www.apache.org/licenses/LICENSE-2.0
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.
18 #include "ovsdb-types.h"
23 #include "dynamic-string.h"
25 #include "ovsdb-error.h"
26 #include "ovsdb-parser.h"
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);
39 /* ovsdb_atomic_type */
41 ovsdb_atomic_type_to_string(enum ovsdb_atomic_type type)
47 case OVSDB_TYPE_INTEGER:
53 case OVSDB_TYPE_BOOLEAN:
56 case OVSDB_TYPE_STRING:
69 ovsdb_atomic_type_to_json(enum ovsdb_atomic_type type)
71 return json_string_create(ovsdb_atomic_type_to_string(type));
75 ovsdb_atomic_type_from_string(const char *string, enum ovsdb_atomic_type *type)
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;
94 ovsdb_atomic_type_from_json(enum ovsdb_atomic_type *type,
95 const struct json *json)
97 if (json->type == JSON_STRING) {
98 if (ovsdb_atomic_type_from_string(json_string(json), type)) {
101 *type = OVSDB_TYPE_VOID;
102 return ovsdb_syntax_error(json, NULL,
103 "\"%s\" is not an atomic-type",
107 *type = OVSDB_TYPE_VOID;
108 return ovsdb_syntax_error(json, NULL, "atomic-type expected");
112 /* ovsdb_base_type */
115 ovsdb_base_type_init(struct ovsdb_base_type *base, enum ovsdb_atomic_type type)
119 switch (base->type) {
120 case OVSDB_TYPE_VOID:
123 case OVSDB_TYPE_INTEGER:
124 base->u.integer.min = INT64_MIN;
125 base->u.integer.max = INT64_MAX;
128 case OVSDB_TYPE_REAL:
129 base->u.real.min = -DBL_MAX;
130 base->u.real.max = DBL_MAX;
133 case OVSDB_TYPE_BOOLEAN:
136 case OVSDB_TYPE_STRING:
137 base->u.string.minLen = 0;
138 base->u.string.maxLen = UINT_MAX;
141 case OVSDB_TYPE_UUID:
142 base->u.uuid.refTableName = NULL;
143 base->u.uuid.refTable = NULL;
155 ovsdb_base_type_clone(struct ovsdb_base_type *dst,
156 const struct ovsdb_base_type *src)
161 case OVSDB_TYPE_VOID:
162 case OVSDB_TYPE_INTEGER:
163 case OVSDB_TYPE_REAL:
164 case OVSDB_TYPE_BOOLEAN:
167 case OVSDB_TYPE_STRING:
170 case OVSDB_TYPE_UUID:
171 if (dst->u.uuid.refTableName) {
172 dst->u.uuid.refTableName = xstrdup(dst->u.uuid.refTableName);
183 ovsdb_base_type_destroy(struct ovsdb_base_type *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:
193 case OVSDB_TYPE_STRING:
196 case OVSDB_TYPE_UUID:
197 free(base->u.uuid.refTableName);
210 ovsdb_base_type_is_valid(const struct ovsdb_base_type *base)
212 switch (base->type) {
213 case OVSDB_TYPE_VOID:
216 case OVSDB_TYPE_INTEGER:
217 return base->u.integer.min <= base->u.integer.max;
219 case OVSDB_TYPE_REAL:
220 return base->u.real.min <= base->u.real.max;
222 case OVSDB_TYPE_BOOLEAN:
225 case OVSDB_TYPE_STRING:
226 return base->u.string.minLen <= base->u.string.maxLen;
228 case OVSDB_TYPE_UUID:
238 ovsdb_base_type_has_constraints(const struct ovsdb_base_type *base)
240 switch (base->type) {
241 case OVSDB_TYPE_VOID:
244 case OVSDB_TYPE_INTEGER:
245 return (base->u.integer.min != INT64_MIN
246 || base->u.integer.max != INT64_MAX);
248 case OVSDB_TYPE_REAL:
249 return (base->u.real.min != -DBL_MAX
250 || base->u.real.max != DBL_MAX);
252 case OVSDB_TYPE_BOOLEAN:
255 case OVSDB_TYPE_STRING:
256 return base->u.string.minLen != 0 || base->u.string.maxLen != UINT_MAX;
258 case OVSDB_TYPE_UUID:
259 return base->u.uuid.refTableName != NULL;
270 ovsdb_base_type_clear_constraints(struct ovsdb_base_type *base)
272 enum ovsdb_atomic_type type = base->type;
273 ovsdb_base_type_destroy(base);
274 ovsdb_base_type_init(base, type);
277 static struct ovsdb_error *
278 parse_optional_uint(struct ovsdb_parser *parser, const char *member,
281 const struct json *json;
283 json = ovsdb_parser_member(parser, member, OP_INTEGER | OP_OPTIONAL);
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",
290 *uint = json->u.integer;
296 ovsdb_base_type_from_json(struct ovsdb_base_type *base,
297 const struct json *json)
299 struct ovsdb_parser parser;
300 struct ovsdb_error *error;
301 const struct json *type;
303 if (json->type == JSON_STRING) {
304 error = ovsdb_atomic_type_from_json(&base->type, json);
308 ovsdb_base_type_init(base, base->type);
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);
319 error = ovsdb_atomic_type_from_json(&base->type, type);
324 ovsdb_base_type_init(base, base->type);
325 if (base->type == OVSDB_TYPE_INTEGER) {
326 const struct json *min, *max;
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");
338 } else if (base->type == OVSDB_TYPE_REAL) {
339 const struct json *min, *max;
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");
348 } else if (base->type == OVSDB_TYPE_STRING) {
350 error = parse_optional_uint(&parser, "minLength",
351 &base->u.string.minLen);
354 error = parse_optional_uint(&parser, "maxLength",
355 &base->u.string.maxLen);
357 if (!error && base->u.string.minLen > base->u.string.maxLen) {
358 error = ovsdb_syntax_error(json, NULL,
359 "minLength exceeds maxLength");
361 } else if (base->type == OVSDB_TYPE_UUID) {
362 const struct json *refTable;
364 refTable = ovsdb_parser_member(&parser, "refTable",
365 OP_ID | OP_OPTIONAL);
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. */
375 ovsdb_error_destroy(ovsdb_parser_finish(&parser));
377 error = ovsdb_parser_finish(&parser);
380 ovsdb_base_type_destroy(base);
381 base->type = OVSDB_TYPE_VOID;
387 ovsdb_base_type_to_json(const struct ovsdb_base_type *base)
391 if (!ovsdb_base_type_has_constraints(base)) {
392 return json_string_create(ovsdb_atomic_type_to_string(base->type));
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:
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));
407 if (base->u.integer.max != INT64_MAX) {
408 json_object_put(json, "maxInteger",
409 json_integer_create(base->u.integer.max));
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));
418 if (base->u.real.max != DBL_MAX) {
419 json_object_put(json, "maxReal",
420 json_real_create(base->u.real.max));
424 case OVSDB_TYPE_BOOLEAN:
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));
432 if (base->u.string.maxLen != UINT_MAX) {
433 json_object_put(json, "maxLength",
434 json_integer_create(base->u.string.maxLen));
438 case OVSDB_TYPE_UUID:
439 if (base->u.uuid.refTableName) {
440 json_object_put_string(json, "refTable",
441 base->u.uuid.refTableName);
458 ovsdb_type_clone(struct ovsdb_type *dst, const struct ovsdb_type *src)
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;
467 ovsdb_type_destroy(struct ovsdb_type *type)
469 ovsdb_base_type_destroy(&type->key);
470 ovsdb_base_type_destroy(&type->value);
474 ovsdb_type_is_valid(const struct ovsdb_type *type)
476 return (type->key.type != OVSDB_TYPE_VOID
477 && ovsdb_base_type_is_valid(&type->key)
478 && ovsdb_base_type_is_valid(&type->value)
480 && type->n_min <= type->n_max
481 && type->n_max >= 1);
484 static struct ovsdb_error *
485 n_from_json(const struct json *json, unsigned int *n)
489 } else if (json->type == JSON_INTEGER
490 && json->u.integer >= 0 && json->u.integer < UINT_MAX) {
491 *n = json->u.integer;
494 return ovsdb_syntax_error(json, NULL, "bad min or max value");
499 ovsdb_type_to_english(const struct ovsdb_type *type)
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)) {
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) {
510 ds_put_format(&s, " of %u or more", type->n_min);
512 ds_put_cstr(&s, " of");
514 } else if (type->n_min) {
515 ds_put_format(&s, " of %u to %u", type->n_min, type->n_max);
517 ds_put_format(&s, " of up to %u", type->n_max);
519 if (ovsdb_type_is_set(type)) {
520 ds_put_format(&s, " %ss", key);
522 ds_put_format(&s, " (%s, %s) pairs", key, value);
529 ovsdb_type_from_json(struct ovsdb_type *type, const struct json *json)
531 type->value.type = OVSDB_TYPE_VOID;
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;
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);
554 error = ovsdb_base_type_from_json(&type->key, key);
560 error = ovsdb_base_type_from_json(&type->value, value);
566 error = n_from_json(min, &type->n_min);
571 if (max && max->type == JSON_STRING
572 && !strcmp(max->u.string, "unlimited")) {
573 type->n_max = UINT_MAX;
575 error = n_from_json(max, &type->n_max);
581 if (!ovsdb_type_is_valid(type)) {
582 return ovsdb_syntax_error(json, NULL,
583 "ovsdb type fails constraint checks");
588 return ovsdb_syntax_error(json, NULL, "ovsdb type expected");
593 ovsdb_type_to_json(const struct ovsdb_type *type)
595 if (ovsdb_type_is_scalar(type)
596 && !ovsdb_base_type_has_constraints(&type->key)) {
597 return ovsdb_base_type_to_json(&type->key);
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));
605 if (type->n_min != 1) {
606 json_object_put(json, "min", json_integer_create(type->n_min));
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));