#include "openflow/nicira-ext.h"
#include "packets.h"
#include "shash.h"
+#include "tun-metadata.h"
#include "unaligned.h"
#include "util.h"
#include "openvswitch/vlog.h"
enum ofp_version);
static void nx_put_header__(struct ofpbuf *, uint64_t header, bool masked);
+static void nx_put_header_len(struct ofpbuf *, enum mf_field_id field,
+ enum ofp_version version, bool masked,
+ size_t n_bytes);
/* Rate limit for nx_match parse errors. These always indicate a bug in the
* peer and so there's not much point in showing a lot of them. */
}
*header = ntohll(get_unaligned_be64(b->data));
}
- if (nxm_length(*header) <= nxm_experimenter_len(*header)) {
+ if (nxm_length(*header) < nxm_experimenter_len(*header)) {
VLOG_WARN_RL(&rl, "OXM header "NXM_HEADER_FMT" has invalid length %d "
"(minimum is %d)",
NXM_HEADER_ARGS(*header), nxm_length(*header),
- nxm_header_len(*header) + 1);
+ nxm_header_len(*header));
goto error;
}
ofpbuf_pull(b, nxm_header_len(*header));
} else if (!mf_is_all_wild(field, &match->wc)) {
error = OFPERR_OFPBMC_DUP_FIELD;
} else {
- mf_set(field, &value, &mask, match);
+ char *err_str;
+
+ mf_set(field, &value, &mask, match, &err_str);
+ if (err_str) {
+ VLOG_DBG_RL(&rl, "error parsing OXM at offset %"PRIdPTR" "
+ "within match (%s)", pos - p, err_str);
+ free(err_str);
+ return OFPERR_OFPBMC_BAD_VALUE;
+ }
}
if (error) {
* 'put' functions whose names end in 'm' add a field that might be wildcarded.
* Other 'put' functions add exact-match fields.
*/
-
-static void
-nxm_put_unmasked(struct ofpbuf *b, enum mf_field_id field,
- enum ofp_version version, const void *value, size_t n_bytes)
+void
+nxm_put__(struct ofpbuf *b, enum mf_field_id field, enum ofp_version version,
+ const void *value, const void *mask, size_t n_bytes)
{
- nx_put_header(b, field, version, false);
+ nx_put_header_len(b, field, version, !!mask, n_bytes);
ofpbuf_put(b, value, n_bytes);
+ if (mask) {
+ ofpbuf_put(b, mask, n_bytes);
+ }
+
}
static void
{
if (!is_all_zeros(mask, n_bytes)) {
bool masked = !is_all_ones(mask, n_bytes);
- nx_put_header(b, field, version, masked);
- ofpbuf_put(b, value, n_bytes);
- if (masked) {
- ofpbuf_put(b, mask, n_bytes);
- }
+ nxm_put__(b, field, version, value, masked ? mask : NULL, n_bytes);
}
}
nxm_put_8(struct ofpbuf *b, enum mf_field_id field, enum ofp_version version,
uint8_t value)
{
- nxm_put_unmasked(b, field, version, &value, sizeof value);
+ nxm_put__(b, field, version, &value, NULL, sizeof value);
}
static void
nxm_put_16(struct ofpbuf *b, enum mf_field_id field, enum ofp_version version,
ovs_be16 value)
{
- nxm_put_unmasked(b, field, version, &value, sizeof value);
+ nxm_put__(b, field, version, &value, NULL, sizeof value);
}
static void
nxm_put_32(struct ofpbuf *b, enum mf_field_id field, enum ofp_version version,
ovs_be32 value)
{
- nxm_put_unmasked(b, field, version, &value, sizeof value);
+ nxm_put__(b, field, version, &value, NULL, sizeof value);
}
static void
static void
nxm_put_eth_masked(struct ofpbuf *b,
enum mf_field_id field, enum ofp_version version,
- const uint8_t value[ETH_ADDR_LEN],
- const uint8_t mask[ETH_ADDR_LEN])
+ const struct eth_addr value, const struct eth_addr mask)
{
- nxm_put(b, field, version, value, mask, ETH_ADDR_LEN);
+ nxm_put(b, field, version, value.ea, mask.ea, ETH_ADDR_LEN);
}
static void
int match_len;
int i;
- BUILD_ASSERT_DECL(FLOW_WC_SEQ == 31);
+ BUILD_ASSERT_DECL(FLOW_WC_SEQ == 34);
/* Metadata. */
if (match->wc.masks.dp_hash) {
flow->tunnel.tun_id, match->wc.masks.tunnel.tun_id);
/* Other tunnel metadata. */
+ nxm_put_16m(b, MFF_TUN_FLAGS, oxm,
+ htons(flow->tunnel.flags), htons(match->wc.masks.tunnel.flags));
nxm_put_32m(b, MFF_TUN_SRC, oxm,
flow->tunnel.ip_src, match->wc.masks.tunnel.ip_src);
nxm_put_32m(b, MFF_TUN_DST, oxm,
flow->tunnel.gbp_id, match->wc.masks.tunnel.gbp_id);
nxm_put_8m(b, MFF_TUN_GBP_FLAGS, oxm,
flow->tunnel.gbp_flags, match->wc.masks.tunnel.gbp_flags);
+ tun_metadata_to_nx_match(b, oxm, match);
/* Registers. */
if (oxm < OFP15_VERSION) {
nxm_put_32m(b, MFF_PKT_MARK, oxm, htonl(flow->pkt_mark),
htonl(match->wc.masks.pkt_mark));
+ /* Connection tracking. */
+ nxm_put_32m(b, MFF_CT_STATE, oxm, htonl(flow->ct_state),
+ htonl(match->wc.masks.ct_state));
+ nxm_put_16m(b, MFF_CT_ZONE, oxm, htons(flow->ct_zone),
+ htons(match->wc.masks.ct_zone));
+
/* OpenFlow 1.1+ Metadata. */
nxm_put_64m(b, MFF_METADATA, oxm,
flow->metadata, match->wc.masks.metadata);
for (i = 0; i < MFF_N_IDS; i++) {
if (bitmap_is_set(fa->used.bm, i)) {
- nxm_put_unmasked(b, i, version, &fa->value[i],
- mf_from_id(i)->n_bytes);
+ int len = mf_field_len(mf_from_id(i), &fa->value[i], NULL, NULL);
+ nxm_put__(b, i, version,
+ &fa->value[i].u8 + mf_from_id(i)->n_bytes - len, NULL,
+ len);
}
}
nx_put_header__(b, mf_oxm_header(field, version), masked);
}
+static void
+nx_put_header_len(struct ofpbuf *b, enum mf_field_id field,
+ enum ofp_version version, bool masked, size_t n_bytes)
+{
+ uint64_t header = mf_oxm_header(field, version);
+
+ header = NXM_HEADER(nxm_vendor(header), nxm_class(header),
+ nxm_field(header), false,
+ nxm_experimenter_len(header) + n_bytes);
+
+ nx_put_header__(b, header, masked);
+}
+
void
nx_put_entry(struct ofpbuf *b,
enum mf_field_id field, enum ofp_version version,
const union mf_value *value, const union mf_value *mask)
{
- int n_bytes = mf_from_id(field)->n_bytes;
- bool masked = mask && !is_all_ones(mask, n_bytes);
+ const struct mf_field *mf = mf_from_id(field);
+ bool masked;
+ int len, offset;
- nx_put_header(b, field, version, masked);
- ofpbuf_put(b, value, n_bytes);
+ len = mf_field_len(mf, value, mask, &masked);
+ offset = mf->n_bytes - len;
+
+ nx_put_header_len(b, field, version, masked, len);
+ ofpbuf_put(b, &value->u8 + offset, len);
if (masked) {
- ofpbuf_put(b, mask, n_bytes);
+ ofpbuf_put(b, &mask->u8 + offset, len);
}
}
\f
for (s += strspn(s, ", "); *s; s += strspn(s, ", ")) {
const char *name;
uint64_t header;
+ ovs_be64 nw_header;
+ ovs_be64 *header_ptr;
int name_len;
size_t n;
s += name_len + 1;
- nx_put_header__(b, header, false);
+ header_ptr = ofpbuf_put_uninit(b, nxm_header_len(header));
s = ofpbuf_put_hex(b, s, &n);
if (n != nxm_field_bytes(header)) {
- ovs_fatal(0, "%.2s: hex digits expected", s);
+ const struct mf_field *field = mf_from_oxm_header(header);
+
+ if (field && field->variable_len) {
+ if (n <= field->n_bytes) {
+ int len = (nxm_hasmask(header) ? n * 2 : n) +
+ nxm_experimenter_len(header);
+
+ header = NXM_HEADER(nxm_vendor(header), nxm_class(header),
+ nxm_field(header),
+ nxm_hasmask(header) ? 1 : 0, len);
+ } else {
+ ovs_fatal(0, "expected to read at most %d bytes but got "
+ "%"PRIuSIZE, field->n_bytes, n);
+ }
+ } else {
+ ovs_fatal(0, "expected to read %d bytes but got %"PRIuSIZE,
+ nxm_field_bytes(header), n);
+ }
}
+ nw_header = htonll(header);
+ memcpy(header_ptr, &nw_header, nxm_header_len(header));
+
if (nxm_hasmask(header)) {
s += strspn(s, " ");
if (*s != '/') {
union mf_value src_value;
union mf_value dst_value;
- mf_mask_field_and_prereqs(move->dst.field, &wc->masks);
- mf_mask_field_and_prereqs(move->src.field, &wc->masks);
+ mf_mask_field_and_prereqs(move->dst.field, wc);
+ mf_mask_field_and_prereqs(move->src.field, wc);
/* A flow may wildcard nw_frag. Do nothing if setting a transport
* header field on a packet that does not have them. */