struct ofpbuf *
flow_mod_match_conj(enum ofputil_protocol proto)
{
struct ofputil_flow_mod fm;
struct ofpbuf acts;
struct ofpact_ipv4 *a_set_field;
struct ofpact_goto_table *a_goto;
memset(&fm, 0, sizeof(fm));
fm.command = OFPFC_ADD;
fm.table_id = 3;
fm.new_cookie = htonll(0x123456789abcdef0);
fm.cookie_mask = OVS_BE64_MAX;
fm.importance = 0x9878;
match_init_catchall(&fm.match);
match_set_conj_id(&fm.match, 0xabcdef);
ofpbuf_init(&acts, 64);
ofpact_put_STRIP_VLAN(&acts);
a_set_field = ofpact_put_SET_IPV4_DST(&acts);
a_set_field->ipv4 = inet_addr("192.168.2.9");
a_goto = ofpact_put_GOTO_TABLE(&acts);
a_goto->table_id = 100;
fm.ofpacts = acts.data;
fm.ofpacts_len = acts.size;
return ofputil_encode_flow_mod(&fm, proto);
}
/* Convert 'str_' (as described in the documentation for the "monitor" command
* in the ovs-ofctl man page) into 'fmr'. */
void
parse_flow_monitor_request(struct ofputil_flow_monitor_request *fmr,
const char *str_)
{
static uint32_t id;
char *string = xstrdup(str_);
char *save_ptr = NULL;
char *name;
fmr->id = id++;
fmr->flags = (NXFMF_INITIAL | NXFMF_ADD | NXFMF_DELETE | NXFMF_MODIFY
| NXFMF_OWN | NXFMF_ACTIONS);
fmr->out_port = OFPP_NONE;
fmr->table_id = 0xff;
match_init_catchall(&fmr->match);
for (name = strtok_r(string, "=, \t\r\n", &save_ptr); name;
name = strtok_r(NULL, "=, \t\r\n", &save_ptr)) {
const struct protocol *p;
if (!strcmp(name, "!initial")) {
fmr->flags &= ~NXFMF_INITIAL;
} else if (!strcmp(name, "!add")) {
fmr->flags &= ~NXFMF_ADD;
} else if (!strcmp(name, "!delete")) {
fmr->flags &= ~NXFMF_DELETE;
} else if (!strcmp(name, "!modify")) {
fmr->flags &= ~NXFMF_MODIFY;
} else if (!strcmp(name, "!actions")) {
fmr->flags &= ~NXFMF_ACTIONS;
} else if (!strcmp(name, "!own")) {
fmr->flags &= ~NXFMF_OWN;
} else if (parse_protocol(name, &p)) {
match_set_dl_type(&fmr->match, htons(p->dl_type));
if (p->nw_proto) {
match_set_nw_proto(&fmr->match, p->nw_proto);
}
} else {
char *value;
value = strtok_r(NULL, ", \t\r\n", &save_ptr);
if (!value) {
ovs_fatal(0, "%s: field %s missing value", str_, name);
}
if (!strcmp(name, "table")) {
fmr->table_id = str_to_u8(value, name);
} else if (!strcmp(name, "out_port")) {
fmr->out_port = u16_to_ofp(atoi(value));
} else if (mf_from_name(name)) {
parse_field(mf_from_name(name), value, &fmr->match);
} else {
ovs_fatal(0, "%s: unknown keyword %s", str_, name);
}
}
}
free(string);
}
/* Returns NULL if successful, otherwise a malloc()'d string describing the
* error. The caller is responsible for freeing the returned string. */
static char * WARN_UNUSED_RESULT
learn_parse__(char *orig, char *arg, struct ofpbuf *ofpacts)
{
struct ofpact_learn *learn;
struct match match;
char *name, *value;
learn = ofpact_put_LEARN(ofpacts);
learn->idle_timeout = OFP_FLOW_PERMANENT;
learn->hard_timeout = OFP_FLOW_PERMANENT;
learn->priority = OFP_DEFAULT_PRIORITY;
learn->table_id = 1;
match_init_catchall(&match);
while (ofputil_parse_key_value(&arg, &name, &value)) {
if (!strcmp(name, "table")) {
learn->table_id = atoi(value);
if (learn->table_id == 255) {
return xasprintf("%s: table id 255 not valid for `learn' "
"action", orig);
}
} else if (!strcmp(name, "priority")) {
learn->priority = atoi(value);
} else if (!strcmp(name, "idle_timeout")) {
learn->idle_timeout = atoi(value);
} else if (!strcmp(name, "hard_timeout")) {
learn->hard_timeout = atoi(value);
} else if (!strcmp(name, "fin_idle_timeout")) {
learn->fin_idle_timeout = atoi(value);
} else if (!strcmp(name, "fin_hard_timeout")) {
learn->fin_hard_timeout = atoi(value);
} else if (!strcmp(name, "cookie")) {
learn->cookie = strtoull(value, NULL, 0);
} else {
struct ofpact_learn_spec *spec;
char *error;
spec = ofpbuf_put_zeros(ofpacts, sizeof *spec);
learn = ofpacts->frame;
learn->n_specs++;
error = learn_parse_spec(orig, name, value, spec);
if (error) {
return error;
}
/* Update 'match' 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, &match);
}
}
}
ofpact_update_len(ofpacts, &learn->ofpact);
return NULL;
}
/* Returns NULL if successful, otherwise a malloc()'d string describing the
* error. The caller is responsible for freeing the returned string. */
static char * OVS_WARN_UNUSED_RESULT
learn_parse__(char *orig, char *arg, struct ofpbuf *ofpacts)
{
struct ofpact_learn *learn;
struct match match;
char *name, *value;
learn = ofpact_put_LEARN(ofpacts);
learn->idle_timeout = OFP_FLOW_PERMANENT;
learn->hard_timeout = OFP_FLOW_PERMANENT;
learn->priority = OFP_DEFAULT_PRIORITY;
learn->table_id = 1;
match_init_catchall(&match);
while (ofputil_parse_key_value(&arg, &name, &value)) {
if (!strcmp(name, "table")) {
learn->table_id = atoi(value);
if (learn->table_id == 255) {
return xasprintf("%s: table id 255 not valid for `learn' "
"action", orig);
}
} else if (!strcmp(name, "priority")) {
learn->priority = atoi(value);
} else if (!strcmp(name, "idle_timeout")) {
learn->idle_timeout = atoi(value);
} else if (!strcmp(name, "hard_timeout")) {
learn->hard_timeout = atoi(value);
} else if (!strcmp(name, "fin_idle_timeout")) {
learn->fin_idle_timeout = atoi(value);
} else if (!strcmp(name, "fin_hard_timeout")) {
learn->fin_hard_timeout = atoi(value);
} else if (!strcmp(name, "cookie")) {
learn->cookie = htonll(strtoull(value, NULL, 0));
} else if (!strcmp(name, "send_flow_rem")) {
learn->flags |= NX_LEARN_F_SEND_FLOW_REM;
} else if (!strcmp(name, "delete_learned")) {
learn->flags |= NX_LEARN_F_DELETE_LEARNED;
} else {
struct ofpact_learn_spec *spec;
char *error;
spec = ofpbuf_put_zeros(ofpacts, sizeof *spec);
error = learn_parse_spec(orig, name, value, spec, ofpacts, &match);
if (error) {
return error;
}
learn = ofpacts->header;
}
}
ofpact_finish_LEARN(ofpacts, &learn);
return NULL;
}
void
fill_match(struct match *match)
{
match_init_catchall(match);
match_set_in_port(match, 0xabcd);
match_set_dl_vlan(match, htons(999));
match_set_dl_dst(match, "\xaa\xbb\xcc\x99\x88\x77");
match_set_dl_type(match, htons(ETH_TYPE_IP));
match_set_nw_dst(match, inet_addr("192.168.2.1"));
match_set_tun_src(match, inet_addr("192.168.2.3"));
match_set_tun_dst(match, inet_addr("192.168.2.4"));
match_set_tun_id(match, htonll(50000));
}
void
fill_match(struct match *match)
{
const struct eth_addr dl_dst =
{ { { 0xaa, 0xbb, 0xcc, 0x99, 0x88, 0x77 } } };
match_init_catchall(match);
match_set_in_port(match, 0xabcd);
match_set_dl_vlan(match, htons(999));
match_set_dl_dst(match, dl_dst);
match_set_dl_type(match, htons(ETH_TYPE_IP));
match_set_nw_dst(match, inet_addr("192.168.2.1"));
match_set_tun_src(match, inet_addr("192.168.2.3"));
match_set_tun_dst(match, inet_addr("192.168.2.4"));
match_set_tun_id(match, htonll(50000));
}
struct ofpbuf *
aggregate_stats_request(enum ofputil_protocol proto)
{
struct ofputil_flow_stats_request fsr;
memset(&fsr, 0, sizeof(fsr));
fsr.aggregate = true;
match_init_catchall(&fsr.match);
fsr.out_port = OFPP_ANY;
fsr.out_group = OFPG_ANY;
fsr.table_id = OFPTT_ALL;
fsr.cookie = fsr.cookie_mask = htonll(0);
return ofputil_encode_flow_stats_request(&fsr, proto);
}
/* Checks that 'learn' is a valid action on 'flow'. Returns 0 if it is valid,
* otherwise an OFPERR_*. */
enum ofperr
learn_check(const struct ofpact_learn *learn, const struct match *src_match)
{
const struct ofpact_learn_spec *spec;
struct match dst_match;
match_init_catchall(&dst_match);
OFPACT_LEARN_SPEC_FOR_EACH (spec, learn) {
enum ofperr error;
/* Check the source. */
if (spec->src_type == NX_LEARN_SRC_FIELD) {
error = mf_check_src(&spec->src, src_match);
if (error) {
return error;
}
}
/* Check the destination. */
switch (spec->dst_type) {
case NX_LEARN_DST_MATCH:
error = mf_check_src(&spec->dst, &dst_match);
if (error) {
return error;
}
if (spec->src_type & NX_LEARN_SRC_IMMEDIATE) {
mf_write_subfield_value(&spec->dst,
ofpact_learn_spec_imm(spec),
&dst_match);
}
break;
case NX_LEARN_DST_LOAD:
error = mf_check_dst(&spec->dst, &dst_match);
if (error) {
return error;
}
break;
case NX_LEARN_DST_OUTPUT:
/* Nothing to do. */
break;
}
}
return 0;
}
/* Checks that 'learn' is a valid action on 'flow'. Returns 0 if it is valid,
* otherwise an OFPERR_*. */
enum ofperr
learn_check(const struct ofpact_learn *learn, const struct flow *flow)
{
const struct ofpact_learn_spec *spec;
struct match match;
match_init_catchall(&match);
for (spec = learn->specs; spec < &learn->specs[learn->n_specs]; spec++) {
enum ofperr error;
/* Check the source. */
if (spec->src_type == NX_LEARN_SRC_FIELD) {
error = mf_check_src(&spec->src, flow);
if (error) {
return error;
}
}
/* Check the destination. */
switch (spec->dst_type) {
case NX_LEARN_DST_MATCH:
error = mf_check_src(&spec->dst, &match.flow);
if (error) {
return error;
}
mf_write_subfield(&spec->dst, &spec->src_imm, &match);
break;
case NX_LEARN_DST_LOAD:
error = mf_check_dst(&spec->dst, &match.flow);
if (error) {
return error;
}
break;
case NX_LEARN_DST_OUTPUT:
/* Nothing to do. */
break;
}
}
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;
}
/* Convert 'str_' (as described in the Flow Syntax section of the ovs-ofctl man
* page) into 'fm' for sending the specified flow_mod 'command' to a switch.
* If 'actions' is specified, an action must be in 'string' and may be expanded
* or reallocated.
*
* To parse syntax for an OFPT_FLOW_MOD (or NXT_FLOW_MOD), use an OFPFC_*
* constant for 'command'. To parse syntax for an OFPST_FLOW or
* OFPST_AGGREGATE (or NXST_FLOW or NXST_AGGREGATE), use -1 for 'command'. */
void
parse_ofp_str(struct ofputil_flow_mod *fm, int command, const char *str_,
bool verbose)
{
enum {
F_OUT_PORT = 1 << 0,
F_ACTIONS = 1 << 1,
F_TIMEOUT = 1 << 3,
F_PRIORITY = 1 << 4,
F_FLAGS = 1 << 5,
} fields;
char *string = xstrdup(str_);
char *save_ptr = NULL;
char *act_str = NULL;
char *name;
switch (command) {
case -1:
fields = F_OUT_PORT;
break;
case OFPFC_ADD:
fields = F_ACTIONS | F_TIMEOUT | F_PRIORITY | F_FLAGS;
break;
case OFPFC_DELETE:
fields = F_OUT_PORT;
break;
case OFPFC_DELETE_STRICT:
fields = F_OUT_PORT | F_PRIORITY;
break;
case OFPFC_MODIFY:
fields = F_ACTIONS | F_TIMEOUT | F_PRIORITY | F_FLAGS;
break;
case OFPFC_MODIFY_STRICT:
fields = F_ACTIONS | F_TIMEOUT | F_PRIORITY | F_FLAGS;
break;
default:
NOT_REACHED();
}
match_init_catchall(&fm->match);
fm->priority = OFP_DEFAULT_PRIORITY;
fm->cookie = htonll(0);
fm->cookie_mask = htonll(0);
if (command == OFPFC_MODIFY || command == OFPFC_MODIFY_STRICT) {
/* For modify, by default, don't update the cookie. */
fm->new_cookie = htonll(UINT64_MAX);
} else{
fm->new_cookie = htonll(0);
}
fm->table_id = 0xff;
fm->command = command;
fm->idle_timeout = OFP_FLOW_PERMANENT;
fm->hard_timeout = OFP_FLOW_PERMANENT;
fm->buffer_id = UINT32_MAX;
fm->out_port = OFPP_ANY;
fm->flags = 0;
if (fields & F_ACTIONS) {
act_str = strstr(string, "action");
if (!act_str) {
ofp_fatal(str_, verbose, "must specify an action");
}
*act_str = '\0';
act_str = strchr(act_str + 1, '=');
if (!act_str) {
ofp_fatal(str_, verbose, "must specify an action");
}
act_str++;
}
for (name = strtok_r(string, "=, \t\r\n", &save_ptr); name;
name = strtok_r(NULL, "=, \t\r\n", &save_ptr)) {
const struct protocol *p;
if (parse_protocol(name, &p)) {
match_set_dl_type(&fm->match, htons(p->dl_type));
if (p->nw_proto) {
match_set_nw_proto(&fm->match, p->nw_proto);
}
} else if (fields & F_FLAGS && !strcmp(name, "send_flow_rem")) {
fm->flags |= OFPFF_SEND_FLOW_REM;
} else if (fields & F_FLAGS && !strcmp(name, "check_overlap")) {
fm->flags |= OFPFF_CHECK_OVERLAP;
} else if (fields & F_FLAGS && !strcmp(name, "reset_counts")) {
fm->flags |= OFPFF12_RESET_COUNTS;
} else if (fields & F_FLAGS && !strcmp(name, "no_packet_counts")) {
fm->flags |= OFPFF13_NO_PKT_COUNTS;
} else if (fields & F_FLAGS && !strcmp(name, "no_byte_counts")) {
fm->flags |= OFPFF13_NO_BYT_COUNTS;
} else {
char *value;
value = strtok_r(NULL, ", \t\r\n", &save_ptr);
if (!value) {
ofp_fatal(str_, verbose, "field %s missing value", name);
}
if (!strcmp(name, "table")) {
fm->table_id = str_to_u8(value, name);
} else if (!strcmp(name, "out_port")) {
if (!ofputil_port_from_string(value, &fm->out_port)) {
ofp_fatal(str_, verbose, "%s is not a valid OpenFlow port",
name);
}
} else if (fields & F_PRIORITY && !strcmp(name, "priority")) {
fm->priority = str_to_u16(value, name);
} else if (fields & F_TIMEOUT && !strcmp(name, "idle_timeout")) {
fm->idle_timeout = str_to_u16(value, name);
} else if (fields & F_TIMEOUT && !strcmp(name, "hard_timeout")) {
fm->hard_timeout = str_to_u16(value, name);
} else if (!strcmp(name, "cookie")) {
char *mask = strchr(value, '/');
if (mask) {
/* A mask means we're searching for a cookie. */
if (command == OFPFC_ADD) {
ofp_fatal(str_, verbose, "flow additions cannot use "
"a cookie mask");
}
*mask = '\0';
fm->cookie = htonll(str_to_u64(value));
fm->cookie_mask = htonll(str_to_u64(mask+1));
} else {
/* No mask means that the cookie is being set. */
if (command != OFPFC_ADD && command != OFPFC_MODIFY
&& command != OFPFC_MODIFY_STRICT) {
ofp_fatal(str_, verbose, "cannot set cookie");
}
fm->new_cookie = htonll(str_to_u64(value));
}
} else if (mf_from_name(name)) {
parse_field(mf_from_name(name), value, &fm->match);
} else if (!strcmp(name, "duration")
|| !strcmp(name, "n_packets")
|| !strcmp(name, "n_bytes")
|| !strcmp(name, "idle_age")
|| !strcmp(name, "hard_age")) {
/* Ignore these, so that users can feed the output of
* "ovs-ofctl dump-flows" back into commands that parse
* flows. */
} else {
ofp_fatal(str_, verbose, "unknown keyword %s", name);
}
}
}
if (!fm->cookie_mask && fm->new_cookie == htonll(UINT64_MAX)
&& (command == OFPFC_MODIFY || command == OFPFC_MODIFY_STRICT)) {
/* On modifies without a mask, we are supposed to add a flow if
* one does not exist. If a cookie wasn't been specified, use a
* default of zero. */
fm->new_cookie = htonll(0);
}
if (fields & F_ACTIONS) {
struct ofpbuf ofpacts;
enum ofperr err;
ofpbuf_init(&ofpacts, 32);
str_to_inst_ofpacts(act_str, &ofpacts);
fm->ofpacts_len = ofpacts.size;
fm->ofpacts = ofpbuf_steal_data(&ofpacts);
err = ofpacts_check(fm->ofpacts, fm->ofpacts_len, &fm->match.flow,
OFPP_MAX, 0);
if (err) {
exit(EXIT_FAILURE);
}
} else {
fm->ofpacts_len = 0;
fm->ofpacts = NULL;
}
free(string);
}
/* Composes 'fm' so that executing it will implement 'learn' given that the
* packet being processed has 'flow' as its flow.
*
* Uses 'ofpacts' to store the flow mod's actions. The caller must initialize
* 'ofpacts' and retains ownership of it. 'fm->ofpacts' will point into the
* 'ofpacts' buffer.
*
* The caller has to actually execute 'fm'. */
void
learn_execute(const struct ofpact_learn *learn, const struct flow *flow,
struct ofputil_flow_mod *fm, struct ofpbuf *ofpacts)
{
const struct ofpact_learn_spec *spec;
match_init_catchall(&fm->match);
fm->priority = learn->priority;
fm->cookie = htonll(0);
fm->cookie_mask = htonll(0);
fm->new_cookie = learn->cookie;
fm->modify_cookie = fm->new_cookie != OVS_BE64_MAX;
fm->table_id = learn->table_id;
fm->command = OFPFC_MODIFY_STRICT;
fm->idle_timeout = learn->idle_timeout;
fm->hard_timeout = learn->hard_timeout;
fm->importance = 0;
fm->buffer_id = UINT32_MAX;
fm->out_port = OFPP_NONE;
fm->flags = 0;
if (learn->flags & NX_LEARN_F_SEND_FLOW_REM) {
fm->flags |= OFPUTIL_FF_SEND_FLOW_REM;
}
fm->ofpacts = NULL;
fm->ofpacts_len = 0;
fm->delete_reason = OFPRR_DELETE;
if (learn->fin_idle_timeout || learn->fin_hard_timeout) {
struct ofpact_fin_timeout *oft;
oft = ofpact_put_FIN_TIMEOUT(ofpacts);
oft->fin_idle_timeout = learn->fin_idle_timeout;
oft->fin_hard_timeout = learn->fin_hard_timeout;
}
for (spec = learn->specs; spec < &learn->specs[learn->n_specs]; spec++) {
struct ofpact_set_field *sf;
union mf_subvalue value;
if (spec->src_type == NX_LEARN_SRC_FIELD) {
mf_read_subfield(&spec->src, flow, &value);
} else {
value = spec->src_imm;
}
switch (spec->dst_type) {
case NX_LEARN_DST_MATCH:
mf_write_subfield(&spec->dst, &value, &fm->match);
break;
case NX_LEARN_DST_LOAD:
sf = ofpact_put_reg_load(ofpacts);
sf->field = spec->dst.field;
bitwise_copy(&value, sizeof value, 0,
&sf->value, spec->dst.field->n_bytes, spec->dst.ofs,
spec->n_bits);
bitwise_one(&sf->mask, spec->dst.field->n_bytes, spec->dst.ofs,
spec->n_bits);
break;
case NX_LEARN_DST_OUTPUT:
if (spec->n_bits <= 16
|| is_all_zeros(value.u8, sizeof value - 2)) {
ovs_be16 *last_be16 = &value.be16[ARRAY_SIZE(value.be16) - 1];
ofp_port_t port = u16_to_ofp(ntohs(*last_be16));
if (ofp_to_u16(port) < ofp_to_u16(OFPP_MAX)
|| port == OFPP_IN_PORT
|| port == OFPP_FLOOD
|| port == OFPP_LOCAL
|| port == OFPP_ALL) {
ofpact_put_OUTPUT(ofpacts)->port = port;
}
}
break;
}
}
ofpact_pad(ofpacts);
fm->ofpacts = ofpbuf_data(ofpacts);
fm->ofpacts_len = ofpbuf_size(ofpacts);
}
/* Appends a description of 'learn' to 's', in the format that ovs-ofctl(8)
* describes. */
void
learn_format(const struct ofpact_learn *learn, struct ds *s)
{
const struct ofpact_learn_spec *spec;
struct match match;
match_init_catchall(&match);
ds_put_format(s, "learn(table=%"PRIu8, learn->table_id);
if (learn->idle_timeout != OFP_FLOW_PERMANENT) {
ds_put_format(s, ",idle_timeout=%"PRIu16, learn->idle_timeout);
}
if (learn->hard_timeout != OFP_FLOW_PERMANENT) {
ds_put_format(s, ",hard_timeout=%"PRIu16, learn->hard_timeout);
}
if (learn->fin_idle_timeout) {
ds_put_format(s, ",fin_idle_timeout=%"PRIu16, learn->fin_idle_timeout);
}
if (learn->fin_hard_timeout) {
ds_put_format(s, ",fin_hard_timeout=%"PRIu16, learn->fin_hard_timeout);
}
if (learn->priority != OFP_DEFAULT_PRIORITY) {
ds_put_format(s, ",priority=%"PRIu16, learn->priority);
}
if (learn->flags & NX_LEARN_F_SEND_FLOW_REM) {
ds_put_cstr(s, ",send_flow_rem");
}
if (learn->flags & NX_LEARN_F_DELETE_LEARNED) {
ds_put_cstr(s, ",delete_learned");
}
if (learn->cookie != 0) {
ds_put_format(s, ",cookie=%#"PRIx64, ntohll(learn->cookie));
}
for (spec = learn->specs; spec < &learn->specs[learn->n_specs]; spec++) {
ds_put_char(s, ',');
switch (spec->src_type | spec->dst_type) {
case NX_LEARN_SRC_IMMEDIATE | NX_LEARN_DST_MATCH:
if (spec->dst.ofs == 0
&& spec->dst.n_bits == spec->dst.field->n_bits) {
union mf_value value;
memset(&value, 0, sizeof value);
bitwise_copy(&spec->src_imm, sizeof spec->src_imm, 0,
&value, spec->dst.field->n_bytes, 0,
spec->dst.field->n_bits);
ds_put_format(s, "%s=", spec->dst.field->name);
mf_format(spec->dst.field, &value, NULL, s);
} else {
mf_format_subfield(&spec->dst, s);
ds_put_char(s, '=');
mf_format_subvalue(&spec->src_imm, s);
}
break;
case NX_LEARN_SRC_FIELD | NX_LEARN_DST_MATCH:
mf_format_subfield(&spec->dst, s);
if (spec->src.field != spec->dst.field ||
spec->src.ofs != spec->dst.ofs) {
ds_put_char(s, '=');
mf_format_subfield(&spec->src, s);
}
break;
case NX_LEARN_SRC_IMMEDIATE | NX_LEARN_DST_LOAD:
ds_put_format(s, "load:");
mf_format_subvalue(&spec->src_imm, s);
ds_put_cstr(s, "->");
mf_format_subfield(&spec->dst, s);
break;
case NX_LEARN_SRC_FIELD | NX_LEARN_DST_LOAD:
ds_put_cstr(s, "load:");
mf_format_subfield(&spec->src, s);
ds_put_cstr(s, "->");
mf_format_subfield(&spec->dst, s);
break;
case NX_LEARN_SRC_FIELD | NX_LEARN_DST_OUTPUT:
ds_put_cstr(s, "output:");
mf_format_subfield(&spec->src, s);
break;
}
}
ds_put_char(s, ')');
}
/* Composes 'fm' so that executing it will implement 'learn' given that the
* packet being processed has 'flow' as its flow.
*
* Uses 'ofpacts' to store the flow mod's actions. The caller must initialize
* 'ofpacts' and retains ownership of it. 'fm->ofpacts' will point into the
* 'ofpacts' buffer.
*
* The caller has to actually execute 'fm'. */
void
learn_execute(const struct ofpact_learn *learn, const struct flow *flow,
struct ofputil_flow_mod *fm, struct ofpbuf *ofpacts)
{
const struct ofpact_learn_spec *spec;
match_init_catchall(&fm->match);
fm->priority = learn->priority;
fm->cookie = htonll(0);
fm->cookie_mask = htonll(0);
fm->new_cookie = htonll(learn->cookie);
fm->table_id = learn->table_id;
fm->command = OFPFC_MODIFY_STRICT;
fm->idle_timeout = learn->idle_timeout;
fm->hard_timeout = learn->hard_timeout;
fm->buffer_id = UINT32_MAX;
fm->out_port = OFPP_NONE;
fm->flags = learn->flags;
fm->ofpacts = NULL;
fm->ofpacts_len = 0;
if (learn->fin_idle_timeout || learn->fin_hard_timeout) {
struct ofpact_fin_timeout *oft;
oft = ofpact_put_FIN_TIMEOUT(ofpacts);
oft->fin_idle_timeout = learn->fin_idle_timeout;
oft->fin_hard_timeout = learn->fin_hard_timeout;
}
for (spec = learn->specs; spec < &learn->specs[learn->n_specs]; spec++) {
union mf_subvalue value;
int chunk, ofs;
if (spec->src_type == NX_LEARN_SRC_FIELD) {
mf_read_subfield(&spec->src, flow, &value);
} else {
value = spec->src_imm;
}
switch (spec->dst_type) {
case NX_LEARN_DST_MATCH:
mf_write_subfield(&spec->dst, &value, &fm->match);
break;
case NX_LEARN_DST_LOAD:
for (ofs = 0; ofs < spec->n_bits; ofs += chunk) {
struct ofpact_reg_load *load;
chunk = MIN(spec->n_bits - ofs, 64);
load = ofpact_put_REG_LOAD(ofpacts);
load->dst.field = spec->dst.field;
load->dst.ofs = spec->dst.ofs + ofs;
load->dst.n_bits = chunk;
bitwise_copy(&value, sizeof value, ofs,
&load->subvalue, sizeof load->subvalue, 0,
chunk);
}
break;
case NX_LEARN_DST_OUTPUT:
if (spec->n_bits <= 16
|| is_all_zeros(value.u8, sizeof value - 2)) {
ofp_port_t port = u16_to_ofp(ntohs(value.be16[7]));
if (ofp_to_u16(port) < ofp_to_u16(OFPP_MAX)
|| port == OFPP_IN_PORT
|| port == OFPP_FLOOD
|| port == OFPP_LOCAL
|| port == OFPP_ALL) {
ofpact_put_OUTPUT(ofpacts)->port = port;
}
}
break;
}
}
ofpact_pad(ofpacts);
fm->ofpacts = ofpacts->data;
fm->ofpacts_len = ofpacts->size;
}
/* Composes 'fm' so that executing it will implement 'learn' given that the
* packet being processed has 'flow' as its flow.
*
* Uses 'ofpacts' to store the flow mod's actions. The caller must initialize
* 'ofpacts' and retains ownership of it. 'fm->ofpacts' will point into the
* 'ofpacts' buffer.
*
* The caller has to actually execute 'fm'. */
void
learn_execute(const struct ofpact_learn *learn, const struct flow *flow,
struct ofputil_flow_mod *fm, struct ofpbuf *ofpacts)
{
const struct ofpact_learn_spec *spec;
match_init_catchall(&fm->match);
fm->priority = learn->priority;
fm->cookie = htonll(0);
fm->cookie_mask = htonll(0);
fm->new_cookie = learn->cookie;
fm->modify_cookie = fm->new_cookie != OVS_BE64_MAX;
fm->table_id = learn->table_id;
fm->command = OFPFC_MODIFY_STRICT;
fm->idle_timeout = learn->idle_timeout;
fm->hard_timeout = learn->hard_timeout;
fm->importance = 0;
fm->buffer_id = UINT32_MAX;
fm->out_port = OFPP_NONE;
fm->ofpacts_tlv_bitmap = 0;
fm->flags = 0;
if (learn->flags & NX_LEARN_F_SEND_FLOW_REM) {
fm->flags |= OFPUTIL_FF_SEND_FLOW_REM;
}
fm->ofpacts = NULL;
fm->ofpacts_len = 0;
if (learn->fin_idle_timeout || learn->fin_hard_timeout) {
struct ofpact_fin_timeout *oft;
oft = ofpact_put_FIN_TIMEOUT(ofpacts);
oft->fin_idle_timeout = learn->fin_idle_timeout;
oft->fin_hard_timeout = learn->fin_hard_timeout;
}
OFPACT_LEARN_SPEC_FOR_EACH (spec, learn) {
struct ofpact_set_field *sf;
union mf_subvalue value;
if (spec->src_type == NX_LEARN_SRC_FIELD) {
mf_read_subfield(&spec->src, flow, &value);
} else {
mf_subvalue_from_value(&spec->dst, &value,
ofpact_learn_spec_imm(spec));
}
switch (spec->dst_type) {
case NX_LEARN_DST_MATCH:
mf_write_subfield(&spec->dst, &value, &fm->match);
match_add_ethernet_prereq(&fm->match, spec->dst.field);
mf_vl_mff_set_tlv_bitmap(
spec->dst.field, &fm->match.flow.tunnel.metadata.present.map);
break;
case NX_LEARN_DST_LOAD:
sf = ofpact_put_reg_load(ofpacts, spec->dst.field, NULL, NULL);
bitwise_copy(&value, sizeof value, 0,
sf->value, spec->dst.field->n_bytes, spec->dst.ofs,
spec->n_bits);
bitwise_one(ofpact_set_field_mask(sf), spec->dst.field->n_bytes,
spec->dst.ofs, spec->n_bits);
mf_vl_mff_set_tlv_bitmap(spec->dst.field, &fm->ofpacts_tlv_bitmap);
break;
case NX_LEARN_DST_OUTPUT:
if (spec->n_bits <= 16
|| is_all_zeros(value.u8, sizeof value - 2)) {
ofp_port_t port = u16_to_ofp(ntohll(value.integer));
if (ofp_to_u16(port) < ofp_to_u16(OFPP_MAX)
|| port == OFPP_IN_PORT
|| port == OFPP_FLOOD
|| port == OFPP_LOCAL
|| port == OFPP_ALL) {
ofpact_put_OUTPUT(ofpacts)->port = port;
}
}
break;
}
}
fm->ofpacts = ofpacts->data;
fm->ofpacts_len = ofpacts->size;
}
/* Appends a description of 'learn' to 's', in the format that ovs-ofctl(8)
* describes. */
void
learn_format(const struct ofpact_learn *learn,
const struct ofputil_port_map *port_map, struct ds *s)
{
const struct ofpact_learn_spec *spec;
struct match match;
match_init_catchall(&match);
ds_put_format(s, "%slearn(%s%stable=%s%"PRIu8,
colors.learn, colors.end, colors.special, colors.end,
learn->table_id);
if (learn->idle_timeout != OFP_FLOW_PERMANENT) {
ds_put_format(s, ",%sidle_timeout=%s%"PRIu16,
colors.param, colors.end, learn->idle_timeout);
}
if (learn->hard_timeout != OFP_FLOW_PERMANENT) {
ds_put_format(s, ",%shard_timeout=%s%"PRIu16,
colors.param, colors.end, learn->hard_timeout);
}
if (learn->fin_idle_timeout) {
ds_put_format(s, ",%sfin_idle_timeout=%s%"PRIu16,
colors.param, colors.end, learn->fin_idle_timeout);
}
if (learn->fin_hard_timeout) {
ds_put_format(s, "%s,fin_hard_timeout=%s%"PRIu16,
colors.param, colors.end, learn->fin_hard_timeout);
}
if (learn->priority != OFP_DEFAULT_PRIORITY) {
ds_put_format(s, "%s,priority=%s%"PRIu16,
colors.special, colors.end, learn->priority);
}
if (learn->flags & NX_LEARN_F_SEND_FLOW_REM) {
ds_put_format(s, ",%ssend_flow_rem%s", colors.value, colors.end);
}
if (learn->flags & NX_LEARN_F_DELETE_LEARNED) {
ds_put_format(s, ",%sdelete_learned%s", colors.value, colors.end);
}
if (learn->cookie != 0) {
ds_put_format(s, ",%scookie=%s%#"PRIx64,
colors.param, colors.end, ntohll(learn->cookie));
}
if (learn->limit != 0) {
ds_put_format(s, ",%slimit=%s%"PRIu32,
colors.param, colors.end, learn->limit);
}
if (learn->flags & NX_LEARN_F_WRITE_RESULT) {
ds_put_format(s, ",%sresult_dst=%s", colors.param, colors.end);
mf_format_subfield(&learn->result_dst, s);
}
OFPACT_LEARN_SPEC_FOR_EACH (spec, learn) {
unsigned int n_bytes = DIV_ROUND_UP(spec->n_bits, 8);
ds_put_char(s, ',');
switch (spec->src_type | spec->dst_type) {
case NX_LEARN_SRC_IMMEDIATE | NX_LEARN_DST_MATCH: {
if (spec->dst.ofs == 0
&& spec->dst.n_bits == spec->dst.field->n_bits) {
union mf_value value;
memset(&value, 0, sizeof value);
memcpy(&value.b[spec->dst.field->n_bytes - n_bytes],
ofpact_learn_spec_imm(spec), n_bytes);
ds_put_format(s, "%s%s=%s", colors.param,
spec->dst.field->name, colors.end);
mf_format(spec->dst.field, &value, NULL, port_map, s);
} else {
ds_put_format(s, "%s", colors.param);
mf_format_subfield(&spec->dst, s);
ds_put_format(s, "=%s", colors.end);
ds_put_hex(s, ofpact_learn_spec_imm(spec), n_bytes);
}
break;
}
case NX_LEARN_SRC_FIELD | NX_LEARN_DST_MATCH:
ds_put_format(s, "%s", colors.param);
mf_format_subfield(&spec->dst, s);
ds_put_format(s, "%s", colors.end);
if (spec->src.field != spec->dst.field ||
spec->src.ofs != spec->dst.ofs) {
ds_put_format(s, "%s=%s", colors.param, colors.end);
mf_format_subfield(&spec->src, s);
}
break;
case NX_LEARN_SRC_IMMEDIATE | NX_LEARN_DST_LOAD:
ds_put_format(s, "%sload:%s", colors.special, colors.end);
ds_put_hex(s, ofpact_learn_spec_imm(spec), n_bytes);
ds_put_format(s, "%s->%s", colors.special, colors.end);
mf_format_subfield(&spec->dst, s);
break;
case NX_LEARN_SRC_FIELD | NX_LEARN_DST_LOAD:
ds_put_format(s, "%sload:%s", colors.special, colors.end);
mf_format_subfield(&spec->src, s);
ds_put_format(s, "%s->%s", colors.special, colors.end);
mf_format_subfield(&spec->dst, s);
break;
case NX_LEARN_SRC_FIELD | NX_LEARN_DST_OUTPUT:
ds_put_format(s, "%soutput:%s", colors.special, colors.end);
mf_format_subfield(&spec->src, s);
break;
}
}