2 * Copyright (c) 2010, 2011 Nicira Networks.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at:
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
19 #include "ofp-parse.h"
27 #include "byte-order.h"
28 #include "dynamic-string.h"
30 #include "meta-flow.h"
32 #include "multipath.h"
36 #include "openflow/openflow.h"
38 #include "socket-util.h"
42 VLOG_DEFINE_THIS_MODULE(ofp_parse);
45 str_to_table_id(const char *str)
49 if (!str_to_int(str, 10, &table_id) || table_id < 0 || table_id > 255) {
50 ovs_fatal(0, "invalid table \"%s\"", str);
56 str_to_u16(const char *str, const char *name)
60 if (!str_to_int(str, 0, &value) || value < 0 || value > 65535) {
61 ovs_fatal(0, "invalid %s \"%s\"", name, str);
67 str_to_u32(const char *str)
73 ovs_fatal(0, "missing required numeric argument");
77 value = strtoul(str, &tail, 0);
78 if (errno == EINVAL || errno == ERANGE || *tail) {
79 ovs_fatal(0, "invalid numeric format %s", str);
85 str_to_u64(const char *str)
91 ovs_fatal(0, "missing required numeric argument");
95 value = strtoull(str, &tail, 0);
96 if (errno == EINVAL || errno == ERANGE || *tail) {
97 ovs_fatal(0, "invalid numeric format %s", str);
103 str_to_mac(const char *str, uint8_t mac[6])
105 if (sscanf(str, ETH_ADDR_SCAN_FMT, ETH_ADDR_SCAN_ARGS(mac))
106 != ETH_ADDR_SCAN_COUNT) {
107 ovs_fatal(0, "invalid mac address %s", str);
112 str_to_ip(const char *str, ovs_be32 *ip)
114 struct in_addr in_addr;
116 if (lookup_ip(str, &in_addr)) {
117 ovs_fatal(0, "%s: could not convert to IP address", str);
119 *ip = in_addr.s_addr;
122 static struct ofp_action_output *
123 put_output_action(struct ofpbuf *b, uint16_t port)
125 struct ofp_action_output *oao;
127 oao = ofputil_put_OFPAT_OUTPUT(b);
128 oao->port = htons(port);
133 parse_enqueue(struct ofpbuf *b, char *arg)
136 char *port = strtok_r(arg, ":q", &sp);
137 char *queue = strtok_r(NULL, "", &sp);
138 struct ofp_action_enqueue *oae;
140 if (port == NULL || queue == NULL) {
141 ovs_fatal(0, "\"enqueue\" syntax is \"enqueue:PORT:QUEUE\"");
144 oae = ofputil_put_OFPAT_ENQUEUE(b);
145 oae->port = htons(str_to_u32(port));
146 oae->queue_id = htonl(str_to_u32(queue));
150 parse_output(struct ofpbuf *b, char *arg)
152 if (strchr(arg, '[')) {
153 struct nx_action_output_reg *naor;
157 nxm_parse_field_bits(arg, &src, &ofs, &n_bits);
159 naor = ofputil_put_NXAST_OUTPUT_REG(b);
160 naor->ofs_nbits = nxm_encode_ofs_nbits(ofs, n_bits);
161 naor->src = htonl(src);
162 naor->max_len = htons(UINT16_MAX);
164 put_output_action(b, str_to_u32(arg));
169 parse_resubmit(struct ofpbuf *b, char *arg)
171 struct nx_action_resubmit *nar;
172 char *in_port_s, *table_s;
176 in_port_s = strsep(&arg, ",");
177 if (in_port_s && in_port_s[0]) {
178 if (!ofputil_port_from_string(in_port_s, &in_port)) {
179 in_port = str_to_u32(in_port_s);
182 in_port = OFPP_IN_PORT;
185 table_s = strsep(&arg, ",");
186 table = table_s && table_s[0] ? str_to_u32(table_s) : 255;
188 if (in_port == OFPP_IN_PORT && table == 255) {
189 ovs_fatal(0, "at least one \"in_port\" or \"table\" must be specified "
193 if (in_port != OFPP_IN_PORT && table == 255) {
194 nar = ofputil_put_NXAST_RESUBMIT(b);
196 nar = ofputil_put_NXAST_RESUBMIT_TABLE(b);
199 nar->in_port = htons(in_port);
203 parse_set_tunnel(struct ofpbuf *b, const char *arg)
205 uint64_t tun_id = str_to_u64(arg);
206 if (tun_id > UINT32_MAX) {
207 ofputil_put_NXAST_SET_TUNNEL64(b)->tun_id = htonll(tun_id);
209 ofputil_put_NXAST_SET_TUNNEL(b)->tun_id = htonl(tun_id);
214 parse_note(struct ofpbuf *b, const char *arg)
216 size_t start_ofs = b->size;
217 struct nx_action_note *nan;
221 nan = ofputil_put_NXAST_NOTE(b);
223 b->size -= sizeof nan->note;
224 while (*arg != '\0') {
235 byte = hexits_value(arg, 2, &ok);
237 ovs_fatal(0, "bad hex digit in `note' argument");
239 ofpbuf_put(b, &byte, 1);
244 len = b->size - start_ofs;
245 remainder = len % OFP_ACTION_ALIGN;
247 ofpbuf_put_zeros(b, OFP_ACTION_ALIGN - remainder);
249 nan = (struct nx_action_note *)((char *)b->data + start_ofs);
250 nan->len = htons(b->size - start_ofs);
254 parse_named_action(enum ofputil_action_code code, const struct flow *flow,
255 struct ofpbuf *b, char *arg)
257 struct ofp_action_dl_addr *oada;
258 struct ofp_action_vlan_pcp *oavp;
259 struct ofp_action_vlan_vid *oavv;
260 struct ofp_action_nw_addr *oana;
261 struct ofp_action_tp_port *oata;
264 case OFPUTIL_OFPAT_OUTPUT:
265 parse_output(b, arg);
268 case OFPUTIL_OFPAT_SET_VLAN_VID:
269 oavv = ofputil_put_OFPAT_SET_VLAN_VID(b);
270 oavv->vlan_vid = htons(str_to_u32(arg));
273 case OFPUTIL_OFPAT_SET_VLAN_PCP:
274 oavp = ofputil_put_OFPAT_SET_VLAN_PCP(b);
275 oavp->vlan_pcp = str_to_u32(arg);
278 case OFPUTIL_OFPAT_STRIP_VLAN:
279 ofputil_put_OFPAT_STRIP_VLAN(b);
282 case OFPUTIL_OFPAT_SET_DL_SRC:
283 case OFPUTIL_OFPAT_SET_DL_DST:
284 oada = ofputil_put_action(code, b);
285 str_to_mac(arg, oada->dl_addr);
288 case OFPUTIL_OFPAT_SET_NW_SRC:
289 case OFPUTIL_OFPAT_SET_NW_DST:
290 oana = ofputil_put_action(code, b);
291 str_to_ip(arg, &oana->nw_addr);
294 case OFPUTIL_OFPAT_SET_NW_TOS:
295 ofputil_put_OFPAT_SET_NW_TOS(b)->nw_tos = str_to_u32(arg);
298 case OFPUTIL_OFPAT_SET_TP_SRC:
299 case OFPUTIL_OFPAT_SET_TP_DST:
300 oata = ofputil_put_action(code, b);
301 oata->tp_port = htons(str_to_u32(arg));
304 case OFPUTIL_OFPAT_ENQUEUE:
305 parse_enqueue(b, arg);
308 case OFPUTIL_NXAST_RESUBMIT:
309 parse_resubmit(b, arg);
312 case OFPUTIL_NXAST_SET_TUNNEL:
313 parse_set_tunnel(b, arg);
316 case OFPUTIL_NXAST_SET_QUEUE:
317 ofputil_put_NXAST_SET_QUEUE(b)->queue_id = htonl(str_to_u32(arg));
320 case OFPUTIL_NXAST_POP_QUEUE:
321 ofputil_put_NXAST_POP_QUEUE(b);
324 case OFPUTIL_NXAST_REG_MOVE:
325 nxm_parse_reg_move(ofputil_put_NXAST_REG_MOVE(b), arg);
328 case OFPUTIL_NXAST_REG_LOAD:
329 nxm_parse_reg_load(ofputil_put_NXAST_REG_LOAD(b), arg);
332 case OFPUTIL_NXAST_NOTE:
336 case OFPUTIL_NXAST_SET_TUNNEL64:
337 ofputil_put_NXAST_SET_TUNNEL64(b)->tun_id = htonll(str_to_u64(arg));
340 case OFPUTIL_NXAST_MULTIPATH:
341 multipath_parse(ofputil_put_NXAST_MULTIPATH(b), arg);
344 case OFPUTIL_NXAST_AUTOPATH:
345 autopath_parse(ofputil_put_NXAST_AUTOPATH(b), arg);
348 case OFPUTIL_NXAST_BUNDLE:
349 bundle_parse(b, arg);
352 case OFPUTIL_NXAST_BUNDLE_LOAD:
353 bundle_parse_load(b, arg);
356 case OFPUTIL_NXAST_RESUBMIT_TABLE:
357 case OFPUTIL_NXAST_OUTPUT_REG:
360 case OFPUTIL_NXAST_LEARN:
361 learn_parse(b, arg, flow);
364 case OFPUTIL_NXAST_EXIT:
365 ofputil_put_NXAST_EXIT(b);
371 str_to_action(const struct flow *flow, char *str, struct ofpbuf *b)
373 char *pos, *act, *arg;
378 while (ofputil_parse_key_value(&pos, &act, &arg)) {
382 code = ofputil_action_code_from_name(act);
384 parse_named_action(code, flow, b, arg);
385 } else if (!strcasecmp(act, "drop")) {
386 /* A drop action in OpenFlow occurs by just not setting
389 ovs_fatal(0, "Drop actions must not be preceded by other "
391 } else if (ofputil_parse_key_value(&pos, &act, &arg)) {
392 ovs_fatal(0, "Drop actions must not be followed by other "
396 } else if (!strcasecmp(act, "CONTROLLER")) {
397 struct ofp_action_output *oao;
398 oao = put_output_action(b, OFPP_CONTROLLER);
400 /* Unless a numeric argument is specified, we send the whole
401 * packet to the controller. */
402 if (arg[0] && (strspn(arg, "0123456789") == strlen(arg))) {
403 oao->max_len = htons(str_to_u32(arg));
405 oao->max_len = htons(UINT16_MAX);
407 } else if (ofputil_port_from_string(act, &port)) {
408 put_output_action(b, port);
410 ovs_fatal(0, "Unknown action: %s", act);
423 parse_protocol(const char *name, const struct protocol **p_out)
425 static const struct protocol protocols[] = {
426 { "ip", ETH_TYPE_IP, 0 },
427 { "arp", ETH_TYPE_ARP, 0 },
428 { "icmp", ETH_TYPE_IP, IPPROTO_ICMP },
429 { "tcp", ETH_TYPE_IP, IPPROTO_TCP },
430 { "udp", ETH_TYPE_IP, IPPROTO_UDP },
431 { "ipv6", ETH_TYPE_IPV6, 0 },
432 { "ip6", ETH_TYPE_IPV6, 0 },
433 { "icmp6", ETH_TYPE_IPV6, IPPROTO_ICMPV6 },
434 { "tcp6", ETH_TYPE_IPV6, IPPROTO_TCP },
435 { "udp6", ETH_TYPE_IPV6, IPPROTO_UDP },
437 const struct protocol *p;
439 for (p = protocols; p < &protocols[ARRAY_SIZE(protocols)]; p++) {
440 if (!strcmp(p->name, name)) {
450 ofp_fatal(const char *flow, bool verbose, const char *format, ...)
455 fprintf(stderr, "%s:\n", flow);
458 va_start(args, format);
459 ovs_fatal_valist(0, format, args);
463 parse_field(const struct mf_field *mf, const char *s, struct cls_rule *rule)
465 union mf_value value, mask;
468 error = mf_parse(mf, s, &value, &mask);
470 ovs_fatal(0, "%s", error);
473 mf_set(mf, &value, &mask, rule);
476 /* Convert 'str_' (as described in the Flow Syntax section of the ovs-ofctl man
477 * page) into 'fm' for sending the specified flow_mod 'command' to a switch.
478 * If 'actions' is specified, an action must be in 'string' and may be expanded
481 * To parse syntax for an OFPT_FLOW_MOD (or NXT_FLOW_MOD), use an OFPFC_*
482 * constant for 'command'. To parse syntax for an OFPST_FLOW or
483 * OFPST_AGGREGATE (or NXST_FLOW or NXST_AGGREGATE), use -1 for 'command'. */
485 parse_ofp_str(struct ofputil_flow_mod *fm, int command, const char *str_,
494 char *string = xstrdup(str_);
495 char *save_ptr = NULL;
496 char *act_str = NULL;
505 fields = F_ACTIONS | F_TIMEOUT | F_PRIORITY;
512 case OFPFC_DELETE_STRICT:
513 fields = F_OUT_PORT | F_PRIORITY;
520 case OFPFC_MODIFY_STRICT:
521 fields = F_ACTIONS | F_PRIORITY;
528 cls_rule_init_catchall(&fm->cr, OFP_DEFAULT_PRIORITY);
529 fm->cookie = htonll(0);
530 fm->cookie_mask = htonll(0);
532 fm->command = command;
533 fm->idle_timeout = OFP_FLOW_PERMANENT;
534 fm->hard_timeout = OFP_FLOW_PERMANENT;
535 fm->buffer_id = UINT32_MAX;
536 fm->out_port = OFPP_NONE;
538 if (fields & F_ACTIONS) {
539 act_str = strstr(string, "action");
541 ofp_fatal(str_, verbose, "must specify an action");
545 act_str = strchr(act_str + 1, '=');
547 ofp_fatal(str_, verbose, "must specify an action");
552 for (name = strtok_r(string, "=, \t\r\n", &save_ptr); name;
553 name = strtok_r(NULL, "=, \t\r\n", &save_ptr)) {
554 const struct protocol *p;
556 if (parse_protocol(name, &p)) {
557 cls_rule_set_dl_type(&fm->cr, htons(p->dl_type));
559 cls_rule_set_nw_proto(&fm->cr, p->nw_proto);
564 value = strtok_r(NULL, ", \t\r\n", &save_ptr);
566 ofp_fatal(str_, verbose, "field %s missing value", name);
569 if (!strcmp(name, "table")) {
570 fm->table_id = str_to_table_id(value);
571 } else if (!strcmp(name, "out_port")) {
572 fm->out_port = atoi(value);
573 } else if (fields & F_PRIORITY && !strcmp(name, "priority")) {
574 fm->cr.priority = str_to_u16(value, name);
575 } else if (fields & F_TIMEOUT && !strcmp(name, "idle_timeout")) {
576 fm->idle_timeout = str_to_u16(value, name);
577 } else if (fields & F_TIMEOUT && !strcmp(name, "hard_timeout")) {
578 fm->hard_timeout = str_to_u16(value, name);
579 } else if (!strcmp(name, "cookie")) {
580 char *mask = strchr(value, '/');
582 if (command == OFPFC_ADD) {
583 ofp_fatal(str_, verbose, "flow additions cannot use "
587 fm->cookie_mask = htonll(str_to_u64(mask+1));
589 fm->cookie_mask = htonll(UINT64_MAX);
591 fm->cookie = htonll(str_to_u64(value));
592 } else if (mf_from_name(name)) {
593 parse_field(mf_from_name(name), value, &fm->cr);
594 } else if (!strcmp(name, "duration")
595 || !strcmp(name, "n_packets")
596 || !strcmp(name, "n_bytes")) {
597 /* Ignore these, so that users can feed the output of
598 * "ovs-ofctl dump-flows" back into commands that parse
601 ofp_fatal(str_, verbose, "unknown keyword %s", name);
605 if (fields & F_ACTIONS) {
606 struct ofpbuf actions;
608 ofpbuf_init(&actions, sizeof(union ofp_action));
609 str_to_action(&fm->cr.flow, act_str, &actions);
610 fm->actions = ofpbuf_steal_data(&actions);
611 fm->n_actions = actions.size / sizeof(union ofp_action);
620 /* Parses 'string' as an OFPT_FLOW_MOD or NXT_FLOW_MOD with command 'command'
621 * (one of OFPFC_*) and appends the parsed OpenFlow message to 'packets'.
622 * '*cur_format' should initially contain the flow format currently configured
623 * on the connection; this function will add a message to change the flow
624 * format and update '*cur_format', if this is necessary to add the parsed
627 parse_ofp_flow_mod_str(struct list *packets, enum nx_flow_format *cur_format,
628 bool *flow_mod_table_id, char *string, uint16_t command,
631 enum nx_flow_format min_format, next_format;
632 struct cls_rule rule_copy;
634 struct ofputil_flow_mod fm;
636 parse_ofp_str(&fm, command, string, verbose);
638 min_format = ofputil_min_flow_format(&fm.cr);
639 if (command != OFPFC_ADD && fm.cookie_mask != htonll(0)) {
640 min_format = NXFF_NXM;
642 next_format = MAX(*cur_format, min_format);
643 if (next_format != *cur_format) {
644 struct ofpbuf *sff = ofputil_make_set_flow_format(next_format);
645 list_push_back(packets, &sff->list_node);
646 *cur_format = next_format;
649 /* Normalize a copy of the rule. This ensures that non-normalized flows
650 * get logged but doesn't affect what gets sent to the switch, so that the
651 * switch can do whatever it likes with the flow. */
653 ofputil_normalize_rule(&rule_copy, next_format);
655 if (fm.table_id != 0xff && !*flow_mod_table_id) {
656 struct ofpbuf *sff = ofputil_make_flow_mod_table_id(true);
657 list_push_back(packets, &sff->list_node);
658 *flow_mod_table_id = true;
661 ofm = ofputil_encode_flow_mod(&fm, *cur_format, *flow_mod_table_id);
662 list_push_back(packets, &ofm->list_node);
665 /* Similar to parse_ofp_flow_mod_str(), except that the string is read from
666 * 'stream' and the command is always OFPFC_ADD. Returns false if end-of-file
667 * is reached before reading a flow, otherwise true. */
669 parse_ofp_flow_mod_file(struct list *packets,
670 enum nx_flow_format *cur, bool *flow_mod_table_id,
671 FILE *stream, uint16_t command)
677 ok = ds_get_preprocessed_line(&s, stream) == 0;
679 parse_ofp_flow_mod_str(packets, cur, flow_mod_table_id,
680 ds_cstr(&s), command, true);
688 parse_ofp_flow_stats_request_str(struct ofputil_flow_stats_request *fsr,
689 bool aggregate, char *string)
691 struct ofputil_flow_mod fm;
693 parse_ofp_str(&fm, -1, string, false);
694 fsr->aggregate = aggregate;
695 fsr->cookie = fm.cookie;
696 fsr->cookie_mask = fm.cookie_mask;
698 fsr->out_port = fm.out_port;
699 fsr->table_id = fm.table_id;