/*
- * Copyright (c) 2010, 2011, 2012 Nicira, Inc.
+ * Copyright (c) 2010, 2011, 2012, 2013 Nicira, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <errno.h>
#include <stdlib.h>
-#include "autopath.h"
#include "bundle.h"
#include "byte-order.h"
#include "dynamic-string.h"
NO_RETURN;
static uint8_t
-str_to_table_id(const char *str)
+str_to_u8(const char *str, const char *name)
{
- int table_id;
+ int value;
- if (!str_to_int(str, 10, &table_id) || table_id < 0 || table_id > 255) {
- ovs_fatal(0, "invalid table \"%s\"", str);
+ if (!str_to_int(str, 10, &value) || value < 0 || value > 255) {
+ ovs_fatal(0, "invalid %s \"%s\"", name, str);
}
- return table_id;
+ return value;
}
static uint16_t
}
enqueue = ofpact_put_ENQUEUE(ofpacts);
- enqueue->port = str_to_u32(port);
+ enqueue->port = u16_to_ofp(str_to_u32(port));
enqueue->queue = str_to_u32(queue);
}
struct ofpact_output *output;
output = ofpact_put_OUTPUT(ofpacts);
- output->port = str_to_u32(arg);
+ output->port = u16_to_ofp(str_to_u32(arg));
output->max_len = output->port == OFPP_CONTROLLER ? UINT16_MAX : 0;
}
}
}
}
+static void
+parse_set_mpls_ttl(struct ofpbuf *b, const char *arg)
+{
+ struct ofpact_mpls_ttl *mpls_ttl = ofpact_put_SET_MPLS_TTL(b);
+
+ if (*arg == '\0') {
+ ovs_fatal(0, "parse_set_mpls_ttl: expected ttl.");
+ }
+
+ mpls_ttl->ttl = atoi(arg);
+}
+
static void
set_field_parse(const char *arg, struct ofpbuf *ofpacts)
{
}
static void
-parse_named_action(enum ofputil_action_code code, const struct flow *flow,
+parse_sample(struct ofpbuf *b, char *arg)
+{
+ struct ofpact_sample *os = ofpact_put_SAMPLE(b);
+ char *key, *value;
+
+ while (ofputil_parse_key_value(&arg, &key, &value)) {
+ if (!strcmp(key, "probability")) {
+ os->probability = str_to_u16(value, "probability");
+ if (os->probability == 0) {
+ ovs_fatal(0, "invalid probability value \"%s\"", value);
+ }
+ } else if (!strcmp(key, "collector_set_id")) {
+ os->collector_set_id = str_to_u32(value);
+ } else if (!strcmp(key, "obs_domain_id")) {
+ os->obs_domain_id = str_to_u32(value);
+ } else if (!strcmp(key, "obs_point_id")) {
+ os->obs_point_id = str_to_u32(value);
+ } else {
+ ovs_fatal(0, "invalid key \"%s\" in \"sample\" argument",
+ key);
+ }
+ }
+ if (os->probability == 0) {
+ ovs_fatal(0, "non-zero \"probability\" must be specified on sample");
+ }
+}
+
+static void
+parse_named_action(enum ofputil_action_code code,
char *arg, struct ofpbuf *ofpacts)
{
struct ofpact_tunnel *tunnel;
case OFPUTIL_OFPAT11_PUSH_VLAN:
ethertype = str_to_u16(arg, "ethertype");
if (ethertype != ETH_TYPE_VLAN_8021Q) {
- /* TODO:XXXX ETH_TYPE_VLAN_8021AD case isn't supported */
+ /* XXX ETH_TYPE_VLAN_8021AD case isn't supported */
ovs_fatal(0, "%s: not a valid VLAN ethertype", arg);
}
ofpact_put_PUSH_VLAN(ofpacts);
break;
+ case OFPUTIL_OFPAT11_SET_QUEUE:
+ ofpact_put_SET_QUEUE(ofpacts)->queue_id = str_to_u32(arg);
+ break;
+
+
case OFPUTIL_OFPAT10_SET_DL_SRC:
case OFPUTIL_OFPAT11_SET_DL_SRC:
str_to_mac(arg, ofpact_put_SET_ETH_SRC(ofpacts)->mac);
multipath_parse(ofpact_put_MULTIPATH(ofpacts), arg);
break;
- case OFPUTIL_NXAST_AUTOPATH__DEPRECATED:
- autopath_parse(ofpact_put_AUTOPATH(ofpacts), arg);
- break;
-
case OFPUTIL_NXAST_BUNDLE:
bundle_parse(arg, ofpacts);
break;
NOT_REACHED();
case OFPUTIL_NXAST_LEARN:
- learn_parse(arg, flow, ofpacts);
+ learn_parse(arg, ofpacts);
break;
case OFPUTIL_NXAST_EXIT:
parse_dec_ttl(ofpacts, arg);
break;
+ case OFPUTIL_NXAST_SET_MPLS_TTL:
+ case OFPUTIL_OFPAT11_SET_MPLS_TTL:
+ parse_set_mpls_ttl(ofpacts, arg);
+ break;
+
+ case OFPUTIL_OFPAT11_DEC_MPLS_TTL:
+ case OFPUTIL_NXAST_DEC_MPLS_TTL:
+ ofpact_put_DEC_MPLS_TTL(ofpacts);
+ break;
+
case OFPUTIL_NXAST_FIN_TIMEOUT:
parse_fin_timeout(ofpacts, arg);
break;
case OFPUTIL_NXAST_CONTROLLER:
parse_controller(ofpacts, arg);
break;
+
+ case OFPUTIL_OFPAT11_PUSH_MPLS:
+ case OFPUTIL_NXAST_PUSH_MPLS:
+ ofpact_put_PUSH_MPLS(ofpacts)->ethertype =
+ htons(str_to_u16(arg, "push_mpls"));
+ break;
+
+ case OFPUTIL_OFPAT11_POP_MPLS:
+ case OFPUTIL_NXAST_POP_MPLS:
+ ofpact_put_POP_MPLS(ofpacts)->ethertype =
+ htons(str_to_u16(arg, "pop_mpls"));
+ break;
+
+ case OFPUTIL_NXAST_STACK_PUSH:
+ nxm_parse_stack_action(ofpact_put_STACK_PUSH(ofpacts), arg);
+ break;
+ case OFPUTIL_NXAST_STACK_POP:
+ nxm_parse_stack_action(ofpact_put_STACK_POP(ofpacts), arg);
+ break;
+
+ case OFPUTIL_NXAST_SAMPLE:
+ parse_sample(ofpacts, arg);
+ break;
}
}
static bool
-str_to_ofpact__(const struct flow *flow, char *pos, char *act, char *arg,
+str_to_ofpact__(char *pos, char *act, char *arg,
struct ofpbuf *ofpacts, int n_actions)
{
int code = ofputil_action_code_from_name(act);
if (code >= 0) {
- parse_named_action(code, flow, arg, ofpacts);
+ parse_named_action(code, arg, ofpacts);
} else if (!strcasecmp(act, "drop")) {
if (n_actions) {
ovs_fatal(0, "Drop actions must not be preceded by other "
}
return false;
} else {
- uint16_t port;
+ ofp_port_t port;
if (ofputil_port_from_string(act, &port)) {
ofpact_put_OUTPUT(ofpacts)->port = port;
} else {
}
static void
-str_to_ofpacts(const struct flow *flow, char *str, struct ofpbuf *ofpacts)
+str_to_ofpacts(char *str, struct ofpbuf *ofpacts)
{
char *pos, *act, *arg;
enum ofperr error;
pos = str;
n_actions = 0;
while (ofputil_parse_key_value(&pos, &act, &arg)) {
- if (!str_to_ofpact__(flow, pos, act, arg, ofpacts, n_actions)) {
+ if (!str_to_ofpact__(pos, act, arg, ofpacts, n_actions)) {
break;
}
n_actions++;
break;
case OVSINST_OFPIT11_WRITE_ACTIONS:
- /* TODO:XXX */
+ /* XXX */
ovs_fatal(0, "instruction write-actions is not supported yet");
break;
ofpact_put_CLEAR_ACTIONS(ofpacts);
break;
+ case OVSINST_OFPIT13_METER:
+ ofpact_put_METER(ofpacts)->meter_id = str_to_u32(arg);
+ break;
+
case OVSINST_OFPIT11_WRITE_METADATA:
parse_metadata(ofpacts, arg);
break;
if (!table_s || !table_s[0]) {
ovs_fatal(0, "instruction goto-table needs table id");
}
- ogt->table_id = str_to_table_id(table_s);
+ ogt->table_id = str_to_u8(table_s, "table");
break;
}
}
}
static void
-str_to_inst_ofpacts(const struct flow *flow, char *str, struct ofpbuf *ofpacts)
+str_to_inst_ofpacts(char *str, struct ofpbuf *ofpacts)
{
char *pos, *inst, *arg;
int type;
pos = str;
while (ofputil_parse_key_value(&pos, &inst, &arg)) {
- type = ofpact_instruction_type_from_name(inst);
+ type = ovs_instruction_type_from_name(inst);
if (type < 0) {
- if (!str_to_ofpact__(flow, pos, inst, arg, ofpacts, n_actions)) {
+ if (!str_to_ofpact__(pos, inst, arg, ofpacts, n_actions)) {
break;
}
{ "tcp6", ETH_TYPE_IPV6, IPPROTO_TCP },
{ "udp6", ETH_TYPE_IPV6, IPPROTO_UDP },
{ "rarp", ETH_TYPE_RARP, 0},
-};
+ { "mpls", ETH_TYPE_MPLS, 0 },
+ { "mplsm", ETH_TYPE_MPLS_MCAST, 0 },
+ };
const struct protocol *p;
for (p = protocols; p < &protocols[ARRAY_SIZE(protocols)]; p++) {
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;
}
if (!strcmp(name, "table")) {
- fm->table_id = str_to_table_id(value);
+ fm->table_id = str_to_u8(value, name);
} else if (!strcmp(name, "out_port")) {
- if (!ofputil_port_from_string(name, &fm->out_port)) {
+ if (!ofputil_port_from_string(value, &fm->out_port)) {
ofp_fatal(str_, verbose, "%s is not a valid OpenFlow port",
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, "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. */
}
if (fields & F_ACTIONS) {
struct ofpbuf ofpacts;
+ enum ofperr err;
ofpbuf_init(&ofpacts, 32);
- str_to_inst_ofpacts(&fm->match.flow, act_str, &ofpacts);
+ 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);
+ if (err) {
+ exit(EXIT_FAILURE);
+ }
+
} else {
fm->ofpacts_len = 0;
fm->ofpacts = NULL;
free(string);
}
+/* Convert 'str_' (as described in the Flow Syntax section of the ovs-ofctl man
+ * page) into 'mm' for sending the specified meter_mod 'command' to a switch.
+ */
+void
+parse_ofp_meter_mod_str(struct ofputil_meter_mod *mm, const char *str_,
+ int command, bool verbose)
+{
+ enum {
+ F_METER = 1 << 0,
+ F_FLAGS = 1 << 1,
+ F_BANDS = 1 << 2,
+ } fields;
+ char *string = xstrdup(str_);
+ char *save_ptr = NULL;
+ char *band_str = NULL;
+ char *name;
+
+ switch (command) {
+ case -1:
+ fields = F_METER;
+ break;
+
+ case OFPMC13_ADD:
+ fields = F_METER | F_FLAGS | F_BANDS;
+ break;
+
+ case OFPMC13_DELETE:
+ fields = F_METER;
+ break;
+
+ case OFPMC13_MODIFY:
+ fields = F_METER | F_FLAGS | F_BANDS;
+ break;
+
+ default:
+ NOT_REACHED();
+ }
+
+ mm->command = command;
+ mm->meter.meter_id = 0;
+ mm->meter.flags = 0;
+ if (fields & F_BANDS) {
+ band_str = strstr(string, "band");
+ if (!band_str) {
+ ofp_fatal(str_, verbose, "must specify bands");
+ }
+ *band_str = '\0';
+
+ band_str = strchr(band_str + 1, '=');
+ if (!band_str) {
+ ofp_fatal(str_, verbose, "must specify bands");
+ }
+
+ band_str++;
+ }
+ for (name = strtok_r(string, "=, \t\r\n", &save_ptr); name;
+ name = strtok_r(NULL, "=, \t\r\n", &save_ptr)) {
+
+ if (fields & F_FLAGS && !strcmp(name, "kbps")) {
+ mm->meter.flags |= OFPMF13_KBPS;
+ } else if (fields & F_FLAGS && !strcmp(name, "pktps")) {
+ mm->meter.flags |= OFPMF13_PKTPS;
+ } else if (fields & F_FLAGS && !strcmp(name, "burst")) {
+ mm->meter.flags |= OFPMF13_BURST;
+ } else if (fields & F_FLAGS && !strcmp(name, "stats")) {
+ mm->meter.flags |= OFPMF13_STATS;
+ } 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, "meter")) {
+ if (!strcmp(value, "all")) {
+ mm->meter.meter_id = OFPM13_ALL;
+ } else if (!strcmp(value, "controller")) {
+ mm->meter.meter_id = OFPM13_CONTROLLER;
+ } else if (!strcmp(value, "slowpath")) {
+ mm->meter.meter_id = OFPM13_SLOWPATH;
+ } else {
+ mm->meter.meter_id = str_to_u32(value);
+ if (mm->meter.meter_id > OFPM13_MAX) {
+ ofp_fatal(str_, verbose, "invalid value for %s", name);
+ }
+ }
+ } else {
+ ofp_fatal(str_, verbose, "unknown keyword %s", name);
+ }
+ }
+ }
+ if (fields & F_METER && !mm->meter.meter_id) {
+ ofp_fatal(str_, verbose, "must specify 'meter'");
+ }
+ if (fields & F_FLAGS && !mm->meter.flags) {
+ ofp_fatal(str_, verbose,
+ "meter must specify either 'kbps' or 'pktps'");
+ }
+
+ if (fields & F_BANDS) {
+ struct ofpbuf bands;
+ uint16_t n_bands = 0;
+ struct ofputil_meter_band *band = NULL;
+ int i;
+
+ ofpbuf_init(&bands, 64);
+
+ for (name = strtok_r(band_str, "=, \t\r\n", &save_ptr); name;
+ name = strtok_r(NULL, "=, \t\r\n", &save_ptr)) {
+
+ 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, "type")) {
+ /* Start a new band */
+ band = ofpbuf_put_zeros(&bands, sizeof *band);
+ n_bands++;
+
+ if (!strcmp(value, "drop")) {
+ band->type = OFPMBT13_DROP;
+ } else if (!strcmp(value, "dscp_remark")) {
+ band->type = OFPMBT13_DSCP_REMARK;
+ } else {
+ ofp_fatal(str_, verbose, "field %s unknown value %s", name,
+ value);
+ }
+ } else if (!band || !band->type) {
+ ofp_fatal(str_, verbose,
+ "band must start with the 'type' keyword");
+ } else if (!strcmp(name, "rate")) {
+ band->rate = str_to_u32(value);
+ } else if (!strcmp(name, "burst_size")) {
+ band->burst_size = str_to_u32(value);
+ } else if (!strcmp(name, "prec_level")) {
+ band->prec_level = str_to_u8(value, name);
+ } else {
+ ofp_fatal(str_, verbose, "unknown keyword %s", name);
+ }
+ }
+ /* validate bands */
+ if (!n_bands) {
+ ofp_fatal(str_, verbose, "meter must have bands");
+ }
+
+ mm->meter.n_bands = n_bands;
+ mm->meter.bands = ofpbuf_steal_data(&bands);
+
+ for (i = 0; i < n_bands; ++i) {
+ band = &mm->meter.bands[i];
+
+ if (!band->type) {
+ ofp_fatal(str_, verbose, "band must have 'type'");
+ }
+ if (band->type == OFPMBT13_DSCP_REMARK) {
+ if (!band->prec_level) {
+ ofp_fatal(str_, verbose, "'dscp_remark' band must have"
+ " 'prec_level'");
+ }
+ } else {
+ if (band->prec_level) {
+ ofp_fatal(str_, verbose, "Only 'dscp_remark' band may have"
+ " 'prec_level'");
+ }
+ }
+ if (!band->rate) {
+ ofp_fatal(str_, verbose, "band must have 'rate'");
+ }
+ if (mm->meter.flags & OFPMF13_BURST) {
+ if (!band->burst_size) {
+ ofp_fatal(str_, verbose, "band must have 'burst_size' "
+ "when 'burst' flag is set");
+ }
+ } else {
+ if (band->burst_size) {
+ ofp_fatal(str_, verbose, "band may have 'burst_size' only "
+ "when 'burst' flag is set");
+ }
+ }
+ }
+ } else {
+ mm->meter.n_bands = 0;
+ mm->meter.bands = NULL;
+ }
+
+ free(string);
+}
+
/* Convert 'str_' (as described in the documentation for the "monitor" command
* in the ovs-ofctl man page) into 'fmr'. */
void
}
if (!strcmp(name, "table")) {
- fmr->table_id = str_to_table_id(value);
+ fmr->table_id = str_to_u8(value, name);
} else if (!strcmp(name, "out_port")) {
- fmr->out_port = atoi(value);
+ fmr->out_port = u16_to_ofp(atoi(value));
} else if (mf_from_name(name)) {
parse_field(mf_from_name(name), value, &fmr->match);
} else {
parse_ofpacts(const char *s_, struct ofpbuf *ofpacts)
{
char *s = xstrdup(s_);
- str_to_ofpacts(NULL, s, ofpacts);
+ str_to_ofpacts(s, ofpacts);
free(s);
}
}
}
+ if (!flow->in_port.ofp_port) {
+ flow->in_port.ofp_port = OFPP_NONE;
+ }
+
exit:
free(copy);
git://git.onelab.eu / sliver-openvswitch.git / blobdiff