1 /* Copyright (c) 2009, 2010, 2011, 2012, 2014, 2016 Nicira, Inc.
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-data.h"
25 #include "openvswitch/dynamic-string.h"
27 #include "ovs-thread.h"
28 #include "ovsdb-error.h"
29 #include "ovsdb-parser.h"
30 #include "openvswitch/json.h"
31 #include "openvswitch/shash.h"
38 wrap_json(const char *name
, struct json
*wrapped
)
40 return json_array_create_2(json_string_create(name
), wrapped
);
43 /* Initializes 'atom' with the default value of the given 'type'.
45 * The default value for an atom is as defined in RFC 7047:
47 * - "integer" or "real": 0
51 * - "string": "" (the empty string)
53 * - "uuid": 00000000-0000-0000-0000-000000000000
55 * The caller must eventually arrange for 'atom' to be destroyed (with
56 * ovsdb_atom_destroy()). */
58 ovsdb_atom_init_default(union ovsdb_atom
*atom
, enum ovsdb_atomic_type type
)
64 case OVSDB_TYPE_INTEGER
:
72 case OVSDB_TYPE_BOOLEAN
:
73 atom
->boolean
= false;
76 case OVSDB_TYPE_STRING
:
77 atom
->string
= xmemdup("", 1);
81 uuid_zero(&atom
->uuid
);
90 /* Returns a read-only atom of the given 'type' that has the default value for
91 * 'type'. The caller must not modify or free the returned atom.
93 * See ovsdb_atom_init_default() for an explanation of the default value of an
95 const union ovsdb_atom
*
96 ovsdb_atom_default(enum ovsdb_atomic_type type
)
98 static union ovsdb_atom default_atoms
[OVSDB_N_TYPES
];
99 static struct ovsthread_once once
= OVSTHREAD_ONCE_INITIALIZER
;
101 if (ovsthread_once_start(&once
)) {
104 for (i
= 0; i
< OVSDB_N_TYPES
; i
++) {
105 if (i
!= OVSDB_TYPE_VOID
) {
106 ovsdb_atom_init_default(&default_atoms
[i
], i
);
109 ovsthread_once_done(&once
);
112 ovs_assert(ovsdb_atomic_type_is_valid(type
));
113 return &default_atoms
[type
];
116 /* Returns true if 'atom', which must have the given 'type', has the default
117 * value for that type.
119 * See ovsdb_atom_init_default() for an explanation of the default value of an
122 ovsdb_atom_is_default(const union ovsdb_atom
*atom
,
123 enum ovsdb_atomic_type type
)
126 case OVSDB_TYPE_VOID
:
129 case OVSDB_TYPE_INTEGER
:
130 return atom
->integer
== 0;
132 case OVSDB_TYPE_REAL
:
133 return atom
->real
== 0.0;
135 case OVSDB_TYPE_BOOLEAN
:
136 return atom
->boolean
== false;
138 case OVSDB_TYPE_STRING
:
139 return atom
->string
[0] == '\0';
141 case OVSDB_TYPE_UUID
:
142 return uuid_is_zero(&atom
->uuid
);
150 /* Initializes 'new' as a copy of 'old', with the given 'type'.
152 * The caller must eventually arrange for 'new' to be destroyed (with
153 * ovsdb_atom_destroy()). */
155 ovsdb_atom_clone(union ovsdb_atom
*new, const union ovsdb_atom
*old
,
156 enum ovsdb_atomic_type type
)
159 case OVSDB_TYPE_VOID
:
162 case OVSDB_TYPE_INTEGER
:
163 new->integer
= old
->integer
;
166 case OVSDB_TYPE_REAL
:
167 new->real
= old
->real
;
170 case OVSDB_TYPE_BOOLEAN
:
171 new->boolean
= old
->boolean
;
174 case OVSDB_TYPE_STRING
:
175 new->string
= xstrdup(old
->string
);
178 case OVSDB_TYPE_UUID
:
179 new->uuid
= old
->uuid
;
188 /* Swaps the contents of 'a' and 'b', which need not have the same type. */
190 ovsdb_atom_swap(union ovsdb_atom
*a
, union ovsdb_atom
*b
)
192 union ovsdb_atom tmp
= *a
;
197 /* Returns a hash value for 'atom', which has the specified 'type', folding
198 * 'basis' into the calculation. */
200 ovsdb_atom_hash(const union ovsdb_atom
*atom
, enum ovsdb_atomic_type type
,
204 case OVSDB_TYPE_VOID
:
207 case OVSDB_TYPE_INTEGER
:
208 return hash_int(atom
->integer
, basis
);
210 case OVSDB_TYPE_REAL
:
211 return hash_double(atom
->real
, basis
);
213 case OVSDB_TYPE_BOOLEAN
:
214 return hash_boolean(atom
->boolean
, basis
);
216 case OVSDB_TYPE_STRING
:
217 return hash_string(atom
->string
, basis
);
219 case OVSDB_TYPE_UUID
:
220 return hash_int(uuid_hash(&atom
->uuid
), basis
);
228 /* Compares 'a' and 'b', which both have type 'type', and returns a
229 * strcmp()-like result. */
231 ovsdb_atom_compare_3way(const union ovsdb_atom
*a
,
232 const union ovsdb_atom
*b
,
233 enum ovsdb_atomic_type type
)
236 case OVSDB_TYPE_VOID
:
239 case OVSDB_TYPE_INTEGER
:
240 return a
->integer
< b
->integer
? -1 : a
->integer
> b
->integer
;
242 case OVSDB_TYPE_REAL
:
243 return a
->real
< b
->real
? -1 : a
->real
> b
->real
;
245 case OVSDB_TYPE_BOOLEAN
:
246 return a
->boolean
- b
->boolean
;
248 case OVSDB_TYPE_STRING
:
249 return strcmp(a
->string
, b
->string
);
251 case OVSDB_TYPE_UUID
:
252 return uuid_compare_3way(&a
->uuid
, &b
->uuid
);
260 static struct ovsdb_error
*
261 unwrap_json(const struct json
*json
, const char *name
,
262 enum json_type value_type
, const struct json
**value
)
264 if (json
->type
!= JSON_ARRAY
265 || json
->u
.array
.n
!= 2
266 || json
->u
.array
.elems
[0]->type
!= JSON_STRING
267 || (name
&& strcmp(json
->u
.array
.elems
[0]->u
.string
, name
))
268 || json
->u
.array
.elems
[1]->type
!= value_type
)
271 return ovsdb_syntax_error(json
, NULL
, "expected [\"%s\", <%s>]", name
,
272 json_type_to_string(value_type
));
274 *value
= json
->u
.array
.elems
[1];
278 static struct ovsdb_error
*
279 parse_json_pair(const struct json
*json
,
280 const struct json
**elem0
, const struct json
**elem1
)
282 if (json
->type
!= JSON_ARRAY
|| json
->u
.array
.n
!= 2) {
283 return ovsdb_syntax_error(json
, NULL
, "expected 2-element array");
285 *elem0
= json
->u
.array
.elems
[0];
286 *elem1
= json
->u
.array
.elems
[1];
291 ovsdb_symbol_referenced(struct ovsdb_symbol
*symbol
,
292 const struct ovsdb_base_type
*base
)
294 ovs_assert(base
->type
== OVSDB_TYPE_UUID
);
296 if (base
->u
.uuid
.refTableName
) {
297 switch (base
->u
.uuid
.refType
) {
298 case OVSDB_REF_STRONG
:
299 symbol
->strong_ref
= true;
302 symbol
->weak_ref
= true;
308 static union ovsdb_atom
*
309 alloc_default_atoms(enum ovsdb_atomic_type type
, size_t n
)
311 if (type
!= OVSDB_TYPE_VOID
&& n
) {
312 union ovsdb_atom
*atoms
;
315 atoms
= xmalloc(n
* sizeof *atoms
);
316 for (i
= 0; i
< n
; i
++) {
317 ovsdb_atom_init_default(&atoms
[i
], type
);
321 /* Avoid wasting memory in the n == 0 case, because xmalloc(0) is
322 * treated as xmalloc(1). */
327 static struct ovsdb_error
* OVS_WARN_UNUSED_RESULT
328 ovsdb_atom_parse_uuid(struct uuid
*uuid
, const struct json
*json
,
329 struct ovsdb_symbol_table
*symtab
,
330 const struct ovsdb_base_type
*base
)
332 struct ovsdb_error
*error0
;
333 const struct json
*value
;
335 error0
= unwrap_json(json
, "uuid", JSON_STRING
, &value
);
337 const char *uuid_string
= json_string(value
);
338 if (!uuid_from_string(uuid
, uuid_string
)) {
339 return ovsdb_syntax_error(json
, NULL
, "\"%s\" is not a valid UUID",
343 struct ovsdb_error
*error1
;
345 error1
= unwrap_json(json
, "named-uuid", JSON_STRING
, &value
);
347 struct ovsdb_symbol
*symbol
;
349 ovsdb_error_destroy(error0
);
350 if (!ovsdb_parser_is_id(json_string(value
))) {
351 return ovsdb_syntax_error(json
, NULL
, "named-uuid string is "
355 symbol
= ovsdb_symbol_table_insert(symtab
, json_string(value
));
356 *uuid
= symbol
->uuid
;
357 ovsdb_symbol_referenced(symbol
, base
);
360 ovsdb_error_destroy(error1
);
366 static struct ovsdb_error
* OVS_WARN_UNUSED_RESULT
367 ovsdb_atom_from_json__(union ovsdb_atom
*atom
,
368 const struct ovsdb_base_type
*base
,
369 const struct json
*json
,
370 struct ovsdb_symbol_table
*symtab
)
372 enum ovsdb_atomic_type type
= base
->type
;
375 case OVSDB_TYPE_VOID
:
378 case OVSDB_TYPE_INTEGER
:
379 if (json
->type
== JSON_INTEGER
) {
380 atom
->integer
= json
->u
.integer
;
385 case OVSDB_TYPE_REAL
:
386 if (json
->type
== JSON_INTEGER
) {
387 atom
->real
= json
->u
.integer
;
389 } else if (json
->type
== JSON_REAL
) {
390 atom
->real
= json
->u
.real
;
395 case OVSDB_TYPE_BOOLEAN
:
396 if (json
->type
== JSON_TRUE
) {
397 atom
->boolean
= true;
399 } else if (json
->type
== JSON_FALSE
) {
400 atom
->boolean
= false;
405 case OVSDB_TYPE_STRING
:
406 if (json
->type
== JSON_STRING
) {
407 atom
->string
= xstrdup(json
->u
.string
);
412 case OVSDB_TYPE_UUID
:
413 return ovsdb_atom_parse_uuid(&atom
->uuid
, json
, symtab
, base
);
420 return ovsdb_syntax_error(json
, NULL
, "expected %s",
421 ovsdb_atomic_type_to_string(type
));
424 /* Parses 'json' as an atom of the type described by 'base'. If successful,
425 * returns NULL and initializes 'atom' with the parsed atom. On failure,
426 * returns an error and the contents of 'atom' are indeterminate. The caller
427 * is responsible for freeing the error or the atom that is returned.
429 * Violations of constraints expressed by 'base' are treated as errors.
431 * If 'symtab' is nonnull, then named UUIDs in 'symtab' are accepted. Refer to
432 * RFC 7047 for information about this, and for the syntax that this function
433 * accepts. If 'base' is a reference and a symbol is parsed, then the symbol's
434 * 'strong_ref' or 'weak_ref' member is set to true, as appropriate. */
436 ovsdb_atom_from_json(union ovsdb_atom
*atom
,
437 const struct ovsdb_base_type
*base
,
438 const struct json
*json
,
439 struct ovsdb_symbol_table
*symtab
)
441 struct ovsdb_error
*error
;
443 error
= ovsdb_atom_from_json__(atom
, base
, json
, symtab
);
448 error
= ovsdb_atom_check_constraints(atom
, base
);
450 ovsdb_atom_destroy(atom
, base
->type
);
455 /* Converts 'atom', of the specified 'type', to JSON format, and returns the
456 * JSON. The caller is responsible for freeing the returned JSON.
458 * Refer to RFC 7047 for the format of the JSON that this function produces. */
460 ovsdb_atom_to_json(const union ovsdb_atom
*atom
, enum ovsdb_atomic_type type
)
463 case OVSDB_TYPE_VOID
:
466 case OVSDB_TYPE_INTEGER
:
467 return json_integer_create(atom
->integer
);
469 case OVSDB_TYPE_REAL
:
470 return json_real_create(atom
->real
);
472 case OVSDB_TYPE_BOOLEAN
:
473 return json_boolean_create(atom
->boolean
);
475 case OVSDB_TYPE_STRING
:
476 return json_string_create(atom
->string
);
478 case OVSDB_TYPE_UUID
:
479 return wrap_json("uuid", json_string_create_nocopy(
480 xasprintf(UUID_FMT
, UUID_ARGS(&atom
->uuid
))));
489 ovsdb_atom_from_string__(union ovsdb_atom
*atom
,
490 union ovsdb_atom
**range_end_atom
,
491 const struct ovsdb_base_type
*base
, const char *s
,
492 struct ovsdb_symbol_table
*symtab
)
494 enum ovsdb_atomic_type type
= base
->type
;
497 case OVSDB_TYPE_VOID
:
500 case OVSDB_TYPE_INTEGER
: {
501 long long int integer
, end
;
503 && str_to_llong_range(s
, 10, &integer
, &end
)) {
505 return xasprintf("\"%s\" is not a valid range. "
506 "Range end cannot be before start.", s
);
508 *range_end_atom
= alloc_default_atoms(type
, 1);
509 if (!(*range_end_atom
)) {
510 return xasprintf("\"%s\" is not a valid range", s
);
512 (*range_end_atom
)->integer
= end
;
513 } else if (!str_to_llong(s
, 10, &integer
)) {
514 return xasprintf("\"%s\" is not a valid integer or range", s
);
516 atom
->integer
= integer
;
520 case OVSDB_TYPE_REAL
:
521 if (!str_to_double(s
, &atom
->real
)) {
522 return xasprintf("\"%s\" is not a valid real number", s
);
524 /* Our JSON input routines map negative zero to zero, so do that here
525 * too for consistency. */
526 if (atom
->real
== 0.0) {
531 case OVSDB_TYPE_BOOLEAN
:
532 if (!strcmp(s
, "true") || !strcmp(s
, "yes") || !strcmp(s
, "on")
533 || !strcmp(s
, "1")) {
534 atom
->boolean
= true;
535 } else if (!strcmp(s
, "false") || !strcmp(s
, "no") || !strcmp(s
, "off")
536 || !strcmp(s
, "0")) {
537 atom
->boolean
= false;
539 return xasprintf("\"%s\" is not a valid boolean "
540 "(use \"true\" or \"false\")", s
);
544 case OVSDB_TYPE_STRING
:
546 return xstrdup("An empty string is not valid as input; "
547 "use \"\" to represent the empty string");
548 } else if (*s
== '"') {
549 size_t s_len
= strlen(s
);
551 if (s_len
< 2 || s
[s_len
- 1] != '"') {
552 return xasprintf("%s: missing quote at end of "
554 } else if (!json_string_unescape(s
+ 1, s_len
- 2,
556 char *error
= xasprintf("%s: %s", s
, atom
->string
);
561 atom
->string
= xstrdup(s
);
565 case OVSDB_TYPE_UUID
:
567 struct ovsdb_symbol
*symbol
= ovsdb_symbol_table_insert(symtab
, s
);
568 atom
->uuid
= symbol
->uuid
;
569 ovsdb_symbol_referenced(symbol
, base
);
570 } else if (!uuid_from_string(&atom
->uuid
, s
)) {
571 return xasprintf("\"%s\" is not a valid UUID", s
);
583 /* Initializes 'atom' and optionally 'range_end_atom' to a value of type 'base'
584 * parsed from 's', which takes one of the following forms:
586 * - OVSDB_TYPE_INTEGER: A decimal integer optionally preceded by a sign
587 * or two decimal integers optionally preceded by a sign and separated
588 * by a hyphen, representing inclusive range of integers
589 * ['atom', 'range_end_atom'].
591 * - OVSDB_TYPE_REAL: A floating-point number in the format accepted by
594 * - OVSDB_TYPE_BOOLEAN: "true", "yes", "on", "1" for true, or "false",
595 * "no", "off", or "0" for false.
597 * - OVSDB_TYPE_STRING: A JSON string if it begins with a quote, otherwise
598 * an arbitrary string.
600 * - OVSDB_TYPE_UUID: A UUID in RFC 4122 format. If 'symtab' is nonnull,
601 * then an identifier beginning with '@' is also acceptable. If the
602 * named identifier is already in 'symtab', then the associated UUID is
603 * used; otherwise, a new, random UUID is used and added to the symbol
604 * table. If 'base' is a reference and a symbol is parsed, then the
605 * symbol's 'strong_ref' or 'weak_ref' member is set to true, as
608 * Returns a null pointer if successful, otherwise an error message describing
609 * the problem. On failure, the contents of 'atom' are indeterminate. The
610 * caller is responsible for freeing the atom or the error.
612 * Does not attempt to parse range if 'range_end_atom' is a null pointer.
613 * Dynamically allocates ovdsb_atom and stores its address in '*range_end_atom'
614 * if successfully parses range. Caller is responsible for deallocating
615 * the memory by calling 'ovsdb_atom_destroy' and then 'free' on the address.
616 * Does not allocate memory and sets '*range_end_atom' to a null pointer
617 * if does not parse a range or fails for any reason.
620 ovsdb_atom_from_string(union ovsdb_atom
*atom
,
621 union ovsdb_atom
**range_end_atom
,
622 const struct ovsdb_base_type
*base
, const char *s
,
623 struct ovsdb_symbol_table
*symtab
)
625 struct ovsdb_error
*error
;
628 if (range_end_atom
) {
629 *range_end_atom
= NULL
;
632 msg
= ovsdb_atom_from_string__(atom
, range_end_atom
, base
, s
, symtab
);
637 error
= ovsdb_atom_check_constraints(atom
, base
);
639 if (!error
&& range_end_atom
&& *range_end_atom
) {
640 /* Check range constraints */
641 int64_t start
= atom
->integer
;
642 int64_t end
= (*range_end_atom
)->integer
;
644 for (int64_t i
= start
+ 1; i
<= end
; i
++) {
645 union ovsdb_atom ai
= { .integer
= i
};
646 error
= ovsdb_atom_check_constraints(&ai
, base
);
652 error
= ovsdb_atom_check_constraints(*range_end_atom
, base
);
656 error
= ovsdb_atom_range_check_size(start
, end
);
661 ovsdb_atom_destroy(atom
, base
->type
);
662 if (range_end_atom
&& *range_end_atom
) {
663 ovsdb_atom_destroy(*range_end_atom
, base
->type
);
664 free(*range_end_atom
);
665 *range_end_atom
= NULL
;
667 msg
= ovsdb_error_to_string(error
);
668 ovsdb_error_destroy(error
);
674 string_needs_quotes(const char *s
)
680 if (!isalpha(c
) && c
!= '_') {
684 while ((c
= *p
++) != '\0') {
685 if (!isalpha(c
) && c
!= '_' && c
!= '-' && c
!= '.') {
690 if (!strcmp(s
, "true") || !strcmp(s
, "false")) {
697 /* Appends 'atom' (which has the given 'type') to 'out', in a format acceptable
698 * to ovsdb_atom_from_string(). */
700 ovsdb_atom_to_string(const union ovsdb_atom
*atom
, enum ovsdb_atomic_type type
,
704 case OVSDB_TYPE_VOID
:
707 case OVSDB_TYPE_INTEGER
:
708 ds_put_format(out
, "%"PRId64
, atom
->integer
);
711 case OVSDB_TYPE_REAL
:
712 ds_put_format(out
, "%.*g", DBL_DIG
, atom
->real
);
715 case OVSDB_TYPE_BOOLEAN
:
716 ds_put_cstr(out
, atom
->boolean
? "true" : "false");
719 case OVSDB_TYPE_STRING
:
720 if (string_needs_quotes(atom
->string
)) {
723 json
.type
= JSON_STRING
;
724 json
.u
.string
= atom
->string
;
725 json_to_ds(&json
, 0, out
);
727 ds_put_cstr(out
, atom
->string
);
731 case OVSDB_TYPE_UUID
:
732 ds_put_format(out
, UUID_FMT
, UUID_ARGS(&atom
->uuid
));
741 /* Appends 'atom' (which has the given 'type') to 'out', in a bare string
742 * format that cannot be parsed uniformly back into a datum but is easier for
743 * shell scripts, etc., to deal with. */
745 ovsdb_atom_to_bare(const union ovsdb_atom
*atom
, enum ovsdb_atomic_type type
,
748 if (type
== OVSDB_TYPE_STRING
) {
749 ds_put_cstr(out
, atom
->string
);
751 ovsdb_atom_to_string(atom
, type
, out
);
755 static struct ovsdb_error
*
756 check_string_constraints(const char *s
,
757 const struct ovsdb_string_constraints
*c
)
762 msg
= utf8_validate(s
, &n_chars
);
764 struct ovsdb_error
*error
;
766 error
= ovsdb_error("constraint violation",
767 "not a valid UTF-8 string: %s", msg
);
772 if (n_chars
< c
->minLen
) {
774 "constraint violation",
775 "\"%s\" length %"PRIuSIZE
" is less than minimum allowed "
776 "length %u", s
, n_chars
, c
->minLen
);
777 } else if (n_chars
> c
->maxLen
) {
779 "constraint violation",
780 "\"%s\" length %"PRIuSIZE
" is greater than maximum allowed "
781 "length %u", s
, n_chars
, c
->maxLen
);
787 /* Checks whether 'atom' meets the constraints (if any) defined in 'base'.
788 * (base->type must specify 'atom''s type.) Returns a null pointer if the
789 * constraints are met, otherwise an error that explains the violation.
791 * Checking UUID constraints is deferred to transaction commit time, so this
792 * function does nothing for UUID constraints. */
794 ovsdb_atom_check_constraints(const union ovsdb_atom
*atom
,
795 const struct ovsdb_base_type
*base
)
798 && ovsdb_datum_find_key(base
->enum_
, atom
, base
->type
) == UINT_MAX
) {
799 struct ovsdb_error
*error
;
800 struct ds actual
= DS_EMPTY_INITIALIZER
;
801 struct ds valid
= DS_EMPTY_INITIALIZER
;
803 ovsdb_atom_to_string(atom
, base
->type
, &actual
);
804 ovsdb_datum_to_string(base
->enum_
,
805 ovsdb_base_type_get_enum_type(base
->type
),
807 error
= ovsdb_error("constraint violation",
808 "%s is not one of the allowed values (%s)",
809 ds_cstr(&actual
), ds_cstr(&valid
));
816 switch (base
->type
) {
817 case OVSDB_TYPE_VOID
:
820 case OVSDB_TYPE_INTEGER
:
821 if (atom
->integer
>= base
->u
.integer
.min
822 && atom
->integer
<= base
->u
.integer
.max
) {
824 } else if (base
->u
.integer
.min
!= INT64_MIN
) {
825 if (base
->u
.integer
.max
!= INT64_MAX
) {
826 return ovsdb_error("constraint violation",
827 "%"PRId64
" is not in the valid range "
828 "%"PRId64
" to %"PRId64
" (inclusive)",
830 base
->u
.integer
.min
, base
->u
.integer
.max
);
832 return ovsdb_error("constraint violation",
833 "%"PRId64
" is less than minimum allowed "
835 atom
->integer
, base
->u
.integer
.min
);
838 return ovsdb_error("constraint violation",
839 "%"PRId64
" is greater than maximum allowed "
841 atom
->integer
, base
->u
.integer
.max
);
845 case OVSDB_TYPE_REAL
:
846 if (atom
->real
>= base
->u
.real
.min
&& atom
->real
<= base
->u
.real
.max
) {
848 } else if (base
->u
.real
.min
!= -DBL_MAX
) {
849 if (base
->u
.real
.max
!= DBL_MAX
) {
850 return ovsdb_error("constraint violation",
851 "%.*g is not in the valid range "
852 "%.*g to %.*g (inclusive)",
854 DBL_DIG
, base
->u
.real
.min
,
855 DBL_DIG
, base
->u
.real
.max
);
857 return ovsdb_error("constraint violation",
858 "%.*g is less than minimum allowed "
861 DBL_DIG
, base
->u
.real
.min
);
864 return ovsdb_error("constraint violation",
865 "%.*g is greater than maximum allowed "
868 DBL_DIG
, base
->u
.real
.max
);
872 case OVSDB_TYPE_BOOLEAN
:
875 case OVSDB_TYPE_STRING
:
876 return check_string_constraints(atom
->string
, &base
->u
.string
);
878 case OVSDB_TYPE_UUID
:
887 /* Initializes 'datum' as an empty datum. (An empty datum can be treated as
890 ovsdb_datum_init_empty(struct ovsdb_datum
*datum
)
894 datum
->values
= NULL
;
897 /* Initializes 'datum' as a datum that has the default value for 'type'.
899 * The default value for a particular type is as defined in RFC 7047:
901 * - If n_min is 0, then the default value is the empty set (or map).
903 * - If n_min is 1, the default value is a single value or a single
904 * key-value pair, whose key and value are the defaults for their
905 * atomic types. (See ovsdb_atom_init_default() for details.)
907 * - n_min > 1 is invalid. See ovsdb_type_is_valid().
910 ovsdb_datum_init_default(struct ovsdb_datum
*datum
,
911 const struct ovsdb_type
*type
)
913 datum
->n
= type
->n_min
;
914 datum
->keys
= alloc_default_atoms(type
->key
.type
, datum
->n
);
915 datum
->values
= alloc_default_atoms(type
->value
.type
, datum
->n
);
918 /* Returns a read-only datum of the given 'type' that has the default value for
919 * 'type'. The caller must not modify or free the returned datum.
921 * See ovsdb_datum_init_default() for an explanation of the default value of a
923 const struct ovsdb_datum
*
924 ovsdb_datum_default(const struct ovsdb_type
*type
)
926 if (type
->n_min
== 0) {
927 static const struct ovsdb_datum empty
;
929 } else if (type
->n_min
== 1) {
930 static struct ovsdb_datum default_data
[OVSDB_N_TYPES
][OVSDB_N_TYPES
];
931 struct ovsdb_datum
*d
;
932 int kt
= type
->key
.type
;
933 int vt
= type
->value
.type
;
935 ovs_assert(ovsdb_type_is_valid(type
));
937 d
= &default_data
[kt
][vt
];
940 d
->keys
= CONST_CAST(union ovsdb_atom
*, ovsdb_atom_default(kt
));
941 if (vt
!= OVSDB_TYPE_VOID
) {
942 d
->values
= CONST_CAST(union ovsdb_atom
*,
943 ovsdb_atom_default(vt
));
952 /* Returns true if 'datum', which must have the given 'type', has the default
953 * value for that type.
955 * See ovsdb_datum_init_default() for an explanation of the default value of a
958 ovsdb_datum_is_default(const struct ovsdb_datum
*datum
,
959 const struct ovsdb_type
*type
)
963 if (datum
->n
!= type
->n_min
) {
966 for (i
= 0; i
< datum
->n
; i
++) {
967 if (!ovsdb_atom_is_default(&datum
->keys
[i
], type
->key
.type
)) {
970 if (type
->value
.type
!= OVSDB_TYPE_VOID
971 && !ovsdb_atom_is_default(&datum
->values
[i
], type
->value
.type
)) {
979 static union ovsdb_atom
*
980 clone_atoms(const union ovsdb_atom
*old
, enum ovsdb_atomic_type type
, size_t n
)
982 if (type
!= OVSDB_TYPE_VOID
&& n
) {
983 union ovsdb_atom
*new;
986 new = xmalloc(n
* sizeof *new);
987 for (i
= 0; i
< n
; i
++) {
988 ovsdb_atom_clone(&new[i
], &old
[i
], type
);
992 /* Avoid wasting memory in the n == 0 case, because xmalloc(0) is
993 * treated as xmalloc(1). */
998 /* Initializes 'new' as a copy of 'old', with the given 'type'.
1000 * The caller must eventually arrange for 'new' to be destroyed (with
1001 * ovsdb_datum_destroy()). */
1003 ovsdb_datum_clone(struct ovsdb_datum
*new, const struct ovsdb_datum
*old
,
1004 const struct ovsdb_type
*type
)
1006 unsigned int n
= old
->n
;
1008 new->keys
= clone_atoms(old
->keys
, type
->key
.type
, n
);
1009 new->values
= clone_atoms(old
->values
, type
->value
.type
, n
);
1013 free_data(enum ovsdb_atomic_type type
,
1014 union ovsdb_atom
*atoms
, size_t n_atoms
)
1016 if (ovsdb_atom_needs_destruction(type
)) {
1018 for (i
= 0; i
< n_atoms
; i
++) {
1019 ovsdb_atom_destroy(&atoms
[i
], type
);
1025 /* Frees the data owned by 'datum', which must have the given 'type'.
1027 * This does not actually call free(datum). If necessary, the caller must be
1028 * responsible for that. */
1030 ovsdb_datum_destroy(struct ovsdb_datum
*datum
, const struct ovsdb_type
*type
)
1032 free_data(type
->key
.type
, datum
->keys
, datum
->n
);
1033 free_data(type
->value
.type
, datum
->values
, datum
->n
);
1036 /* Swaps the contents of 'a' and 'b', which need not have the same type. */
1038 ovsdb_datum_swap(struct ovsdb_datum
*a
, struct ovsdb_datum
*b
)
1040 struct ovsdb_datum tmp
= *a
;
1045 struct ovsdb_datum_sort_cbdata
{
1046 enum ovsdb_atomic_type key_type
;
1047 enum ovsdb_atomic_type value_type
;
1048 struct ovsdb_datum
*datum
;
1052 ovsdb_datum_sort_compare_cb(size_t a
, size_t b
, void *cbdata_
)
1054 struct ovsdb_datum_sort_cbdata
*cbdata
= cbdata_
;
1057 retval
= ovsdb_atom_compare_3way(&cbdata
->datum
->keys
[a
],
1058 &cbdata
->datum
->keys
[b
],
1060 if (retval
|| cbdata
->value_type
== OVSDB_TYPE_VOID
) {
1064 return ovsdb_atom_compare_3way(&cbdata
->datum
->values
[a
],
1065 &cbdata
->datum
->values
[b
],
1066 cbdata
->value_type
);
1070 ovsdb_datum_sort_swap_cb(size_t a
, size_t b
, void *cbdata_
)
1072 struct ovsdb_datum_sort_cbdata
*cbdata
= cbdata_
;
1074 ovsdb_atom_swap(&cbdata
->datum
->keys
[a
], &cbdata
->datum
->keys
[b
]);
1075 if (cbdata
->datum
->values
) {
1076 ovsdb_atom_swap(&cbdata
->datum
->values
[a
], &cbdata
->datum
->values
[b
]);
1081 ovsdb_datum_sort__(struct ovsdb_datum
*datum
, enum ovsdb_atomic_type key_type
,
1082 enum ovsdb_atomic_type value_type
)
1084 struct ovsdb_datum_sort_cbdata cbdata
;
1086 cbdata
.key_type
= key_type
;
1087 cbdata
.value_type
= value_type
;
1088 cbdata
.datum
= datum
;
1089 sort(datum
->n
, ovsdb_datum_sort_compare_cb
, ovsdb_datum_sort_swap_cb
,
1093 /* The keys in an ovsdb_datum must be unique and in sorted order. Most
1094 * functions that modify an ovsdb_datum maintain these invariants. For those
1095 * that don't, this function checks and restores these invariants for 'datum',
1096 * whose keys are of type 'key_type'.
1098 * This function returns NULL if successful, otherwise an error message. The
1099 * caller must free the returned error when it is no longer needed. On error,
1100 * 'datum' is sorted but not unique. */
1101 struct ovsdb_error
*
1102 ovsdb_datum_sort(struct ovsdb_datum
*datum
, enum ovsdb_atomic_type key_type
)
1110 ovsdb_datum_sort__(datum
, key_type
, OVSDB_TYPE_VOID
);
1112 for (i
= 0; i
< datum
->n
- 1; i
++) {
1113 if (ovsdb_atom_equals(&datum
->keys
[i
], &datum
->keys
[i
+ 1],
1115 if (datum
->values
) {
1116 return ovsdb_error(NULL
, "map contains duplicate key");
1118 return ovsdb_error(NULL
, "set contains duplicate");
1125 /* This function is the same as ovsdb_datum_sort(), except that the caller
1126 * knows that 'datum' is unique. The operation therefore "cannot fail", so
1127 * this function assert-fails if it actually does. */
1129 ovsdb_datum_sort_assert(struct ovsdb_datum
*datum
,
1130 enum ovsdb_atomic_type key_type
)
1132 struct ovsdb_error
*error
= ovsdb_datum_sort(datum
, key_type
);
1138 /* This is similar to ovsdb_datum_sort(), except that it drops duplicate keys
1139 * instead of reporting an error. In a map type, the smallest value among a
1140 * group of duplicate pairs is retained and the others are dropped.
1142 * Returns the number of keys (or pairs) that were dropped. */
1144 ovsdb_datum_sort_unique(struct ovsdb_datum
*datum
,
1145 enum ovsdb_atomic_type key_type
,
1146 enum ovsdb_atomic_type value_type
)
1154 ovsdb_datum_sort__(datum
, key_type
, value_type
);
1157 for (src
= 1; src
< datum
->n
; src
++) {
1158 if (ovsdb_atom_equals(&datum
->keys
[src
], &datum
->keys
[dst
- 1],
1160 ovsdb_atom_destroy(&datum
->keys
[src
], key_type
);
1161 if (value_type
!= OVSDB_TYPE_VOID
) {
1162 ovsdb_atom_destroy(&datum
->values
[src
], value_type
);
1166 datum
->keys
[dst
] = datum
->keys
[src
];
1167 if (value_type
!= OVSDB_TYPE_VOID
) {
1168 datum
->values
[dst
] = datum
->values
[src
];
1175 return datum
->n
- src
;
1178 /* Checks that each of the atoms in 'datum' conforms to the constraints
1179 * specified by its 'type'. Returns an error if a constraint is violated,
1180 * otherwise a null pointer.
1182 * This function is not commonly useful because the most ordinary way to obtain
1183 * a datum is ultimately via ovsdb_atom_from_string() or
1184 * ovsdb_atom_from_json(), which check constraints themselves. */
1185 struct ovsdb_error
*
1186 ovsdb_datum_check_constraints(const struct ovsdb_datum
*datum
,
1187 const struct ovsdb_type
*type
)
1189 struct ovsdb_error
*error
;
1192 for (i
= 0; i
< datum
->n
; i
++) {
1193 error
= ovsdb_atom_check_constraints(&datum
->keys
[i
], &type
->key
);
1199 if (type
->value
.type
!= OVSDB_TYPE_VOID
) {
1200 for (i
= 0; i
< datum
->n
; i
++) {
1201 error
= ovsdb_atom_check_constraints(&datum
->values
[i
],
1212 static struct ovsdb_error
*
1213 ovsdb_datum_from_json__(struct ovsdb_datum
*datum
,
1214 const struct ovsdb_type
*type
,
1215 const struct json
*json
,
1216 struct ovsdb_symbol_table
*symtab
)
1218 struct ovsdb_error
*error
;
1220 if (ovsdb_type_is_map(type
)
1221 || (json
->type
== JSON_ARRAY
1222 && json
->u
.array
.n
> 0
1223 && json
->u
.array
.elems
[0]->type
== JSON_STRING
1224 && !strcmp(json
->u
.array
.elems
[0]->u
.string
, "set"))) {
1225 bool is_map
= ovsdb_type_is_map(type
);
1226 const char *class = is_map
? "map" : "set";
1227 const struct json
*inner
;
1231 error
= unwrap_json(json
, class, JSON_ARRAY
, &inner
);
1236 n
= inner
->u
.array
.n
;
1237 if (n
< type
->n_min
|| n
> type
->n_max
) {
1238 return ovsdb_syntax_error(json
, NULL
, "%s must have %u to "
1239 "%u members but %"PRIuSIZE
" are present",
1240 class, type
->n_min
, type
->n_max
, n
);
1244 datum
->keys
= xmalloc(n
* sizeof *datum
->keys
);
1245 datum
->values
= is_map
? xmalloc(n
* sizeof *datum
->values
) : NULL
;
1246 for (i
= 0; i
< n
; i
++) {
1247 const struct json
*element
= inner
->u
.array
.elems
[i
];
1248 const struct json
*key
= NULL
;
1249 const struct json
*value
= NULL
;
1254 error
= parse_json_pair(element
, &key
, &value
);
1260 error
= ovsdb_atom_from_json(&datum
->keys
[i
], &type
->key
,
1267 error
= ovsdb_atom_from_json(&datum
->values
[i
],
1268 &type
->value
, value
, symtab
);
1270 ovsdb_atom_destroy(&datum
->keys
[i
], type
->key
.type
);
1280 ovsdb_datum_destroy(datum
, type
);
1284 datum
->keys
= xmalloc(sizeof *datum
->keys
);
1285 datum
->values
= NULL
;
1287 error
= ovsdb_atom_from_json(&datum
->keys
[0], &type
->key
,
1296 /* Parses 'json' as a datum of the type described by 'type'. If successful,
1297 * returns NULL and initializes 'datum' with the parsed datum. On failure,
1298 * returns an error and the contents of 'datum' are indeterminate. The caller
1299 * is responsible for freeing the error or the datum that is returned.
1301 * Violations of constraints expressed by 'type' are treated as errors.
1303 * If 'symtab' is nonnull, then named UUIDs in 'symtab' are accepted. Refer to
1304 * RFC 7047 for information about this, and for the syntax that this function
1306 struct ovsdb_error
*
1307 ovsdb_datum_from_json(struct ovsdb_datum
*datum
,
1308 const struct ovsdb_type
*type
,
1309 const struct json
*json
,
1310 struct ovsdb_symbol_table
*symtab
)
1312 struct ovsdb_error
*error
;
1314 error
= ovsdb_datum_from_json__(datum
, type
, json
, symtab
);
1319 error
= ovsdb_datum_sort(datum
, type
->key
.type
);
1321 ovsdb_datum_destroy(datum
, type
);
1326 /* Parses 'json' as a datum of the type described by 'type' for internal
1327 * use. This function is similar to 'ovsdb_datum_from_json', except the
1328 * member size of set or map is not checked.
1330 * The datum generated should be used then discard. It is not suitable
1331 * for storing into IDL because of the possible member size violation. */
1332 struct ovsdb_error
*
1333 ovsdb_transient_datum_from_json(struct ovsdb_datum
*datum
,
1334 const struct ovsdb_type
*type
,
1335 const struct json
*json
)
1337 struct ovsdb_type relaxed_type
= *type
;
1339 relaxed_type
.n_min
= 0;
1340 relaxed_type
.n_max
= UINT_MAX
;
1342 return ovsdb_datum_from_json(datum
, &relaxed_type
, json
, NULL
);
1345 /* Converts 'datum', of the specified 'type', to JSON format, and returns the
1346 * JSON. The caller is responsible for freeing the returned JSON.
1348 * 'type' constraints on datum->n are ignored.
1350 * Refer to RFC 7047 for the format of the JSON that this function produces. */
1352 ovsdb_datum_to_json(const struct ovsdb_datum
*datum
,
1353 const struct ovsdb_type
*type
)
1355 if (ovsdb_type_is_map(type
)) {
1356 struct json
**elems
;
1359 elems
= xmalloc(datum
->n
* sizeof *elems
);
1360 for (i
= 0; i
< datum
->n
; i
++) {
1361 elems
[i
] = json_array_create_2(
1362 ovsdb_atom_to_json(&datum
->keys
[i
], type
->key
.type
),
1363 ovsdb_atom_to_json(&datum
->values
[i
], type
->value
.type
));
1366 return wrap_json("map", json_array_create(elems
, datum
->n
));
1367 } else if (datum
->n
== 1) {
1368 return ovsdb_atom_to_json(&datum
->keys
[0], type
->key
.type
);
1370 struct json
**elems
;
1373 elems
= xmalloc(datum
->n
* sizeof *elems
);
1374 for (i
= 0; i
< datum
->n
; i
++) {
1375 elems
[i
] = ovsdb_atom_to_json(&datum
->keys
[i
], type
->key
.type
);
1378 return wrap_json("set", json_array_create(elems
, datum
->n
));
1383 skip_spaces(const char *p
)
1385 while (isspace((unsigned char) *p
)) {
1392 parse_atom_token(const char **s
, const struct ovsdb_base_type
*base
,
1393 union ovsdb_atom
*atom
, union ovsdb_atom
**range_end_atom
,
1394 struct ovsdb_symbol_table
*symtab
)
1396 char *token
, *error
;
1398 error
= ovsdb_token_parse(s
, &token
);
1400 error
= ovsdb_atom_from_string(atom
, range_end_atom
,
1401 base
, token
, symtab
);
1408 parse_key_value(const char **s
, const struct ovsdb_type
*type
,
1409 union ovsdb_atom
*key
, union ovsdb_atom
*value
,
1410 struct ovsdb_symbol_table
*symtab
,
1411 union ovsdb_atom
**range_end_key
)
1413 const char *start
= *s
;
1416 error
= parse_atom_token(s
, &type
->key
, key
, range_end_key
, symtab
);
1418 if (!error
&& type
->value
.type
!= OVSDB_TYPE_VOID
) {
1419 *s
= skip_spaces(*s
);
1422 *s
= skip_spaces(*s
);
1423 error
= parse_atom_token(s
, &type
->value
, value
, NULL
, symtab
);
1425 error
= xasprintf("%s: syntax error at \"%c\" expecting \"=\"",
1429 ovsdb_atom_destroy(key
, type
->key
.type
);
1430 if (range_end_key
&& *range_end_key
) {
1431 ovsdb_atom_destroy(*range_end_key
, type
->key
.type
);
1432 free(*range_end_key
);
1433 *range_end_key
= NULL
;
1441 free_key_value_range(const struct ovsdb_type
*type
,
1442 union ovsdb_atom
*key
, union ovsdb_atom
*value
,
1443 union ovsdb_atom
**range_end_atom
)
1445 ovsdb_atom_destroy(key
, type
->key
.type
);
1446 if (type
->value
.type
!= OVSDB_TYPE_VOID
) {
1447 ovsdb_atom_destroy(value
, type
->value
.type
);
1449 if (range_end_atom
&& *range_end_atom
) {
1450 ovsdb_atom_destroy(*range_end_atom
, type
->key
.type
);
1451 free(*range_end_atom
);
1452 *range_end_atom
= NULL
;
1456 /* Initializes 'datum' as a datum of the given 'type', parsing its contents
1457 * from 's'. The format of 's' is a series of space or comma separated atoms
1458 * or, for a map, '='-delimited pairs of atoms. Each atom must in a format
1459 * acceptable to ovsdb_atom_from_string(). Optionally, a set may be enclosed
1460 * in "[]" or a map in "{}"; for an empty set or map these punctuators are
1463 * Optionally, a symbol table may be supplied as 'symtab'. It is passed to
1464 * ovsdb_atom_to_string(). */
1466 ovsdb_datum_from_string(struct ovsdb_datum
*datum
,
1467 const struct ovsdb_type
*type
, const char *s
,
1468 struct ovsdb_symbol_table
*symtab
)
1470 bool is_map
= ovsdb_type_is_map(type
);
1471 struct ovsdb_error
*dberror
;
1476 ovsdb_datum_init_empty(datum
);
1478 /* Swallow a leading delimiter if there is one. */
1480 if (*p
== (is_map
? '{' : '[')) {
1481 end_delim
= is_map
? '}' : ']';
1482 p
= skip_spaces(p
+ 1);
1485 return xstrdup("use \"{}\" to specify the empty map");
1487 return xstrdup("use \"[]\" to specify the empty set");
1493 while (*p
&& *p
!= end_delim
) {
1494 union ovsdb_atom key
, value
;
1495 union ovsdb_atom
*range_end_key
= NULL
;
1497 if (ovsdb_token_is_delim(*p
)) {
1498 char *type_str
= ovsdb_type_to_english(type
);
1499 error
= xasprintf("%s: unexpected \"%c\" parsing %s",
1506 error
= parse_key_value(&p
, type
, &key
, &value
,
1507 symtab
, &range_end_key
);
1511 ovsdb_datum_add_unsafe(datum
, &key
, &value
, type
, range_end_key
);
1512 free_key_value_range(type
, &key
, &value
, &range_end_key
);
1514 /* Skip optional white space and comma. */
1517 p
= skip_spaces(p
+ 1);
1521 if (*p
!= end_delim
) {
1522 error
= xasprintf("%s: missing \"%c\" at end of data", s
, end_delim
);
1526 p
= skip_spaces(p
+ 1);
1528 error
= xasprintf("%s: trailing garbage after \"%c\"",
1534 if (datum
->n
< type
->n_min
) {
1535 error
= xasprintf("%s: %u %s specified but the minimum number is %u",
1536 s
, datum
->n
, is_map
? "pair(s)" : "value(s)",
1539 } else if (datum
->n
> type
->n_max
) {
1540 error
= xasprintf("%s: %u %s specified but the maximum number is %u",
1541 s
, datum
->n
, is_map
? "pair(s)" : "value(s)",
1546 dberror
= ovsdb_datum_sort(datum
, type
->key
.type
);
1548 ovsdb_error_destroy(dberror
);
1549 if (ovsdb_type_is_map(type
)) {
1550 error
= xasprintf("%s: map contains duplicate key", s
);
1552 error
= xasprintf("%s: set contains duplicate value", s
);
1560 ovsdb_datum_destroy(datum
, type
);
1561 ovsdb_datum_init_empty(datum
);
1565 /* Appends to 'out' the 'datum' (with the given 'type') in a format acceptable
1566 * to ovsdb_datum_from_string(). */
1568 ovsdb_datum_to_string(const struct ovsdb_datum
*datum
,
1569 const struct ovsdb_type
*type
, struct ds
*out
)
1571 bool is_map
= ovsdb_type_is_map(type
);
1574 if (type
->n_max
> 1 || !datum
->n
) {
1575 ds_put_char(out
, is_map
? '{' : '[');
1577 for (i
= 0; i
< datum
->n
; i
++) {
1579 ds_put_cstr(out
, ", ");
1582 ovsdb_atom_to_string(&datum
->keys
[i
], type
->key
.type
, out
);
1584 ds_put_char(out
, '=');
1585 ovsdb_atom_to_string(&datum
->values
[i
], type
->value
.type
, out
);
1588 if (type
->n_max
> 1 || !datum
->n
) {
1589 ds_put_char(out
, is_map
? '}' : ']');
1593 /* Appends to 'out' the 'datum' (with the given 'type') in a bare string format
1594 * that cannot be parsed uniformly back into a datum but is easier for shell
1595 * scripts, etc., to deal with. */
1597 ovsdb_datum_to_bare(const struct ovsdb_datum
*datum
,
1598 const struct ovsdb_type
*type
, struct ds
*out
)
1600 bool is_map
= ovsdb_type_is_map(type
);
1603 for (i
= 0; i
< datum
->n
; i
++) {
1605 ds_put_cstr(out
, " ");
1608 ovsdb_atom_to_bare(&datum
->keys
[i
], type
->key
.type
, out
);
1610 ds_put_char(out
, '=');
1611 ovsdb_atom_to_bare(&datum
->values
[i
], type
->value
.type
, out
);
1616 /* Initializes 'datum' as a string-to-string map whose contents are copied from
1617 * 'smap', which is not modified. */
1619 ovsdb_datum_from_smap(struct ovsdb_datum
*datum
, const struct smap
*smap
)
1621 datum
->n
= smap_count(smap
);
1622 datum
->keys
= xmalloc(datum
->n
* sizeof *datum
->keys
);
1623 datum
->values
= xmalloc(datum
->n
* sizeof *datum
->values
);
1625 struct smap_node
*node
;
1627 SMAP_FOR_EACH (node
, smap
) {
1628 datum
->keys
[i
].string
= xstrdup(node
->key
);
1629 datum
->values
[i
].string
= xstrdup(node
->value
);
1632 ovs_assert(i
== datum
->n
);
1634 ovsdb_datum_sort_unique(datum
, OVSDB_TYPE_STRING
, OVSDB_TYPE_STRING
);
1638 hash_atoms(enum ovsdb_atomic_type type
, const union ovsdb_atom
*atoms
,
1639 unsigned int n
, uint32_t basis
)
1641 if (type
!= OVSDB_TYPE_VOID
) {
1644 for (i
= 0; i
< n
; i
++) {
1645 basis
= ovsdb_atom_hash(&atoms
[i
], type
, basis
);
1652 ovsdb_datum_hash(const struct ovsdb_datum
*datum
,
1653 const struct ovsdb_type
*type
, uint32_t basis
)
1655 basis
= hash_atoms(type
->key
.type
, datum
->keys
, datum
->n
, basis
);
1656 basis
^= (type
->key
.type
<< 24) | (type
->value
.type
<< 16) | datum
->n
;
1657 basis
= hash_atoms(type
->value
.type
, datum
->values
, datum
->n
, basis
);
1662 atom_arrays_compare_3way(const union ovsdb_atom
*a
,
1663 const union ovsdb_atom
*b
,
1664 enum ovsdb_atomic_type type
,
1669 for (i
= 0; i
< n
; i
++) {
1670 int cmp
= ovsdb_atom_compare_3way(&a
[i
], &b
[i
], type
);
1680 ovsdb_datum_equals(const struct ovsdb_datum
*a
,
1681 const struct ovsdb_datum
*b
,
1682 const struct ovsdb_type
*type
)
1684 return !ovsdb_datum_compare_3way(a
, b
, type
);
1688 ovsdb_datum_compare_3way(const struct ovsdb_datum
*a
,
1689 const struct ovsdb_datum
*b
,
1690 const struct ovsdb_type
*type
)
1695 return a
->n
< b
->n
? -1 : 1;
1698 cmp
= atom_arrays_compare_3way(a
->keys
, b
->keys
, type
->key
.type
, a
->n
);
1703 return (type
->value
.type
== OVSDB_TYPE_VOID
? 0
1704 : atom_arrays_compare_3way(a
->values
, b
->values
, type
->value
.type
,
1708 /* If 'key' is one of the keys in 'datum', returns its index within 'datum',
1709 * otherwise UINT_MAX. 'key.type' must be the type of the atoms stored in the
1710 * 'keys' array in 'datum'.
1713 ovsdb_datum_find_key(const struct ovsdb_datum
*datum
,
1714 const union ovsdb_atom
*key
,
1715 enum ovsdb_atomic_type key_type
)
1717 unsigned int low
= 0;
1718 unsigned int high
= datum
->n
;
1719 while (low
< high
) {
1720 unsigned int idx
= (low
+ high
) / 2;
1721 int cmp
= ovsdb_atom_compare_3way(key
, &datum
->keys
[idx
], key_type
);
1724 } else if (cmp
> 0) {
1733 /* If 'key' and 'value' is one of the key-value pairs in 'datum', returns its
1734 * index within 'datum', otherwise UINT_MAX. 'key.type' must be the type of
1735 * the atoms stored in the 'keys' array in 'datum'. 'value_type' may be the
1736 * type of the 'values' atoms or OVSDB_TYPE_VOID to compare only keys.
1739 ovsdb_datum_find_key_value(const struct ovsdb_datum
*datum
,
1740 const union ovsdb_atom
*key
,
1741 enum ovsdb_atomic_type key_type
,
1742 const union ovsdb_atom
*value
,
1743 enum ovsdb_atomic_type value_type
)
1745 unsigned int idx
= ovsdb_datum_find_key(datum
, key
, key_type
);
1747 && value_type
!= OVSDB_TYPE_VOID
1748 && !ovsdb_atom_equals(&datum
->values
[idx
], value
, value_type
)) {
1754 /* If atom 'i' in 'a' is also in 'b', returns its index in 'b', otherwise
1755 * UINT_MAX. 'type' must be the type of 'a' and 'b', except that
1756 * type->value.type may be set to OVSDB_TYPE_VOID to compare keys but not
1759 ovsdb_datum_find(const struct ovsdb_datum
*a
, int i
,
1760 const struct ovsdb_datum
*b
,
1761 const struct ovsdb_type
*type
)
1763 return ovsdb_datum_find_key_value(b
,
1764 &a
->keys
[i
], type
->key
.type
,
1765 a
->values
? &a
->values
[i
] : NULL
,
1769 /* Returns true if every element in 'a' is also in 'b', false otherwise. */
1771 ovsdb_datum_includes_all(const struct ovsdb_datum
*a
,
1772 const struct ovsdb_datum
*b
,
1773 const struct ovsdb_type
*type
)
1780 for (i
= 0; i
< a
->n
; i
++) {
1781 if (ovsdb_datum_find(a
, i
, b
, type
) == UINT_MAX
) {
1788 /* Returns true if no element in 'a' is also in 'b', false otherwise. */
1790 ovsdb_datum_excludes_all(const struct ovsdb_datum
*a
,
1791 const struct ovsdb_datum
*b
,
1792 const struct ovsdb_type
*type
)
1796 for (i
= 0; i
< a
->n
; i
++) {
1797 if (ovsdb_datum_find(a
, i
, b
, type
) != UINT_MAX
) {
1805 ovsdb_datum_reallocate(struct ovsdb_datum
*a
, const struct ovsdb_type
*type
,
1806 unsigned int capacity
)
1808 a
->keys
= xrealloc(a
->keys
, capacity
* sizeof *a
->keys
);
1809 if (type
->value
.type
!= OVSDB_TYPE_VOID
) {
1810 a
->values
= xrealloc(a
->values
, capacity
* sizeof *a
->values
);
1814 /* Removes the element with index 'idx' from 'datum', which has type 'type'.
1815 * If 'idx' is not the last element in 'datum', then the removed element is
1816 * replaced by the (former) last element.
1818 * This function does not maintain ovsdb_datum invariants. Use
1819 * ovsdb_datum_sort() to check and restore these invariants. */
1821 ovsdb_datum_remove_unsafe(struct ovsdb_datum
*datum
, size_t idx
,
1822 const struct ovsdb_type
*type
)
1824 ovsdb_atom_destroy(&datum
->keys
[idx
], type
->key
.type
);
1825 datum
->keys
[idx
] = datum
->keys
[datum
->n
- 1];
1826 if (type
->value
.type
!= OVSDB_TYPE_VOID
) {
1827 ovsdb_atom_destroy(&datum
->values
[idx
], type
->value
.type
);
1828 datum
->values
[idx
] = datum
->values
[datum
->n
- 1];
1833 /* Adds the element with the given 'key' and 'value' to 'datum', which must
1834 * have the specified 'type'. Optionally if 'range_end_atom' is not
1835 * a null pointer, adds a set of integers to 'datum' from inclusive
1836 * range ['key', 'range_end_atom'].
1838 * This function always allocates memory, so it is not an efficient way to add
1839 * a number of elements to a datum.
1841 * When adding a range of integers, this function allocates the memory once
1842 * for the whole range.
1844 * This function does not maintain ovsdb_datum invariants. Use
1845 * ovsdb_datum_sort() to check and restore these invariants. (But a datum with
1846 * 0 or 1 elements cannot violate the invariants anyhow.) */
1848 ovsdb_datum_add_unsafe(struct ovsdb_datum
*datum
,
1849 const union ovsdb_atom
*key
,
1850 const union ovsdb_atom
*value
,
1851 const struct ovsdb_type
*type
,
1852 const union ovsdb_atom
*range_end_atom
)
1854 size_t idx
= datum
->n
;
1855 datum
->n
+= range_end_atom
?
1856 (range_end_atom
->integer
- key
->integer
+ 1) : 1;
1857 datum
->keys
= xrealloc(datum
->keys
, datum
->n
* sizeof *datum
->keys
);
1858 if (range_end_atom
&& key
->integer
<= range_end_atom
->integer
) {
1859 for (int64_t i
= key
->integer
; i
<= range_end_atom
->integer
; i
++) {
1860 datum
->keys
[idx
++].integer
= i
;
1863 ovsdb_atom_clone(&datum
->keys
[idx
], key
, type
->key
.type
);
1864 if (type
->value
.type
!= OVSDB_TYPE_VOID
) {
1865 datum
->values
= xrealloc(datum
->values
,
1866 datum
->n
* sizeof *datum
->values
);
1867 ovsdb_atom_clone(&datum
->values
[idx
], value
, type
->value
.type
);
1873 ovsdb_datum_union(struct ovsdb_datum
*a
, const struct ovsdb_datum
*b
,
1874 const struct ovsdb_type
*type
, bool replace
)
1880 for (bi
= 0; bi
< b
->n
; bi
++) {
1883 ai
= ovsdb_datum_find_key(a
, &b
->keys
[bi
], type
->key
.type
);
1884 if (ai
== UINT_MAX
) {
1886 ovsdb_datum_reallocate(a
, type
, a
->n
+ (b
->n
- bi
));
1888 ovsdb_atom_clone(&a
->keys
[n
], &b
->keys
[bi
], type
->key
.type
);
1889 if (type
->value
.type
!= OVSDB_TYPE_VOID
) {
1890 ovsdb_atom_clone(&a
->values
[n
], &b
->values
[bi
],
1894 } else if (replace
&& type
->value
.type
!= OVSDB_TYPE_VOID
) {
1895 ovsdb_atom_destroy(&a
->values
[ai
], type
->value
.type
);
1896 ovsdb_atom_clone(&a
->values
[ai
], &b
->values
[bi
],
1901 struct ovsdb_error
*error
;
1903 error
= ovsdb_datum_sort(a
, type
->key
.type
);
1909 ovsdb_datum_subtract(struct ovsdb_datum
*a
, const struct ovsdb_type
*a_type
,
1910 const struct ovsdb_datum
*b
,
1911 const struct ovsdb_type
*b_type
)
1913 bool changed
= false;
1916 ovs_assert(a_type
->key
.type
== b_type
->key
.type
);
1917 ovs_assert(a_type
->value
.type
== b_type
->value
.type
1918 || b_type
->value
.type
== OVSDB_TYPE_VOID
);
1920 /* XXX The big-O of this could easily be improved. */
1921 for (i
= 0; i
< a
->n
; ) {
1922 unsigned int idx
= ovsdb_datum_find(a
, i
, b
, b_type
);
1923 if (idx
!= UINT_MAX
) {
1925 ovsdb_datum_remove_unsafe(a
, i
, a_type
);
1931 ovsdb_datum_sort_assert(a
, a_type
->key
.type
);
1935 struct ovsdb_symbol_table
*
1936 ovsdb_symbol_table_create(void)
1938 struct ovsdb_symbol_table
*symtab
= xmalloc(sizeof *symtab
);
1939 shash_init(&symtab
->sh
);
1944 ovsdb_symbol_table_destroy(struct ovsdb_symbol_table
*symtab
)
1947 shash_destroy_free_data(&symtab
->sh
);
1952 struct ovsdb_symbol
*
1953 ovsdb_symbol_table_get(const struct ovsdb_symbol_table
*symtab
,
1956 return shash_find_data(&symtab
->sh
, name
);
1959 struct ovsdb_symbol
*
1960 ovsdb_symbol_table_put(struct ovsdb_symbol_table
*symtab
, const char *name
,
1961 const struct uuid
*uuid
, bool created
)
1963 struct ovsdb_symbol
*symbol
;
1965 ovs_assert(!ovsdb_symbol_table_get(symtab
, name
));
1966 symbol
= xmalloc(sizeof *symbol
);
1967 symbol
->uuid
= *uuid
;
1968 symbol
->created
= created
;
1969 symbol
->strong_ref
= false;
1970 symbol
->weak_ref
= false;
1971 shash_add(&symtab
->sh
, name
, symbol
);
1975 struct ovsdb_symbol
*
1976 ovsdb_symbol_table_insert(struct ovsdb_symbol_table
*symtab
,
1979 struct ovsdb_symbol
*symbol
;
1981 symbol
= ovsdb_symbol_table_get(symtab
, name
);
1985 uuid_generate(&uuid
);
1986 symbol
= ovsdb_symbol_table_put(symtab
, name
, &uuid
, false);
1991 /* APIs for Generating and apply diffs. */
1993 /* Generate a difference ovsdb_dataum between 'old' and 'new'.
1994 * 'new' can be regenerated by applying the difference to the 'old'.
1996 * The diff operation is reversible. Given 'old',
1997 * 'new' can be recreated by applying diff to 'old'.
2000 * Let d = 'old' diff 'new'
2001 * then 'new' = 'old' diff d
2003 * The 'diff' datum is always safe; the orders of keys are maintained
2004 * since they are added in order. */
2006 ovsdb_datum_diff(struct ovsdb_datum
*diff
,
2007 const struct ovsdb_datum
*old
,
2008 const struct ovsdb_datum
*new,
2009 const struct ovsdb_type
*type
)
2013 ovsdb_datum_init_empty(diff
);
2014 if (!ovsdb_type_is_composite(type
)) {
2015 ovsdb_datum_clone(diff
, new, type
);
2019 /* Generate the diff in O(n) time. */
2020 for (oi
= ni
= 0; oi
< old
->n
&& ni
< new->n
; ) {
2021 int c
= ovsdb_atom_compare_3way(&old
->keys
[oi
], &new->keys
[ni
],
2024 ovsdb_datum_add_unsafe(diff
, &old
->keys
[oi
], &old
->values
[oi
],
2028 ovsdb_datum_add_unsafe(diff
, &new->keys
[ni
], &new->values
[ni
],
2032 if (type
->value
.type
!= OVSDB_TYPE_VOID
&&
2033 ovsdb_atom_compare_3way(&old
->values
[oi
], &new->values
[ni
],
2034 type
->value
.type
)) {
2035 ovsdb_datum_add_unsafe(diff
, &new->keys
[ni
], &new->values
[ni
],
2042 for (; oi
< old
->n
; oi
++) {
2043 ovsdb_datum_add_unsafe(diff
, &old
->keys
[oi
], &old
->values
[oi
],
2047 for (; ni
< new->n
; ni
++) {
2048 ovsdb_datum_add_unsafe(diff
, &new->keys
[ni
], &new->values
[ni
],
2053 /* Apply 'diff' to 'old' to regenerate 'new'.
2055 * Return NULL if the 'new' is successfully generated, otherwise, return
2056 * ovsdb_error and the stat of 'new' is indeterministic. */
2057 struct ovsdb_error
*
2058 ovsdb_datum_apply_diff(struct ovsdb_datum
*new,
2059 const struct ovsdb_datum
*old
,
2060 const struct ovsdb_datum
*diff
,
2061 const struct ovsdb_type
*type
)
2063 ovsdb_datum_init_empty(new);
2064 ovsdb_datum_diff(new, old
, diff
, type
);
2066 /* Make sure member size of 'new' conforms to type. */
2067 if (new->n
< type
->n_min
|| new->n
> type
->n_max
) {
2068 ovsdb_datum_destroy(new, type
);
2069 return ovsdb_error(NULL
, "Datum crated by diff has size error");
2076 /* Extracts a token from the beginning of 's' and returns a pointer just after
2077 * the token. Stores the token itself into '*outp', which the caller is
2078 * responsible for freeing (with free()).
2080 * If 's[0]' is a delimiter, the returned token is the empty string.
2082 * A token extends from 's' to the first delimiter, as defined by
2083 * ovsdb_token_is_delim(), or until the end of the string. A delimiter can be
2084 * escaped with a backslash, in which case the backslash does not appear in the
2085 * output. Double quotes also cause delimiters to be ignored, but the double
2086 * quotes are retained in the output. (Backslashes inside double quotes are
2087 * not removed, either.)
2090 ovsdb_token_parse(const char **s
, char **outp
)
2099 for (p
= *s
; *p
!= '\0'; ) {
2103 ds_put_char(&out
, '\\');
2106 error
= xasprintf("%s: backslash at end of argument", *s
);
2109 ds_put_char(&out
, *p
++);
2110 } else if (!in_quotes
&& ovsdb_token_is_delim(c
)) {
2114 ds_put_char(&out
, c
);
2116 in_quotes
= !in_quotes
;
2121 error
= xasprintf("%s: quoted string extends past end of argument",
2125 *outp
= ds_cstr(&out
);
2135 /* Returns true if 'c' delimits tokens, or if 'c' is 0, and false otherwise. */
2137 ovsdb_token_is_delim(unsigned char c
)
2139 return strchr(":=, []{}!<>", c
) != NULL
;
2142 struct ovsdb_error
*
2143 ovsdb_atom_range_check_size(int64_t range_start
, int64_t range_end
)
2145 if ((uint64_t) range_end
- (uint64_t) range_start
2146 >= MAX_OVSDB_ATOM_RANGE_SIZE
) {
2147 return ovsdb_error("constraint violation",
2148 "Range \"%"PRId64
"-%"PRId64
"\" is too big. "
2149 "Maximum allowed size is %d.",
2150 range_start
, range_end
, MAX_OVSDB_ATOM_RANGE_SIZE
);