ovsdb: Implement new "declare" operation.
[openvswitch] / lib / ovsdb-data.c
1 /* Copyright (c) 2009 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-data.h"
19
20 #include <assert.h>
21
22 #include "hash.h"
23 #include "ovsdb-error.h"
24 #include "json.h"
25 #include "shash.h"
26 #include "sort.h"
27
28 static struct json *
29 wrap_json(const char *name, struct json *wrapped)
30 {
31     return json_array_create_2(json_string_create(name), wrapped);
32 }
33
34 void
35 ovsdb_atom_init_default(union ovsdb_atom *atom, enum ovsdb_atomic_type type)
36 {
37     switch (type) {
38     case OVSDB_TYPE_VOID:
39         NOT_REACHED();
40
41     case OVSDB_TYPE_INTEGER:
42         atom->integer = 0;
43         break;
44
45     case OVSDB_TYPE_REAL:
46         atom->real = 0.0;
47         break;
48
49     case OVSDB_TYPE_BOOLEAN:
50         atom->boolean = false;
51         break;
52
53     case OVSDB_TYPE_STRING:
54         atom->string = xmemdup("", 1);
55         break;
56
57     case OVSDB_TYPE_UUID:
58         uuid_zero(&atom->uuid);
59         break;
60
61     case OVSDB_N_TYPES:
62     default:
63         NOT_REACHED();
64     }
65 }
66
67 void
68 ovsdb_atom_clone(union ovsdb_atom *new, const union ovsdb_atom *old,
69                  enum ovsdb_atomic_type type)
70 {
71     switch (type) {
72     case OVSDB_TYPE_VOID:
73         NOT_REACHED();
74
75     case OVSDB_TYPE_INTEGER:
76         new->integer = old->integer;
77         break;
78
79     case OVSDB_TYPE_REAL:
80         new->real = old->real;
81         break;
82
83     case OVSDB_TYPE_BOOLEAN:
84         new->boolean = old->boolean;
85         break;
86
87     case OVSDB_TYPE_STRING:
88         new->string = xstrdup(old->string);
89         break;
90
91     case OVSDB_TYPE_UUID:
92         new->uuid = old->uuid;
93         break;
94
95     case OVSDB_N_TYPES:
96     default:
97         NOT_REACHED();
98     }
99 }
100
101 void
102 ovsdb_atom_swap(union ovsdb_atom *a, union ovsdb_atom *b)
103 {
104     union ovsdb_atom tmp = *a;
105     *a = *b;
106     *b = tmp;
107 }
108
109 uint32_t
110 ovsdb_atom_hash(const union ovsdb_atom *atom, enum ovsdb_atomic_type type,
111                 uint32_t basis)
112 {
113     switch (type) {
114     case OVSDB_TYPE_VOID:
115         NOT_REACHED();
116
117     case OVSDB_TYPE_INTEGER:
118         return hash_int(atom->integer, basis);
119
120     case OVSDB_TYPE_REAL:
121         return hash_double(atom->real, basis);
122
123     case OVSDB_TYPE_BOOLEAN:
124         return hash_boolean(atom->boolean, basis);
125
126     case OVSDB_TYPE_STRING:
127         return hash_string(atom->string, basis);
128
129     case OVSDB_TYPE_UUID:
130         return hash_int(uuid_hash(&atom->uuid), basis);
131
132     case OVSDB_N_TYPES:
133     default:
134         NOT_REACHED();
135     }
136 }
137
138 int
139 ovsdb_atom_compare_3way(const union ovsdb_atom *a,
140                         const union ovsdb_atom *b,
141                         enum ovsdb_atomic_type type)
142 {
143     switch (type) {
144     case OVSDB_TYPE_VOID:
145         NOT_REACHED();
146
147     case OVSDB_TYPE_INTEGER:
148         return a->integer < b->integer ? -1 : a->integer > b->integer;
149
150     case OVSDB_TYPE_REAL:
151         return a->real < b->real ? -1 : a->real > b->real;
152
153     case OVSDB_TYPE_BOOLEAN:
154         return a->boolean - b->boolean;
155
156     case OVSDB_TYPE_STRING:
157         return strcmp(a->string, b->string);
158
159     case OVSDB_TYPE_UUID:
160         return uuid_compare_3way(&a->uuid, &b->uuid);
161
162     case OVSDB_N_TYPES:
163     default:
164         NOT_REACHED();
165     }
166 }
167
168 static struct ovsdb_error *
169 unwrap_json(const struct json *json, const char *name,
170             enum json_type value_type, const struct json **value)
171 {
172     if (json->type != JSON_ARRAY
173         || json->u.array.n != 2
174         || json->u.array.elems[0]->type != JSON_STRING
175         || (name && strcmp(json->u.array.elems[0]->u.string, name))
176         || json->u.array.elems[1]->type != value_type)
177     {
178         return ovsdb_syntax_error(json, NULL, "expected [\"%s\", <%s>]", name,
179                                   json_type_to_string(value_type));
180     }
181     *value = json->u.array.elems[1];
182     return NULL;
183 }
184
185 static struct ovsdb_error *
186 parse_json_pair(const struct json *json,
187                 const struct json **elem0, const struct json **elem1)
188 {
189     if (json->type != JSON_ARRAY || json->u.array.n != 2) {
190         return ovsdb_syntax_error(json, NULL, "expected 2-element array");
191     }
192     *elem0 = json->u.array.elems[0];
193     *elem1 = json->u.array.elems[1];
194     return NULL;
195 }
196
197 static struct ovsdb_error *
198 ovsdb_atom_parse_uuid(struct uuid *uuid, const struct json *json,
199                       const struct ovsdb_symbol_table *symtab)
200     WARN_UNUSED_RESULT;
201
202 static struct ovsdb_error *
203 ovsdb_atom_parse_uuid(struct uuid *uuid, const struct json *json,
204                       const struct ovsdb_symbol_table *symtab)
205 {
206     struct ovsdb_error *error0;
207     const struct json *value;
208
209     error0 = unwrap_json(json, "uuid", JSON_STRING, &value);
210     if (!error0) {
211         const char *uuid_string = json_string(value);
212         if (!uuid_from_string(uuid, uuid_string)) {
213             return ovsdb_syntax_error(json, NULL, "\"%s\" is not a valid UUID",
214                                       uuid_string);
215         }
216     } else if (symtab) {
217         struct ovsdb_error *error1;
218
219         error1 = unwrap_json(json, "named-uuid", JSON_STRING, &value);
220         if (!error1) {
221             const char *name = json_string(value);
222             const struct ovsdb_symbol *symbol;
223
224             ovsdb_error_destroy(error0);
225
226             symbol = ovsdb_symbol_table_get(symtab, name);
227             if (symbol) {
228                 *uuid = symbol->uuid;
229                 return NULL;
230             } else {
231                 return ovsdb_syntax_error(json, NULL,
232                                           "unknown named-uuid \"%s\"", name);
233             }
234         }
235         ovsdb_error_destroy(error1);
236     }
237
238     return error0;
239 }
240
241 struct ovsdb_error *
242 ovsdb_atom_from_json(union ovsdb_atom *atom, enum ovsdb_atomic_type type,
243                      const struct json *json,
244                      const struct ovsdb_symbol_table *symtab)
245 {
246     switch (type) {
247     case OVSDB_TYPE_VOID:
248         NOT_REACHED();
249
250     case OVSDB_TYPE_INTEGER:
251         if (json->type == JSON_INTEGER) {
252             atom->integer = json->u.integer;
253             return NULL;
254         }
255         break;
256
257     case OVSDB_TYPE_REAL:
258         if (json->type == JSON_INTEGER) {
259             atom->real = json->u.integer;
260             return NULL;
261         } else if (json->type == JSON_REAL) {
262             atom->real = json->u.real;
263             return NULL;
264         }
265         break;
266
267     case OVSDB_TYPE_BOOLEAN:
268         if (json->type == JSON_TRUE) {
269             atom->boolean = true;
270             return NULL;
271         } else if (json->type == JSON_FALSE) {
272             atom->boolean = false;
273             return NULL;
274         }
275         break;
276
277     case OVSDB_TYPE_STRING:
278         if (json->type == JSON_STRING) {
279             atom->string = xstrdup(json->u.string);
280             return NULL;
281         }
282         break;
283
284     case OVSDB_TYPE_UUID:
285         return ovsdb_atom_parse_uuid(&atom->uuid, json, symtab);
286
287     case OVSDB_N_TYPES:
288     default:
289         NOT_REACHED();
290     }
291
292     return ovsdb_syntax_error(json, NULL, "expected %s",
293                               ovsdb_atomic_type_to_string(type));
294 }
295
296 struct json *
297 ovsdb_atom_to_json(const union ovsdb_atom *atom, enum ovsdb_atomic_type type)
298 {
299     switch (type) {
300     case OVSDB_TYPE_VOID:
301         NOT_REACHED();
302
303     case OVSDB_TYPE_INTEGER:
304         return json_integer_create(atom->integer);
305
306     case OVSDB_TYPE_REAL:
307         return json_real_create(atom->real);
308
309     case OVSDB_TYPE_BOOLEAN:
310         return json_boolean_create(atom->boolean);
311
312     case OVSDB_TYPE_STRING:
313         return json_string_create(atom->string);
314
315     case OVSDB_TYPE_UUID:
316         return wrap_json("uuid", json_string_create_nocopy(
317                              xasprintf(UUID_FMT, UUID_ARGS(&atom->uuid))));
318
319     case OVSDB_N_TYPES:
320     default:
321         NOT_REACHED();
322     }
323 }
324 \f
325 static union ovsdb_atom *
326 alloc_default_atoms(enum ovsdb_atomic_type type, size_t n)
327 {
328     if (type != OVSDB_TYPE_VOID && n) {
329         union ovsdb_atom *atoms;
330         unsigned int i;
331
332         atoms = xmalloc(n * sizeof *atoms);
333         for (i = 0; i < n; i++) {
334             ovsdb_atom_init_default(&atoms[i], type);
335         }
336         return atoms;
337     } else {
338         /* Avoid wasting memory in the n == 0 case, because xmalloc(0) is
339          * treated as xmalloc(1). */
340         return NULL;
341     }
342 }
343
344 void
345 ovsdb_datum_init_default(struct ovsdb_datum *datum,
346                          const struct ovsdb_type *type)
347 {
348     datum->n = type->n_min;
349     datum->keys = alloc_default_atoms(type->key_type, datum->n);
350     datum->values = alloc_default_atoms(type->value_type, datum->n);
351 }
352
353 static union ovsdb_atom *
354 clone_atoms(const union ovsdb_atom *old, enum ovsdb_atomic_type type, size_t n)
355 {
356     if (type != OVSDB_TYPE_VOID && n) {
357         union ovsdb_atom *new;
358         unsigned int i;
359
360         new = xmalloc(n * sizeof *new);
361         for (i = 0; i < n; i++) {
362             ovsdb_atom_clone(&new[i], &old[i], type);
363         }
364         return new;
365     } else {
366         /* Avoid wasting memory in the n == 0 case, because xmalloc(0) is
367          * treated as xmalloc(1). */
368         return NULL;
369     }
370 }
371
372 void
373 ovsdb_datum_clone(struct ovsdb_datum *new, const struct ovsdb_datum *old,
374                   const struct ovsdb_type *type)
375 {
376     unsigned int n = old->n;
377     new->n = n;
378     new->keys = clone_atoms(old->keys, type->key_type, n);
379     new->values = clone_atoms(old->values, type->value_type, n);
380 }
381
382 static void
383 free_data(enum ovsdb_atomic_type type,
384           union ovsdb_atom *atoms, size_t n_atoms)
385 {
386     if (ovsdb_atom_needs_destruction(type)) {
387         unsigned int i;
388         for (i = 0; i < n_atoms; i++) {
389             ovsdb_atom_destroy(&atoms[i], type);
390         }
391     }
392     free(atoms);
393 }
394
395 void
396 ovsdb_datum_destroy(struct ovsdb_datum *datum, const struct ovsdb_type *type)
397 {
398     free_data(type->key_type, datum->keys, datum->n);
399     free_data(type->value_type, datum->values, datum->n);
400 }
401
402 void
403 ovsdb_datum_swap(struct ovsdb_datum *a, struct ovsdb_datum *b)
404 {
405     struct ovsdb_datum tmp = *a;
406     *a = *b;
407     *b = tmp;
408 }
409
410 struct ovsdb_datum_sort_cbdata {
411     const struct ovsdb_type *type;
412     struct ovsdb_datum *datum;
413 };
414
415 static int
416 ovsdb_datum_sort_compare_cb(size_t a, size_t b, void *cbdata_)
417 {
418     struct ovsdb_datum_sort_cbdata *cbdata = cbdata_;
419
420     return ovsdb_atom_compare_3way(&cbdata->datum->keys[a],
421                                    &cbdata->datum->keys[b],
422                                    cbdata->type->key_type);
423 }
424
425 static void
426 ovsdb_datum_sort_swap_cb(size_t a, size_t b, void *cbdata_)
427 {
428     struct ovsdb_datum_sort_cbdata *cbdata = cbdata_;
429
430     ovsdb_atom_swap(&cbdata->datum->keys[a], &cbdata->datum->keys[b]);
431     if (cbdata->type->value_type != OVSDB_TYPE_VOID) {
432         ovsdb_atom_swap(&cbdata->datum->values[a], &cbdata->datum->values[b]);
433     }
434 }
435
436 static struct ovsdb_error *
437 ovsdb_datum_sort(struct ovsdb_datum *datum, const struct ovsdb_type *type)
438 {
439     if (datum->n < 2) {
440         return NULL;
441     } else {
442         struct ovsdb_datum_sort_cbdata cbdata;
443         size_t i;
444
445         cbdata.type = type;
446         cbdata.datum = datum;
447         sort(datum->n, ovsdb_datum_sort_compare_cb, ovsdb_datum_sort_swap_cb,
448              &cbdata);
449
450         for (i = 0; i < datum->n - 1; i++) {
451             if (ovsdb_atom_equals(&datum->keys[i], &datum->keys[i + 1],
452                                   type->key_type)) {
453                 if (ovsdb_type_is_map(type)) {
454                     return ovsdb_error(NULL, "map contains duplicate key");
455                 } else {
456                     return ovsdb_error(NULL, "set contains duplicate");
457                 }
458             }
459         }
460
461         return NULL;
462     }
463 }
464
465 struct ovsdb_error *
466 ovsdb_datum_from_json(struct ovsdb_datum *datum,
467                       const struct ovsdb_type *type,
468                       const struct json *json,
469                       const struct ovsdb_symbol_table *symtab)
470 {
471     struct ovsdb_error *error;
472
473     if (ovsdb_type_is_scalar(type)) {
474         datum->n = 1;
475         datum->keys = xmalloc(sizeof *datum->keys);
476         datum->values = NULL;
477
478         error = ovsdb_atom_from_json(&datum->keys[0], type->key_type,
479                                      json, symtab);
480         if (error) {
481             free(datum->keys);
482         }
483         return error;
484     } else {
485         bool is_map = ovsdb_type_is_map(type);
486         const char *class = is_map ? "map" : "set";
487         const struct json *inner;
488         unsigned int i;
489         size_t n;
490
491         assert(is_map || ovsdb_type_is_set(type));
492
493         error = unwrap_json(json, class, JSON_ARRAY, &inner);
494         if (error) {
495             return error;
496         }
497
498         n = inner->u.array.n;
499         if (n < type->n_min || n > type->n_max) {
500             return ovsdb_syntax_error(json, NULL, "%s must have %u to "
501                                       "%u members but %zu are present",
502                                       class, type->n_min, type->n_max, n);
503         }
504
505         datum->n = 0;
506         datum->keys = xmalloc(n * sizeof *datum->keys);
507         datum->values = is_map ? xmalloc(n * sizeof *datum->values) : NULL;
508         for (i = 0; i < n; i++) {
509             const struct json *element = inner->u.array.elems[i];
510             const struct json *key = NULL;
511             const struct json *value = NULL;
512
513             if (!is_map) {
514                 key = element;
515             } else {
516                 error = parse_json_pair(element, &key, &value);
517                 if (error) {
518                     goto error;
519                 }
520             }
521
522             error = ovsdb_atom_from_json(&datum->keys[i], type->key_type,
523                                          key, symtab);
524             if (error) {
525                 goto error;
526             }
527
528             if (is_map) {
529                 error = ovsdb_atom_from_json(&datum->values[i],
530                                              type->value_type, value, symtab);
531                 if (error) {
532                     ovsdb_atom_destroy(&datum->keys[i], type->key_type);
533                     goto error;
534                 }
535             }
536
537             datum->n++;
538         }
539
540         error = ovsdb_datum_sort(datum, type);
541         if (error) {
542             goto error;
543         }
544
545         return NULL;
546
547     error:
548         ovsdb_datum_destroy(datum, type);
549         return error;
550     }
551 }
552
553 struct json *
554 ovsdb_datum_to_json(const struct ovsdb_datum *datum,
555                     const struct ovsdb_type *type)
556 {
557     /* These tests somewhat tolerate a 'datum' that does not exactly match
558      * 'type', in particular a datum with 'n' not in the allowed range. */
559     if (datum->n == 1 && ovsdb_type_is_scalar(type)) {
560         return ovsdb_atom_to_json(&datum->keys[0], type->key_type);
561     } else if (type->value_type == OVSDB_TYPE_VOID) {
562         struct json **elems;
563         size_t i;
564
565         elems = xmalloc(datum->n * sizeof *elems);
566         for (i = 0; i < datum->n; i++) {
567             elems[i] = ovsdb_atom_to_json(&datum->keys[i], type->key_type);
568         }
569
570         return wrap_json("set", json_array_create(elems, datum->n));
571     } else {
572         struct json **elems;
573         size_t i;
574
575         elems = xmalloc(datum->n * sizeof *elems);
576         for (i = 0; i < datum->n; i++) {
577             elems[i] = json_array_create_2(
578                 ovsdb_atom_to_json(&datum->keys[i], type->key_type),
579                 ovsdb_atom_to_json(&datum->values[i], type->value_type));
580         }
581
582         return wrap_json("map", json_array_create(elems, datum->n));
583     }
584 }
585
586 static uint32_t
587 hash_atoms(enum ovsdb_atomic_type type, const union ovsdb_atom *atoms,
588            unsigned int n, uint32_t basis)
589 {
590     if (type != OVSDB_TYPE_VOID) {
591         unsigned int i;
592
593         for (i = 0; i < n; i++) {
594             basis = ovsdb_atom_hash(&atoms[i], type, basis);
595         }
596     }
597     return basis;
598 }
599
600 uint32_t
601 ovsdb_datum_hash(const struct ovsdb_datum *datum,
602                  const struct ovsdb_type *type, uint32_t basis)
603 {
604     basis = hash_atoms(type->key_type, datum->keys, datum->n, basis);
605     basis ^= (type->key_type << 24) | (type->value_type << 16) | datum->n;
606     basis = hash_atoms(type->value_type, datum->values, datum->n, basis);
607     return basis;
608 }
609
610 static int
611 atom_arrays_compare_3way(const union ovsdb_atom *a,
612                   const union ovsdb_atom *b,
613                   enum ovsdb_atomic_type type,
614                   size_t n)
615 {
616     unsigned int i;
617
618     for (i = 0; i < n; i++) {
619         int cmp = ovsdb_atom_compare_3way(&a[i], &b[i], type);
620         if (cmp) {
621             return cmp;
622         }
623     }
624
625     return 0;
626 }
627
628 bool
629 ovsdb_datum_equals(const struct ovsdb_datum *a,
630                    const struct ovsdb_datum *b,
631                    const struct ovsdb_type *type)
632 {
633     return !ovsdb_datum_compare_3way(a, b, type);
634 }
635
636 int
637 ovsdb_datum_compare_3way(const struct ovsdb_datum *a,
638                          const struct ovsdb_datum *b,
639                          const struct ovsdb_type *type)
640 {
641     int cmp;
642
643     if (a->n != b->n) {
644         return a->n < b->n ? -1 : 1;
645     }
646
647     cmp = atom_arrays_compare_3way(a->keys, b->keys, type->key_type, a->n);
648     if (cmp) {
649         return cmp;
650     }
651
652     return (type->value_type == OVSDB_TYPE_VOID ? 0
653             : atom_arrays_compare_3way(a->values, b->values, type->value_type,
654                                        a->n));
655 }
656
657 static bool
658 ovsdb_datum_contains(const struct ovsdb_datum *a, int i,
659                      const struct ovsdb_datum *b,
660                      const struct ovsdb_type *type)
661 {
662     int low = 0;
663     int high = b->n;
664     while (low < high) {
665         int j = (low + high) / 2;
666         int cmp = ovsdb_atom_compare_3way(&a->keys[i], &b->keys[j], type->key_type);
667         if (cmp < 0) {
668             high = j;
669         } else if (cmp > 0) {
670             low = j + 1;
671         } else {
672             return (type->value_type == OVSDB_TYPE_VOID
673                     || ovsdb_atom_equals(&a->values[i], &b->values[j],
674                                          type->value_type));
675         }
676     }
677     return false;
678 }
679
680 /* Returns true if every element in 'a' is also in 'b', false otherwise. */
681 bool
682 ovsdb_datum_includes_all(const struct ovsdb_datum *a,
683                          const struct ovsdb_datum *b,
684                          const struct ovsdb_type *type)
685 {
686     size_t i;
687
688     for (i = 0; i < a->n; i++) {
689         if (!ovsdb_datum_contains(a, i, b, type)) {
690             return false;
691         }
692     }
693     return true;
694 }
695
696 /* Returns true if no element in 'a' is also in 'b', false otherwise. */
697 bool
698 ovsdb_datum_excludes_all(const struct ovsdb_datum *a,
699                          const struct ovsdb_datum *b,
700                          const struct ovsdb_type *type)
701 {
702     size_t i;
703
704     for (i = 0; i < a->n; i++) {
705         if (ovsdb_datum_contains(a, i, b, type)) {
706             return false;
707         }
708     }
709     return true;
710 }
711 \f
712 struct ovsdb_symbol_table {
713     struct shash sh;
714 };
715
716 struct ovsdb_symbol_table *
717 ovsdb_symbol_table_create(void)
718 {
719     struct ovsdb_symbol_table *symtab = xmalloc(sizeof *symtab);
720     shash_init(&symtab->sh);
721     return symtab;
722 }
723
724 void
725 ovsdb_symbol_table_destroy(struct ovsdb_symbol_table *symtab)
726 {
727     if (symtab) {
728         struct shash_node *node, *next;
729
730         SHASH_FOR_EACH_SAFE (node, next, &symtab->sh) {
731             struct ovsdb_symbol *symbol = node->data;
732             free(symbol);
733             shash_delete(&symtab->sh, node);
734         }
735         shash_destroy(&symtab->sh);
736         free(symtab);
737     }
738 }
739
740 struct ovsdb_symbol *
741 ovsdb_symbol_table_get(const struct ovsdb_symbol_table *symtab,
742                        const char *name)
743 {
744     return shash_find_data(&symtab->sh, name);
745 }
746
747 void
748 ovsdb_symbol_table_put(struct ovsdb_symbol_table *symtab, const char *name,
749                        const struct uuid *uuid, bool used)
750 {
751     struct ovsdb_symbol *symbol;
752
753     assert(!ovsdb_symbol_table_get(symtab, name));
754     symbol = xmalloc(sizeof *symbol);
755     symbol->uuid = *uuid;
756     symbol->used = used;
757     shash_add(&symtab->sh, name, symbol);
758 }