static enum ofperr
process_switch_features(struct lswitch *sw, struct ofp_header *oh)
{
struct ofputil_switch_features features;
struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length));
enum ofperr error = ofputil_pull_switch_features(&b, &features);
if (error) {
VLOG_ERR("received invalid switch feature reply (%s)",
ofperr_to_string(error));
return error;
}
sw->datapath_id = features.datapath_id;
return 0;
}
static enum ofperr
nx_pull_raw(const uint8_t *p, unsigned int match_len, bool strict,
struct match *match, ovs_be64 *cookie, ovs_be64 *cookie_mask)
{
uint32_t header;
ovs_assert((cookie != NULL) == (cookie_mask != NULL));
match_init_catchall(match);
if (cookie) {
*cookie = *cookie_mask = htonll(0);
}
if (!match_len) {
return 0;
}
for (;
(header = nx_entry_ok(p, match_len)) != 0;
p += 4 + NXM_LENGTH(header), match_len -= 4 + NXM_LENGTH(header)) {
const struct mf_field *mf;
enum ofperr error;
mf = mf_from_nxm_header(header);
if (!mf) {
if (strict) {
error = OFPERR_OFPBMC_BAD_FIELD;
} else {
continue;
}
} else if (!mf_are_prereqs_ok(mf, &match->flow)) {
error = OFPERR_OFPBMC_BAD_PREREQ;
} else if (!mf_is_all_wild(mf, &match->wc)) {
error = OFPERR_OFPBMC_DUP_FIELD;
} else {
unsigned int width = mf->n_bytes;
union mf_value value;
memcpy(&value, p + 4, width);
if (!mf_is_value_valid(mf, &value)) {
error = OFPERR_OFPBMC_BAD_VALUE;
} else if (!NXM_HASMASK(header)) {
error = 0;
mf_set_value(mf, &value, match);
} else {
union mf_value mask;
memcpy(&mask, p + 4 + width, width);
if (!mf_is_mask_valid(mf, &mask)) {
error = OFPERR_OFPBMC_BAD_MASK;
} else {
error = check_mask_consistency(p, mf);
if (!error) {
mf_set(mf, &value, &mask, match);
}
}
}
}
/* Check if the match is for a cookie rather than a classifier rule. */
if ((header == NXM_NX_COOKIE || header == NXM_NX_COOKIE_W) && cookie) {
if (*cookie_mask) {
error = OFPERR_OFPBMC_DUP_FIELD;
} else {
unsigned int width = sizeof *cookie;
memcpy(cookie, p + 4, width);
if (NXM_HASMASK(header)) {
memcpy(cookie_mask, p + 4 + width, width);
} else {
*cookie_mask = OVS_BE64_MAX;
}
error = 0;
}
}
if (error) {
VLOG_DBG_RL(&rl, "bad nxm_entry %#08"PRIx32" (vendor=%"PRIu32", "
"field=%"PRIu32", hasmask=%"PRIu32", len=%"PRIu32"), "
"(%s)", header,
NXM_VENDOR(header), NXM_FIELD(header),
NXM_HASMASK(header), NXM_LENGTH(header),
ofperr_to_string(error));
return error;
}
}
return match_len ? OFPERR_OFPBMC_BAD_LEN : 0;
}
/* Parses 'arg' as a set of arguments to the "learn" action and appends a
* matching NXAST_LEARN action to 'b'. The format parsed is described in
* ovs-ofctl(8).
*
* Prints an error on stderr and aborts the program if 'arg' syntax is invalid.
*
* If 'flow' is nonnull, then it should be the flow from a cls_rule that is
* the matching rule for the learning action. This helps to better validate
* the action's arguments.
*
* Modifies 'arg'. */
void
learn_parse(struct ofpbuf *b, char *arg, const struct flow *flow)
{
char *orig = xstrdup(arg);
char *name, *value;
enum ofperr error;
size_t learn_ofs;
size_t len;
struct nx_action_learn *learn;
struct cls_rule rule;
learn_ofs = b->size;
learn = ofputil_put_NXAST_LEARN(b);
learn->idle_timeout = htons(OFP_FLOW_PERMANENT);
learn->hard_timeout = htons(OFP_FLOW_PERMANENT);
learn->priority = htons(OFP_DEFAULT_PRIORITY);
learn->cookie = htonll(0);
learn->flags = htons(0);
learn->table_id = 1;
cls_rule_init_catchall(&rule, 0);
while (ofputil_parse_key_value(&arg, &name, &value)) {
learn = ofpbuf_at_assert(b, learn_ofs, sizeof *learn);
if (!strcmp(name, "table")) {
learn->table_id = atoi(value);
if (learn->table_id == 255) {
ovs_fatal(0, "%s: table id 255 not valid for `learn' action",
orig);
}
} else if (!strcmp(name, "priority")) {
learn->priority = htons(atoi(value));
} else if (!strcmp(name, "idle_timeout")) {
learn->idle_timeout = htons(atoi(value));
} else if (!strcmp(name, "hard_timeout")) {
learn->hard_timeout = htons(atoi(value));
} else if (!strcmp(name, "fin_idle_timeout")) {
learn->fin_idle_timeout = htons(atoi(value));
} else if (!strcmp(name, "fin_hard_timeout")) {
learn->fin_hard_timeout = htons(atoi(value));
} else if (!strcmp(name, "cookie")) {
learn->cookie = htonll(strtoull(value, NULL, 0));
} else {
struct learn_spec spec;
learn_parse_spec(orig, name, value, &spec);
/* Check prerequisites. */
if (spec.src_type == NX_LEARN_SRC_FIELD
&& flow && !mf_are_prereqs_ok(spec.src.field, flow)) {
ovs_fatal(0, "%s: cannot specify source field %s because "
"prerequisites are not satisfied",
orig, spec.src.field->name);
}
if ((spec.dst_type == NX_LEARN_DST_MATCH
|| spec.dst_type == NX_LEARN_DST_LOAD)
&& !mf_are_prereqs_ok(spec.dst.field, &rule.flow)) {
ovs_fatal(0, "%s: cannot specify destination field %s because "
"prerequisites are not satisfied",
orig, spec.dst.field->name);
}
/* Update 'rule' to allow for satisfying destination
* prerequisites. */
if (spec.src_type == NX_LEARN_SRC_IMMEDIATE
&& spec.dst_type == NX_LEARN_DST_MATCH) {
mf_write_subfield(&spec.dst, &spec.src_imm, &rule);
}
/* Output the flow_mod_spec. */
put_u16(b, spec.n_bits | spec.src_type | spec.dst_type);
if (spec.src_type == NX_LEARN_SRC_IMMEDIATE) {
int n_bytes = DIV_ROUND_UP(spec.n_bits, 16) * 2;
int ofs = sizeof spec.src_imm - n_bytes;
ofpbuf_put(b, &spec.src_imm.u8[ofs], n_bytes);
} else {
put_u32(b, spec.src.field->nxm_header);
put_u16(b, spec.src.ofs);
}
if (spec.dst_type == NX_LEARN_DST_MATCH ||
spec.dst_type == NX_LEARN_DST_LOAD) {
put_u32(b, spec.dst.field->nxm_header);
put_u16(b, spec.dst.ofs);
} else {
assert(spec.dst_type == NX_LEARN_DST_OUTPUT);
}
}
}
put_u16(b, 0);
len = b->size - learn_ofs;
if (len % 8) {
ofpbuf_put_zeros(b, 8 - len % 8);
}
learn = ofpbuf_at_assert(b, learn_ofs, sizeof *learn);
learn->len = htons(b->size - learn_ofs);
/* In theory the above should have caught any errors, but... */
if (flow) {
error = learn_check(learn, flow);
if (error) {
ovs_fatal(0, "%s: %s", orig, ofperr_to_string(error));
}
}
free(orig);
}
static void
process_packet_in(struct lswitch *sw, const struct ofp_header *oh)
{
struct ofputil_packet_in pi;
uint32_t buffer_id;
uint64_t ofpacts_stub[64];
struct ofpbuf ofpacts;
struct ofputil_packet_out po;
enum ofperr error;
uint8_t icmp_packet[128];
const struct mf_field *mf;
const struct mf_field *mf_id;
union mf_value sf_value, sf_mask;
union mf_value sf_value_id, sf_mask_id;
error = ofputil_decode_packet_in(oh, true, &pi, NULL, &buffer_id, NULL);
if (error) {
VLOG_WARN_RL(&rl, "failed to decode packet-in: %s",
ofperr_to_string(error));
return;
}
/* Ignore packets sent via output to OFPP_CONTROLLER. This library never
* uses such an action. You never know what experiments might be going on,
* though, and it seems best not to interfere with them. */
if (pi.reason != OFPR_ACTION || buffer_id != UINT32_MAX) {
return;
}
struct ethhdr *old_pkt = pi.packet;
struct iphdr * old_ipv4 = (struct iphdr*)(old_pkt + 1);
uint16_t old_tot_len = ntohs(old_ipv4->tot_len);
uint8_t header_len = old_ipv4->ihl*4;
if (pi.packet_len < header_len + sizeof(struct ethhdr) + 8 || old_tot_len < header_len + 8)
return;
if (old_pkt->h_proto != htons(ETH_P_IP))
return;
//VLOG_INFO("AFTER MATCH");
uint32_t icmp_packet_len = sizeof(struct ethhdr) + sizeof(struct iphdr) + header_len + sizeof(struct icmphdr) + 8;
icmp_unexpect_ttl(icmp_packet, &pi, header_len, ICMP_TIME_EXCEEDED, ICMP_EXC_TTL, 0);
ofpbuf_use_stack(&ofpacts, ofpacts_stub, sizeof ofpacts_stub);
mf_id = mf_from_name("tun_id");
if (!mf_id)
return;
sf_value_id.be64 = pi.flow_metadata.flow.tunnel.tun_id;
sf_mask_id.be64 = OVS_BE64_MAX;
ofpact_put_set_field(&ofpacts, mf_id, &sf_value_id, &sf_mask_id);
mf = mf_from_name("tun_dst");
if (!mf)
return;
sf_value.be32 = pi.flow_metadata.flow.tunnel.ip_src;
sf_mask.be32 = OVS_BE32_MAX;
ofpact_put_set_field(&ofpacts, mf, &sf_value, &sf_mask);
ofpact_put_OUTPUT(&ofpacts)->port = OFPP_IN_PORT;
/* Prepare packet_out in case we need one. */
po.buffer_id = buffer_id;
po.packet = icmp_packet;
po.packet_len = icmp_packet_len;
po.in_port = pi.flow_metadata.flow.in_port.ofp_port;
po.ofpacts = ofpacts.data;
po.ofpacts_len = ofpacts.size;
queue_tx(sw, ofputil_encode_packet_out(&po, sw->protocol));
//VLOG_INFO("AFTER MATCH last");
}