mir/ovs
2
0
Fork 0
mirror of https://github.com/openvswitch/ovs synced 2025-08-22 18:07:40 +00:00
Code Issues Releases Wiki Activity

Embrace anonymous unions.

Browse Source 
Several OVS structs contain embedded named unions, like this:

struct {
    ...
    union {
        ...
    } u;
};

C11 standardized a feature that many compilers already implemented
anyway, where an embedded union may be unnamed, like this:

struct {
    ...
    union {
        ...
    };
};

This is more convenient because it allows the programmer to omit "u."
in many places.  OVS already used this feature in several places.  This
commit embraces it in several others.

Signed-off-by: Ben Pfaff <blp@ovn.org>
Acked-by: Justin Pettit <jpettit@ovn.org>
Tested-by: Alin Gabriel Serdean <aserdean@ovn.org>
Acked-by: Alin Gabriel Serdean <aserdean@ovn.org>
This commit is contained in:
Ben Pfaff 2018-05-24 10:32:59 -07:00
parent 3d62892884
commit fa37affad3
38 changed files with 457 additions and 456 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/openvswitch/json.h
View File

@ -71,7 +71,7 @@ struct json {
long long int integer; long long int integer;
double real; double real;
char *string; char *string;
} u; };
}; };
struct json *json_null_create(void); struct json *json_null_create(void);

8
lib/db-ctl-base.c
View File

@ -1809,12 +1809,12 @@ cmd_show_row(struct ctl_context *ctx, const struct ovsdb_idl_row *row,
datum = ovsdb_idl_read(row, column); datum = ovsdb_idl_read(row, column);
if (column->type.key.type == OVSDB_TYPE_UUID && if (column->type.key.type == OVSDB_TYPE_UUID &&
column->type.key.u.uuid.refTableName) { column->type.key.uuid.refTableName) {
const struct cmd_show_table *ref_show; const struct cmd_show_table *ref_show;
size_t j; size_t j;
ref_show = cmd_show_find_table_by_name( ref_show = cmd_show_find_table_by_name(
column->type.key.u.uuid.refTableName); column->type.key.uuid.refTableName);
if (ref_show) { if (ref_show) {
for (j = 0; j < datum->n; j++) { for (j = 0; j < datum->n; j++) {
const struct ovsdb_idl_row *ref_row; const struct ovsdb_idl_row *ref_row;
@ -1830,14 +1830,14 @@ cmd_show_row(struct ctl_context *ctx, const struct ovsdb_idl_row *row,
} }
} else if (ovsdb_type_is_map(&column->type) && } else if (ovsdb_type_is_map(&column->type) &&
column->type.value.type == OVSDB_TYPE_UUID && column->type.value.type == OVSDB_TYPE_UUID &&
column->type.value.u.uuid.refTableName) { column->type.value.uuid.refTableName) {
const struct cmd_show_table *ref_show; const struct cmd_show_table *ref_show;
size_t j; size_t j;
/* Prints the key to ref'ed table name map if the ref'ed table /* Prints the key to ref'ed table name map if the ref'ed table
* is also defined in 'cmd_show_tables'. */ * is also defined in 'cmd_show_tables'. */
ref_show = cmd_show_find_table_by_name( ref_show = cmd_show_find_table_by_name(
column->type.value.u.uuid.refTableName); column->type.value.uuid.refTableName);
if (ref_show && ref_show->name_column) { if (ref_show && ref_show->name_column) {
ds_put_char_multiple(&ctx->output, ' ', (level + 1) * 4); ds_put_char_multiple(&ctx->output, ' ', (level + 1) * 4);
ds_put_format(&ctx->output, "%s:\n", column->name); ds_put_format(&ctx->output, "%s:\n", column->name);

8
lib/dpif-netdev.c
View File

@ -3061,19 +3061,19 @@ dpif_netdev_operate(struct dpif *dpif, struct dpif_op **ops, size_t n_ops)
switch (op->type) { switch (op->type) {
case DPIF_OP_FLOW_PUT: case DPIF_OP_FLOW_PUT:
op->error = dpif_netdev_flow_put(dpif, &op->u.flow_put); op->error = dpif_netdev_flow_put(dpif, &op->flow_put);
break; break;
case DPIF_OP_FLOW_DEL: case DPIF_OP_FLOW_DEL:
op->error = dpif_netdev_flow_del(dpif, &op->u.flow_del); op->error = dpif_netdev_flow_del(dpif, &op->flow_del);
break; break;
case DPIF_OP_EXECUTE: case DPIF_OP_EXECUTE:
op->error = dpif_netdev_execute(dpif, &op->u.execute); op->error = dpif_netdev_execute(dpif, &op->execute);
break; break;
case DPIF_OP_FLOW_GET: case DPIF_OP_FLOW_GET:
op->error = dpif_netdev_flow_get(dpif, &op->u.flow_get); op->error = dpif_netdev_flow_get(dpif, &op->flow_get);
break; break;
} }
} }

38
lib/dpif-netlink.c
View File

@ -1923,7 +1923,7 @@ dpif_netlink_operate__(struct dpif_netlink *dpif,
switch (op->type) { switch (op->type) {
case DPIF_OP_FLOW_PUT: case DPIF_OP_FLOW_PUT:
put = &op->u.flow_put; put = &op->flow_put;
dpif_netlink_init_flow_put(dpif, put, &flow); dpif_netlink_init_flow_put(dpif, put, &flow);
if (put->stats) { if (put->stats) {
flow.nlmsg_flags |= NLM_F_ECHO; flow.nlmsg_flags |= NLM_F_ECHO;
@ -1933,7 +1933,7 @@ dpif_netlink_operate__(struct dpif_netlink *dpif,
break; break;
case DPIF_OP_FLOW_DEL: case DPIF_OP_FLOW_DEL:
del = &op->u.flow_del; del = &op->flow_del;
dpif_netlink_init_flow_del(dpif, del, &flow); dpif_netlink_init_flow_del(dpif, del, &flow);
if (del->stats) { if (del->stats) {
flow.nlmsg_flags |= NLM_F_ECHO; flow.nlmsg_flags |= NLM_F_ECHO;
@ -1945,26 +1945,26 @@ dpif_netlink_operate__(struct dpif_netlink *dpif,
case DPIF_OP_EXECUTE: case DPIF_OP_EXECUTE:
/* Can't execute a packet that won't fit in a Netlink attribute. */ /* Can't execute a packet that won't fit in a Netlink attribute. */
if (OVS_UNLIKELY(nl_attr_oversized( if (OVS_UNLIKELY(nl_attr_oversized(
dp_packet_size(op->u.execute.packet)))) { dp_packet_size(op->execute.packet)))) {
/* Report an error immediately if this is the first operation. /* Report an error immediately if this is the first operation.
* Otherwise the easiest thing to do is to postpone to the next * Otherwise the easiest thing to do is to postpone to the next
* call (when this will be the first operation). */ * call (when this will be the first operation). */
if (i == 0) { if (i == 0) {
VLOG_ERR_RL(&error_rl, VLOG_ERR_RL(&error_rl,
"dropping oversized %"PRIu32"-byte packet", "dropping oversized %"PRIu32"-byte packet",
dp_packet_size(op->u.execute.packet)); dp_packet_size(op->execute.packet));
op->error = ENOBUFS; op->error = ENOBUFS;
return 1; return 1;
} }
n_ops = i; n_ops = i;
} else { } else {
dpif_netlink_encode_execute(dpif->dp_ifindex, &op->u.execute, dpif_netlink_encode_execute(dpif->dp_ifindex, &op->execute,
&aux->request); &aux->request);
} }
break; break;
case DPIF_OP_FLOW_GET: case DPIF_OP_FLOW_GET:
get = &op->u.flow_get; get = &op->flow_get;
dpif_netlink_init_flow_get(dpif, get, &flow); dpif_netlink_init_flow_get(dpif, get, &flow);
aux->txn.reply = get->buffer; aux->txn.reply = get->buffer;
dpif_netlink_flow_to_ofpbuf(&flow, &aux->request); dpif_netlink_flow_to_ofpbuf(&flow, &aux->request);
@ -1992,7 +1992,7 @@ dpif_netlink_operate__(struct dpif_netlink *dpif,
switch (op->type) { switch (op->type) {
case DPIF_OP_FLOW_PUT: case DPIF_OP_FLOW_PUT:
put = &op->u.flow_put; put = &op->flow_put;
if (put->stats) { if (put->stats) {
if (!op->error) { if (!op->error) {
struct dpif_netlink_flow reply; struct dpif_netlink_flow reply;
@ -2007,7 +2007,7 @@ dpif_netlink_operate__(struct dpif_netlink *dpif,
break; break;
case DPIF_OP_FLOW_DEL: case DPIF_OP_FLOW_DEL:
del = &op->u.flow_del; del = &op->flow_del;
if (del->stats) { if (del->stats) {
if (!op->error) { if (!op->error) {
struct dpif_netlink_flow reply; struct dpif_netlink_flow reply;
@ -2025,7 +2025,7 @@ dpif_netlink_operate__(struct dpif_netlink *dpif,
break; break;
case DPIF_OP_FLOW_GET: case DPIF_OP_FLOW_GET:
get = &op->u.flow_get; get = &op->flow_get;
if (!op->error) { if (!op->error) {
struct dpif_netlink_flow reply; struct dpif_netlink_flow reply;
@ -2157,12 +2157,12 @@ parse_flow_put(struct dpif_netlink *dpif, struct dpif_flow_put *put)
struct dpif_op op; struct dpif_op op;
op.type = DPIF_OP_FLOW_DEL; op.type = DPIF_OP_FLOW_DEL;
op.u.flow_del.key = put->key; op.flow_del.key = put->key;
op.u.flow_del.key_len = put->key_len; op.flow_del.key_len = put->key_len;
op.u.flow_del.ufid = put->ufid; op.flow_del.ufid = put->ufid;
op.u.flow_del.pmd_id = put->pmd_id; op.flow_del.pmd_id = put->pmd_id;
op.u.flow_del.stats = NULL; op.flow_del.stats = NULL;
op.u.flow_del.terse = false; op.flow_del.terse = false;
opp = &op; opp = &op;
dpif_netlink_operate__(dpif, &opp, 1); dpif_netlink_operate__(dpif, &opp, 1);
@ -2203,7 +2203,7 @@ try_send_to_netdev(struct dpif_netlink *dpif, struct dpif_op *op)
switch (op->type) { switch (op->type) {
case DPIF_OP_FLOW_PUT: { case DPIF_OP_FLOW_PUT: {
struct dpif_flow_put *put = &op->u.flow_put; struct dpif_flow_put *put = &op->flow_put;
if (!put->ufid) { if (!put->ufid) {
break; break;
@ -2214,7 +2214,7 @@ try_send_to_netdev(struct dpif_netlink *dpif, struct dpif_op *op)
break; break;
} }
case DPIF_OP_FLOW_DEL: { case DPIF_OP_FLOW_DEL: {
struct dpif_flow_del *del = &op->u.flow_del; struct dpif_flow_del *del = &op->flow_del;
if (!del->ufid) { if (!del->ufid) {
break; break;
@ -2226,9 +2226,9 @@ try_send_to_netdev(struct dpif_netlink *dpif, struct dpif_op *op)
break; break;
} }
case DPIF_OP_FLOW_GET: { case DPIF_OP_FLOW_GET: {
struct dpif_flow_get *get = &op->u.flow_get; struct dpif_flow_get *get = &op->flow_get;
if (!op->u.flow_get.ufid) { if (!op->flow_get.ufid) {
break; break;
} }

62
lib/dpif.c
View File

@ -998,16 +998,16 @@ dpif_flow_get(struct dpif *dpif,
struct dpif_op op; struct dpif_op op;
op.type = DPIF_OP_FLOW_GET; op.type = DPIF_OP_FLOW_GET;
op.u.flow_get.key = key; op.flow_get.key = key;
op.u.flow_get.key_len = key_len; op.flow_get.key_len = key_len;
op.u.flow_get.ufid = ufid; op.flow_get.ufid = ufid;
op.u.flow_get.pmd_id = pmd_id; op.flow_get.pmd_id = pmd_id;
op.u.flow_get.buffer = buf; op.flow_get.buffer = buf;
memset(flow, 0, sizeof *flow); memset(flow, 0, sizeof *flow);
op.u.flow_get.flow = flow; op.flow_get.flow = flow;
op.u.flow_get.flow->key = key; op.flow_get.flow->key = key;
op.u.flow_get.flow->key_len = key_len; op.flow_get.flow->key_len = key_len;
opp = &op; opp = &op;
dpif_operate(dpif, &opp, 1); dpif_operate(dpif, &opp, 1);
@ -1028,16 +1028,16 @@ dpif_flow_put(struct dpif *dpif, enum dpif_flow_put_flags flags,
struct dpif_op op; struct dpif_op op;
op.type = DPIF_OP_FLOW_PUT; op.type = DPIF_OP_FLOW_PUT;
op.u.flow_put.flags = flags; op.flow_put.flags = flags;
op.u.flow_put.key = key; op.flow_put.key = key;
op.u.flow_put.key_len = key_len; op.flow_put.key_len = key_len;
op.u.flow_put.mask = mask; op.flow_put.mask = mask;
op.u.flow_put.mask_len = mask_len; op.flow_put.mask_len = mask_len;
op.u.flow_put.actions = actions; op.flow_put.actions = actions;
op.u.flow_put.actions_len = actions_len; op.flow_put.actions_len = actions_len;
op.u.flow_put.ufid = ufid; op.flow_put.ufid = ufid;
op.u.flow_put.pmd_id = pmd_id; op.flow_put.pmd_id = pmd_id;
op.u.flow_put.stats = stats; op.flow_put.stats = stats;
opp = &op; opp = &op;
dpif_operate(dpif, &opp, 1); dpif_operate(dpif, &opp, 1);
@ -1055,12 +1055,12 @@ dpif_flow_del(struct dpif *dpif,
struct dpif_op op; struct dpif_op op;
op.type = DPIF_OP_FLOW_DEL; op.type = DPIF_OP_FLOW_DEL;
op.u.flow_del.key = key; op.flow_del.key = key;
op.u.flow_del.key_len = key_len; op.flow_del.key_len = key_len;
op.u.flow_del.ufid = ufid; op.flow_del.ufid = ufid;
op.u.flow_del.pmd_id = pmd_id; op.flow_del.pmd_id = pmd_id;
op.u.flow_del.stats = stats; op.flow_del.stats = stats;
op.u.flow_del.terse = false; op.flow_del.terse = false;
opp = &op; opp = &op;
dpif_operate(dpif, &opp, 1); dpif_operate(dpif, &opp, 1);
@ -1317,7 +1317,7 @@ dpif_execute(struct dpif *dpif, struct dpif_execute *execute)
struct dpif_op op; struct dpif_op op;
op.type = DPIF_OP_EXECUTE; op.type = DPIF_OP_EXECUTE;
op.u.execute = *execute; op.execute = *execute;
opp = &op; opp = &op;
dpif_operate(dpif, &opp, 1); dpif_operate(dpif, &opp, 1);
@ -1345,7 +1345,7 @@ dpif_operate(struct dpif *dpif, struct dpif_op **ops, size_t n_ops)
struct dpif_op *op = ops[chunk]; struct dpif_op *op = ops[chunk];
if (op->type == DPIF_OP_EXECUTE if (op->type == DPIF_OP_EXECUTE
&& dpif_execute_needs_help(&op->u.execute)) { && dpif_execute_needs_help(&op->execute)) {
break; break;
} }
} }
@ -1363,7 +1363,7 @@ dpif_operate(struct dpif *dpif, struct dpif_op **ops, size_t n_ops)
switch (op->type) { switch (op->type) {
case DPIF_OP_FLOW_PUT: { case DPIF_OP_FLOW_PUT: {
struct dpif_flow_put *put = &op->u.flow_put; struct dpif_flow_put *put = &op->flow_put;
COVERAGE_INC(dpif_flow_put); COVERAGE_INC(dpif_flow_put);
log_flow_put_message(dpif, &this_module, put, error); log_flow_put_message(dpif, &this_module, put, error);
@ -1374,7 +1374,7 @@ dpif_operate(struct dpif *dpif, struct dpif_op **ops, size_t n_ops)
} }
case DPIF_OP_FLOW_GET: { case DPIF_OP_FLOW_GET: {
struct dpif_flow_get *get = &op->u.flow_get; struct dpif_flow_get *get = &op->flow_get;
COVERAGE_INC(dpif_flow_get); COVERAGE_INC(dpif_flow_get);
if (error) { if (error) {
@ -1386,7 +1386,7 @@ dpif_operate(struct dpif *dpif, struct dpif_op **ops, size_t n_ops)
} }
case DPIF_OP_FLOW_DEL: { case DPIF_OP_FLOW_DEL: {
struct dpif_flow_del *del = &op->u.flow_del; struct dpif_flow_del *del = &op->flow_del;
COVERAGE_INC(dpif_flow_del); COVERAGE_INC(dpif_flow_del);
log_flow_del_message(dpif, &this_module, del, error); log_flow_del_message(dpif, &this_module, del, error);
@ -1398,7 +1398,7 @@ dpif_operate(struct dpif *dpif, struct dpif_op **ops, size_t n_ops)
case DPIF_OP_EXECUTE: case DPIF_OP_EXECUTE:
COVERAGE_INC(dpif_execute); COVERAGE_INC(dpif_execute);
log_execute_message(dpif, &this_module, &op->u.execute, log_execute_message(dpif, &this_module, &op->execute,
false, error); false, error);
break; break;
} }
@ -1411,7 +1411,7 @@ dpif_operate(struct dpif *dpif, struct dpif_op **ops, size_t n_ops)
struct dpif_op *op = ops[0]; struct dpif_op *op = ops[0];
COVERAGE_INC(dpif_execute); COVERAGE_INC(dpif_execute);
op->error = dpif_execute_with_help(dpif, &op->u.execute); op->error = dpif_execute_with_help(dpif, &op->execute);
ops++; ops++;
n_ops--; n_ops--;
} }

2
lib/dpif.h
View File

@ -760,7 +760,7 @@ struct dpif_op {
struct dpif_flow_del flow_del; struct dpif_flow_del flow_del;
struct dpif_execute execute; struct dpif_execute execute;
struct dpif_flow_get flow_get; struct dpif_flow_get flow_get;
} u; };
}; };
void dpif_operate(struct dpif *, struct dpif_op **ops, size_t n_ops); void dpif_operate(struct dpif *, struct dpif_op **ops, size_t n_ops);

106
lib/json.c
View File

@ -59,7 +59,7 @@ struct json_token {
double real; double real;
long long int integer; long long int integer;
const char *string; const char *string;
} u; };
}; };
enum json_lex_state { enum json_lex_state {
@ -170,7 +170,7 @@ struct json *
json_string_create_nocopy(char *s) json_string_create_nocopy(char *s)
{ {
struct json *json = json_create(JSON_STRING); struct json *json = json_create(JSON_STRING);
json->u.string = s; json->string = s;
return json; return json;
} }
@ -184,9 +184,9 @@ struct json *
json_array_create_empty(void) json_array_create_empty(void)
{ {
struct json *json = json_create(JSON_ARRAY); struct json *json = json_create(JSON_ARRAY);
json->u.array.elems = NULL; json->array.elems = NULL;
json->u.array.n = 0; json->array.n = 0;
json->u.array.n_allocated = 0; json->array.n_allocated = 0;
return json; return json;
} }
@ -215,9 +215,9 @@ struct json *
json_array_create(struct json **elements, size_t n) json_array_create(struct json **elements, size_t n)
{ {
struct json *json = json_create(JSON_ARRAY); struct json *json = json_create(JSON_ARRAY);
json->u.array.elems = elements; json->array.elems = elements;
json->u.array.n = n; json->array.n = n;
json->u.array.n_allocated = n; json->array.n_allocated = n;
return json; return json;
} }
@ -252,8 +252,8 @@ struct json *
json_object_create(void) json_object_create(void)
{ {
struct json *json = json_create(JSON_OBJECT); struct json *json = json_create(JSON_OBJECT);
json->u.object = xmalloc(sizeof *json->u.object); json->object = xmalloc(sizeof *json->object);
shash_init(json->u.object); shash_init(json->object);
return json; return json;
} }
@ -261,7 +261,7 @@ struct json *
json_integer_create(long long int integer) json_integer_create(long long int integer)
{ {
struct json *json = json_create(JSON_INTEGER); struct json *json = json_create(JSON_INTEGER);
json->u.integer = integer; json->integer = integer;
return json; return json;
} }
@ -269,20 +269,20 @@ struct json *
json_real_create(double real) json_real_create(double real)
{ {
struct json *json = json_create(JSON_REAL); struct json *json = json_create(JSON_REAL);
json->u.real = real; json->real = real;
return json; return json;
} }
void void
json_object_put(struct json *json, const char *name, struct json *value) json_object_put(struct json *json, const char *name, struct json *value)
{ {
json_destroy(shash_replace(json->u.object, name, value)); json_destroy(shash_replace(json->object, name, value));
} }
void void
json_object_put_nocopy(struct json *json, char *name, struct json *value) json_object_put_nocopy(struct json *json, char *name, struct json *value)
{ {
json_destroy(shash_replace_nocopy(json->u.object, name, value)); json_destroy(shash_replace_nocopy(json->object, name, value));
} }
void void
@ -306,21 +306,21 @@ const char *
json_string(const struct json *json) json_string(const struct json *json)
{ {
ovs_assert(json->type == JSON_STRING); ovs_assert(json->type == JSON_STRING);
return json->u.string; return json->string;
} }
struct json_array * struct json_array *
json_array(const struct json *json) json_array(const struct json *json)
{ {
ovs_assert(json->type == JSON_ARRAY); ovs_assert(json->type == JSON_ARRAY);
return CONST_CAST(struct json_array *, &json->u.array); return CONST_CAST(struct json_array *, &json->array);
} }
struct shash * struct shash *
json_object(const struct json *json) json_object(const struct json *json)
{ {
ovs_assert(json->type == JSON_OBJECT); ovs_assert(json->type == JSON_OBJECT);
return CONST_CAST(struct shash *, json->u.object); return CONST_CAST(struct shash *, json->object);
} }
bool bool
@ -334,14 +334,14 @@ double
json_real(const struct json *json) json_real(const struct json *json)
{ {
ovs_assert(json->type == JSON_REAL || json->type == JSON_INTEGER); ovs_assert(json->type == JSON_REAL || json->type == JSON_INTEGER);
return json->type == JSON_REAL ? json->u.real : json->u.integer; return json->type == JSON_REAL ? json->real : json->integer;
} }
int64_t int64_t
json_integer(const struct json *json) json_integer(const struct json *json)
{ {
ovs_assert(json->type == JSON_INTEGER); ovs_assert(json->type == JSON_INTEGER);
return json->u.integer; return json->integer;
} }
static void json_destroy_object(struct shash *object); static void json_destroy_object(struct shash *object);
@ -354,15 +354,15 @@ json_destroy(struct json *json)
if (json && !--json->count) { if (json && !--json->count) {
switch (json->type) { switch (json->type) {
case JSON_OBJECT: case JSON_OBJECT:
json_destroy_object(json->u.object); json_destroy_object(json->object);
break; break;
case JSON_ARRAY: case JSON_ARRAY:
json_destroy_array(&json->u.array); json_destroy_array(&json->array);
break; break;
case JSON_STRING: case JSON_STRING:
free(json->u.string); free(json->string);
break; break;
case JSON_NULL: case JSON_NULL:
@ -414,13 +414,13 @@ json_deep_clone(const struct json *json)
{ {
switch (json->type) { switch (json->type) {
case JSON_OBJECT: case JSON_OBJECT:
return json_clone_object(json->u.object); return json_clone_object(json->object);
case JSON_ARRAY: case JSON_ARRAY:
return json_clone_array(&json->u.array); return json_clone_array(&json->array);
case JSON_STRING: case JSON_STRING:
return json_string_create(json->u.string); return json_string_create(json->string);
case JSON_NULL: case JSON_NULL:
case JSON_FALSE: case JSON_FALSE:
@ -428,10 +428,10 @@ json_deep_clone(const struct json *json)
return json_create(json->type); return json_create(json->type);
case JSON_INTEGER: case JSON_INTEGER:
return json_integer_create(json->u.integer); return json_integer_create(json->integer);
case JSON_REAL: case JSON_REAL:
return json_real_create(json->u.real); return json_real_create(json->real);
case JSON_N_TYPES: case JSON_N_TYPES:
default: default:
@ -515,13 +515,13 @@ json_hash(const struct json *json, size_t basis)
{ {
switch (json->type) { switch (json->type) {
case JSON_OBJECT: case JSON_OBJECT:
return json_hash_object(json->u.object, basis); return json_hash_object(json->object, basis);
case JSON_ARRAY: case JSON_ARRAY:
return json_hash_array(&json->u.array, basis); return json_hash_array(&json->array, basis);
case JSON_STRING: case JSON_STRING:
return hash_string(json->u.string, basis); return hash_string(json->string, basis);
case JSON_NULL: case JSON_NULL:
case JSON_FALSE: case JSON_FALSE:
@ -529,10 +529,10 @@ json_hash(const struct json *json, size_t basis)
return hash_int(json->type << 8, basis); return hash_int(json->type << 8, basis);
case JSON_INTEGER: case JSON_INTEGER:
return hash_int(json->u.integer, basis); return hash_int(json->integer, basis);
case JSON_REAL: case JSON_REAL:
return hash_double(json->u.real, basis); return hash_double(json->real, basis);
case JSON_N_TYPES: case JSON_N_TYPES:
default: default:
@ -590,13 +590,13 @@ json_equal(const struct json *a, const struct json *b)
switch (a->type) { switch (a->type) {
case JSON_OBJECT: case JSON_OBJECT:
return json_equal_object(a->u.object, b->u.object); return json_equal_object(a->object, b->object);
case JSON_ARRAY: case JSON_ARRAY:
return json_equal_array(&a->u.array, &b->u.array); return json_equal_array(&a->array, &b->array);
case JSON_STRING: case JSON_STRING:
return !strcmp(a->u.string, b->u.string); return !strcmp(a->string, b->string);
case JSON_NULL: case JSON_NULL:
case JSON_FALSE: case JSON_FALSE:
@ -604,10 +604,10 @@ json_equal(const struct json *a, const struct json *b)
return true; return true;
case JSON_INTEGER: case JSON_INTEGER:
return a->u.integer == b->u.integer; return a->integer == b->integer;
case JSON_REAL: case JSON_REAL:
return a->u.real == b->u.real; return a->real == b->real;
case JSON_N_TYPES: case JSON_N_TYPES:
default: default:
@ -742,7 +742,7 @@ json_lex_number(struct json_parser *p)
* We suppress negative zeros as a matter of policy. */ * We suppress negative zeros as a matter of policy. */
if (!significand) { if (!significand) {
token.type = T_INTEGER; token.type = T_INTEGER;
token.u.integer = 0; token.integer = 0;
json_parser_input(p, &token); json_parser_input(p, &token);
return; return;
} }
@ -761,20 +761,20 @@ json_lex_number(struct json_parser *p)
? (unsigned long long int) LLONG_MAX + 1 ? (unsigned long long int) LLONG_MAX + 1
: LLONG_MAX)) { : LLONG_MAX)) {
token.type = T_INTEGER; token.type = T_INTEGER;
token.u.integer = negative ? -significand : significand; token.integer = negative ? -significand : significand;
json_parser_input(p, &token); json_parser_input(p, &token);
return; return;
} }
} }
token.type = T_REAL; token.type = T_REAL;
if (!str_to_double(ds_cstr(&p->buffer), &token.u.real)) { if (!str_to_double(ds_cstr(&p->buffer), &token.real)) {
json_error(p, "number outside valid range"); json_error(p, "number outside valid range");
return; return;
} }
/* Suppress negative zero. */ /* Suppress negative zero. */
if (token.u.real == 0) { if (token.real == 0) {
token.u.real = 0; token.real = 0;
} }
json_parser_input(p, &token); json_parser_input(p, &token);
} }
@ -922,7 +922,7 @@ json_string_escape(const char *in, struct ds *out)
{ {
struct json json = { struct json json = {
.type = JSON_STRING, .type = JSON_STRING,
.u.string = CONST_CAST(char *, in), .string = CONST_CAST(char *, in),
}; };
json_to_ds(&json, 0, out); json_to_ds(&json, 0, out);
} }
@ -933,7 +933,7 @@ json_parser_input_string(struct json_parser *p, const char *s)
struct json_token token; struct json_token token;
token.type = T_STRING; token.type = T_STRING;
token.u.string = s; token.string = s;
json_parser_input(p, &token); json_parser_input(p, &token);
} }
@ -1298,15 +1298,15 @@ json_parse_value(struct json_parser *p, struct json_token *token,
return; return;
case T_INTEGER: case T_INTEGER:
value = json_integer_create(token->u.integer); value = json_integer_create(token->integer);
break; break;
case T_REAL: case T_REAL:
value = json_real_create(token->u.real); value = json_real_create(token->real);
break; break;
case T_STRING: case T_STRING:
value = json_string_create(token->u.string); value = json_string_create(token->string);
break; break;
case T_EOF: case T_EOF:
@ -1379,7 +1379,7 @@ json_parser_input(struct json_parser *p, struct json_token *token)
/* Fall through. */ /* Fall through. */
case JSON_PARSE_OBJECT_NAME: case JSON_PARSE_OBJECT_NAME:
if (token->type == T_STRING) { if (token->type == T_STRING) {
p->member_name = xstrdup(token->u.string); p->member_name = xstrdup(token->string);
p->parse_state = JSON_PARSE_OBJECT_COLON; p->parse_state = JSON_PARSE_OBJECT_COLON;
} else { } else {
json_error(p, "syntax error parsing object expecting string"); json_error(p, "syntax error parsing object expecting string");
@ -1535,23 +1535,23 @@ json_serialize(const struct json *json, struct json_serializer *s)
break; break;
case JSON_OBJECT: case JSON_OBJECT:
json_serialize_object(json->u.object, s); json_serialize_object(json->object, s);
break; break;
case JSON_ARRAY: case JSON_ARRAY:
json_serialize_array(&json->u.array, s); json_serialize_array(&json->array, s);
break; break;
case JSON_INTEGER: case JSON_INTEGER:
ds_put_format(ds, "%lld", json->u.integer); ds_put_format(ds, "%lld", json->integer);
break; break;
case JSON_REAL: case JSON_REAL:
ds_put_format(ds, "%.*g", DBL_DIG, json->u.real); ds_put_format(ds, "%.*g", DBL_DIG, json->real);
break; break;
case JSON_STRING: case JSON_STRING:
json_serialize_string(json->u.string, ds); json_serialize_string(json->string, ds);
break; break;
case JSON_N_TYPES: case JSON_N_TYPES:

4
lib/jsonrpc.c
View File

@ -695,7 +695,7 @@ jsonrpc_msg_from_json(struct json *json, struct jsonrpc_msg **msgp)
} }
msg = xzalloc(sizeof *msg); msg = xzalloc(sizeof *msg);
msg->method = method ? xstrdup(method->u.string) : NULL; msg->method = method ? xstrdup(method->string) : NULL;
msg->params = null_from_json_null(shash_find_and_delete(object, "params")); msg->params = null_from_json_null(shash_find_and_delete(object, "params"));
msg->result = null_from_json_null(shash_find_and_delete(object, "result")); msg->result = null_from_json_null(shash_find_and_delete(object, "result"));
msg->error = null_from_json_null(shash_find_and_delete(object, "error")); msg->error = null_from_json_null(shash_find_and_delete(object, "error"));
@ -1129,7 +1129,7 @@ jsonrpc_session_recv(struct jsonrpc_session *s)
jsonrpc_session_send(s, reply); jsonrpc_session_send(s, reply);
} else if (msg->type == JSONRPC_REPLY } else if (msg->type == JSONRPC_REPLY
&& msg->id && msg->id->type == JSON_STRING && msg->id && msg->id->type == JSON_STRING
&& !strcmp(msg->id->u.string, "echo")) { && !strcmp(msg->id->string, "echo")) {
/* It's a reply to our echo request. Suppress it. */ /* It's a reply to our echo request. Suppress it. */
} else { } else {
return msg; return msg;

50
lib/netdev-dummy.c
View File

@ -84,7 +84,7 @@ struct dummy_packet_conn {
union { union {
struct dummy_packet_pconn pconn; struct dummy_packet_pconn pconn;
struct dummy_packet_rconn rconn; struct dummy_packet_rconn rconn;
} u; };
}; };
struct pkt_list_node { struct pkt_list_node {
@ -307,11 +307,11 @@ dummy_packet_conn_get_config(struct dummy_packet_conn *conn, struct smap *args)
switch (conn->type) { switch (conn->type) {
case PASSIVE: case PASSIVE:
smap_add(args, "pstream", pstream_get_name(conn->u.pconn.pstream)); smap_add(args, "pstream", pstream_get_name(conn->pconn.pstream));
break; break;
case ACTIVE: case ACTIVE:
smap_add(args, "stream", stream_get_name(conn->u.rconn.rstream->stream)); smap_add(args, "stream", stream_get_name(conn->rconn.rstream->stream));
break; break;
case NONE: case NONE:
@ -324,8 +324,8 @@ static void
dummy_packet_conn_close(struct dummy_packet_conn *conn) dummy_packet_conn_close(struct dummy_packet_conn *conn)
{ {
int i; int i;
struct dummy_packet_pconn *pconn = &conn->u.pconn; struct dummy_packet_pconn *pconn = &conn->pconn;
struct dummy_packet_rconn *rconn = &conn->u.rconn; struct dummy_packet_rconn *rconn = &conn->rconn;
switch (conn->type) { switch (conn->type) {
case PASSIVE: case PASSIVE:
@ -372,14 +372,14 @@ dummy_packet_conn_set_config(struct dummy_packet_conn *conn,
switch (conn->type) { switch (conn->type) {
case PASSIVE: case PASSIVE:
if (pstream && if (pstream &&
!strcmp(pstream_get_name(conn->u.pconn.pstream), pstream)) { !strcmp(pstream_get_name(conn->pconn.pstream), pstream)) {
return; return;
} }
dummy_packet_conn_close(conn); dummy_packet_conn_close(conn);
break; break;
case ACTIVE: case ACTIVE:
if (stream && if (stream &&
!strcmp(stream_get_name(conn->u.rconn.rstream->stream), stream)) { !strcmp(stream_get_name(conn->rconn.rstream->stream), stream)) {
return; return;
} }
dummy_packet_conn_close(conn); dummy_packet_conn_close(conn);
@ -392,7 +392,7 @@ dummy_packet_conn_set_config(struct dummy_packet_conn *conn,
if (pstream) { if (pstream) {
int error; int error;
error = pstream_open(pstream, &conn->u.pconn.pstream, DSCP_DEFAULT); error = pstream_open(pstream, &conn->pconn.pstream, DSCP_DEFAULT);
if (error) { if (error) {
VLOG_WARN("%s: open failed (%s)", pstream, ovs_strerror(error)); VLOG_WARN("%s: open failed (%s)", pstream, ovs_strerror(error));
} else { } else {
@ -411,11 +411,11 @@ dummy_packet_conn_set_config(struct dummy_packet_conn *conn,
reconnect_enable(reconnect, time_msec()); reconnect_enable(reconnect, time_msec());
reconnect_set_backoff(reconnect, 100, INT_MAX); reconnect_set_backoff(reconnect, 100, INT_MAX);
reconnect_set_probe_interval(reconnect, 0); reconnect_set_probe_interval(reconnect, 0);
conn->u.rconn.reconnect = reconnect; conn->rconn.reconnect = reconnect;
conn->type = ACTIVE; conn->type = ACTIVE;
error = stream_open(stream, &active_stream, DSCP_DEFAULT); error = stream_open(stream, &active_stream, DSCP_DEFAULT);
conn->u.rconn.rstream = dummy_packet_stream_create(active_stream); conn->rconn.rstream = dummy_packet_stream_create(active_stream);
switch (error) { switch (error) {
case 0: case 0:
@ -429,7 +429,7 @@ dummy_packet_conn_set_config(struct dummy_packet_conn *conn,
default: default:
reconnect_connect_failed(reconnect, time_msec(), error); reconnect_connect_failed(reconnect, time_msec(), error);
stream_close(active_stream); stream_close(active_stream);
conn->u.rconn.rstream->stream = NULL; conn->rconn.rstream->stream = NULL;
break; break;
} }
} }
@ -440,7 +440,7 @@ dummy_pconn_run(struct netdev_dummy *dev)
OVS_REQUIRES(dev->mutex) OVS_REQUIRES(dev->mutex)
{ {
struct stream *new_stream; struct stream *new_stream;
struct dummy_packet_pconn *pconn = &dev->conn.u.pconn; struct dummy_packet_pconn *pconn = &dev->conn.pconn;
int error; int error;
size_t i; size_t i;
@ -483,7 +483,7 @@ static void
dummy_rconn_run(struct netdev_dummy *dev) dummy_rconn_run(struct netdev_dummy *dev)
OVS_REQUIRES(dev->mutex) OVS_REQUIRES(dev->mutex)
{ {
struct dummy_packet_rconn *rconn = &dev->conn.u.rconn; struct dummy_packet_rconn *rconn = &dev->conn.rconn;
switch (reconnect_run(rconn->reconnect, time_msec())) { switch (reconnect_run(rconn->reconnect, time_msec())) {
case RECONNECT_CONNECT: case RECONNECT_CONNECT:
@ -559,15 +559,15 @@ dummy_packet_conn_wait(struct dummy_packet_conn *conn)
int i; int i;
switch (conn->type) { switch (conn->type) {
case PASSIVE: case PASSIVE:
pstream_wait(conn->u.pconn.pstream); pstream_wait(conn->pconn.pstream);
for (i = 0; i < conn->u.pconn.n_streams; i++) { for (i = 0; i < conn->pconn.n_streams; i++) {
struct dummy_packet_stream *s = conn->u.pconn.streams[i]; struct dummy_packet_stream *s = conn->pconn.streams[i];
dummy_packet_stream_wait(s); dummy_packet_stream_wait(s);
} }
break; break;
case ACTIVE: case ACTIVE:
if (reconnect_is_connected(conn->u.rconn.reconnect)) { if (reconnect_is_connected(conn->rconn.reconnect)) {
dummy_packet_stream_wait(conn->u.rconn.rstream); dummy_packet_stream_wait(conn->rconn.rstream);
} }
break; break;
@ -585,18 +585,18 @@ dummy_packet_conn_send(struct dummy_packet_conn *conn,
switch (conn->type) { switch (conn->type) {
case PASSIVE: case PASSIVE:
for (i = 0; i < conn->u.pconn.n_streams; i++) { for (i = 0; i < conn->pconn.n_streams; i++) {
struct dummy_packet_stream *s = conn->u.pconn.streams[i]; struct dummy_packet_stream *s = conn->pconn.streams[i];
dummy_packet_stream_send(s, buffer, size); dummy_packet_stream_send(s, buffer, size);
pstream_wait(conn->u.pconn.pstream); pstream_wait(conn->pconn.pstream);
} }
break; break;
case ACTIVE: case ACTIVE:
if (reconnect_is_connected(conn->u.rconn.reconnect)) { if (reconnect_is_connected(conn->rconn.reconnect)) {
dummy_packet_stream_send(conn->u.rconn.rstream, buffer, size); dummy_packet_stream_send(conn->rconn.rstream, buffer, size);
dummy_packet_stream_wait(conn->u.rconn.rstream); dummy_packet_stream_wait(conn->rconn.rstream);
} }
break; break;
@ -612,7 +612,7 @@ dummy_netdev_get_conn_state(struct dummy_packet_conn *conn)
enum dummy_netdev_conn_state state; enum dummy_netdev_conn_state state;
if (conn->type == ACTIVE) { if (conn->type == ACTIVE) {
if (reconnect_is_connected(conn->u.rconn.reconnect)) { if (reconnect_is_connected(conn->rconn.reconnect)) {
state = CONN_STATE_CONNECTED; state = CONN_STATE_CONNECTED;
} else { } else {
state = CONN_STATE_NOT_CONNECTED; state = CONN_STATE_NOT_CONNECTED;

72
lib/ovsdb-data.c
View File

@ -262,16 +262,16 @@ unwrap_json(const struct json *json, const char *name,
enum json_type value_type, const struct json **value) enum json_type value_type, const struct json **value)
{ {
if (json->type != JSON_ARRAY if (json->type != JSON_ARRAY
|| json->u.array.n != 2 || json->array.n != 2
|| json->u.array.elems[0]->type != JSON_STRING || json->array.elems[0]->type != JSON_STRING
|| (name && strcmp(json->u.array.elems[0]->u.string, name)) || (name && strcmp(json->array.elems[0]->string, name))
|| json->u.array.elems[1]->type != value_type) || json->array.elems[1]->type != value_type)
{ {
*value = NULL; *value = NULL;
return ovsdb_syntax_error(json, NULL, "expected [\"%s\", <%s>]", name, return ovsdb_syntax_error(json, NULL, "expected [\"%s\", <%s>]", name,
json_type_to_string(value_type)); json_type_to_string(value_type));
} }
*value = json->u.array.elems[1]; *value = json->array.elems[1];
return NULL; return NULL;
} }
@ -279,11 +279,11 @@ static struct ovsdb_error *
parse_json_pair(const struct json *json, parse_json_pair(const struct json *json,
const struct json **elem0, const struct json **elem1) const struct json **elem0, const struct json **elem1)
{ {
if (json->type != JSON_ARRAY || json->u.array.n != 2) { if (json->type != JSON_ARRAY || json->array.n != 2) {
return ovsdb_syntax_error(json, NULL, "expected 2-element array"); return ovsdb_syntax_error(json, NULL, "expected 2-element array");
} }
*elem0 = json->u.array.elems[0]; *elem0 = json->array.elems[0];
*elem1 = json->u.array.elems[1]; *elem1 = json->array.elems[1];
return NULL; return NULL;
} }
@ -293,8 +293,8 @@ ovsdb_symbol_referenced(struct ovsdb_symbol *symbol,
{ {
ovs_assert(base->type == OVSDB_TYPE_UUID); ovs_assert(base->type == OVSDB_TYPE_UUID);
if (base->u.uuid.refTableName) { if (base->uuid.refTableName) {
switch (base->u.uuid.refType) { switch (base->uuid.refType) {
case OVSDB_REF_STRONG: case OVSDB_REF_STRONG:
symbol->strong_ref = true; symbol->strong_ref = true;
break; break;
@ -377,17 +377,17 @@ ovsdb_atom_from_json__(union ovsdb_atom *atom,
case OVSDB_TYPE_INTEGER: case OVSDB_TYPE_INTEGER:
if (json->type == JSON_INTEGER) { if (json->type == JSON_INTEGER) {
atom->integer = json->u.integer; atom->integer = json->integer;
return NULL; return NULL;
} }
break; break;
case OVSDB_TYPE_REAL: case OVSDB_TYPE_REAL:
if (json->type == JSON_INTEGER) { if (json->type == JSON_INTEGER) {
atom->real = json->u.integer; atom->real = json->integer;
return NULL; return NULL;
} else if (json->type == JSON_REAL) { } else if (json->type == JSON_REAL) {
atom->real = json->u.real; atom->real = json->real;
return NULL; return NULL;
} }
break; break;
@ -404,7 +404,7 @@ ovsdb_atom_from_json__(union ovsdb_atom *atom,
case OVSDB_TYPE_STRING: case OVSDB_TYPE_STRING:
if (json->type == JSON_STRING) { if (json->type == JSON_STRING) {
atom->string = xstrdup(json->u.string); atom->string = xstrdup(json->string);
return NULL; return NULL;
} }
break; break;
@ -720,7 +720,7 @@ ovsdb_atom_to_string(const union ovsdb_atom *atom, enum ovsdb_atomic_type type,
struct json json; struct json json;
json.type = JSON_STRING; json.type = JSON_STRING;
json.u.string = atom->string; json.string = atom->string;
json_to_ds(&json, 0, out); json_to_ds(&json, 0, out);
} else { } else {
ds_put_cstr(out, atom->string); ds_put_cstr(out, atom->string);
@ -817,54 +817,54 @@ ovsdb_atom_check_constraints(const union ovsdb_atom *atom,
OVS_NOT_REACHED(); OVS_NOT_REACHED();
case OVSDB_TYPE_INTEGER: case OVSDB_TYPE_INTEGER:
if (atom->integer >= base->u.integer.min if (atom->integer >= base->integer.min
&& atom->integer <= base->u.integer.max) { && atom->integer <= base->integer.max) {
return NULL; return NULL;
} else if (base->u.integer.min != INT64_MIN) { } else if (base->integer.min != INT64_MIN) {
if (base->u.integer.max != INT64_MAX) { if (base->integer.max != INT64_MAX) {
return ovsdb_error("constraint violation", return ovsdb_error("constraint violation",
"%"PRId64" is not in the valid range " "%"PRId64" is not in the valid range "
"%"PRId64" to %"PRId64" (inclusive)", "%"PRId64" to %"PRId64" (inclusive)",
atom->integer, atom->integer,
base->u.integer.min, base->u.integer.max); base->integer.min, base->integer.max);
} else { } else {
return ovsdb_error("constraint violation", return ovsdb_error("constraint violation",
"%"PRId64" is less than minimum allowed " "%"PRId64" is less than minimum allowed "
"value %"PRId64, "value %"PRId64,
atom->integer, base->u.integer.min); atom->integer, base->integer.min);
} }
} else { } else {
return ovsdb_error("constraint violation", return ovsdb_error("constraint violation",
"%"PRId64" is greater than maximum allowed " "%"PRId64" is greater than maximum allowed "
"value %"PRId64, "value %"PRId64,
atom->integer, base->u.integer.max); atom->integer, base->integer.max);
} }
OVS_NOT_REACHED(); OVS_NOT_REACHED();
case OVSDB_TYPE_REAL: case OVSDB_TYPE_REAL:
if (atom->real >= base->u.real.min && atom->real <= base->u.real.max) { if (atom->real >= base->real.min && atom->real <= base->real.max) {
return NULL; return NULL;
} else if (base->u.real.min != -DBL_MAX) { } else if (base->real.min != -DBL_MAX) {
if (base->u.real.max != DBL_MAX) { if (base->real.max != DBL_MAX) {
return ovsdb_error("constraint violation", return ovsdb_error("constraint violation",
"%.*g is not in the valid range " "%.*g is not in the valid range "
"%.*g to %.*g (inclusive)", "%.*g to %.*g (inclusive)",
DBL_DIG, atom->real, DBL_DIG, atom->real,
DBL_DIG, base->u.real.min, DBL_DIG, base->real.min,
DBL_DIG, base->u.real.max); DBL_DIG, base->real.max);
} else { } else {
return ovsdb_error("constraint violation", return ovsdb_error("constraint violation",
"%.*g is less than minimum allowed " "%.*g is less than minimum allowed "
"value %.*g", "value %.*g",
DBL_DIG, atom->real, DBL_DIG, atom->real,
DBL_DIG, base->u.real.min); DBL_DIG, base->real.min);
} }
} else { } else {
return ovsdb_error("constraint violation", return ovsdb_error("constraint violation",
"%.*g is greater than maximum allowed " "%.*g is greater than maximum allowed "
"value %.*g", "value %.*g",
DBL_DIG, atom->real, DBL_DIG, atom->real,
DBL_DIG, base->u.real.max); DBL_DIG, base->real.max);
} }
OVS_NOT_REACHED(); OVS_NOT_REACHED();
@ -872,7 +872,7 @@ ovsdb_atom_check_constraints(const union ovsdb_atom *atom,
return NULL; return NULL;
case OVSDB_TYPE_STRING: case OVSDB_TYPE_STRING:
return check_string_constraints(atom->string, &base->u.string); return check_string_constraints(atom->string, &base->string);
case OVSDB_TYPE_UUID: case OVSDB_TYPE_UUID:
return NULL; return NULL;
@ -1218,9 +1218,9 @@ ovsdb_datum_from_json__(struct ovsdb_datum *datum,
if (ovsdb_type_is_map(type) if (ovsdb_type_is_map(type)
|| (json->type == JSON_ARRAY || (json->type == JSON_ARRAY
&& json->u.array.n > 0 && json->array.n > 0
&& json->u.array.elems[0]->type == JSON_STRING && json->array.elems[0]->type == JSON_STRING
&& !strcmp(json->u.array.elems[0]->u.string, "set"))) { && !strcmp(json->array.elems[0]->string, "set"))) {
bool is_map = ovsdb_type_is_map(type); bool is_map = ovsdb_type_is_map(type);
const char *class = is_map ? "map" : "set"; const char *class = is_map ? "map" : "set";
const struct json *inner; const struct json *inner;
@ -1232,7 +1232,7 @@ ovsdb_datum_from_json__(struct ovsdb_datum *datum,
return error; return error;
} }
n = inner->u.array.n; n = inner->array.n;
if (n < type->n_min || n > type->n_max) { if (n < type->n_min || n > type->n_max) {
return ovsdb_syntax_error(json, NULL, "%s must have %u to " return ovsdb_syntax_error(json, NULL, "%s must have %u to "
"%u members but %"PRIuSIZE" are present", "%u members but %"PRIuSIZE" are present",
@ -1243,7 +1243,7 @@ ovsdb_datum_from_json__(struct ovsdb_datum *datum,
datum->keys = xmalloc(n * sizeof *datum->keys); datum->keys = xmalloc(n * sizeof *datum->keys);
datum->values = is_map ? xmalloc(n * sizeof *datum->values) : NULL; datum->values = is_map ? xmalloc(n * sizeof *datum->values) : NULL;
for (i = 0; i < n; i++) { for (i = 0; i < n; i++) {
const struct json *element = inner->u.array.elems[i]; const struct json *element = inner->array.elems[i];
const struct json *key = NULL; const struct json *key = NULL;
const struct json *value = NULL; const struct json *value = NULL;
@ -1365,7 +1365,7 @@ ovsdb_base_to_json(const union ovsdb_atom *atom,
{ {
if (!use_row_names if (!use_row_names
|| base->type != OVSDB_TYPE_UUID || base->type != OVSDB_TYPE_UUID
|| !base->u.uuid.refTableName) { || !base->uuid.refTableName) {
return ovsdb_atom_to_json(atom, base->type); return ovsdb_atom_to_json(atom, base->type);
} else { } else {
return json_array_create_2( return json_array_create_2(

58
lib/ovsdb-idl.c
View File

@ -995,7 +995,7 @@ add_row_references(const struct ovsdb_base_type *type,
struct uuid **dstsp, size_t *n_dstsp, struct uuid **dstsp, size_t *n_dstsp,
size_t *allocated_dstsp) size_t *allocated_dstsp)
{ {
if (type->type != OVSDB_TYPE_UUID || !type->u.uuid.refTableName) { if (type->type != OVSDB_TYPE_UUID || !type->uuid.refTableName) {
return; return;
} }
@ -1123,15 +1123,15 @@ ovsdb_idl_db_get_mode(struct ovsdb_idl_db *db,
static void static void
add_ref_table(struct ovsdb_idl_db *db, const struct ovsdb_base_type *base) add_ref_table(struct ovsdb_idl_db *db, const struct ovsdb_base_type *base)
{ {
if (base->type == OVSDB_TYPE_UUID && base->u.uuid.refTableName) { if (base->type == OVSDB_TYPE_UUID && base->uuid.refTableName) {
struct ovsdb_idl_table *table; struct ovsdb_idl_table *table;
table = shash_find_data(&db->table_by_name, base->u.uuid.refTableName); table = shash_find_data(&db->table_by_name, base->uuid.refTableName);
if (table) { if (table) {
table->need_table = true; table->need_table = true;
} else { } else {
VLOG_WARN("%s IDL class missing referenced table %s", VLOG_WARN("%s IDL class missing referenced table %s",
db->class_->database, base->u.uuid.refTableName); db->class_->database, base->uuid.refTableName);
} }
} }
} }
@ -1993,9 +1993,9 @@ ovsdb_idl_db_parse_update_rpc(struct ovsdb_idl_db *db,
bool is_update2 = !strcmp(msg->method, "update2"); bool is_update2 = !strcmp(msg->method, "update2");
if ((is_update || is_update2) if ((is_update || is_update2)
&& msg->params->type == JSON_ARRAY && msg->params->type == JSON_ARRAY
&& msg->params->u.array.n == 2 && msg->params->array.n == 2
&& json_equal(msg->params->u.array.elems[0], db->monitor_id)) { && json_equal(msg->params->array.elems[0], db->monitor_id)) {
ovsdb_idl_db_parse_update(db, msg->params->u.array.elems[1], ovsdb_idl_db_parse_update(db, msg->params->array.elems[1],
is_update2); is_update2);
return true; return true;
} }
@ -2011,8 +2011,8 @@ ovsdb_idl_handle_monitor_canceled(struct ovsdb_idl *idl,
if (msg->type != JSONRPC_NOTIFY if (msg->type != JSONRPC_NOTIFY
|| strcmp(msg->method, "monitor_canceled") || strcmp(msg->method, "monitor_canceled")
|| msg->params->type != JSON_ARRAY || msg->params->type != JSON_ARRAY
|| msg->params->u.array.n != 1 || msg->params->array.n != 1
|| !json_equal(msg->params->u.array.elems[0], db->monitor_id)) { || !json_equal(msg->params->array.elems[0], db->monitor_id)) {
return false; return false;
} }
@ -3549,11 +3549,11 @@ substitute_uuids(struct json *json, const struct ovsdb_idl_txn *txn)
struct uuid uuid; struct uuid uuid;
size_t i; size_t i;
if (json->u.array.n == 2 if (json->array.n == 2
&& json->u.array.elems[0]->type == JSON_STRING && json->array.elems[0]->type == JSON_STRING
&& json->u.array.elems[1]->type == JSON_STRING && json->array.elems[1]->type == JSON_STRING
&& !strcmp(json->u.array.elems[0]->u.string, "uuid") && !strcmp(json->array.elems[0]->string, "uuid")
&& uuid_from_string(&uuid, json->u.array.elems[1]->u.string)) { && uuid_from_string(&uuid, json->array.elems[1]->string)) {
const struct ovsdb_idl_row *row; const struct ovsdb_idl_row *row;
row = ovsdb_idl_txn_get_row(txn, &uuid); row = ovsdb_idl_txn_get_row(txn, &uuid);
@ -3566,8 +3566,8 @@ substitute_uuids(struct json *json, const struct ovsdb_idl_txn *txn)
} }
} }
for (i = 0; i < json->u.array.n; i++) { for (i = 0; i < json->array.n; i++) {
json->u.array.elems[i] = substitute_uuids(json->u.array.elems[i], json->array.elems[i] = substitute_uuids(json->array.elems[i],
txn); txn);
} }
} else if (json->type == JSON_OBJECT) { } else if (json->type == JSON_OBJECT) {
@ -3981,7 +3981,7 @@ ovsdb_idl_txn_commit(struct ovsdb_idl_txn *txn)
insert = xmalloc(sizeof *insert); insert = xmalloc(sizeof *insert);
insert->dummy = row->uuid; insert->dummy = row->uuid;
insert->op_index = operations->u.array.n - 1; insert->op_index = operations->array.n - 1;
uuid_zero(&insert->real); uuid_zero(&insert->real);
hmap_insert(&txn->inserted_rows, &insert->hmap_node, hmap_insert(&txn->inserted_rows, &insert->hmap_node,
uuid_hash(&insert->dummy)); uuid_hash(&insert->dummy));
@ -4051,7 +4051,7 @@ ovsdb_idl_txn_commit(struct ovsdb_idl_txn *txn)
/* Add increment. */ /* Add increment. */
if (txn->inc_table && (any_updates || txn->inc_force)) { if (txn->inc_table && (any_updates || txn->inc_force)) {
any_updates = true; any_updates = true;
txn->inc_index = operations->u.array.n - 1; txn->inc_index = operations->array.n - 1;
struct json *op = json_object_create(); struct json *op = json_object_create();
json_object_put_string(op, "op", "mutate"); json_object_put_string(op, "op", "mutate");
@ -4544,10 +4544,10 @@ ovsdb_idl_txn_process_inc_reply(struct ovsdb_idl_txn *txn,
if (!check_json_type(count, JSON_INTEGER, "\"mutate\" reply \"count\"")) { if (!check_json_type(count, JSON_INTEGER, "\"mutate\" reply \"count\"")) {
return false; return false;
} }
if (count->u.integer != 1) { if (count->integer != 1) {
VLOG_WARN_RL(&syntax_rl, VLOG_WARN_RL(&syntax_rl,
"\"mutate\" reply \"count\" is %lld instead of 1", "\"mutate\" reply \"count\" is %lld instead of 1",
count->u.integer); count->integer);
return false; return false;
} }
@ -4556,13 +4556,13 @@ ovsdb_idl_txn_process_inc_reply(struct ovsdb_idl_txn *txn,
if (!check_json_type(rows, JSON_ARRAY, "\"select\" reply \"rows\"")) { if (!check_json_type(rows, JSON_ARRAY, "\"select\" reply \"rows\"")) {
return false; return false;
} }
if (rows->u.array.n != 1) { if (rows->array.n != 1) {
VLOG_WARN_RL(&syntax_rl, "\"select\" reply \"rows\" has %"PRIuSIZE" elements " VLOG_WARN_RL(&syntax_rl, "\"select\" reply \"rows\" has %"PRIuSIZE" elements "
"instead of 1", "instead of 1",
rows->u.array.n); rows->array.n);
return false; return false;
} }
row = rows->u.array.elems[0]; row = rows->array.elems[0];
if (!check_json_type(row, JSON_OBJECT, "\"select\" reply row")) { if (!check_json_type(row, JSON_OBJECT, "\"select\" reply row")) {
return false; return false;
} }
@ -4571,7 +4571,7 @@ ovsdb_idl_txn_process_inc_reply(struct ovsdb_idl_txn *txn,
"\"select\" reply inc column")) { "\"select\" reply inc column")) {
return false; return false;
} }
txn->inc_new_value = column->u.integer; txn->inc_new_value = column->integer;
return true; return true;
} }
@ -4643,7 +4643,7 @@ ovsdb_idl_db_txn_process_reply(struct ovsdb_idl_db *db,
status = TXN_ERROR; status = TXN_ERROR;
ovsdb_idl_txn_set_error_json(txn, msg->result); ovsdb_idl_txn_set_error_json(txn, msg->result);
} else { } else {
struct json_array *ops = &msg->result->u.array; struct json_array *ops = &msg->result->array;
int hard_errors = 0; int hard_errors = 0;
int soft_errors = 0; int soft_errors = 0;
int lock_errors = 0; int lock_errors = 0;
@ -4662,14 +4662,14 @@ ovsdb_idl_db_txn_process_reply(struct ovsdb_idl_db *db,
error = shash_find_data(json_object(op), "error"); error = shash_find_data(json_object(op), "error");
if (error) { if (error) {
if (error->type == JSON_STRING) { if (error->type == JSON_STRING) {
if (!strcmp(error->u.string, "timed out")) { if (!strcmp(error->string, "timed out")) {
soft_errors++; soft_errors++;
} else if (!strcmp(error->u.string, "not owner")) { } else if (!strcmp(error->string, "not owner")) {
lock_errors++; lock_errors++;
} else if (!strcmp(error->u.string, "not allowed")) { } else if (!strcmp(error->string, "not allowed")) {
hard_errors++; hard_errors++;
ovsdb_idl_txn_set_error_json(txn, op); ovsdb_idl_txn_set_error_json(txn, op);
} else if (strcmp(error->u.string, "aborted")) { } else if (strcmp(error->string, "aborted")) {
hard_errors++; hard_errors++;
ovsdb_idl_txn_set_error_json(txn, op); ovsdb_idl_txn_set_error_json(txn, op);
VLOG_WARN_RL(&other_rl, VLOG_WARN_RL(&other_rl,

2
lib/ovsdb-parser.c
View File

@ -83,7 +83,7 @@ ovsdb_parser_member(struct ovsdb_parser *parser, const char *name,
if (((int) value->type >= 0 && value->type < JSON_N_TYPES if (((int) value->type >= 0 && value->type < JSON_N_TYPES
&& types & (1u << value->type)) && types & (1u << value->type))
|| (types & OP_ID && value->type == JSON_STRING || (types & OP_ID && value->type == JSON_STRING
&& ovsdb_parser_is_id(value->u.string))) && ovsdb_parser_is_id(value->string)))
{ {
sset_add(&parser->used, name); sset_add(&parser->used, name);
return value; return value;

108
lib/ovsdb-types.c
View File

@ -125,26 +125,26 @@ ovsdb_base_type_init(struct ovsdb_base_type *base, enum ovsdb_atomic_type type)
break; break;
case OVSDB_TYPE_INTEGER: case OVSDB_TYPE_INTEGER:
base->u.integer.min = INT64_MIN; base->integer.min = INT64_MIN;
base->u.integer.max = INT64_MAX; base->integer.max = INT64_MAX;
break; break;
case OVSDB_TYPE_REAL: case OVSDB_TYPE_REAL:
base->u.real.min = -DBL_MAX; base->real.min = -DBL_MAX;
base->u.real.max = DBL_MAX; base->real.max = DBL_MAX;
break; break;
case OVSDB_TYPE_BOOLEAN: case OVSDB_TYPE_BOOLEAN:
break; break;
case OVSDB_TYPE_STRING: case OVSDB_TYPE_STRING:
base->u.string.minLen = 0; base->string.minLen = 0;
base->u.string.maxLen = UINT_MAX; base->string.maxLen = UINT_MAX;
break; break;
case OVSDB_TYPE_UUID: case OVSDB_TYPE_UUID:
base->u.uuid.refTableName = NULL; base->uuid.refTableName = NULL;
base->u.uuid.refTable = NULL; base->uuid.refTable = NULL;
break; break;
case OVSDB_N_TYPES: case OVSDB_N_TYPES:
@ -204,8 +204,8 @@ ovsdb_base_type_clone(struct ovsdb_base_type *dst,
break; break;
case OVSDB_TYPE_UUID: case OVSDB_TYPE_UUID:
if (dst->u.uuid.refTableName) { if (dst->uuid.refTableName) {
dst->u.uuid.refTableName = xstrdup(dst->u.uuid.refTableName); dst->uuid.refTableName = xstrdup(dst->uuid.refTableName);
} }
break; break;
@ -236,7 +236,7 @@ ovsdb_base_type_destroy(struct ovsdb_base_type *base)
break; break;
case OVSDB_TYPE_UUID: case OVSDB_TYPE_UUID:
free(base->u.uuid.refTableName); free(base->uuid.refTableName);
break; break;
case OVSDB_N_TYPES: case OVSDB_N_TYPES:
@ -256,16 +256,16 @@ ovsdb_base_type_is_valid(const struct ovsdb_base_type *base)
return true; return true;
case OVSDB_TYPE_INTEGER: case OVSDB_TYPE_INTEGER:
return base->u.integer.min <= base->u.integer.max; return base->integer.min <= base->integer.max;
case OVSDB_TYPE_REAL: case OVSDB_TYPE_REAL:
return base->u.real.min <= base->u.real.max; return base->real.min <= base->real.max;
case OVSDB_TYPE_BOOLEAN: case OVSDB_TYPE_BOOLEAN:
return true; return true;
case OVSDB_TYPE_STRING: case OVSDB_TYPE_STRING:
return base->u.string.minLen <= base->u.string.maxLen; return base->string.minLen <= base->string.maxLen;
case OVSDB_TYPE_UUID: case OVSDB_TYPE_UUID:
return true; return true;
@ -288,21 +288,21 @@ ovsdb_base_type_has_constraints(const struct ovsdb_base_type *base)
OVS_NOT_REACHED(); OVS_NOT_REACHED();
case OVSDB_TYPE_INTEGER: case OVSDB_TYPE_INTEGER:
return (base->u.integer.min != INT64_MIN return (base->integer.min != INT64_MIN
|| base->u.integer.max != INT64_MAX); || base->integer.max != INT64_MAX);
case OVSDB_TYPE_REAL: case OVSDB_TYPE_REAL:
return (base->u.real.min != -DBL_MAX return (base->real.min != -DBL_MAX
|| base->u.real.max != DBL_MAX); || base->real.max != DBL_MAX);
case OVSDB_TYPE_BOOLEAN: case OVSDB_TYPE_BOOLEAN:
return false; return false;
case OVSDB_TYPE_STRING: case OVSDB_TYPE_STRING:
return base->u.string.minLen != 0 || base->u.string.maxLen != UINT_MAX; return base->string.minLen != 0 || base->string.maxLen != UINT_MAX;
case OVSDB_TYPE_UUID: case OVSDB_TYPE_UUID:
return base->u.uuid.refTableName != NULL; return base->uuid.refTableName != NULL;
case OVSDB_N_TYPES: case OVSDB_N_TYPES:
OVS_NOT_REACHED(); OVS_NOT_REACHED();
@ -328,12 +328,12 @@ parse_optional_uint(struct ovsdb_parser *parser, const char *member,
json = ovsdb_parser_member(parser, member, OP_INTEGER | OP_OPTIONAL); json = ovsdb_parser_member(parser, member, OP_INTEGER | OP_OPTIONAL);
if (json) { if (json) {
if (json->u.integer < 0 || json->u.integer > UINT_MAX) { if (json->integer < 0 || json->integer > UINT_MAX) {
return ovsdb_syntax_error(json, NULL, return ovsdb_syntax_error(json, NULL,
"%s out of valid range 0 to %u", "%s out of valid range 0 to %u",
member, UINT_MAX); member, UINT_MAX);
} }
*uint = json->u.integer; *uint = json->integer;
} }
return NULL; return NULL;
} }
@ -387,9 +387,9 @@ ovsdb_base_type_from_json(struct ovsdb_base_type *base,
OP_INTEGER | OP_OPTIONAL); OP_INTEGER | OP_OPTIONAL);
max = ovsdb_parser_member(&parser, "maxInteger", max = ovsdb_parser_member(&parser, "maxInteger",
OP_INTEGER | OP_OPTIONAL); OP_INTEGER | OP_OPTIONAL);
base->u.integer.min = min ? min->u.integer : INT64_MIN; base->integer.min = min ? min->integer : INT64_MIN;
base->u.integer.max = max ? max->u.integer : INT64_MAX; base->integer.max = max ? max->integer : INT64_MAX;
if (base->u.integer.min > base->u.integer.max) { if (base->integer.min > base->integer.max) {
error = ovsdb_syntax_error(json, NULL, error = ovsdb_syntax_error(json, NULL,
"minInteger exceeds maxInteger"); "minInteger exceeds maxInteger");
} }
@ -398,21 +398,21 @@ ovsdb_base_type_from_json(struct ovsdb_base_type *base,
min = ovsdb_parser_member(&parser, "minReal", OP_NUMBER | OP_OPTIONAL); min = ovsdb_parser_member(&parser, "minReal", OP_NUMBER | OP_OPTIONAL);
max = ovsdb_parser_member(&parser, "maxReal", OP_NUMBER | OP_OPTIONAL); max = ovsdb_parser_member(&parser, "maxReal", OP_NUMBER | OP_OPTIONAL);
base->u.real.min = min ? json_real(min) : -DBL_MAX; base->real.min = min ? json_real(min) : -DBL_MAX;
base->u.real.max = max ? json_real(max) : DBL_MAX; base->real.max = max ? json_real(max) : DBL_MAX;
if (base->u.real.min > base->u.real.max) { if (base->real.min > base->real.max) {
error = ovsdb_syntax_error(json, NULL, "minReal exceeds maxReal"); error = ovsdb_syntax_error(json, NULL, "minReal exceeds maxReal");
} }
} else if (base->type == OVSDB_TYPE_STRING) { } else if (base->type == OVSDB_TYPE_STRING) {
if (!error) { if (!error) {
error = parse_optional_uint(&parser, "minLength", error = parse_optional_uint(&parser, "minLength",
&base->u.string.minLen); &base->string.minLen);
} }
if (!error) { if (!error) {
error = parse_optional_uint(&parser, "maxLength", error = parse_optional_uint(&parser, "maxLength",
&base->u.string.maxLen); &base->string.maxLen);
} }
if (!error && base->u.string.minLen > base->u.string.maxLen) { if (!error && base->string.minLen > base->string.maxLen) {
error = ovsdb_syntax_error(json, NULL, error = ovsdb_syntax_error(json, NULL,
"minLength exceeds maxLength"); "minLength exceeds maxLength");
} }
@ -424,9 +424,9 @@ ovsdb_base_type_from_json(struct ovsdb_base_type *base,
if (refTable) { if (refTable) {
const struct json *refType; const struct json *refType;
base->u.uuid.refTableName = xstrdup(refTable->u.string); base->uuid.refTableName = xstrdup(refTable->string);
/* We can't set base->u.uuid.refTable here because we don't have /* We can't set base->uuid.refTable here because we don't have
* enough context (we might not even be running in ovsdb-server). * enough context (we might not even be running in ovsdb-server).
* ovsdb_create() will set refTable later. */ * ovsdb_create() will set refTable later. */
@ -435,16 +435,16 @@ ovsdb_base_type_from_json(struct ovsdb_base_type *base,
if (refType) { if (refType) {
const char *refType_s = json_string(refType); const char *refType_s = json_string(refType);
if (!strcmp(refType_s, "strong")) { if (!strcmp(refType_s, "strong")) {
base->u.uuid.refType = OVSDB_REF_STRONG; base->uuid.refType = OVSDB_REF_STRONG;
} else if (!strcmp(refType_s, "weak")) { } else if (!strcmp(refType_s, "weak")) {
base->u.uuid.refType = OVSDB_REF_WEAK; base->uuid.refType = OVSDB_REF_WEAK;
} else { } else {
error = ovsdb_syntax_error(json, NULL, "refType must be " error = ovsdb_syntax_error(json, NULL, "refType must be "
"\"strong\" or \"weak\" (not " "\"strong\" or \"weak\" (not "
"\"%s\")", refType_s); "\"%s\")", refType_s);
} }
} else { } else {
base->u.uuid.refType = OVSDB_REF_STRONG; base->uuid.refType = OVSDB_REF_STRONG;
} }
} }
} }
@ -486,24 +486,24 @@ ovsdb_base_type_to_json(const struct ovsdb_base_type *base)
OVS_NOT_REACHED(); OVS_NOT_REACHED();
case OVSDB_TYPE_INTEGER: case OVSDB_TYPE_INTEGER:
if (base->u.integer.min != INT64_MIN) { if (base->integer.min != INT64_MIN) {
json_object_put(json, "minInteger", json_object_put(json, "minInteger",
json_integer_create(base->u.integer.min)); json_integer_create(base->integer.min));
} }
if (base->u.integer.max != INT64_MAX) { if (base->integer.max != INT64_MAX) {
json_object_put(json, "maxInteger", json_object_put(json, "maxInteger",
json_integer_create(base->u.integer.max)); json_integer_create(base->integer.max));
} }
break; break;
case OVSDB_TYPE_REAL: case OVSDB_TYPE_REAL:
if (base->u.real.min != -DBL_MAX) { if (base->real.min != -DBL_MAX) {
json_object_put(json, "minReal", json_object_put(json, "minReal",
json_real_create(base->u.real.min)); json_real_create(base->real.min));
} }
if (base->u.real.max != DBL_MAX) { if (base->real.max != DBL_MAX) {
json_object_put(json, "maxReal", json_object_put(json, "maxReal",
json_real_create(base->u.real.max)); json_real_create(base->real.max));
} }
break; break;
@ -511,21 +511,21 @@ ovsdb_base_type_to_json(const struct ovsdb_base_type *base)
break; break;
case OVSDB_TYPE_STRING: case OVSDB_TYPE_STRING:
if (base->u.string.minLen != 0) { if (base->string.minLen != 0) {
json_object_put(json, "minLength", json_object_put(json, "minLength",
json_integer_create(base->u.string.minLen)); json_integer_create(base->string.minLen));
} }
if (base->u.string.maxLen != UINT_MAX) { if (base->string.maxLen != UINT_MAX) {
json_object_put(json, "maxLength", json_object_put(json, "maxLength",
json_integer_create(base->u.string.maxLen)); json_integer_create(base->string.maxLen));
} }
break; break;
case OVSDB_TYPE_UUID: case OVSDB_TYPE_UUID:
if (base->u.uuid.refTableName) { if (base->uuid.refTableName) {
json_object_put_string(json, "refTable", json_object_put_string(json, "refTable",
base->u.uuid.refTableName); base->uuid.refTableName);
if (base->u.uuid.refType == OVSDB_REF_WEAK) { if (base->uuid.refType == OVSDB_REF_WEAK) {
json_object_put_string(json, "refType", "weak"); json_object_put_string(json, "refType", "weak");
} }
} }
@ -575,8 +575,8 @@ n_from_json(const struct json *json, unsigned int *n)
if (!json) { if (!json) {
return NULL; return NULL;
} else if (json->type == JSON_INTEGER } else if (json->type == JSON_INTEGER
&& json->u.integer >= 0 && json->u.integer < UINT_MAX) { && json->integer >= 0 && json->integer < UINT_MAX) {
*n = json->u.integer; *n = json->integer;
return NULL; return NULL;
} else { } else {
return ovsdb_syntax_error(json, NULL, "bad min or max value"); return ovsdb_syntax_error(json, NULL, "bad min or max value");
@ -657,7 +657,7 @@ ovsdb_type_from_json(struct ovsdb_type *type, const struct json *json)
} }
if (max && max->type == JSON_STRING if (max && max->type == JSON_STRING
&& !strcmp(max->u.string, "unlimited")) { && !strcmp(max->string, "unlimited")) {
type->n_max = UINT_MAX; type->n_max = UINT_MAX;
} else { } else {
error = n_from_json(max, &type->n_max); error = n_from_json(max, &type->n_max);

16
lib/ovsdb-types.h
View File

@ -83,19 +83,19 @@ struct ovsdb_base_type {
struct ovsdb_table *refTable; /* Referenced table, if available. */ struct ovsdb_table *refTable; /* Referenced table, if available. */
enum ovsdb_ref_type refType; /* Reference type. */ enum ovsdb_ref_type refType; /* Reference type. */
} uuid; } uuid;
} u; };
}; };
#define OVSDB_BASE_VOID_INIT { .type = OVSDB_TYPE_VOID } #define OVSDB_BASE_VOID_INIT { .type = OVSDB_TYPE_VOID }
#define OVSDB_BASE_INTEGER_INIT { .type = OVSDB_TYPE_INTEGER, \ #define OVSDB_BASE_INTEGER_INIT { .type = OVSDB_TYPE_INTEGER, \
.u.integer = { INT64_MIN, INT64_MAX } } .integer = { INT64_MIN, INT64_MAX } }
#define OVSDB_BASE_REAL_INIT { .type = OVSDB_TYPE_REAL, \ #define OVSDB_BASE_REAL_INIT { .type = OVSDB_TYPE_REAL, \
.u.real = { -DBL_MAX, DBL_MAX } } .real = { -DBL_MAX, DBL_MAX } }
#define OVSDB_BASE_BOOLEAN_INIT { .type = OVSDB_TYPE_BOOLEAN } #define OVSDB_BASE_BOOLEAN_INIT { .type = OVSDB_TYPE_BOOLEAN }
#define OVSDB_BASE_STRING_INIT { .type = OVSDB_TYPE_STRING, \ #define OVSDB_BASE_STRING_INIT { .type = OVSDB_TYPE_STRING, \
.u.string = { 0, UINT_MAX } } .string = { 0, UINT_MAX } }
#define OVSDB_BASE_UUID_INIT { .type = OVSDB_TYPE_UUID, \ #define OVSDB_BASE_UUID_INIT { .type = OVSDB_TYPE_UUID, \
.u.uuid = { NULL, NULL, 0 } } .uuid = { NULL, NULL, 0 } }
void ovsdb_base_type_init(struct ovsdb_base_type *, enum ovsdb_atomic_type); void ovsdb_base_type_init(struct ovsdb_base_type *, enum ovsdb_atomic_type);
void ovsdb_base_type_clone(struct ovsdb_base_type *, void ovsdb_base_type_clone(struct ovsdb_base_type *,
@ -180,21 +180,21 @@ ovsdb_atomic_type_is_valid(enum ovsdb_atomic_type atomic_type)
static inline bool static inline bool
ovsdb_base_type_is_ref(const struct ovsdb_base_type *base) ovsdb_base_type_is_ref(const struct ovsdb_base_type *base)
{ {
return base->type == OVSDB_TYPE_UUID && base->u.uuid.refTableName; return base->type == OVSDB_TYPE_UUID && base->uuid.refTableName;
} }
static inline bool static inline bool
ovsdb_base_type_is_strong_ref(const struct ovsdb_base_type *base) ovsdb_base_type_is_strong_ref(const struct ovsdb_base_type *base)
{ {
return (ovsdb_base_type_is_ref(base) return (ovsdb_base_type_is_ref(base)
&& base->u.uuid.refType == OVSDB_REF_STRONG); && base->uuid.refType == OVSDB_REF_STRONG);
} }
static inline bool static inline bool
ovsdb_base_type_is_weak_ref(const struct ovsdb_base_type *base) ovsdb_base_type_is_weak_ref(const struct ovsdb_base_type *base)
{ {
return (ovsdb_base_type_is_ref(base) return (ovsdb_base_type_is_ref(base)
&& base->u.uuid.refType == OVSDB_REF_WEAK); && base->uuid.refType == OVSDB_REF_WEAK);
} }
static inline bool ovsdb_type_is_scalar(const struct ovsdb_type *type) static inline bool ovsdb_type_is_scalar(const struct ovsdb_type *type)

66
ofproto/ofproto-dpif-upcall.c
View File

@ -1553,15 +1553,15 @@ handle_upcalls(struct udpif *udpif, struct upcall *upcalls,
op = &ops[n_ops++]; op = &ops[n_ops++];
op->ukey = NULL; op->ukey = NULL;
op->dop.type = DPIF_OP_EXECUTE; op->dop.type = DPIF_OP_EXECUTE;
op->dop.u.execute.packet = CONST_CAST(struct dp_packet *, packet); op->dop.execute.packet = CONST_CAST(struct dp_packet *, packet);
op->dop.u.execute.flow = upcall->flow; op->dop.execute.flow = upcall->flow;
odp_key_to_dp_packet(upcall->key, upcall->key_len, odp_key_to_dp_packet(upcall->key, upcall->key_len,
op->dop.u.execute.packet); op->dop.execute.packet);
op->dop.u.execute.actions = upcall->odp_actions.data; op->dop.execute.actions = upcall->odp_actions.data;
op->dop.u.execute.actions_len = upcall->odp_actions.size; op->dop.execute.actions_len = upcall->odp_actions.size;
op->dop.u.execute.needs_help = (upcall->xout.slow & SLOW_ACTION) != 0; op->dop.execute.needs_help = (upcall->xout.slow & SLOW_ACTION) != 0;
op->dop.u.execute.probe = false; op->dop.execute.probe = false;
op->dop.u.execute.mtu = upcall->mru; op->dop.execute.mtu = upcall->mru;
} }
} }
@ -2265,12 +2265,12 @@ delete_op_init__(struct udpif *udpif, struct ukey_op *op,
{ {
op->ukey = NULL; op->ukey = NULL;
op->dop.type = DPIF_OP_FLOW_DEL; op->dop.type = DPIF_OP_FLOW_DEL;
op->dop.u.flow_del.key = flow->key; op->dop.flow_del.key = flow->key;
op->dop.u.flow_del.key_len = flow->key_len; op->dop.flow_del.key_len = flow->key_len;
op->dop.u.flow_del.ufid = flow->ufid_present ? &flow->ufid : NULL; op->dop.flow_del.ufid = flow->ufid_present ? &flow->ufid : NULL;
op->dop.u.flow_del.pmd_id = flow->pmd_id; op->dop.flow_del.pmd_id = flow->pmd_id;
op->dop.u.flow_del.stats = &op->stats; op->dop.flow_del.stats = &op->stats;
op->dop.u.flow_del.terse = udpif_use_ufid(udpif); op->dop.flow_del.terse = udpif_use_ufid(udpif);
} }
static void static void
@ -2278,12 +2278,12 @@ delete_op_init(struct udpif *udpif, struct ukey_op *op, struct udpif_key *ukey)
{ {
op->ukey = ukey; op->ukey = ukey;
op->dop.type = DPIF_OP_FLOW_DEL; op->dop.type = DPIF_OP_FLOW_DEL;
op->dop.u.flow_del.key = ukey->key; op->dop.flow_del.key = ukey->key;
op->dop.u.flow_del.key_len = ukey->key_len; op->dop.flow_del.key_len = ukey->key_len;
op->dop.u.flow_del.ufid = ukey->ufid_present ? &ukey->ufid : NULL; op->dop.flow_del.ufid = ukey->ufid_present ? &ukey->ufid : NULL;
op->dop.u.flow_del.pmd_id = ukey->pmd_id; op->dop.flow_del.pmd_id = ukey->pmd_id;
op->dop.u.flow_del.stats = &op->stats; op->dop.flow_del.stats = &op->stats;
op->dop.u.flow_del.terse = udpif_use_ufid(udpif); op->dop.flow_del.terse = udpif_use_ufid(udpif);
} }
static void static void
@ -2292,16 +2292,16 @@ put_op_init(struct ukey_op *op, struct udpif_key *ukey,
{ {
op->ukey = ukey; op->ukey = ukey;
op->dop.type = DPIF_OP_FLOW_PUT; op->dop.type = DPIF_OP_FLOW_PUT;
op->dop.u.flow_put.flags = flags; op->dop.flow_put.flags = flags;
op->dop.u.flow_put.key = ukey->key; op->dop.flow_put.key = ukey->key;
op->dop.u.flow_put.key_len = ukey->key_len; op->dop.flow_put.key_len = ukey->key_len;
op->dop.u.flow_put.mask = ukey->mask; op->dop.flow_put.mask = ukey->mask;
op->dop.u.flow_put.mask_len = ukey->mask_len; op->dop.flow_put.mask_len = ukey->mask_len;
op->dop.u.flow_put.ufid = ukey->ufid_present ? &ukey->ufid : NULL; op->dop.flow_put.ufid = ukey->ufid_present ? &ukey->ufid : NULL;
op->dop.u.flow_put.pmd_id = ukey->pmd_id; op->dop.flow_put.pmd_id = ukey->pmd_id;
op->dop.u.flow_put.stats = NULL; op->dop.flow_put.stats = NULL;
ukey_get_actions(ukey, &op->dop.u.flow_put.actions, ukey_get_actions(ukey, &op->dop.flow_put.actions,
&op->dop.u.flow_put.actions_len); &op->dop.flow_put.actions_len);
} }
/* Executes datapath operations 'ops' and attributes stats retrieved from the /* Executes datapath operations 'ops' and attributes stats retrieved from the
@ -2322,7 +2322,7 @@ push_dp_ops(struct udpif *udpif, struct ukey_op *ops, size_t n_ops)
struct ukey_op *op = &ops[i]; struct ukey_op *op = &ops[i];
struct dpif_flow_stats *push, *stats, push_buf; struct dpif_flow_stats *push, *stats, push_buf;
stats = op->dop.u.flow_del.stats; stats = op->dop.flow_del.stats;
push = &push_buf; push = &push_buf;
if (op->dop.type != DPIF_OP_FLOW_DEL) { if (op->dop.type != DPIF_OP_FLOW_DEL) {
@ -2353,8 +2353,8 @@ push_dp_ops(struct udpif *udpif, struct ukey_op *ops, size_t n_ops)
} }
if (push->n_packets || netflow_exists()) { if (push->n_packets || netflow_exists()) {
const struct nlattr *key = op->dop.u.flow_del.key; const struct nlattr *key = op->dop.flow_del.key;
size_t key_len = op->dop.u.flow_del.key_len; size_t key_len = op->dop.flow_del.key_len;
struct netflow *netflow; struct netflow *netflow;
struct reval_context ctx = { struct reval_context ctx = {
.netflow = &netflow, .netflow = &netflow,

12
ofproto/ofproto.c
View File

@ -152,7 +152,7 @@ struct learned_cookie {
/* In 'dead_cookies' list when removed from hmap. */ /* In 'dead_cookies' list when removed from hmap. */
struct ovs_list list_node; struct ovs_list list_node;
} u; };
/* Key. */ /* Key. */
ovs_be64 cookie OVS_GUARDED_BY(ofproto_mutex); ovs_be64 cookie OVS_GUARDED_BY(ofproto_mutex);
@ -3099,14 +3099,14 @@ learned_cookies_update_one__(struct ofproto *ofproto,
uint32_t hash = hash_learned_cookie(learn->cookie, learn->table_id); uint32_t hash = hash_learned_cookie(learn->cookie, learn->table_id);
struct learned_cookie *c; struct learned_cookie *c;
HMAP_FOR_EACH_WITH_HASH (c, u.hmap_node, hash, &ofproto->learned_cookies) { HMAP_FOR_EACH_WITH_HASH (c, hmap_node, hash, &ofproto->learned_cookies) {
if (c->cookie == learn->cookie && c->table_id == learn->table_id) { if (c->cookie == learn->cookie && c->table_id == learn->table_id) {
c->n += delta; c->n += delta;
ovs_assert(c->n >= 0); ovs_assert(c->n >= 0);
if (!c->n) { if (!c->n) {
hmap_remove(&ofproto->learned_cookies, &c->u.hmap_node); hmap_remove(&ofproto->learned_cookies, &c->hmap_node);
ovs_list_push_back(dead_cookies, &c->u.list_node); ovs_list_push_back(dead_cookies, &c->list_node);
} }
return; return;
@ -3115,7 +3115,7 @@ learned_cookies_update_one__(struct ofproto *ofproto,
ovs_assert(delta > 0); ovs_assert(delta > 0);
c = xmalloc(sizeof *c); c = xmalloc(sizeof *c);
hmap_insert(&ofproto->learned_cookies, &c->u.hmap_node, hash); hmap_insert(&ofproto->learned_cookies, &c->hmap_node, hash);
c->cookie = learn->cookie; c->cookie = learn->cookie;
c->table_id = learn->table_id; c->table_id = learn->table_id;
c->n = delta; c->n = delta;
@ -3183,7 +3183,7 @@ learned_cookies_flush(struct ofproto *ofproto, struct ovs_list *dead_cookies)
struct minimatch match; struct minimatch match;
minimatch_init_catchall(&match); minimatch_init_catchall(&match);
LIST_FOR_EACH_POP (c, u.list_node, dead_cookies) { LIST_FOR_EACH_POP (c, list_node, dead_cookies) {
struct rule_criteria criteria; struct rule_criteria criteria;
struct rule_collection rules; struct rule_collection rules;
rule_criteria_init(&criteria, c->table_id, &match, 0, OVS_VERSION_MAX, rule_criteria_init(&criteria, c->table_id, &match, 0, OVS_VERSION_MAX,

6
ovsdb/column.c
View File

@ -165,15 +165,15 @@ ovsdb_column_set_from_json(const struct json *json,
} }
/* XXX this is O(n**2) */ /* XXX this is O(n**2) */
for (i = 0; i < json->u.array.n; i++) { for (i = 0; i < json->array.n; i++) {
const struct ovsdb_column *column; const struct ovsdb_column *column;
const char *s; const char *s;
if (json->u.array.elems[i]->type != JSON_STRING) { if (json->array.elems[i]->type != JSON_STRING) {
goto error; goto error;
} }
s = json->u.array.elems[i]->u.string; s = json->array.elems[i]->string;
column = shash_find_data(&schema->columns, s); column = shash_find_data(&schema->columns, s);
if (!column) { if (!column) {
error = ovsdb_syntax_error(json, NULL, "%s is not a valid " error = ovsdb_syntax_error(json, NULL, "%s is not a valid "

6
ovsdb/condition.c
View File

@ -81,9 +81,9 @@ ovsdb_clause_from_json(const struct ovsdb_table_schema *ts,
} }
if (json->type != JSON_ARRAY if (json->type != JSON_ARRAY
|| json->u.array.n != 3 || json->array.n != 3
|| json->u.array.elems[0]->type != JSON_STRING || json->array.elems[0]->type != JSON_STRING
|| json->u.array.elems[1]->type != JSON_STRING) { || json->array.elems[1]->type != JSON_STRING) {
return ovsdb_syntax_error(json, NULL, "Parse error in condition."); return ovsdb_syntax_error(json, NULL, "Parse error in condition.");
} }
array = json_array(json); array = json_array(json);

14
ovsdb/execution.c
View File

@ -121,9 +121,9 @@ ovsdb_execute_compose(struct ovsdb *db, const struct ovsdb_session *session,
*durable = false; *durable = false;
if (params->type != JSON_ARRAY if (params->type != JSON_ARRAY
|| !params->u.array.n || !params->array.n
|| params->u.array.elems[0]->type != JSON_STRING || params->array.elems[0]->type != JSON_STRING
|| strcmp(params->u.array.elems[0]->u.string, db->schema->name)) { || strcmp(params->array.elems[0]->string, db->schema->name)) {
if (params->type != JSON_ARRAY) { if (params->type != JSON_ARRAY) {
error = ovsdb_syntax_error(params, NULL, "array expected"); error = ovsdb_syntax_error(params, NULL, "array expected");
} else { } else {
@ -147,10 +147,10 @@ ovsdb_execute_compose(struct ovsdb *db, const struct ovsdb_session *session,
results = NULL; results = NULL;
results = json_array_create_empty(); results = json_array_create_empty();
n_operations = params->u.array.n - 1; n_operations = params->array.n - 1;
error = NULL; error = NULL;
for (i = 1; i <= n_operations; i++) { for (i = 1; i <= n_operations; i++) {
struct json *operation = params->u.array.elems[i]; struct json *operation = params->array.elems[i];
struct ovsdb_error *parse_error; struct ovsdb_error *parse_error;
struct ovsdb_parser parser; struct ovsdb_parser parser;
struct json *result; struct json *result;
@ -735,11 +735,11 @@ ovsdb_execute_wait(struct ovsdb_execution *x, struct ovsdb_parser *parser,
if (!error) { if (!error) {
/* Parse "rows" into 'expected'. */ /* Parse "rows" into 'expected'. */
ovsdb_row_hash_init(&expected, &columns); ovsdb_row_hash_init(&expected, &columns);
for (i = 0; i < rows->u.array.n; i++) { for (i = 0; i < rows->array.n; i++) {
struct ovsdb_row *row; struct ovsdb_row *row;
row = ovsdb_row_create(table); row = ovsdb_row_create(table);
error = ovsdb_row_from_json(row, rows->u.array.elems[i], x->symtab, error = ovsdb_row_from_json(row, rows->array.elems[i], x->symtab,
NULL); NULL);
if (error) { if (error) {
ovsdb_row_destroy(row); ovsdb_row_destroy(row);

4
ovsdb/file.c
View File

@ -135,7 +135,7 @@ ovsdb_file_txn_table_from_json(struct ovsdb_txn *txn,
return ovsdb_syntax_error(json, NULL, "object expected"); return ovsdb_syntax_error(json, NULL, "object expected");
} }
SHASH_FOR_EACH (node, json->u.object) { SHASH_FOR_EACH (node, json->object) {
const char *uuid_string = node->name; const char *uuid_string = node->name;
struct json *txn_row_json = node->data; struct json *txn_row_json = node->data;
struct ovsdb_error *error; struct ovsdb_error *error;
@ -177,7 +177,7 @@ ovsdb_file_txn_from_json(struct ovsdb *db, const struct json *json,
} }
txn = ovsdb_txn_create(db); txn = ovsdb_txn_create(db);
SHASH_FOR_EACH (node, json->u.object) { SHASH_FOR_EACH (node, json->object) {
const char *table_name = node->name; const char *table_name = node->name;
struct json *node_json = node->data; struct json *node_json = node->data;
struct ovsdb_table *table; struct ovsdb_table *table;

26
ovsdb/jsonrpc-server.c
View File

@ -772,7 +772,7 @@ ovsdb_jsonrpc_lookup_db(const struct ovsdb_jsonrpc_session *s,
goto error; goto error;
} }
db_name = params->elems[0]->u.string; db_name = params->elems[0]->string;
db = shash_find_data(&s->up.server->dbs, db_name); db = shash_find_data(&s->up.server->dbs, db_name);
if (!db) { if (!db) {
error = ovsdb_syntax_error( error = ovsdb_syntax_error(
@ -1054,7 +1054,7 @@ execute_cancel(struct ovsdb_jsonrpc_session *s, struct jsonrpc_msg *request)
struct ovsdb_jsonrpc_trigger *t; struct ovsdb_jsonrpc_trigger *t;
struct json *id; struct json *id;
id = request->params->u.array.elems[0]; id = request->params->array.elems[0];
t = ovsdb_jsonrpc_trigger_find(s, id, json_hash(id, 0)); t = ovsdb_jsonrpc_trigger_find(s, id, json_hash(id, 0));
if (t) { if (t) {
ovsdb_jsonrpc_trigger_complete(t); ovsdb_jsonrpc_trigger_complete(t);
@ -1303,16 +1303,16 @@ ovsdb_jsonrpc_parse_monitor_request(
"array of column names expected"); "array of column names expected");
} }
for (i = 0; i < columns->u.array.n; i++) { for (i = 0; i < columns->array.n; i++) {
const struct ovsdb_column *column; const struct ovsdb_column *column;
const char *s; const char *s;
if (columns->u.array.elems[i]->type != JSON_STRING) { if (columns->array.elems[i]->type != JSON_STRING) {
return ovsdb_syntax_error(columns, NULL, return ovsdb_syntax_error(columns, NULL,
"array of column names expected"); "array of column names expected");
} }
s = columns->u.array.elems[i]->u.string; s = columns->array.elems[i]->string;
column = shash_find_data(&table->schema->columns, s); column = shash_find_data(&table->schema->columns, s);
if (!column) { if (!column) {
return ovsdb_syntax_error(columns, NULL, "%s is not a valid " return ovsdb_syntax_error(columns, NULL, "%s is not a valid "
@ -1367,8 +1367,8 @@ ovsdb_jsonrpc_monitor_create(struct ovsdb_jsonrpc_session *s, struct ovsdb *db,
error = ovsdb_syntax_error(params, NULL, "invalid parameters"); error = ovsdb_syntax_error(params, NULL, "invalid parameters");
goto error; goto error;
} }
monitor_id = params->u.array.elems[1]; monitor_id = params->array.elems[1];
monitor_requests = params->u.array.elems[2]; monitor_requests = params->array.elems[2];
if (monitor_requests->type != JSON_OBJECT) { if (monitor_requests->type != JSON_OBJECT) {
error = ovsdb_syntax_error(monitor_requests, NULL, error = ovsdb_syntax_error(monitor_requests, NULL,
"monitor-requests must be object"); "monitor-requests must be object");
@ -1409,7 +1409,7 @@ ovsdb_jsonrpc_monitor_create(struct ovsdb_jsonrpc_session *s, struct ovsdb *db,
/* Parse columns. */ /* Parse columns. */
mr_value = node->data; mr_value = node->data;
if (mr_value->type == JSON_ARRAY) { if (mr_value->type == JSON_ARRAY) {
const struct json_array *array = &mr_value->u.array; const struct json_array *array = &mr_value->array;
for (i = 0; i < array->n; i++) { for (i = 0; i < array->n; i++) {
error = ovsdb_jsonrpc_parse_monitor_request(m->dbmon, error = ovsdb_jsonrpc_parse_monitor_request(m->dbmon,
@ -1503,14 +1503,14 @@ ovsdb_jsonrpc_monitor_cond_change(struct ovsdb_jsonrpc_session *s,
goto error; goto error;
} }
m = ovsdb_jsonrpc_monitor_find(s, params->u.array.elems[0]); m = ovsdb_jsonrpc_monitor_find(s, params->array.elems[0]);
if (!m) { if (!m) {
error = ovsdb_syntax_error(params->u.array.elems[0], NULL, error = ovsdb_syntax_error(params->array.elems[0], NULL,
"unknown monitor session"); "unknown monitor session");
goto error; goto error;
} }
const struct json *new_monitor_id = params->u.array.elems[1]; const struct json *new_monitor_id = params->array.elems[1];
bool changing_id = !json_equal(m->monitor_id, new_monitor_id); bool changing_id = !json_equal(m->monitor_id, new_monitor_id);
if (changing_id && ovsdb_jsonrpc_monitor_find(s, new_monitor_id)) { if (changing_id && ovsdb_jsonrpc_monitor_find(s, new_monitor_id)) {
error = ovsdb_syntax_error(new_monitor_id, NULL, error = ovsdb_syntax_error(new_monitor_id, NULL,
@ -1518,7 +1518,7 @@ ovsdb_jsonrpc_monitor_cond_change(struct ovsdb_jsonrpc_session *s,
goto error; goto error;
} }
monitor_cond_change_reqs = params->u.array.elems[2]; monitor_cond_change_reqs = params->array.elems[2];
if (monitor_cond_change_reqs->type != JSON_OBJECT) { if (monitor_cond_change_reqs->type != JSON_OBJECT) {
error = error =
ovsdb_syntax_error(NULL, NULL, ovsdb_syntax_error(NULL, NULL,
@ -1546,7 +1546,7 @@ ovsdb_jsonrpc_monitor_cond_change(struct ovsdb_jsonrpc_session *s,
mr_value = node->data; mr_value = node->data;
if (mr_value->type == JSON_ARRAY) { if (mr_value->type == JSON_ARRAY) {
const struct json_array *array = &mr_value->u.array; const struct json_array *array = &mr_value->array;
for (i = 0; i < array->n; i++) { for (i = 0; i < array->n; i++) {
error = ovsdb_jsonrpc_parse_monitor_cond_change_request( error = ovsdb_jsonrpc_parse_monitor_cond_change_request(

2
ovsdb/log.c
View File

@ -494,7 +494,7 @@ ovsdb_log_read(struct ovsdb_log *file, struct json **jsonp)
"offset %lld are not valid JSON (%s)", "offset %lld are not valid JSON (%s)",
file->display_name, data_length, file->display_name, data_length,
(long long int) data_offset, (long long int) data_offset,
json->u.string); json->string);
goto error; goto error;
} }
if (json->type != JSON_OBJECT) { if (json->type != JSON_OBJECT) {

6
ovsdb/mutation.c
View File

@ -85,9 +85,9 @@ ovsdb_mutation_from_json(const struct ovsdb_table_schema *ts,
const char *column_name; const char *column_name;
if (json->type != JSON_ARRAY if (json->type != JSON_ARRAY
|| json->u.array.n != 3 || json->array.n != 3
|| json->u.array.elems[0]->type != JSON_STRING || json->array.elems[0]->type != JSON_STRING
|| json->u.array.elems[1]->type != JSON_STRING) { || json->array.elems[1]->type != JSON_STRING) {
return ovsdb_syntax_error(json, NULL, "Parse error in mutation."); return ovsdb_syntax_error(json, NULL, "Parse error in mutation.");
} }
array = json_array(json); array = json_array(json);

66
ovsdb/ovsdb-client.c
View File

@ -488,7 +488,7 @@ parse_json(const char *s)
{ {
struct json *json = json_from_string(s); struct json *json = json_from_string(s);
if (json->type == JSON_STRING) { if (json->type == JSON_STRING) {
ovs_fatal(0, "\"%s\": %s", s, json->u.string); ovs_fatal(0, "\"%s\": %s", s, json->string);
} }
return json; return json;
} }
@ -577,13 +577,13 @@ fetch_dbs(struct jsonrpc *rpc, struct svec *dbs)
ovs_fatal(0, "list_dbs response is not array"); ovs_fatal(0, "list_dbs response is not array");
} }
for (i = 0; i < reply->result->u.array.n; i++) { for (i = 0; i < reply->result->array.n; i++) {
const struct json *name = reply->result->u.array.elems[i]; const struct json *name = reply->result->array.elems[i];
if (name->type != JSON_STRING) { if (name->type != JSON_STRING) {
ovs_fatal(0, "list_dbs response %"PRIuSIZE" is not string", i); ovs_fatal(0, "list_dbs response %"PRIuSIZE" is not string", i);
} }
svec_add(dbs, name->u.string); svec_add(dbs, name->string);
} }
jsonrpc_msg_destroy(reply); jsonrpc_msg_destroy(reply);
svec_sort(dbs); svec_sort(dbs);
@ -650,14 +650,14 @@ parse_database_info_reply(const struct jsonrpc_msg *reply, const char *server,
{ {
const struct json *result = reply->result; const struct json *result = reply->result;
if (result->type != JSON_ARRAY if (result->type != JSON_ARRAY
|| result->u.array.n != 1 || result->array.n != 1
|| result->u.array.elems[0]->type != JSON_OBJECT) { || result->array.elems[0]->type != JSON_OBJECT) {
VLOG_WARN("%s: unexpected reply to _Server request for %s", VLOG_WARN("%s: unexpected reply to _Server request for %s",
server, database); server, database);
return NULL; return NULL;
} }
const struct json *op_result = result->u.array.elems[0]; const struct json *op_result = result->array.elems[0];
const struct json *rows = shash_find_data(json_object(op_result), "rows"); const struct json *rows = shash_find_data(json_object(op_result), "rows");
if (!rows || rows->type != JSON_ARRAY) { if (!rows || rows->type != JSON_ARRAY) {
VLOG_WARN("%s: missing \"rows\" member in _Server reply for %s", VLOG_WARN("%s: missing \"rows\" member in _Server reply for %s",
@ -665,8 +665,8 @@ parse_database_info_reply(const struct jsonrpc_msg *reply, const char *server,
return NULL; return NULL;
} }
for (size_t i = 0; i < rows->u.array.n; i++) { for (size_t i = 0; i < rows->array.n; i++) {
const struct json *row = rows->u.array.elems[i]; const struct json *row = rows->array.elems[i];
if (row->type != JSON_OBJECT) { if (row->type != JSON_OBJECT) {
VLOG_WARN("%s: bad row in _Server reply for %s", VLOG_WARN("%s: bad row in _Server reply for %s",
server, database); server, database);
@ -855,11 +855,11 @@ do_transact__(int argc, char *argv[], struct json *transaction)
{ {
struct jsonrpc_msg *request, *reply; struct jsonrpc_msg *request, *reply;
if (transaction->type != JSON_ARRAY if (transaction->type != JSON_ARRAY
|| !transaction->u.array.n || !transaction->array.n
|| transaction->u.array.elems[0]->type != JSON_STRING) { || transaction->array.elems[0]->type != JSON_STRING) {
ovs_fatal(0, "not a valid OVSDB query"); ovs_fatal(0, "not a valid OVSDB query");
} }
const char *db_name = json_string(transaction->u.array.elems[0]); const char *db_name = json_string(transaction->array.elems[0]);
struct jsonrpc *rpc; struct jsonrpc *rpc;
char *database = CONST_CAST(char *, db_name); char *database = CONST_CAST(char *, db_name);
@ -902,21 +902,21 @@ do_query(struct jsonrpc *rpc OVS_UNUSED, const char *database OVS_UNUSED,
struct json *abort_op = json_object_create(); struct json *abort_op = json_object_create();
json_object_put_string(abort_op, "op", "abort"); json_object_put_string(abort_op, "op", "abort");
json_array_add(transaction, abort_op); json_array_add(transaction, abort_op);
size_t abort_idx = transaction->u.array.n - 2; size_t abort_idx = transaction->array.n - 2;
/* Run query. */ /* Run query. */
struct json *result = do_transact__(argc, argv, transaction); struct json *result = do_transact__(argc, argv, transaction);
/* If the "abort" operation ended the transaction, remove its result. */ /* If the "abort" operation ended the transaction, remove its result. */
if (result->type == JSON_ARRAY if (result->type == JSON_ARRAY
&& result->u.array.n == abort_idx + 1 && result->array.n == abort_idx + 1
&& result->u.array.elems[abort_idx]->type == JSON_OBJECT) { && result->array.elems[abort_idx]->type == JSON_OBJECT) {
struct json *op_result = result->u.array.elems[abort_idx]; struct json *op_result = result->array.elems[abort_idx];
struct json *error = shash_find_data(json_object(op_result), "error"); struct json *error = shash_find_data(json_object(op_result), "error");
if (error if (error
&& error->type == JSON_STRING && error->type == JSON_STRING
&& !strcmp(json_string(error), "aborted")) { && !strcmp(json_string(error), "aborted")) {
result->u.array.n--; result->array.n--;
json_destroy(op_result); json_destroy(op_result);
} }
} }
@ -1178,7 +1178,7 @@ parse_monitor_columns(char *arg, const char *server, const char *database,
} }
} }
if (columns_json->u.array.n == 0) { if (columns_json->array.n == 0) {
const struct shash_node **nodes; const struct shash_node **nodes;
size_t i, n; size_t i, n;
@ -1456,9 +1456,9 @@ do_monitor__(struct jsonrpc *rpc, const char *database,
&& !strcmp(msg->method, "update")) { && !strcmp(msg->method, "update")) {
struct json *params = msg->params; struct json *params = msg->params;
if (params->type == JSON_ARRAY if (params->type == JSON_ARRAY
&& params->u.array.n == 2 && params->array.n == 2
&& params->u.array.elems[0]->type == JSON_NULL) { && params->array.elems[0]->type == JSON_NULL) {
monitor_print(params->u.array.elems[1], mts, n_mts, false); monitor_print(params->array.elems[1], mts, n_mts, false);
fflush(stdout); fflush(stdout);
} }
} else if (msg->type == JSONRPC_NOTIFY } else if (msg->type == JSONRPC_NOTIFY
@ -1466,9 +1466,9 @@ do_monitor__(struct jsonrpc *rpc, const char *database,
&& !strcmp(msg->method, "update2")) { && !strcmp(msg->method, "update2")) {
struct json *params = msg->params; struct json *params = msg->params;
if (params->type == JSON_ARRAY if (params->type == JSON_ARRAY
&& params->u.array.n == 2 && params->array.n == 2
&& params->u.array.elems[0]->type == JSON_NULL) { && params->array.elems[0]->type == JSON_NULL) {
monitor2_print(params->u.array.elems[1], mts, n_mts); monitor2_print(params->array.elems[1], mts, n_mts);
fflush(stdout); fflush(stdout);
} }
} else if (msg->type == JSONRPC_NOTIFY } else if (msg->type == JSONRPC_NOTIFY
@ -1806,13 +1806,13 @@ do_dump(struct jsonrpc *rpc, const char *database,
/* Print database contents. */ /* Print database contents. */
if (reply->result->type != JSON_ARRAY if (reply->result->type != JSON_ARRAY
|| reply->result->u.array.n != n_tables) { || reply->result->array.n != n_tables) {
ovs_fatal(0, "reply is not array of %"PRIuSIZE" elements: %s", ovs_fatal(0, "reply is not array of %"PRIuSIZE" elements: %s",
n_tables, json_to_string(reply->result, 0)); n_tables, json_to_string(reply->result, 0));
} }
for (i = 0; i < n_tables; i++) { for (i = 0; i < n_tables; i++) {
const struct ovsdb_table_schema *ts = tables[i]->data; const struct ovsdb_table_schema *ts = tables[i]->data;
const struct json *op_result = reply->result->u.array.elems[i]; const struct json *op_result = reply->result->array.elems[i];
struct json *rows; struct json *rows;
if (op_result->type != JSON_OBJECT if (op_result->type != JSON_OBJECT
@ -1824,9 +1824,9 @@ do_dump(struct jsonrpc *rpc, const char *database,
} }
if (argc > 1) { if (argc > 1) {
dump_table(tables[i]->name, &custom_columns, &rows->u.array); dump_table(tables[i]->name, &custom_columns, &rows->array);
} else { } else {
dump_table(tables[i]->name, &ts->columns, &rows->u.array); dump_table(tables[i]->name, &ts->columns, &rows->array);
} }
} }
@ -1920,7 +1920,7 @@ do_backup(struct jsonrpc *rpc, const char *database,
/* Print database transaction record. */ /* Print database transaction record. */
if (reply->result->type != JSON_ARRAY if (reply->result->type != JSON_ARRAY
|| reply->result->u.array.n != shash_count(&schema->tables)) { || reply->result->array.n != shash_count(&schema->tables)) {
ovs_fatal(0, "reply is not array of %"PRIuSIZE" elements: %s", ovs_fatal(0, "reply is not array of %"PRIuSIZE" elements: %s",
shash_count(&schema->tables), shash_count(&schema->tables),
json_to_string(reply->result, 0)); json_to_string(reply->result, 0));
@ -1931,7 +1931,7 @@ do_backup(struct jsonrpc *rpc, const char *database,
SHASH_FOR_EACH (node, &schema->tables) { SHASH_FOR_EACH (node, &schema->tables) {
const char *table_name = node->name; const char *table_name = node->name;
const struct ovsdb_table_schema *table = node->data; const struct ovsdb_table_schema *table = node->data;
const struct json *op_result = reply->result->u.array.elems[i++]; const struct json *op_result = reply->result->array.elems[i++];
struct json *rows; struct json *rows;
if (op_result->type != JSON_OBJECT if (op_result->type != JSON_OBJECT
@ -1942,13 +1942,13 @@ do_backup(struct jsonrpc *rpc, const char *database,
table->name, json_to_string(op_result, 0)); table->name, json_to_string(op_result, 0));
} }
if (!rows->u.array.n) { if (!rows->array.n) {
continue; continue;
} }
struct json *output_rows = json_object_create(); struct json *output_rows = json_object_create();
for (size_t j = 0; j < rows->u.array.n; j++) { for (size_t j = 0; j < rows->array.n; j++) {
struct json *row = rows->u.array.elems[j]; struct json *row = rows->array.elems[j];
if (row->type != JSON_OBJECT) { if (row->type != JSON_OBJECT) {
ovs_fatal(0, "%s table reply row is not an object: %s", ovs_fatal(0, "%s table reply row is not an object: %s",
table_name, json_to_string(row, 0)); table_name, json_to_string(row, 0));

1
ovsdb/ovsdb-idlc.in
View File

@ -387,6 +387,7 @@ bool %(s)s_is_updated(const struct %(s)s *, enum %(s)s_column_id);
#endif''') #endif''')
print("\n#endif /* %(prefix)sIDL_HEADER */" % {'prefix': prefix.upper()}) print("\n#endif /* %(prefix)sIDL_HEADER */" % {'prefix': prefix.upper()})
def printEnum(type, members): def printEnum(type, members):
if len(members) == 0: if len(members) == 0:
return return

12
ovsdb/ovsdb-server.c
View File

@ -943,9 +943,9 @@ query_db_remotes(const char *name, const struct shash *all_dbs,
} }
} }
} else if (column->type.key.type == OVSDB_TYPE_UUID } else if (column->type.key.type == OVSDB_TYPE_UUID
&& column->type.key.u.uuid.refTable && column->type.key.uuid.refTable
&& column->type.value.type == OVSDB_TYPE_VOID) { && column->type.value.type == OVSDB_TYPE_VOID) {
const struct ovsdb_table *ref_table = column->type.key.u.uuid.refTable; const struct ovsdb_table *ref_table = column->type.key.uuid.refTable;
HMAP_FOR_EACH (row, hmap_node, &table->rows) { HMAP_FOR_EACH (row, hmap_node, &table->rows) {
const struct ovsdb_datum *datum; const struct ovsdb_datum *datum;
size_t i; size_t i;
@ -1050,12 +1050,12 @@ update_remote_rows(const struct shash *all_dbs, const struct db *db_,
if (db != db_ if (db != db_
|| column->type.key.type != OVSDB_TYPE_UUID || column->type.key.type != OVSDB_TYPE_UUID
|| !column->type.key.u.uuid.refTable || !column->type.key.uuid.refTable
|| column->type.value.type != OVSDB_TYPE_VOID) { || column->type.value.type != OVSDB_TYPE_VOID) {
return; return;
} }
ref_table = column->type.key.u.uuid.refTable; ref_table = column->type.key.uuid.refTable;
HMAP_FOR_EACH (row, hmap_node, &table->rows) { HMAP_FOR_EACH (row, hmap_node, &table->rows) {
const struct ovsdb_datum *datum; const struct ovsdb_datum *datum;
@ -1903,8 +1903,8 @@ sset_from_json(struct sset *sset, const struct json *array)
sset_clear(sset); sset_clear(sset);
ovs_assert(array->type == JSON_ARRAY); ovs_assert(array->type == JSON_ARRAY);
for (i = 0; i < array->u.array.n; i++) { for (i = 0; i < array->array.n; i++) {
const struct json *elem = array->u.array.elems[i]; const struct json *elem = array->array.elems[i];
sset_add(sset, json_string(elem)); sset_add(sset, json_string(elem));
} }
} }

2
ovsdb/ovsdb-tool.c
View File

@ -212,7 +212,7 @@ parse_json(const char *s)
{ {
struct json *json = json_from_string(s); struct json *json = json_from_string(s);
if (json->type == JSON_STRING) { if (json->type == JSON_STRING) {
ovs_fatal(0, "\"%s\": %s", s, json->u.string); ovs_fatal(0, "\"%s\": %s", s, json->string);
} }
return json; return json;
} }

2
ovsdb/ovsdb-util.c
View File

@ -135,7 +135,7 @@ ovsdb_util_read_map_string_uuid_column(const struct ovsdb_row *row,
return NULL; return NULL;
} }
const struct ovsdb_table *ref_table = column->type.value.u.uuid.refTable; const struct ovsdb_table *ref_table = column->type.value.uuid.refTable;
if (!ref_table) { if (!ref_table) {
return NULL; return NULL;
} }

12
ovsdb/ovsdb.c
View File

@ -118,16 +118,16 @@ ovsdb_schema_check_ref_table(struct ovsdb_column *column,
{ {
struct ovsdb_table_schema *refTable; struct ovsdb_table_schema *refTable;
if (base->type != OVSDB_TYPE_UUID || !base->u.uuid.refTableName) { if (base->type != OVSDB_TYPE_UUID || !base->uuid.refTableName) {
return NULL; return NULL;
} }
refTable = shash_find_data(tables, base->u.uuid.refTableName); refTable = shash_find_data(tables, base->uuid.refTableName);
if (!refTable) { if (!refTable) {
return ovsdb_syntax_error(NULL, NULL, return ovsdb_syntax_error(NULL, NULL,
"column %s %s refers to undefined table %s", "column %s %s refers to undefined table %s",
column->name, base_name, column->name, base_name,
base->u.uuid.refTableName); base->uuid.refTableName);
} }
if (ovsdb_base_type_is_strong_ref(base) && !refTable->is_root) { if (ovsdb_base_type_is_strong_ref(base) && !refTable->is_root) {
@ -388,11 +388,11 @@ static void
ovsdb_set_ref_table(const struct shash *tables, ovsdb_set_ref_table(const struct shash *tables,
struct ovsdb_base_type *base) struct ovsdb_base_type *base)
{ {
if (base->type == OVSDB_TYPE_UUID && base->u.uuid.refTableName) { if (base->type == OVSDB_TYPE_UUID && base->uuid.refTableName) {
struct ovsdb_table *table; struct ovsdb_table *table;
table = shash_find_data(tables, base->u.uuid.refTableName); table = shash_find_data(tables, base->uuid.refTableName);
base->u.uuid.refTable = table; base->uuid.refTable = table;
} }
} }

12
ovsdb/replication.c
View File

@ -147,8 +147,8 @@ replication_add_local_db(const char *database, struct ovsdb *db)
static void static void
send_schema_requests(const struct json *result) send_schema_requests(const struct json *result)
{ {
for (size_t i = 0; i < result->u.array.n; i++) { for (size_t i = 0; i < result->array.n; i++) {
const struct json *name = result->u.array.elems[i]; const struct json *name = result->array.elems[i];
if (name->type == JSON_STRING) { if (name->type == JSON_STRING) {
/* Send one schema request for each remote DB. */ /* Send one schema request for each remote DB. */
const char *db_name = json_string(name); const char *db_name = json_string(name);
@ -203,13 +203,13 @@ replication_run(void)
if (msg->type == JSONRPC_NOTIFY && state != RPL_S_ERR if (msg->type == JSONRPC_NOTIFY && state != RPL_S_ERR
&& !strcmp(msg->method, "update")) { && !strcmp(msg->method, "update")) {
if (msg->params->type == JSON_ARRAY if (msg->params->type == JSON_ARRAY
&& msg->params->u.array.n == 2 && msg->params->array.n == 2
&& msg->params->u.array.elems[0]->type == JSON_STRING) { && msg->params->array.elems[0]->type == JSON_STRING) {
char *db_name = msg->params->u.array.elems[0]->u.string; char *db_name = msg->params->array.elems[0]->string;
struct ovsdb *db = find_db(db_name); struct ovsdb *db = find_db(db_name);
if (db) { if (db) {
struct ovsdb_error *error; struct ovsdb_error *error;
error = process_notification(msg->params->u.array.elems[1], error = process_notification(msg->params->array.elems[1],
db); db);
if (error) { if (error) {
ovsdb_error_assert(error); ovsdb_error_assert(error);

4
ovsdb/storage.c
View File

@ -246,12 +246,12 @@ ovsdb_storage_read(struct ovsdb_storage *storage,
raft_next_entry(storage->raft, txnid, &is_snapshot)); raft_next_entry(storage->raft, txnid, &is_snapshot));
if (!json) { if (!json) {
return NULL; return NULL;
} else if (json->type != JSON_ARRAY || json->u.array.n != 2) { } else if (json->type != JSON_ARRAY || json->array.n != 2) {
json_destroy(json); json_destroy(json);
return ovsdb_error(NULL, "invalid commit format"); return ovsdb_error(NULL, "invalid commit format");
} }
struct json **e = json->u.array.elems; struct json **e = json->array.elems;
schema_json = e[0]->type != JSON_NULL ? e[0] : NULL; schema_json = e[0]->type != JSON_NULL ? e[0] : NULL;
txn_json = e[1]->type != JSON_NULL ? e[1] : NULL; txn_json = e[1]->type != JSON_NULL ? e[1] : NULL;
} else if (storage->log) { } else if (storage->log) {

8
ovsdb/table.c
View File

@ -152,7 +152,7 @@ ovsdb_table_schema_from_json(const struct json *json, const char *name,
return ovsdb_syntax_error(json, NULL, return ovsdb_syntax_error(json, NULL,
"maxRows must be at least 1"); "maxRows must be at least 1");
} }
n_max_rows = max_rows->u.integer; n_max_rows = max_rows->integer;
} else { } else {
n_max_rows = UINT_MAX; n_max_rows = UINT_MAX;
} }
@ -187,12 +187,12 @@ ovsdb_table_schema_from_json(const struct json *json, const char *name,
if (indexes) { if (indexes) {
size_t i; size_t i;
ts->indexes = xmalloc(indexes->u.array.n * sizeof *ts->indexes); ts->indexes = xmalloc(indexes->array.n * sizeof *ts->indexes);
for (i = 0; i < indexes->u.array.n; i++) { for (i = 0; i < indexes->array.n; i++) {
struct ovsdb_column_set *index = &ts->indexes[i]; struct ovsdb_column_set *index = &ts->indexes[i];
size_t j; size_t j;
error = ovsdb_column_set_from_json(indexes->u.array.elems[i], error = ovsdb_column_set_from_json(indexes->array.elems[i],
ts, index); ts, index);
if (error) { if (error) {
goto error; goto error;

8
ovsdb/transaction.c
View File

@ -225,7 +225,7 @@ ovsdb_txn_adjust_atom_refs(struct ovsdb_txn *txn, const struct ovsdb_row *r,
return NULL; return NULL;
} }
table = base->u.uuid.refTable; table = base->uuid.refTable;
for (i = 0; i < n; i++) { for (i = 0; i < n; i++) {
const struct uuid *uuid = &atoms[i].uuid; const struct uuid *uuid = &atoms[i].uuid;
struct ovsdb_txn_row *txn_row; struct ovsdb_txn_row *txn_row;
@ -322,7 +322,7 @@ delete_row_refs(struct ovsdb_txn *txn, const struct ovsdb_row *row,
return NULL; return NULL;
} }
table = base->u.uuid.refTable; table = base->uuid.refTable;
for (i = 0; i < n; i++) { for (i = 0; i < n; i++) {
const struct uuid *uuid = &atoms[i].uuid; const struct uuid *uuid = &atoms[i].uuid;
struct ovsdb_txn_row *txn_row; struct ovsdb_txn_row *txn_row;
@ -549,7 +549,7 @@ assess_weak_refs(struct ovsdb_txn *txn, struct ovsdb_txn_row *txn_row)
for (i = 0; i < datum->n; ) { for (i = 0; i < datum->n; ) {
const struct ovsdb_row *row; const struct ovsdb_row *row;
row = ovsdb_table_get_row(column->type.key.u.uuid.refTable, row = ovsdb_table_get_row(column->type.key.uuid.refTable,
&datum->keys[i].uuid); &datum->keys[i].uuid);
if (row) { if (row) {
add_weak_ref(txn_row->new, row); add_weak_ref(txn_row->new, row);
@ -567,7 +567,7 @@ assess_weak_refs(struct ovsdb_txn *txn, struct ovsdb_txn_row *txn_row)
for (i = 0; i < datum->n; ) { for (i = 0; i < datum->n; ) {
const struct ovsdb_row *row; const struct ovsdb_row *row;
row = ovsdb_table_get_row(column->type.value.u.uuid.refTable, row = ovsdb_table_get_row(column->type.value.uuid.refTable,
&datum->values[i].uuid); &datum->values[i].uuid);
if (row) { if (row) {
add_weak_ref(txn_row->new, row); add_weak_ref(txn_row->new, row);

4
ovsdb/trigger.c
View File

@ -230,14 +230,14 @@ ovsdb_trigger_try(struct ovsdb_trigger *t, long long int now)
/* Validate parameters. */ /* Validate parameters. */
const struct json *params = t->request->params; const struct json *params = t->request->params;
if (params->type != JSON_ARRAY || params->u.array.n != 2) { if (params->type != JSON_ARRAY || params->array.n != 2) {
trigger_convert_error(t, ovsdb_syntax_error(params, NULL, trigger_convert_error(t, ovsdb_syntax_error(params, NULL,
"array expected")); "array expected"));
return false; return false;
} }
/* Parse new schema and make a converted copy. */ /* Parse new schema and make a converted copy. */
const struct json *new_schema_json = params->u.array.elems[1]; const struct json *new_schema_json = params->array.elems[1];
struct ovsdb_schema *new_schema; struct ovsdb_schema *new_schema;
struct ovsdb_error *error struct ovsdb_error *error
= ovsdb_schema_from_json(new_schema_json, &new_schema); = ovsdb_schema_from_json(new_schema_json, &new_schema);

8
python/ovs/db/types.py
View File

@ -419,7 +419,7 @@ class BaseType(object):
high = "INT64_MAX" high = "INT64_MAX"
else: else:
high = "INT64_C(%d)" % self.max high = "INT64_C(%d)" % self.max
init.append(".u.integer = { .min = %s, .max = %s }," % (low, high)) init.append(".integer = { .min = %s, .max = %s }," % (low, high))
elif self.type == RealType: elif self.type == RealType:
if self.min is None: if self.min is None:
low = "-DBL_MAX" low = "-DBL_MAX"
@ -429,7 +429,7 @@ class BaseType(object):
high = "DBL_MAX" high = "DBL_MAX"
else: else:
high = self.max high = self.max
init.append(".u.real = { .min = %s, .max = %s }," % (low, high)) init.append(".real = { .min = %s, .max = %s }," % (low, high))
elif self.type == StringType: elif self.type == StringType:
if self.min is None: if self.min is None:
low = 0 low = 0
@ -439,11 +439,11 @@ class BaseType(object):
high = "UINT_MAX" high = "UINT_MAX"
else: else:
high = self.max_length high = self.max_length
init.append(".u.string = { .minLen = %s, .maxLen = %s }," % ( init.append(".string = { .minLen = %s, .maxLen = %s }," % (
low, high)) low, high))
elif self.type == UuidType: elif self.type == UuidType:
if self.ref_table_name is not None: if self.ref_table_name is not None:
init.append(".u.uuid = { .refTableName = \"%s\", " init.append(".uuid = { .refTableName = \"%s\", "
".refType = OVSDB_REF_%s }," % ( ".refType = OVSDB_REF_%s }," % (
escapeCString(self.ref_table_name), escapeCString(self.ref_table_name),
self.ref_type.upper())) self.ref_type.upper()))

2
tests/test-json.c
View File

@ -37,7 +37,7 @@ print_and_free_json(struct json *json)
{ {
bool ok; bool ok;
if (json->type == JSON_STRING) { if (json->type == JSON_STRING) {
printf("error: %s\n", json->u.string); printf("error: %s\n", json->string);
ok = false; ok = false;
} else { } else {
char *s = json_to_string(json, JSSF_SORT | (pretty ? JSSF_PRETTY : 0)); char *s = json_to_string(json, JSSF_SORT | (pretty ? JSSF_PRETTY : 0));

2
tests/test-jsonrpc.c
View File

@ -124,7 +124,7 @@ parse_json(const char *s)
{ {
struct json *json = json_from_string(s); struct json *json = json_from_string(s);
if (json->type == JSON_STRING) { if (json->type == JSON_STRING) {
ovs_fatal(0, "\"%s\": %s", s, json->u.string); ovs_fatal(0, "\"%s\": %s", s, json->string);
} }
return json; return json;
} }

92
tests/test-ovsdb.c
View File

@ -258,7 +258,7 @@ parse_json(const char *s)
{ {
struct json *json = json_from_string(s); struct json *json = json_from_string(s);
if (json->type == JSON_STRING) { if (json->type == JSON_STRING) {
ovs_fatal(0, "\"%s\": %s", s, json->u.string); ovs_fatal(0, "\"%s\": %s", s, json->string);
} }
return json; return json;
} }
@ -266,9 +266,9 @@ parse_json(const char *s)
static struct json * static struct json *
unbox_json(struct json *json) unbox_json(struct json *json)
{ {
if (json->type == JSON_ARRAY && json->u.array.n == 1) { if (json->type == JSON_ARRAY && json->array.n == 1) {
struct json *inner = json->u.array.elems[0]; struct json *inner = json->array.elems[0];
json->u.array.elems[0] = NULL; json->array.elems[0] = NULL;
json_destroy(json); json_destroy(json);
return inner; return inner;
} else { } else {
@ -732,11 +732,11 @@ do_sort_atoms(struct ovs_cmdl_context *ctx)
} }
/* Convert JSON atoms to internal representation. */ /* Convert JSON atoms to internal representation. */
n_atoms = json->u.array.n; n_atoms = json->array.n;
atoms = xmalloc(n_atoms * sizeof *atoms); atoms = xmalloc(n_atoms * sizeof *atoms);
for (i = 0; i < n_atoms; i++) { for (i = 0; i < n_atoms; i++) {
check_ovsdb_error(ovsdb_atom_from_json(&atoms[i], &base, check_ovsdb_error(ovsdb_atom_from_json(&atoms[i], &base,
json->u.array.elems[i], NULL)); json->array.elems[i], NULL));
} }
json_destroy(json); json_destroy(json);
@ -867,13 +867,13 @@ do_compare_rows(struct ovs_cmdl_context *ctx)
rows[i] = ovsdb_row_create(table); rows[i] = ovsdb_row_create(table);
json = parse_json(ctx->argv[i + 2]); json = parse_json(ctx->argv[i + 2]);
if (json->type != JSON_ARRAY || json->u.array.n != 2 if (json->type != JSON_ARRAY || json->array.n != 2
|| json->u.array.elems[0]->type != JSON_STRING) { || json->array.elems[0]->type != JSON_STRING) {
ovs_fatal(0, "\"%s\" does not have expected form " ovs_fatal(0, "\"%s\" does not have expected form "
"[\"name\", {data}]", ctx->argv[i]); "[\"name\", {data}]", ctx->argv[i]);
} }
names[i] = xstrdup(json->u.array.elems[0]->u.string); names[i] = xstrdup(json->array.elems[0]->string);
check_ovsdb_error(ovsdb_row_from_json(rows[i], json->u.array.elems[1], check_ovsdb_error(ovsdb_row_from_json(rows[i], json->array.elems[1],
NULL, NULL)); NULL, NULL));
json_destroy(json); json_destroy(json);
} }
@ -965,10 +965,10 @@ do_evaluate_condition__(struct ovs_cmdl_context *ctx, int mode)
if (json->type != JSON_ARRAY) { if (json->type != JSON_ARRAY) {
ovs_fatal(0, "CONDITION argument is not JSON array"); ovs_fatal(0, "CONDITION argument is not JSON array");
} }
n_conditions = json->u.array.n; n_conditions = json->array.n;
conditions = xmalloc(n_conditions * sizeof *conditions); conditions = xmalloc(n_conditions * sizeof *conditions);
for (i = 0; i < n_conditions; i++) { for (i = 0; i < n_conditions; i++) {
check_ovsdb_error(ovsdb_condition_from_json(ts, json->u.array.elems[i], check_ovsdb_error(ovsdb_condition_from_json(ts, json->array.elems[i],
NULL, &conditions[i])); NULL, &conditions[i]));
} }
json_destroy(json); json_destroy(json);
@ -978,11 +978,11 @@ do_evaluate_condition__(struct ovs_cmdl_context *ctx, int mode)
if (json->type != JSON_ARRAY) { if (json->type != JSON_ARRAY) {
ovs_fatal(0, "ROW argument is not JSON array"); ovs_fatal(0, "ROW argument is not JSON array");
} }
n_rows = json->u.array.n; n_rows = json->array.n;
rows = xmalloc(n_rows * sizeof *rows); rows = xmalloc(n_rows * sizeof *rows);
for (i = 0; i < n_rows; i++) { for (i = 0; i < n_rows; i++) {
rows[i] = ovsdb_row_create(table); rows[i] = ovsdb_row_create(table);
check_ovsdb_error(ovsdb_row_from_json(rows[i], json->u.array.elems[i], check_ovsdb_error(ovsdb_row_from_json(rows[i], json->array.elems[i],
NULL, NULL)); NULL, NULL));
} }
json_destroy(json); json_destroy(json);
@ -1052,11 +1052,11 @@ do_compare_conditions(struct ovs_cmdl_context *ctx)
if (json->type != JSON_ARRAY) { if (json->type != JSON_ARRAY) {
ovs_fatal(0, "CONDITION argument is not JSON array"); ovs_fatal(0, "CONDITION argument is not JSON array");
} }
n_conditions = json->u.array.n; n_conditions = json->array.n;
conditions = xmalloc(n_conditions * sizeof *conditions); conditions = xmalloc(n_conditions * sizeof *conditions);
for (i = 0; i < n_conditions; i++) { for (i = 0; i < n_conditions; i++) {
check_ovsdb_error(ovsdb_condition_from_json(ts, json->u.array.elems[i], check_ovsdb_error(ovsdb_condition_from_json(ts, json->array.elems[i],
NULL, &conditions[i])); NULL, &conditions[i]));
} }
json_destroy(json); json_destroy(json);
@ -1132,11 +1132,11 @@ do_execute_mutations(struct ovs_cmdl_context *ctx)
if (json->type != JSON_ARRAY) { if (json->type != JSON_ARRAY) {
ovs_fatal(0, "MUTATION argument is not JSON array"); ovs_fatal(0, "MUTATION argument is not JSON array");
} }
n_sets = json->u.array.n; n_sets = json->array.n;
sets = xmalloc(n_sets * sizeof *sets); sets = xmalloc(n_sets * sizeof *sets);
for (i = 0; i < n_sets; i++) { for (i = 0; i < n_sets; i++) {
check_ovsdb_error(ovsdb_mutation_set_from_json(ts, check_ovsdb_error(ovsdb_mutation_set_from_json(ts,
json->u.array.elems[i], json->array.elems[i],
NULL, &sets[i])); NULL, &sets[i]));
} }
json_destroy(json); json_destroy(json);
@ -1146,11 +1146,11 @@ do_execute_mutations(struct ovs_cmdl_context *ctx)
if (json->type != JSON_ARRAY) { if (json->type != JSON_ARRAY) {
ovs_fatal(0, "ROW argument is not JSON array"); ovs_fatal(0, "ROW argument is not JSON array");
} }
n_rows = json->u.array.n; n_rows = json->array.n;
rows = xmalloc(n_rows * sizeof *rows); rows = xmalloc(n_rows * sizeof *rows);
for (i = 0; i < n_rows; i++) { for (i = 0; i < n_rows; i++) {
rows[i] = ovsdb_row_create(table); rows[i] = ovsdb_row_create(table);
check_ovsdb_error(ovsdb_row_from_json(rows[i], json->u.array.elems[i], check_ovsdb_error(ovsdb_row_from_json(rows[i], json->array.elems[i],
NULL, NULL)); NULL, NULL));
} }
json_destroy(json); json_destroy(json);
@ -1256,13 +1256,13 @@ do_query(struct ovs_cmdl_context *ctx)
if (json->type != JSON_ARRAY) { if (json->type != JSON_ARRAY) {
ovs_fatal(0, "ROW argument is not JSON array"); ovs_fatal(0, "ROW argument is not JSON array");
} }
cbdata.n_rows = json->u.array.n; cbdata.n_rows = json->array.n;
cbdata.row_uuids = xmalloc(cbdata.n_rows * sizeof *cbdata.row_uuids); cbdata.row_uuids = xmalloc(cbdata.n_rows * sizeof *cbdata.row_uuids);
cbdata.counts = xmalloc(cbdata.n_rows * sizeof *cbdata.counts); cbdata.counts = xmalloc(cbdata.n_rows * sizeof *cbdata.counts);
for (i = 0; i < cbdata.n_rows; i++) { for (i = 0; i < cbdata.n_rows; i++) {
struct ovsdb_row *row = ovsdb_row_create(table); struct ovsdb_row *row = ovsdb_row_create(table);
uuid_generate(ovsdb_row_get_uuid_rw(row)); uuid_generate(ovsdb_row_get_uuid_rw(row));
check_ovsdb_error(ovsdb_row_from_json(row, json->u.array.elems[i], check_ovsdb_error(ovsdb_row_from_json(row, json->array.elems[i],
NULL, NULL)); NULL, NULL));
if (ovsdb_table_get_row(table, ovsdb_row_get_uuid(row))) { if (ovsdb_table_get_row(table, ovsdb_row_get_uuid(row))) {
ovs_fatal(0, "duplicate UUID "UUID_FMT" in table", ovs_fatal(0, "duplicate UUID "UUID_FMT" in table",
@ -1278,11 +1278,11 @@ do_query(struct ovs_cmdl_context *ctx)
if (json->type != JSON_ARRAY) { if (json->type != JSON_ARRAY) {
ovs_fatal(0, "CONDITION argument is not JSON array"); ovs_fatal(0, "CONDITION argument is not JSON array");
} }
for (i = 0; i < json->u.array.n; i++) { for (i = 0; i < json->array.n; i++) {
struct ovsdb_condition cnd; struct ovsdb_condition cnd;
size_t j; size_t j;
check_ovsdb_error(ovsdb_condition_from_json(ts, json->u.array.elems[i], check_ovsdb_error(ovsdb_condition_from_json(ts, json->array.elems[i],
NULL, &cnd)); NULL, &cnd));
memset(cbdata.counts, 0, cbdata.n_rows * sizeof *cbdata.counts); memset(cbdata.counts, 0, cbdata.n_rows * sizeof *cbdata.counts);
@ -1356,7 +1356,7 @@ do_query_distinct(struct ovs_cmdl_context *ctx)
if (json->type != JSON_ARRAY) { if (json->type != JSON_ARRAY) {
ovs_fatal(0, "ROW argument is not JSON array"); ovs_fatal(0, "ROW argument is not JSON array");
} }
n_rows = json->u.array.n; n_rows = json->array.n;
rows = xmalloc(n_rows * sizeof *rows); rows = xmalloc(n_rows * sizeof *rows);
classes = xmalloc(n_rows * sizeof *classes); classes = xmalloc(n_rows * sizeof *classes);
n_classes = 0; n_classes = 0;
@ -1367,7 +1367,7 @@ do_query_distinct(struct ovs_cmdl_context *ctx)
/* Parse row. */ /* Parse row. */
row = ovsdb_row_create(table); row = ovsdb_row_create(table);
uuid_generate(ovsdb_row_get_uuid_rw(row)); uuid_generate(ovsdb_row_get_uuid_rw(row));
check_ovsdb_error(ovsdb_row_from_json(row, json->u.array.elems[i], check_ovsdb_error(ovsdb_row_from_json(row, json->array.elems[i],
NULL, NULL)); NULL, NULL));
/* Initialize row and find equivalence class. */ /* Initialize row and find equivalence class. */
@ -1400,12 +1400,12 @@ do_query_distinct(struct ovs_cmdl_context *ctx)
if (json->type != JSON_ARRAY) { if (json->type != JSON_ARRAY) {
ovs_fatal(0, "CONDITION argument is not JSON array"); ovs_fatal(0, "CONDITION argument is not JSON array");
} }
for (i = 0; i < json->u.array.n; i++) { for (i = 0; i < json->array.n; i++) {
struct ovsdb_row_set results; struct ovsdb_row_set results;
struct ovsdb_condition cnd; struct ovsdb_condition cnd;
size_t j; size_t j;
check_ovsdb_error(ovsdb_condition_from_json(ts, json->u.array.elems[i], check_ovsdb_error(ovsdb_condition_from_json(ts, json->array.elems[i],
NULL, &cnd)); NULL, &cnd));
for (j = 0; j < n_classes; j++) { for (j = 0; j < n_classes; j++) {
@ -1797,10 +1797,10 @@ do_transact(struct ovs_cmdl_context *ctx)
"with at least 1 element", i); "with at least 1 element", i);
} }
n_args = command->u.array.n; n_args = command->array.n;
args = xmalloc((n_args + 1) * sizeof *args); args = xmalloc((n_args + 1) * sizeof *args);
for (j = 0; j < n_args; j++) { for (j = 0; j < n_args; j++) {
struct json *s = command->u.array.elems[j]; struct json *s = command->array.elems[j];
if (s->type != JSON_STRING) { if (s->type != JSON_STRING) {
ovs_fatal(0, "transaction %d argument %d must be JSON string", ovs_fatal(0, "transaction %d argument %d must be JSON string",
i, j); i, j);
@ -2041,7 +2041,7 @@ parse_uuids(const struct json *json, struct ovsdb_symbol_table *symtab,
{ {
struct uuid uuid; struct uuid uuid;
if (json->type == JSON_STRING && uuid_from_string(&uuid, json->u.string)) { if (json->type == JSON_STRING && uuid_from_string(&uuid, json->string)) {
char *name = xasprintf("#%"PRIuSIZE"#", *n); char *name = xasprintf("#%"PRIuSIZE"#", *n);
fprintf(stderr, "%s = "UUID_FMT"\n", name, UUID_ARGS(&uuid)); fprintf(stderr, "%s = "UUID_FMT"\n", name, UUID_ARGS(&uuid));
ovsdb_symbol_table_put(symtab, name, &uuid, false); ovsdb_symbol_table_put(symtab, name, &uuid, false);
@ -2050,8 +2050,8 @@ parse_uuids(const struct json *json, struct ovsdb_symbol_table *symtab,
} else if (json->type == JSON_ARRAY) { } else if (json->type == JSON_ARRAY) {
size_t i; size_t i;
for (i = 0; i < json->u.array.n; i++) { for (i = 0; i < json->array.n; i++) {
parse_uuids(json->u.array.elems[i], symtab, n); parse_uuids(json->array.elems[i], symtab, n);
} }
} else if (json->type == JSON_OBJECT) { } else if (json->type == JSON_OBJECT) {
const struct shash_node *node; const struct shash_node *node;
@ -2068,16 +2068,16 @@ substitute_uuids(struct json *json, const struct ovsdb_symbol_table *symtab)
if (json->type == JSON_STRING) { if (json->type == JSON_STRING) {
const struct ovsdb_symbol *symbol; const struct ovsdb_symbol *symbol;
symbol = ovsdb_symbol_table_get(symtab, json->u.string); symbol = ovsdb_symbol_table_get(symtab, json->string);
if (symbol) { if (symbol) {
free(json->u.string); free(json->string);
json->u.string = xasprintf(UUID_FMT, UUID_ARGS(&symbol->uuid)); json->string = xasprintf(UUID_FMT, UUID_ARGS(&symbol->uuid));
} }
} else if (json->type == JSON_ARRAY) { } else if (json->type == JSON_ARRAY) {
size_t i; size_t i;
for (i = 0; i < json->u.array.n; i++) { for (i = 0; i < json->array.n; i++) {
substitute_uuids(json->u.array.elems[i], symtab); substitute_uuids(json->array.elems[i], symtab);
} }
} else if (json->type == JSON_OBJECT) { } else if (json->type == JSON_OBJECT) {
const struct shash_node *node; const struct shash_node *node;
@ -2326,25 +2326,25 @@ update_conditions(struct ovsdb_idl *idl, char *commands)
} }
struct ovsdb_idl_condition cond = OVSDB_IDL_CONDITION_INIT(&cond); struct ovsdb_idl_condition cond = OVSDB_IDL_CONDITION_INIT(&cond);
for (i = 0; i < json->u.array.n; i++) { for (i = 0; i < json->array.n; i++) {
const struct json *clause = json->u.array.elems[i]; const struct json *clause = json->array.elems[i];
if (clause->type == JSON_TRUE) { if (clause->type == JSON_TRUE) {
ovsdb_idl_condition_add_clause_true(&cond); ovsdb_idl_condition_add_clause_true(&cond);
} else if (clause->type != JSON_ARRAY || clause->u.array.n != 3 } else if (clause->type != JSON_ARRAY || clause->array.n != 3
|| clause->u.array.elems[0]->type != JSON_STRING || clause->array.elems[0]->type != JSON_STRING
|| clause->u.array.elems[1]->type != JSON_STRING) { || clause->array.elems[1]->type != JSON_STRING) {
ovs_fatal(0, "Error parsing condition"); ovs_fatal(0, "Error parsing condition");
} else { } else {
enum ovsdb_function function; enum ovsdb_function function;
const char *function_s = json_string(clause->u.array.elems[1]); const char *function_s = json_string(clause->array.elems[1]);
struct ovsdb_error *error = ovsdb_function_from_string( struct ovsdb_error *error = ovsdb_function_from_string(
function_s, &function); function_s, &function);
if (error) { if (error) {
ovs_fatal(0, "unknown clause function %s", function_s); ovs_fatal(0, "unknown clause function %s", function_s);
} }
const char *column = json_string(clause->u.array.elems[0]); const char *column = json_string(clause->array.elems[0]);
const struct json *arg = clause->u.array.elems[2]; const struct json *arg = clause->array.elems[2];
if (!strcmp(table_name, "simple")) { if (!strcmp(table_name, "simple")) {
parse_simple_json_clause(&cond, function, column, arg); parse_simple_json_clause(&cond, function, column, arg);
} else if (!strcmp(table_name, "link1")) { } else if (!strcmp(table_name, "link1")) {