ids->ofpact.compat = compat;
ids->n_controllers = 1;
ofpbuf_put(out, &id, sizeof id);
- ids = out->l2;
+ ids = out->frame;
ofpact_update_len(out, &ids->ofpact);
return error;
}
for (i = 0; i < ids->n_controllers; i++) {
uint16_t id = ntohs(((ovs_be16 *)(nac_ids + 1))[i]);
ofpbuf_put(out, &id, sizeof id);
- ids = out->l2;
+ ids = out->frame;
}
ofpact_update_len(out, &ids->ofpact);
case OFPUTIL_ACTION_INVALID:
#define OFPAT10_ACTION(ENUM, STRUCT, NAME) case OFPUTIL_##ENUM:
#define OFPAT11_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) case OFPUTIL_##ENUM:
+#define OFPAT13_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) case OFPUTIL_##ENUM:
#include "ofp-util.def"
OVS_NOT_REACHED();
switch (code) {
case OFPUTIL_ACTION_INVALID:
#define OFPAT11_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) case OFPUTIL_##ENUM:
+#define OFPAT13_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) case OFPUTIL_##ENUM:
#include "ofp-util.def"
OVS_NOT_REACHED();
actions = ofpbuf_try_pull(openflow, actions_len);
if (actions == NULL) {
VLOG_WARN_RL(&rl, "OpenFlow message actions length %u exceeds "
- "remaining message length (%"PRIuSIZE")",
- actions_len, openflow->size);
+ "remaining message length (%"PRIu32")",
+ actions_len, ofpbuf_size(openflow));
return OFPERR_OFPBRC_BAD_LEN;
}
return error;
}
- error = ofpacts_verify(ofpacts->data, ofpacts->size);
+ error = ofpacts_verify(ofpbuf_data(ofpacts), ofpbuf_size(ofpacts));
if (error) {
ofpbuf_clear(ofpacts);
}
set_field_to_openflow(const struct ofpact_set_field *sf,
struct ofpbuf *openflow)
{
- struct ofp_header *oh = (struct ofp_header *)openflow->l2;
+ struct ofp_header *oh = (struct ofp_header *)openflow->frame;
if (oh->version >= OFP12_VERSION) {
set_field_to_openflow12(sf, openflow);
switch (code) {
case OFPUTIL_ACTION_INVALID:
#define OFPAT10_ACTION(ENUM, STRUCT, NAME) case OFPUTIL_##ENUM:
+#define OFPAT13_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) case OFPUTIL_##ENUM:
#include "ofp-util.def"
OVS_NOT_REACHED();
const struct ofpact *a;
target = NULL;
- OFPACT_FOR_EACH (a, in->data, in->size) {
+ OFPACT_FOR_EACH (a, ofpbuf_data(in), ofpbuf_size(in)) {
if (a->type == filter) {
target = a;
}
{
const struct ofpact *a;
- OFPACT_FOR_EACH (a, in->data, in->size) {
+ OFPACT_FOR_EACH (a, ofpbuf_data(in), ofpbuf_size(in)) {
if (filter(a)) {
ofpact_copy(out, a);
}
{
enum ofperr error;
struct ofpact *a;
- size_t start = out->size;
+ size_t start = ofpbuf_size(out);
error = ofpacts_from_openflow(in, n_in, version, out);
return error;
}
- OFPACT_FOR_EACH (a, ofpact_end(out->data, start), out->size - start) {
+ OFPACT_FOR_EACH (a, ofpact_end(ofpbuf_data(out), start), ofpbuf_size(out) - start) {
if (!ofpact_is_allowed_in_actions_set(a)) {
VLOG_WARN_RL(&rl, "disallowed action in action set");
return OFPERR_OFPBAC_BAD_TYPE;
}
}
+enum ofperr
+ovs_instruction_type_from_inst_type(enum ovs_instruction_type *instruction_type,
+ const uint16_t inst_type)
+{
+ switch (inst_type) {
+
+#define DEFINE_INST(ENUM, STRUCT, EXTENSIBLE, NAME) \
+ case ENUM: \
+ *instruction_type = OVSINST_##ENUM; \
+ return 0;
+OVS_INSTRUCTIONS
+#undef DEFINE_INST
+
+ default:
+ return OFPERR_OFPBIC_UNKNOWN_INST;
+ }
+}
+
static inline struct ofp11_instruction *
instruction_next(const struct ofp11_instruction *inst)
{
instructions = ofpbuf_try_pull(openflow, instructions_len);
if (instructions == NULL) {
VLOG_WARN_RL(&rl, "OpenFlow message instructions length %u exceeds "
- "remaining message length (%"PRIuSIZE")",
- instructions_len, openflow->size);
+ "remaining message length (%"PRIu32")",
+ instructions_len, ofpbuf_size(openflow));
error = OFPERR_OFPBIC_BAD_LEN;
goto exit;
}
size_t start;
ofpact_pad(ofpacts);
- start = ofpacts->size;
+ start = ofpbuf_size(ofpacts);
on = ofpact_put(ofpacts, OFPACT_WRITE_ACTIONS,
offsetof(struct ofpact_nest, actions));
get_actions_from_instruction(insts[OVSINST_OFPIT11_WRITE_ACTIONS],
goto exit;
}
on = ofpbuf_at_assert(ofpacts, start, sizeof *on);
- on->ofpact.len = ofpacts->size - start;
+ on->ofpact.len = ofpbuf_size(ofpacts) - start;
}
if (insts[OVSINST_OFPIT11_WRITE_METADATA]) {
const struct ofp11_instruction_write_metadata *oiwm;
ogt->table_id = oigt->table_id;
}
- error = ofpacts_verify(ofpacts->data, ofpacts->size);
+ error = ofpacts_verify(ofpbuf_data(ofpacts), ofpbuf_size(ofpacts));
exit:
if (error) {
ofpbuf_clear(ofpacts);
static void
ofpact_note_to_nxast(const struct ofpact_note *note, struct ofpbuf *out)
{
- size_t start_ofs = out->size;
+ size_t start_ofs = ofpbuf_size(out);
struct nx_action_note *nan;
unsigned int remainder;
unsigned int len;
nan = ofputil_put_NXAST_NOTE(out);
- out->size -= sizeof nan->note;
+ ofpbuf_set_size(out, ofpbuf_size(out) - sizeof nan->note);
ofpbuf_put(out, note->data, note->length);
- len = out->size - start_ofs;
+ len = ofpbuf_size(out) - start_ofs;
remainder = len % OFP_ACTION_ALIGN;
if (remainder) {
ofpbuf_put_zeros(out, OFP_ACTION_ALIGN - remainder);
}
nan = ofpbuf_at(out, start_ofs, sizeof *nan);
- nan->len = htons(out->size - start_ofs);
+ nan->len = htons(ofpbuf_size(out) - start_ofs);
}
static void
* follow this action. */
break;
+ case OFPACT_SET_IP_ECN:
+ case OFPACT_SET_IP_TTL:
case OFPACT_CLEAR_ACTIONS:
case OFPACT_WRITE_ACTIONS:
case OFPACT_GOTO_TABLE:
case OFPACT_STACK_PUSH:
case OFPACT_STACK_POP:
case OFPACT_DEC_TTL:
- case OFPACT_SET_IP_ECN:
- case OFPACT_SET_IP_TTL:
case OFPACT_SET_MPLS_LABEL:
case OFPACT_SET_MPLS_TC:
case OFPACT_SET_MPLS_TTL:
enum ofp_version ofp_version)
{
const struct ofpact *a;
- size_t start_size = openflow->size;
+ size_t start_size = ofpbuf_size(openflow);
void (*translate)(const struct ofpact *a, struct ofpbuf *out) =
(ofp_version == OFP10_VERSION) ? ofpact_to_openflow10 :
OFPACT_FOR_EACH (a, ofpacts, ofpacts_len) {
translate(a, openflow);
}
- return openflow->size - start_size;
+ return ofpbuf_size(openflow) - start_size;
}
static void
/* Update the instruction's length (or, if it's empty, delete it). */
oia = ofpbuf_at_assert(openflow, ofs, sizeof *oia);
- if (openflow->size > ofs + sizeof *oia) {
- oia->len = htons(openflow->size - ofs);
+ if (ofpbuf_size(openflow) > ofs + sizeof *oia) {
+ oia->len = htons(ofpbuf_size(openflow) - ofs);
} else {
- openflow->size = ofs;
+ ofpbuf_set_size(openflow, ofs);
}
}
break;
case OVSINST_OFPIT11_APPLY_ACTIONS: {
- const size_t ofs = openflow->size;
+ const size_t ofs = ofpbuf_size(openflow);
const size_t ofpacts_len_left =
(uint8_t*)ofpact_end(ofpacts, ofpacts_len) - (uint8_t*)a;
const struct ofpact *action;
}
case OVSINST_OFPIT11_WRITE_ACTIONS: {
- const size_t ofs = openflow->size;
+ const size_t ofs = ofpbuf_size(openflow);
const struct ofpact_nest *on;
on = ofpact_get_WRITE_ACTIONS(a);
struct ofpact *ofpact;
ofpact_pad(ofpacts);
- ofpact = ofpacts->l2 = ofpbuf_put_uninit(ofpacts, len);
+ ofpact = ofpacts->frame = ofpbuf_put_uninit(ofpacts, len);
ofpact_init(ofpact, type, len);
return ofpact;
}
void
ofpact_update_len(struct ofpbuf *ofpacts, struct ofpact *ofpact)
{
- ovs_assert(ofpact == ofpacts->l2);
+ ovs_assert(ofpact == ofpacts->frame);
ofpact->len = (char *) ofpbuf_tail(ofpacts) - (char *) ofpact;
}
void
ofpact_pad(struct ofpbuf *ofpacts)
{
- unsigned int rem = ofpacts->size % OFPACT_ALIGNTO;
- if (rem) {
- ofpbuf_put_zeros(ofpacts, OFPACT_ALIGNTO - rem);
+ unsigned int pad = PAD_SIZE(ofpbuf_size(ofpacts), OFPACT_ALIGNTO);
+ if (pad) {
+ ofpbuf_put_zeros(ofpacts, pad);
}
}
git://git.onelab.eu / sliver-openvswitch.git / blobdiff