lib/smap.c

   1 /* Copyright (c) 2012, 2014, 2015, 2016 Nicira, Inc.
   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 #include <config.h>
  16 #include "smap.h"
  17
  18 #include <strings.h>
  19
  20 #include "hash.h"
  21 #include "openvswitch/json.h"
  22 #include "packets.h"
  23 #include "util.h"
  24 #include "uuid.h"
  25
  26 static struct smap_node *smap_add__(struct smap *, char *, void *,
  27                                     size_t hash);
  28 static struct smap_node *smap_find__(const struct smap *, const char *key,
  29                                      size_t key_len, size_t hash);
  30 static int compare_nodes_by_key(const void *, const void *);
  31 \f
  32 /* Public Functions. */
  33
  34 void
  35 smap_init(struct smap *smap)
  36 {
  37     hmap_init(&smap->map);
  38 }
  39
  40 void
  41 smap_destroy(struct smap *smap)
  42 {
  43     if (smap) {
  44         smap_clear(smap);
  45         hmap_destroy(&smap->map);
  46     }
  47 }
  48
  49 /* Adds 'key' paired with 'value' to 'smap'.  It is the caller's responsibility
  50  * to avoid duplicate keys if desirable. */
  51 struct smap_node *
  52 smap_add(struct smap *smap, const char *key, const char *value)
  53 {
  54     size_t key_len = strlen(key);
  55     return smap_add__(smap, xmemdup0(key, key_len), xstrdup(value),
  56                       hash_bytes(key, key_len, 0));
  57 }
  58
  59 /* Adds 'key' paired with 'value' to 'smap'.  Takes ownership of 'key' and
  60  * 'value' (which will eventually be freed with free()).  It is the caller's
  61  * responsibility to avoid duplicate keys if desirable. */
  62 struct smap_node *
  63 smap_add_nocopy(struct smap *smap, char *key, char *value)
  64 {
  65     return smap_add__(smap, key, value, hash_bytes(key, strlen(key), 0));
  66 }
  67
  68 /* Attempts to add 'key' to 'smap' associated with 'value'.  If 'key' already
  69  * exists in 'smap', does nothing and returns false.  Otherwise, performs the
  70  * addition and returns true. */
  71 bool
  72 smap_add_once(struct smap *smap, const char *key, const char *value)
  73 {
  74     if (!smap_get(smap, key)) {
  75         smap_add(smap, key, value);
  76         return true;
  77     } else {
  78         return false;
  79     }
  80 }
  81
  82 /* Adds 'key' paired with a value derived from 'format' (similar to printf).
  83  * It is the caller's responsibility to avoid duplicate keys if desirable. */
  84 void
  85 smap_add_format(struct smap *smap, const char *key, const char *format, ...)
  86 {
  87     size_t key_len;
  88     va_list args;
  89     char *value;
  90
  91     va_start(args, format);
  92     value = xvasprintf(format, args);
  93     va_end(args);
  94
  95     key_len = strlen(key);
  96     smap_add__(smap, xmemdup0(key, key_len), value,
  97                hash_bytes(key, key_len, 0));
  98 }
  99
 100 /* Adds 'key' paired with a string representation of 'addr'. It is the
 101  * caller's responsibility to avoid duplicate keys if desirable. */
 102 void
 103 smap_add_ipv6(struct smap *smap, const char *key, struct in6_addr *addr)
 104 {
 105     char buf[INET6_ADDRSTRLEN];
 106     ipv6_string_mapped(buf, addr);
 107     smap_add(smap, key, buf);
 108 }
 109
 110 /* Searches for 'key' in 'smap'.  If it does not already exists, adds it.
 111  * Otherwise, changes its value to 'value'.  The caller retains ownership of
 112  * 'value'. */
 113 void
 114 smap_replace(struct smap *smap, const char *key, const char *value)
 115 {
 116     smap_replace_nocopy(smap, key, xstrdup(value));
 117 }
 118
 119 /* Searches for 'key' in 'smap'.  If it does not already exists, adds it.
 120  * Otherwise, changes its value to 'value'.  Takes ownership of 'value'. */
 121 void
 122 smap_replace_nocopy(struct smap *smap, const char *key, char *value)
 123 {
 124     size_t  key_len = strlen(key);
 125     size_t hash = hash_bytes(key, key_len, 0);
 126
 127     struct smap_node *node;
 128
 129     node = smap_find__(smap, key, key_len, hash);
 130     if (node) {
 131         free(node->value);
 132         node->value = value;
 133     } else {
 134         smap_add__(smap, xmemdup0(key, key_len), value, hash);
 135     }
 136 }
 137
 138 /* If 'key' is in 'smap', removes it.  Otherwise does nothing. */
 139 void
 140 smap_remove(struct smap *smap, const char *key)
 141 {
 142     struct smap_node *node = smap_get_node(smap, key);
 143
 144     if (node) {
 145         smap_remove_node(smap, node);
 146     }
 147 }
 148
 149 /* Removes 'node' from 'smap'. */
 150 void
 151 smap_remove_node(struct smap *smap, struct smap_node *node)
 152 {
 153     hmap_remove(&smap->map, &node->node);
 154     free(node->key);
 155     free(node->value);
 156     free(node);
 157 }
 158
 159 /* Deletes 'node' from 'smap'.
 160  *
 161  * If 'keyp' is nonnull, stores the node's key in '*keyp' and transfers
 162  * ownership to the caller.  Otherwise, frees the node's key.  Similarly for
 163  * 'valuep' and the node's value. */
 164 void
 165 smap_steal(struct smap *smap, struct smap_node *node,
 166            char **keyp, char **valuep)
 167 {
 168     if (keyp) {
 169         *keyp = node->key;
 170     } else {
 171         free(node->key);
 172     }
 173
 174     if (valuep) {
 175         *valuep = node->value;
 176     } else {
 177         free(node->value);
 178     }
 179
 180     hmap_remove(&smap->map, &node->node);
 181     free(node);
 182 }
 183
 184 /* Removes all key-value pairs from 'smap'. */
 185 void
 186 smap_clear(struct smap *smap)
 187 {
 188     struct smap_node *node, *next;
 189
 190     SMAP_FOR_EACH_SAFE (node, next, smap) {
 191         smap_remove_node(smap, node);
 192     }
 193 }
 194
 195 /* Returns the value associated with 'key' in 'smap'.
 196  * If 'smap' does not contain 'key', returns NULL. */
 197 const char *
 198 smap_get(const struct smap *smap, const char *key)
 199 {
 200     return smap_get_def(smap, key, NULL);
 201 }
 202
 203 /* Returns the value associated with 'key' in 'smap'.
 204  * If 'smap' does not contain 'key', returns 'def'. */
 205 const char *
 206 smap_get_def(const struct smap *smap, const char *key, const char *def)
 207 {
 208     struct smap_node *node = smap_get_node(smap, key);
 209     return node ? node->value : def;
 210 }
 211
 212 /* Returns the node associated with 'key' in 'smap', or NULL. */
 213 struct smap_node *
 214 smap_get_node(const struct smap *smap, const char *key)
 215 {
 216     size_t key_len = strlen(key);
 217     return smap_find__(smap, key, key_len, hash_bytes(key, key_len, 0));
 218 }
 219
 220 /* Gets the value associated with 'key' in 'smap' and converts it to a boolean.
 221  * If 'key' is not in 'smap', or its value is neither "true" nor "false",
 222  * returns 'def'. */
 223 bool
 224 smap_get_bool(const struct smap *smap, const char *key, bool def)
 225 {
 226     const char *value = smap_get_def(smap, key, "");
 227     if (def) {
 228         return strcasecmp("false", value) != 0;
 229     } else {
 230         return !strcasecmp("true", value);
 231     }
 232 }
 233
 234 /* Gets the value associated with 'key' in 'smap' and converts it to an int.
 235  * If 'key' is not in 'smap' or a valid integer can't be parsed from it's
 236  * value, returns 'def'. */
 237 int
 238 smap_get_int(const struct smap *smap, const char *key, int def)
 239 {
 240     const char *value = smap_get(smap, key);
 241     int i_value;
 242
 243     if (!value || !str_to_int(value, 10, &i_value)) {
 244         return def;
 245     }
 246
 247     return i_value;
 248 }
 249
 250 /* Gets the value associated with 'key' in 'smap' and converts it to an
 251  * unsigned long long.  If 'key' is not in 'smap' or a valid number can't be
 252  * parsed from it's value, returns 'def'. */
 253 unsigned long long int
 254 smap_get_ullong(const struct smap *smap, const char *key,
 255                 unsigned long long def)
 256 {
 257     const char *value = smap_get(smap, key);
 258     unsigned long long ull_value;
 259
 260     if (!value || !str_to_ullong(value, 10, &ull_value)) {
 261         return def;
 262     }
 263
 264     return ull_value;
 265 }
 266
 267 /* Gets the value associated with 'key' in 'smap' and converts it to a UUID
 268  * using uuid_from_string().  Returns true if successful, false if 'key' is not
 269  * in 'smap' or if 'key' does not have the correct syntax for a UUID. */
 270 bool
 271 smap_get_uuid(const struct smap *smap, const char *key, struct uuid *uuid)
 272 {
 273     return uuid_from_string(uuid, smap_get_def(smap, key, ""));
 274 }
 275
 276 /* Returns true of there are no elements in 'smap'. */
 277 bool
 278 smap_is_empty(const struct smap *smap)
 279 {
 280     return hmap_is_empty(&smap->map);
 281 }
 282
 283 /* Returns the number of elements in 'smap'. */
 284 size_t
 285 smap_count(const struct smap *smap)
 286 {
 287     return hmap_count(&smap->map);
 288 }
 289
 290 /* Initializes 'dst' as a clone of 'src. */
 291 void
 292 smap_clone(struct smap *dst, const struct smap *src)
 293 {
 294     const struct smap_node *node;
 295
 296     smap_init(dst);
 297     SMAP_FOR_EACH (node, src) {
 298         smap_add__(dst, xstrdup(node->key), xstrdup(node->value),
 299                    node->node.hash);
 300     }
 301 }
 302
 303 /* Returns an array of nodes sorted on key or NULL if 'smap' is empty.  The
 304  * caller is responsible for freeing this array. */
 305 const struct smap_node **
 306 smap_sort(const struct smap *smap)
 307 {
 308     if (smap_is_empty(smap)) {
 309         return NULL;
 310     } else {
 311         const struct smap_node **nodes;
 312         struct smap_node *node;
 313         size_t i, n;
 314
 315         n = smap_count(smap);
 316         nodes = xmalloc(n * sizeof *nodes);
 317         i = 0;
 318         SMAP_FOR_EACH (node, smap) {
 319             nodes[i++] = node;
 320         }
 321         ovs_assert(i == n);
 322
 323         qsort(nodes, n, sizeof *nodes, compare_nodes_by_key);
 324
 325         return nodes;
 326     }
 327 }
 328
 329 /* Adds each of the key-value pairs from 'json' (which must be a JSON object
 330  * whose values are strings) to 'smap'.
 331  *
 332  * The caller must have initialized 'smap'.
 333  *
 334  * The caller retains ownership of 'json' and everything in it. */
 335 void
 336 smap_from_json(struct smap *smap, const struct json *json)
 337 {
 338     const struct shash_node *node;
 339
 340     SHASH_FOR_EACH (node, json_object(json)) {
 341         const struct json *value = node->data;
 342         smap_add(smap, node->name, json_string(value));
 343     }
 344 }
 345
 346 /* Returns a JSON object that maps from the keys in 'smap' to their values.
 347  *
 348  * The caller owns the returned value and must eventually json_destroy() it.
 349  *
 350  * The caller retains ownership of 'smap' and everything in it. */
 351 struct json *
 352 smap_to_json(const struct smap *smap)
 353 {
 354     const struct smap_node *node;
 355     struct json *json;
 356
 357     json = json_object_create();
 358     SMAP_FOR_EACH (node, smap) {
 359         json_object_put_string(json, node->key, node->value);
 360     }
 361     return json;
 362 }
 363
 364 /* Returns true if the two maps are equal, meaning that they have the same set
 365  * of key-value pairs.
 366  */
 367 bool
 368 smap_equal(const struct smap *smap1, const struct smap *smap2)
 369 {
 370     if (smap_count(smap1) != smap_count(smap2)) {
 371         return false;
 372     }
 373
 374     const struct smap_node *node;
 375     SMAP_FOR_EACH (node, smap1) {
 376         const char *value2 = smap_get(smap2, node->key);
 377         if (!value2 || strcmp(node->value, value2)) {
 378             return false;
 379         }
 380     }
 381     return true;
 382 }
 383 \f
 384 /* Private Helpers. */
 385
 386 static struct smap_node *
 387 smap_add__(struct smap *smap, char *key, void *value, size_t hash)
 388 {
 389     struct smap_node *node = xmalloc(sizeof *node);
 390     node->key = key;
 391     node->value = value;
 392     hmap_insert(&smap->map, &node->node, hash);
 393     return node;
 394 }
 395
 396 static struct smap_node *
 397 smap_find__(const struct smap *smap, const char *key, size_t key_len,
 398             size_t hash)
 399 {
 400     struct smap_node *node;
 401
 402     HMAP_FOR_EACH_WITH_HASH (node, node, hash, &smap->map) {
 403         if (!strncmp(node->key, key, key_len) && !node->key[key_len]) {
 404             return node;
 405         }
 406     }
 407
 408     return NULL;
 409 }
 410
 411 static int
 412 compare_nodes_by_key(const void *a_, const void *b_)
 413 {
 414     const struct smap_node *const *a = a_;
 415     const struct smap_node *const *b = b_;
 416     return strcmp((*a)->key, (*b)->key);
 417 }