/*
- * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015 Nicira, Inc.
+ * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016 Nicira, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
struct ofpbuf *out)
{
struct ofpact_output_reg *output_reg;
- enum ofperr error;
- struct ofpbuf b;
-
output_reg = ofpact_put_OUTPUT_REG(out);
output_reg->ofpact.raw = NXAST_RAW_OUTPUT_REG2;
output_reg->src.ofs = nxm_decode_ofs(naor->ofs_nbits);
output_reg->src.n_bits = nxm_decode_n_bits(naor->ofs_nbits);
output_reg->max_len = ntohs(naor->max_len);
- ofpbuf_use_const(&b, naor, ntohs(naor->len));
+ struct ofpbuf b = ofpbuf_const_initializer(naor, ntohs(naor->len));
ofpbuf_pull(&b, OBJECT_OFFSETOF(naor, pad));
- error = nx_pull_header(&b, &output_reg->src.field, NULL);
+
+ enum ofperr error = nx_pull_header(&b, &output_reg->src.field, NULL);
if (error) {
return error;
}
}
bundle = ofpacts->header;
- ofpact_update_len(ofpacts, &bundle->ofpact);
+ ofpact_finish(ofpacts, &bundle->ofpact);
if (!error) {
error = bundle_check(bundle, OFPP_MAX, NULL);
const void *action, ovs_be16 action_len, size_t oxm_offset,
struct ofpbuf *ofpacts)
{
- struct ofpact_reg_move *move;
- enum ofperr error;
- struct ofpbuf b;
-
- move = ofpact_put_REG_MOVE(ofpacts);
+ struct ofpact_reg_move *move = ofpact_put_REG_MOVE(ofpacts);
move->ofpact.raw = ONFACT_RAW13_COPY_FIELD;
move->src.ofs = ntohs(src_offset);
move->src.n_bits = ntohs(n_bits);
move->dst.ofs = ntohs(dst_offset);
move->dst.n_bits = ntohs(n_bits);
- ofpbuf_use_const(&b, action, ntohs(action_len));
+ struct ofpbuf b = ofpbuf_const_initializer(action, ntohs(action_len));
ofpbuf_pull(&b, oxm_offset);
- error = nx_pull_header(&b, &move->src.field, NULL);
+
+ enum ofperr error = nx_pull_header(&b, &move->src.field, NULL);
if (error) {
return error;
}
enum ofp_version ofp_version OVS_UNUSED,
struct ofpbuf *ofpacts)
{
- struct ofpact_reg_move *move;
- enum ofperr error;
- struct ofpbuf b;
-
- move = ofpact_put_REG_MOVE(ofpacts);
+ struct ofpact_reg_move *move = ofpact_put_REG_MOVE(ofpacts);
move->ofpact.raw = NXAST_RAW_REG_MOVE;
move->src.ofs = ntohs(narm->src_ofs);
move->src.n_bits = ntohs(narm->n_bits);
move->dst.ofs = ntohs(narm->dst_ofs);
move->dst.n_bits = ntohs(narm->n_bits);
- ofpbuf_use_const(&b, narm, ntohs(narm->len));
+ struct ofpbuf b = ofpbuf_const_initializer(narm, ntohs(narm->len));
ofpbuf_pull(&b, sizeof *narm);
- error = nx_pull_header(&b, &move->src.field, NULL);
+
+ enum ofperr error = nx_pull_header(&b, &move->src.field, NULL);
if (error) {
return error;
}
decode_ofpat_set_field(const struct ofp12_action_set_field *oasf,
bool may_mask, struct ofpbuf *ofpacts)
{
- struct ofpact_set_field *sf;
- enum ofperr error;
- struct ofpbuf b;
-
- sf = ofpact_put_SET_FIELD(ofpacts);
-
- ofpbuf_use_const(&b, oasf, ntohs(oasf->len));
+ struct ofpbuf b = ofpbuf_const_initializer(oasf, ntohs(oasf->len));
ofpbuf_pull(&b, OBJECT_OFFSETOF(oasf, pad));
- error = nx_pull_entry(&b, &sf->field, &sf->value,
- may_mask ? &sf->mask : NULL);
+
+ struct ofpact_set_field *sf = ofpact_put_SET_FIELD(ofpacts);
+ enum ofperr error = nx_pull_entry(&b, &sf->field, &sf->value,
+ may_mask ? &sf->mask : NULL);
if (error) {
return (error == OFPERR_OFPBMC_BAD_MASK
? OFPERR_OFPBAC_BAD_SET_MASK
enum ofp_version ofp_version OVS_UNUSED,
struct ofpbuf *out)
{
- struct ofpact_set_field *sf;
- enum ofperr error;
- struct ofpbuf b;
-
- sf = ofpact_put_SET_FIELD(out);
+ struct ofpact_set_field *sf = ofpact_put_SET_FIELD(out);
sf->ofpact.raw = NXAST_RAW_REG_LOAD2;
- ofpbuf_use_const(&b, narl, ntohs(narl->len));
+ struct ofpbuf b = ofpbuf_const_initializer(narl, ntohs(narl->len));
ofpbuf_pull(&b, OBJECT_OFFSETOF(narl, pad));
- error = nx_pull_entry(&b, &sf->field, &sf->value, &sf->mask);
+
+ enum ofperr error = nx_pull_entry(&b, &sf->field, &sf->value, &sf->mask);
if (error) {
return error;
}
decode_stack_action(const struct nx_action_stack *nasp,
struct ofpact_stack *stack_action)
{
- enum ofperr error;
- struct ofpbuf b;
-
stack_action->subfield.ofs = ntohs(nasp->offset);
- ofpbuf_use_const(&b, nasp, sizeof *nasp);
+ struct ofpbuf b = ofpbuf_const_initializer(nasp, sizeof *nasp);
ofpbuf_pull(&b, OBJECT_OFFSETOF(nasp, pad));
- error = nx_pull_header(&b, &stack_action->subfield.field, NULL);
+ enum ofperr error = nx_pull_header(&b, &stack_action->subfield.field,
+ NULL);
if (error) {
return error;
}
ids->n_controllers = 1;
ofpbuf_put(out, &id, sizeof id);
ids = out->header;
- ofpact_update_len(out, &ids->ofpact);
+ ofpact_finish(out, &ids->ofpact);
return error;
}
ids = out->header;
}
- ofpact_update_len(out, &ids->ofpact);
+ ofpact_finish(out, &ids->ofpact);
return 0;
}
ofpbuf_put(ofpacts, &id, sizeof id);
ids = ofpacts->header;
ids->n_controllers++;
- ofpact_update_len(ofpacts, &ids->ofpact);
+ ofpact_finish(ofpacts, &ids->ofpact);
}
static char * OVS_WARN_UNUSED_RESULT
return xstrdup("dec_ttl_cnt_ids: expected at least one controller "
"id.");
}
- ofpact_update_len(ofpacts, &ids->ofpact);
+ ofpact_finish(ofpacts, &ids->ofpact);
}
return NULL;
}
get_subfield(spec->n_bits, &p, &spec->dst);
}
}
- ofpact_update_len(ofpacts, &learn->ofpact);
+ ofpact_finish(ofpacts, &learn->ofpact);
if (!is_all_zeros(p, (char *) end - (char *) p)) {
return OFPERR_OFPBAC_BAD_ARGUMENT;
note = ofpact_put_NOTE(out);
note->length = length;
ofpbuf_put(out, nan->note, length);
- ofpact_update_len(out, out->header);
+ ofpact_finish(out, out->header);
return 0;
}
parse_NOTE(const char *arg, struct ofpbuf *ofpacts,
enum ofputil_protocol *usable_protocols OVS_UNUSED)
{
- struct ofpact_note *note;
-
- note = ofpact_put_NOTE(ofpacts);
- while (*arg != '\0') {
- uint8_t byte;
- bool ok;
-
- if (*arg == '.') {
- arg++;
- }
- if (*arg == '\0') {
- break;
- }
-
- byte = hexits_value(arg, 2, &ok);
- if (!ok) {
- return xstrdup("bad hex digit in `note' argument");
- }
- ofpbuf_put(ofpacts, &byte, 1);
-
- note = ofpacts->header;
- note->length++;
-
- arg += 2;
+ size_t start_ofs = ofpacts->size;
+ ofpact_put_NOTE(ofpacts);
+ arg = ofpbuf_put_hex(ofpacts, arg, NULL);
+ if (arg[0]) {
+ return xstrdup("bad hex digit in `note' argument");
}
- ofpact_update_len(ofpacts, ¬e->ofpact);
+ struct ofpact_note *note = ofpbuf_at_assert(ofpacts, start_ofs,
+ sizeof *note);
+ note->length = ofpacts->size - (start_ofs + sizeof *note);
+ ofpact_finish(ofpacts, ¬e->ofpact);
return NULL;
}
}
static void
-format_UNROLL_XLATE(const struct ofpact_unroll_xlate *a OVS_UNUSED,
- struct ds *s)
+format_UNROLL_XLATE(const struct ofpact_unroll_xlate *a, struct ds *s)
{
- ds_put_cstr(s, "unroll_xlate");
+ ds_put_format(s, "unroll_xlate(table=%"PRIu8", cookie=%"PRIu64")",
+ a->rule_table_id, ntohll(a->rule_cookie));
}
\f
/* Action structure for NXAST_SAMPLE.
enum ofp_version ofp_version, struct ofpbuf *out)
{
const size_t ct_offset = ofpacts_pull(out);
- struct ofpact_conntrack *conntrack;
- struct ofpbuf openflow;
- int error = 0;
-
- conntrack = ofpact_put_CT(out);
+ struct ofpact_conntrack *conntrack = ofpact_put_CT(out);
conntrack->flags = ntohs(nac->flags);
- error = decode_ct_zone(nac, conntrack);
+
+ int error = decode_ct_zone(nac, conntrack);
if (error) {
goto out;
}
ofpbuf_pull(out, sizeof(*conntrack));
- ofpbuf_use_const(&openflow, nac + 1, ntohs(nac->len) - sizeof(*nac));
+ struct ofpbuf openflow = ofpbuf_const_initializer(
+ nac + 1, ntohs(nac->len) - sizeof(*nac));
error = ofpacts_pull_openflow_actions__(&openflow, openflow.size,
ofp_version,
1u << OVSINST_OFPIT11_APPLY_ACTIONS,
conntrack = ofpbuf_push_uninit(out, sizeof(*conntrack));
out->header = &conntrack->ofpact;
- ofpact_update_len(out, &conntrack->ofpact);
+ ofpact_finish(out, &conntrack->ofpact);
if (conntrack->ofpact.len > sizeof(*conntrack)
&& !(conntrack->flags & NX_CT_F_COMMIT)) {
}
}
- ofpact_update_len(ofpacts, &oc->ofpact);
+ ofpact_finish(ofpacts, &oc->ofpact);
ofpbuf_push_uninit(ofpacts, ct_offset);
return error;
}
ofpacts_decode(const void *actions, size_t actions_len,
enum ofp_version ofp_version, struct ofpbuf *ofpacts)
{
- struct ofpbuf openflow;
-
- ofpbuf_use_const(&openflow, actions, actions_len);
+ struct ofpbuf openflow = ofpbuf_const_initializer(actions, actions_len);
while (openflow.size) {
const struct ofp_action_header *action = openflow.data;
enum ofp_raw_action_type raw;
enum ofpact_type outer_action)
{
const struct ofp_action_header *actions;
+ size_t orig_size = ofpacts->size;
enum ofperr error;
- if (!outer_action) {
- ofpbuf_clear(ofpacts);
- }
-
if (actions_len % OFP_ACTION_ALIGN != 0) {
VLOG_WARN_RL(&rl, "OpenFlow message actions length %u is not a "
"multiple of %d", actions_len, OFP_ACTION_ALIGN);
error = ofpacts_decode(actions, actions_len, version, ofpacts);
if (error) {
- ofpbuf_clear(ofpacts);
+ ofpacts->size = orig_size;
return error;
}
error = ofpacts_verify(ofpacts->data, ofpacts->size, allowed_ovsinsts,
outer_action);
if (error) {
- ofpbuf_clear(ofpacts);
+ ofpacts->size = orig_size;
}
return error;
}
-/* Attempts to convert 'actions_len' bytes of OpenFlow actions from the
- * front of 'openflow' into ofpacts. On success, replaces any existing content
- * in 'ofpacts' by the converted ofpacts; on failure, clears 'ofpacts'.
+/* Attempts to convert 'actions_len' bytes of OpenFlow actions from the front
+ * of 'openflow' into ofpacts. On success, appends the converted actions to
+ * 'ofpacts'; on failure, 'ofpacts' is unchanged (but might be reallocated) .
* Returns 0 if successful, otherwise an OpenFlow error.
*
* Actions are processed according to their OpenFlow version which
const struct ofp11_instruction *insts[N_OVS_INSTRUCTIONS];
enum ofperr error;
+ ofpbuf_clear(ofpacts);
if (version == OFP10_VERSION) {
return ofpacts_pull_openflow_actions__(openflow, instructions_len,
version,
ofpacts, 0);
}
- ofpbuf_clear(ofpacts);
-
if (instructions_len % OFP11_INSTRUCTION_ALIGN != 0) {
VLOG_WARN_RL(&rl, "OpenFlow message instructions length %u is not a "
"multiple of %d",
* bytes and updating its embedded length field. See the large comment near
* the end of ofp-actions.h for more information. */
void
-ofpact_update_len(struct ofpbuf *ofpacts, struct ofpact *ofpact)
+ofpact_finish(struct ofpbuf *ofpacts, struct ofpact *ofpact)
{
ovs_assert(ofpact == ofpacts->header);
ofpact->len = (char *) ofpbuf_tail(ofpacts) - (char *) ofpact;
projects / cascardo / ovs.git / blobdiff