-/* Copyright (c) 2009, 2010 Nicira Networks
+/* Copyright (c) 2009, 2010, 2011, 2013 Nicira, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include "dynamic-string.h"
#include "json.h"
+#include "ovs-thread.h"
+#include "ovsdb-data.h"
#include "ovsdb-error.h"
#include "ovsdb-parser.h"
ovsdb_base_type_init(struct ovsdb_base_type *base, enum ovsdb_atomic_type type)
{
base->type = type;
+ base->enum_ = NULL;
switch (base->type) {
case OVSDB_TYPE_VOID:
break;
case OVSDB_TYPE_STRING:
-#ifdef HAVE_PCRE
- base->u.string.re = NULL;
-#endif
- base->u.string.reMatch = NULL;
- base->u.string.reComment = NULL;
base->u.string.minLen = 0;
base->u.string.maxLen = UINT_MAX;
break;
break;
case OVSDB_N_TYPES:
- NOT_REACHED();
+ OVS_NOT_REACHED();
default:
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
}
+/* Returns the type of the 'enum_' member for an ovsdb_base_type whose 'type'
+ * is 'atomic_type'. */
+const struct ovsdb_type *
+ovsdb_base_type_get_enum_type(enum ovsdb_atomic_type atomic_type)
+{
+ static struct ovsthread_once once = OVSTHREAD_ONCE_INITIALIZER;
+ static struct ovsdb_type *types[OVSDB_N_TYPES];
+
+ if (ovsthread_once_start(&once)) {
+ enum ovsdb_atomic_type i;
+
+ for (i = 0; i < OVSDB_N_TYPES; i++) {
+ struct ovsdb_type *type;
+
+ types[i] = type = xmalloc(sizeof *type);
+ ovsdb_base_type_init(&type->key, i);
+ ovsdb_base_type_init(&type->value, OVSDB_TYPE_VOID);
+ type->n_min = 1;
+ type->n_max = UINT_MAX;
+ }
+
+ ovsthread_once_done(&once);
+ }
+ return types[atomic_type];
+}
+
void
ovsdb_base_type_clone(struct ovsdb_base_type *dst,
const struct ovsdb_base_type *src)
{
*dst = *src;
+ if (src->enum_) {
+ dst->enum_ = xmalloc(sizeof *dst->enum_);
+ ovsdb_datum_clone(dst->enum_, src->enum_,
+ ovsdb_base_type_get_enum_type(dst->type));
+ }
+
switch (dst->type) {
case OVSDB_TYPE_VOID:
case OVSDB_TYPE_INTEGER:
break;
case OVSDB_TYPE_STRING:
-#if HAVE_PCRE
- if (dst->u.string.re) {
- pcre_refcount(dst->u.string.re, 1);
- }
-#else
- if (dst->u.string.reMatch) {
- dst->u.string.reMatch = xstrdup(dst->u.string.reMatch);
- }
- if (dst->u.string.reComment) {
- dst->u.string.reComment = xstrdup(dst->u.string.reComment);
- }
-#endif
break;
-
case OVSDB_TYPE_UUID:
if (dst->u.uuid.refTableName) {
dst->u.uuid.refTableName = xstrdup(dst->u.uuid.refTableName);
case OVSDB_N_TYPES:
default:
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
}
ovsdb_base_type_destroy(struct ovsdb_base_type *base)
{
if (base) {
+ if (base->enum_) {
+ ovsdb_datum_destroy(base->enum_,
+ ovsdb_base_type_get_enum_type(base->type));
+ free(base->enum_);
+ }
+
switch (base->type) {
case OVSDB_TYPE_VOID:
case OVSDB_TYPE_INTEGER:
break;
case OVSDB_TYPE_STRING:
-#ifdef HAVE_PCRE
- if (base->u.string.re && !pcre_refcount(base->u.string.re, -1)) {
- pcre_free(base->u.string.re);
- free(base->u.string.reMatch);
- free(base->u.string.reComment);
- }
-#else
- free(base->u.string.reMatch);
- free(base->u.string.reComment);
-#endif
break;
case OVSDB_TYPE_UUID:
break;
case OVSDB_N_TYPES:
- NOT_REACHED();
+ OVS_NOT_REACHED();
default:
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
}
}
bool
ovsdb_base_type_has_constraints(const struct ovsdb_base_type *base)
{
+ if (base->enum_) {
+ return true;
+ }
+
switch (base->type) {
case OVSDB_TYPE_VOID:
- NOT_REACHED();
+ OVS_NOT_REACHED();
case OVSDB_TYPE_INTEGER:
return (base->u.integer.min != INT64_MIN
return false;
case OVSDB_TYPE_STRING:
- return (base->u.string.reMatch != NULL
- || base->u.string.minLen != 0
- || base->u.string.maxLen != UINT_MAX);
+ return base->u.string.minLen != 0 || base->u.string.maxLen != UINT_MAX;
case OVSDB_TYPE_UUID:
return base->u.uuid.refTableName != NULL;
case OVSDB_N_TYPES:
- NOT_REACHED();
+ OVS_NOT_REACHED();
default:
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
}
ovsdb_base_type_init(base, type);
}
-struct ovsdb_error *
-ovsdb_base_type_set_regex(struct ovsdb_base_type *base,
- const char *reMatch, const char *reComment)
-{
-#ifdef HAVE_PCRE
- const char *errorString;
- const char *pattern;
- int errorOffset;
-
- /* Compile pattern, anchoring it at both ends. */
- pattern = reMatch;
- if (pattern[0] == '\0' || strchr(pattern, '\0')[-1] != '$') {
- pattern = xasprintf("%s$", pattern);
- }
-
-#ifndef PCRE_JAVASCRIPT_COMPAT /* Added in PCRE 7.7. */
-#define PCRE_JAVASCRIPT_COMPAT 0
-#endif
- base->u.string.re = pcre_compile(pattern, (PCRE_ANCHORED | PCRE_UTF8
- | PCRE_JAVASCRIPT_COMPAT),
- &errorString, &errorOffset, NULL);
- if (pattern != reMatch) {
- free((char *) pattern);
- }
- if (!base->u.string.re) {
- return ovsdb_syntax_error(NULL, "invalid regular expression",
- "\"%s\" is not a valid regular "
- "expression: %s", reMatch, errorString);
- }
- pcre_refcount(base->u.string.re, 1);
-#endif
-
- /* Save regular expression. */
- base->u.string.reMatch = xstrdup(reMatch);
- base->u.string.reComment = reComment ? xstrdup(reComment) : NULL;
- return NULL;
-}
-
static struct ovsdb_error *
parse_optional_uint(struct ovsdb_parser *parser, const char *member,
unsigned int *uint)
{
struct ovsdb_parser parser;
struct ovsdb_error *error;
- const struct json *type;
+ const struct json *type, *enum_;
if (json->type == JSON_STRING) {
error = ovsdb_atomic_type_from_json(&base->type, json);
}
ovsdb_base_type_init(base, base->type);
- if (base->type == OVSDB_TYPE_INTEGER) {
+
+ enum_ = ovsdb_parser_member(&parser, "enum", OP_ANY | OP_OPTIONAL);
+ if (enum_) {
+ base->enum_ = xmalloc(sizeof *base->enum_);
+ error = ovsdb_datum_from_json(
+ base->enum_, ovsdb_base_type_get_enum_type(base->type),
+ enum_, NULL);
+ if (error) {
+ free(base->enum_);
+ base->enum_ = NULL;
+ }
+ } else if (base->type == OVSDB_TYPE_INTEGER) {
const struct json *min, *max;
min = ovsdb_parser_member(&parser, "minInteger",
error = ovsdb_syntax_error(json, NULL, "minReal exceeds maxReal");
}
} else if (base->type == OVSDB_TYPE_STRING) {
- const struct json *reMatch;
-
- reMatch = ovsdb_parser_member(&parser, "reMatch",
- OP_STRING | OP_OPTIONAL);
- if (reMatch) {
- const struct json *reComment;
-
- reComment = ovsdb_parser_member(&parser, "reComment",
- OP_STRING | OP_OPTIONAL);
- error = ovsdb_base_type_set_regex(
- base, json_string(reMatch),
- reComment ? json_string(reComment) : NULL);
- }
-
if (!error) {
error = parse_optional_uint(&parser, "minLength",
&base->u.string.minLen);
refTable = ovsdb_parser_member(&parser, "refTable",
OP_ID | OP_OPTIONAL);
if (refTable) {
+ const struct json *refType;
+
base->u.uuid.refTableName = xstrdup(refTable->u.string);
+
/* We can't set base->u.uuid.refTable here because we don't have
* enough context (we might not even be running in ovsdb-server).
* ovsdb_create() will set refTable later. */
+
+ refType = ovsdb_parser_member(&parser, "refType",
+ OP_ID | OP_OPTIONAL);
+ if (refType) {
+ const char *refType_s = json_string(refType);
+ if (!strcmp(refType_s, "strong")) {
+ base->u.uuid.refType = OVSDB_REF_STRONG;
+ } else if (!strcmp(refType_s, "weak")) {
+ base->u.uuid.refType = OVSDB_REF_WEAK;
+ } else {
+ error = ovsdb_syntax_error(json, NULL, "refType must be "
+ "\"strong\" or \"weak\" (not "
+ "\"%s\")", refType_s);
+ }
+ } else {
+ base->u.uuid.refType = OVSDB_REF_STRONG;
+ }
}
}
json = json_object_create();
json_object_put_string(json, "type",
ovsdb_atomic_type_to_string(base->type));
+
+ if (base->enum_) {
+ const struct ovsdb_type *type;
+
+ type = ovsdb_base_type_get_enum_type(base->type);
+ json_object_put(json, "enum", ovsdb_datum_to_json(base->enum_, type));
+ }
+
switch (base->type) {
case OVSDB_TYPE_VOID:
- NOT_REACHED();
+ OVS_NOT_REACHED();
case OVSDB_TYPE_INTEGER:
if (base->u.integer.min != INT64_MIN) {
break;
case OVSDB_TYPE_STRING:
- if (base->u.string.reMatch) {
- json_object_put_string(json, "reMatch", base->u.string.reMatch);
- if (base->u.string.reComment) {
- json_object_put_string(json, "reComment",
- base->u.string.reComment);
- }
- }
if (base->u.string.minLen != 0) {
json_object_put(json, "minLength",
json_integer_create(base->u.string.minLen));
if (base->u.uuid.refTableName) {
json_object_put_string(json, "refTable",
base->u.uuid.refTableName);
+ if (base->u.uuid.refType == OVSDB_REF_WEAK) {
+ json_object_put_string(json, "refType", "weak");
+ }
}
break;
case OVSDB_N_TYPES:
- NOT_REACHED();
+ OVS_NOT_REACHED();
default:
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
return json;
&& ovsdb_base_type_is_valid(&type->key)
&& ovsdb_base_type_is_valid(&type->value)
&& type->n_min <= 1
- && type->n_min <= type->n_max
&& type->n_max >= 1);
}
struct ovsdb_error *
ovsdb_type_from_json(struct ovsdb_type *type, const struct json *json)
{
- type->value.type = OVSDB_TYPE_VOID;
+ ovsdb_base_type_init(&type->value, OVSDB_TYPE_VOID);
type->n_min = 1;
type->n_max = 1;
git://git.onelab.eu / sliver-openvswitch.git / blobdiff