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;
154 struct mf_subfield src;
156 mf_parse_subfield(&src, arg);
158 naor = ofputil_put_NXAST_OUTPUT_REG(b);
159 naor->ofs_nbits = nxm_encode_ofs_nbits(src.ofs, src.n_bits);
160 naor->src = htonl(src.field->nxm_header);
161 naor->max_len = htons(UINT16_MAX);
163 put_output_action(b, str_to_u32(arg));
168 parse_resubmit(struct ofpbuf *b, char *arg)
170 struct nx_action_resubmit *nar;
171 char *in_port_s, *table_s;
175 in_port_s = strsep(&arg, ",");
176 if (in_port_s && in_port_s[0]) {
177 if (!ofputil_port_from_string(in_port_s, &in_port)) {
178 in_port = str_to_u32(in_port_s);
181 in_port = OFPP_IN_PORT;
184 table_s = strsep(&arg, ",");
185 table = table_s && table_s[0] ? str_to_u32(table_s) : 255;
187 if (in_port == OFPP_IN_PORT && table == 255) {
188 ovs_fatal(0, "at least one \"in_port\" or \"table\" must be specified "
192 if (in_port != OFPP_IN_PORT && table == 255) {
193 nar = ofputil_put_NXAST_RESUBMIT(b);
195 nar = ofputil_put_NXAST_RESUBMIT_TABLE(b);
198 nar->in_port = htons(in_port);
202 parse_set_tunnel(struct ofpbuf *b, const char *arg)
204 uint64_t tun_id = str_to_u64(arg);
205 if (tun_id > UINT32_MAX) {
206 ofputil_put_NXAST_SET_TUNNEL64(b)->tun_id = htonll(tun_id);
208 ofputil_put_NXAST_SET_TUNNEL(b)->tun_id = htonl(tun_id);
213 parse_note(struct ofpbuf *b, const char *arg)
215 size_t start_ofs = b->size;
216 struct nx_action_note *nan;
220 nan = ofputil_put_NXAST_NOTE(b);
222 b->size -= sizeof nan->note;
223 while (*arg != '\0') {
234 byte = hexits_value(arg, 2, &ok);
236 ovs_fatal(0, "bad hex digit in `note' argument");
238 ofpbuf_put(b, &byte, 1);
243 len = b->size - start_ofs;
244 remainder = len % OFP_ACTION_ALIGN;
246 ofpbuf_put_zeros(b, OFP_ACTION_ALIGN - remainder);
248 nan = (struct nx_action_note *)((char *)b->data + start_ofs);
249 nan->len = htons(b->size - start_ofs);
253 parse_named_action(enum ofputil_action_code code, const struct flow *flow,
254 struct ofpbuf *b, char *arg)
256 struct ofp_action_dl_addr *oada;
257 struct ofp_action_vlan_pcp *oavp;
258 struct ofp_action_vlan_vid *oavv;
259 struct ofp_action_nw_addr *oana;
260 struct ofp_action_tp_port *oata;
263 case OFPUTIL_OFPAT_OUTPUT:
264 parse_output(b, arg);
267 case OFPUTIL_OFPAT_SET_VLAN_VID:
268 oavv = ofputil_put_OFPAT_SET_VLAN_VID(b);
269 oavv->vlan_vid = htons(str_to_u32(arg));
272 case OFPUTIL_OFPAT_SET_VLAN_PCP:
273 oavp = ofputil_put_OFPAT_SET_VLAN_PCP(b);
274 oavp->vlan_pcp = str_to_u32(arg);
277 case OFPUTIL_OFPAT_STRIP_VLAN:
278 ofputil_put_OFPAT_STRIP_VLAN(b);
281 case OFPUTIL_OFPAT_SET_DL_SRC:
282 case OFPUTIL_OFPAT_SET_DL_DST:
283 oada = ofputil_put_action(code, b);
284 str_to_mac(arg, oada->dl_addr);
287 case OFPUTIL_OFPAT_SET_NW_SRC:
288 case OFPUTIL_OFPAT_SET_NW_DST:
289 oana = ofputil_put_action(code, b);
290 str_to_ip(arg, &oana->nw_addr);
293 case OFPUTIL_OFPAT_SET_NW_TOS:
294 ofputil_put_OFPAT_SET_NW_TOS(b)->nw_tos = str_to_u32(arg);
297 case OFPUTIL_OFPAT_SET_TP_SRC:
298 case OFPUTIL_OFPAT_SET_TP_DST:
299 oata = ofputil_put_action(code, b);
300 oata->tp_port = htons(str_to_u32(arg));
303 case OFPUTIL_OFPAT_ENQUEUE:
304 parse_enqueue(b, arg);
307 case OFPUTIL_NXAST_RESUBMIT:
308 parse_resubmit(b, arg);
311 case OFPUTIL_NXAST_SET_TUNNEL:
312 parse_set_tunnel(b, arg);
315 case OFPUTIL_NXAST_SET_QUEUE:
316 ofputil_put_NXAST_SET_QUEUE(b)->queue_id = htonl(str_to_u32(arg));
319 case OFPUTIL_NXAST_POP_QUEUE:
320 ofputil_put_NXAST_POP_QUEUE(b);
323 case OFPUTIL_NXAST_REG_MOVE:
324 nxm_parse_reg_move(ofputil_put_NXAST_REG_MOVE(b), arg);
327 case OFPUTIL_NXAST_REG_LOAD:
328 nxm_parse_reg_load(ofputil_put_NXAST_REG_LOAD(b), arg);
331 case OFPUTIL_NXAST_NOTE:
335 case OFPUTIL_NXAST_SET_TUNNEL64:
336 ofputil_put_NXAST_SET_TUNNEL64(b)->tun_id = htonll(str_to_u64(arg));
339 case OFPUTIL_NXAST_MULTIPATH:
340 multipath_parse(ofputil_put_NXAST_MULTIPATH(b), arg);
343 case OFPUTIL_NXAST_AUTOPATH:
344 autopath_parse(ofputil_put_NXAST_AUTOPATH(b), arg);
347 case OFPUTIL_NXAST_BUNDLE:
348 bundle_parse(b, arg);
351 case OFPUTIL_NXAST_BUNDLE_LOAD:
352 bundle_parse_load(b, arg);
355 case OFPUTIL_NXAST_RESUBMIT_TABLE:
356 case OFPUTIL_NXAST_OUTPUT_REG:
359 case OFPUTIL_NXAST_LEARN:
360 learn_parse(b, arg, flow);
363 case OFPUTIL_NXAST_EXIT:
364 ofputil_put_NXAST_EXIT(b);
367 case OFPUTIL_NXAST_DEC_TTL:
368 ofputil_put_NXAST_DEC_TTL(b);
374 str_to_action(const struct flow *flow, char *str, struct ofpbuf *b)
376 char *pos, *act, *arg;
381 while (ofputil_parse_key_value(&pos, &act, &arg)) {
385 code = ofputil_action_code_from_name(act);
387 parse_named_action(code, flow, b, arg);
388 } else if (!strcasecmp(act, "drop")) {
389 /* A drop action in OpenFlow occurs by just not setting
392 ovs_fatal(0, "Drop actions must not be preceded by other "
394 } else if (ofputil_parse_key_value(&pos, &act, &arg)) {
395 ovs_fatal(0, "Drop actions must not be followed by other "
399 } else if (!strcasecmp(act, "CONTROLLER")) {
400 struct ofp_action_output *oao;
401 oao = put_output_action(b, OFPP_CONTROLLER);
403 /* Unless a numeric argument is specified, we send the whole
404 * packet to the controller. */
405 if (arg[0] && (strspn(arg, "0123456789") == strlen(arg))) {
406 oao->max_len = htons(str_to_u32(arg));
408 oao->max_len = htons(UINT16_MAX);
410 } else if (ofputil_port_from_string(act, &port)) {
411 put_output_action(b, port);
413 ovs_fatal(0, "Unknown action: %s", act);
426 parse_protocol(const char *name, const struct protocol **p_out)
428 static const struct protocol protocols[] = {
429 { "ip", ETH_TYPE_IP, 0 },
430 { "arp", ETH_TYPE_ARP, 0 },
431 { "icmp", ETH_TYPE_IP, IPPROTO_ICMP },
432 { "tcp", ETH_TYPE_IP, IPPROTO_TCP },
433 { "udp", ETH_TYPE_IP, IPPROTO_UDP },
434 { "ipv6", ETH_TYPE_IPV6, 0 },
435 { "ip6", ETH_TYPE_IPV6, 0 },
436 { "icmp6", ETH_TYPE_IPV6, IPPROTO_ICMPV6 },
437 { "tcp6", ETH_TYPE_IPV6, IPPROTO_TCP },
438 { "udp6", ETH_TYPE_IPV6, IPPROTO_UDP },
440 const struct protocol *p;
442 for (p = protocols; p < &protocols[ARRAY_SIZE(protocols)]; p++) {
443 if (!strcmp(p->name, name)) {
453 ofp_fatal(const char *flow, bool verbose, const char *format, ...)
458 fprintf(stderr, "%s:\n", flow);
461 va_start(args, format);
462 ovs_fatal_valist(0, format, args);
466 parse_field(const struct mf_field *mf, const char *s, struct cls_rule *rule)
468 union mf_value value, mask;
471 error = mf_parse(mf, s, &value, &mask);
473 ovs_fatal(0, "%s", error);
476 mf_set(mf, &value, &mask, rule);
479 /* Convert 'str_' (as described in the Flow Syntax section of the ovs-ofctl man
480 * page) into 'fm' for sending the specified flow_mod 'command' to a switch.
481 * If 'actions' is specified, an action must be in 'string' and may be expanded
484 * To parse syntax for an OFPT_FLOW_MOD (or NXT_FLOW_MOD), use an OFPFC_*
485 * constant for 'command'. To parse syntax for an OFPST_FLOW or
486 * OFPST_AGGREGATE (or NXST_FLOW or NXST_AGGREGATE), use -1 for 'command'. */
488 parse_ofp_str(struct ofputil_flow_mod *fm, int command, const char *str_,
497 char *string = xstrdup(str_);
498 char *save_ptr = NULL;
499 char *act_str = NULL;
508 fields = F_ACTIONS | F_TIMEOUT | F_PRIORITY;
515 case OFPFC_DELETE_STRICT:
516 fields = F_OUT_PORT | F_PRIORITY;
523 case OFPFC_MODIFY_STRICT:
524 fields = F_ACTIONS | F_PRIORITY;
531 cls_rule_init_catchall(&fm->cr, OFP_DEFAULT_PRIORITY);
532 fm->cookie = htonll(0);
533 fm->cookie_mask = htonll(0);
535 fm->command = command;
536 fm->idle_timeout = OFP_FLOW_PERMANENT;
537 fm->hard_timeout = OFP_FLOW_PERMANENT;
538 fm->buffer_id = UINT32_MAX;
539 fm->out_port = OFPP_NONE;
541 if (fields & F_ACTIONS) {
542 act_str = strstr(string, "action");
544 ofp_fatal(str_, verbose, "must specify an action");
548 act_str = strchr(act_str + 1, '=');
550 ofp_fatal(str_, verbose, "must specify an action");
555 for (name = strtok_r(string, "=, \t\r\n", &save_ptr); name;
556 name = strtok_r(NULL, "=, \t\r\n", &save_ptr)) {
557 const struct protocol *p;
559 if (parse_protocol(name, &p)) {
560 cls_rule_set_dl_type(&fm->cr, htons(p->dl_type));
562 cls_rule_set_nw_proto(&fm->cr, p->nw_proto);
567 value = strtok_r(NULL, ", \t\r\n", &save_ptr);
569 ofp_fatal(str_, verbose, "field %s missing value", name);
572 if (!strcmp(name, "table")) {
573 fm->table_id = str_to_table_id(value);
574 } else if (!strcmp(name, "out_port")) {
575 fm->out_port = atoi(value);
576 } else if (fields & F_PRIORITY && !strcmp(name, "priority")) {
577 fm->cr.priority = str_to_u16(value, name);
578 } else if (fields & F_TIMEOUT && !strcmp(name, "idle_timeout")) {
579 fm->idle_timeout = str_to_u16(value, name);
580 } else if (fields & F_TIMEOUT && !strcmp(name, "hard_timeout")) {
581 fm->hard_timeout = str_to_u16(value, name);
582 } else if (!strcmp(name, "cookie")) {
583 char *mask = strchr(value, '/');
585 if (command == OFPFC_ADD) {
586 ofp_fatal(str_, verbose, "flow additions cannot use "
590 fm->cookie_mask = htonll(str_to_u64(mask+1));
592 fm->cookie_mask = htonll(UINT64_MAX);
594 fm->cookie = htonll(str_to_u64(value));
595 } else if (mf_from_name(name)) {
596 parse_field(mf_from_name(name), value, &fm->cr);
597 } else if (!strcmp(name, "duration")
598 || !strcmp(name, "n_packets")
599 || !strcmp(name, "n_bytes")) {
600 /* Ignore these, so that users can feed the output of
601 * "ovs-ofctl dump-flows" back into commands that parse
604 ofp_fatal(str_, verbose, "unknown keyword %s", name);
608 if (fields & F_ACTIONS) {
609 struct ofpbuf actions;
611 ofpbuf_init(&actions, sizeof(union ofp_action));
612 str_to_action(&fm->cr.flow, act_str, &actions);
613 fm->actions = ofpbuf_steal_data(&actions);
614 fm->n_actions = actions.size / sizeof(union ofp_action);
623 /* Parses 'string' as an OFPT_FLOW_MOD or NXT_FLOW_MOD with command 'command'
624 * (one of OFPFC_*) and appends the parsed OpenFlow message to 'packets'.
625 * '*cur_format' should initially contain the flow format currently configured
626 * on the connection; this function will add a message to change the flow
627 * format and update '*cur_format', if this is necessary to add the parsed
630 parse_ofp_flow_mod_str(struct list *packets, enum nx_flow_format *cur_format,
631 bool *flow_mod_table_id, char *string, uint16_t command,
634 enum nx_flow_format min_format, next_format;
635 struct cls_rule rule_copy;
637 struct ofputil_flow_mod fm;
639 parse_ofp_str(&fm, command, string, verbose);
641 min_format = ofputil_min_flow_format(&fm.cr);
642 if (command != OFPFC_ADD && fm.cookie_mask != htonll(0)) {
643 min_format = NXFF_NXM;
645 next_format = MAX(*cur_format, min_format);
646 if (next_format != *cur_format) {
647 struct ofpbuf *sff = ofputil_make_set_flow_format(next_format);
648 list_push_back(packets, &sff->list_node);
649 *cur_format = next_format;
652 /* Normalize a copy of the rule. This ensures that non-normalized flows
653 * get logged but doesn't affect what gets sent to the switch, so that the
654 * switch can do whatever it likes with the flow. */
656 ofputil_normalize_rule(&rule_copy, next_format);
658 if (fm.table_id != 0xff && !*flow_mod_table_id) {
659 struct ofpbuf *sff = ofputil_make_flow_mod_table_id(true);
660 list_push_back(packets, &sff->list_node);
661 *flow_mod_table_id = true;
664 ofm = ofputil_encode_flow_mod(&fm, *cur_format, *flow_mod_table_id);
665 list_push_back(packets, &ofm->list_node);
668 /* Similar to parse_ofp_flow_mod_str(), except that the string is read from
669 * 'stream' and the command is always OFPFC_ADD. Returns false if end-of-file
670 * is reached before reading a flow, otherwise true. */
672 parse_ofp_flow_mod_file(struct list *packets,
673 enum nx_flow_format *cur, bool *flow_mod_table_id,
674 FILE *stream, uint16_t command)
680 ok = ds_get_preprocessed_line(&s, stream) == 0;
682 parse_ofp_flow_mod_str(packets, cur, flow_mod_table_id,
683 ds_cstr(&s), command, true);
691 parse_ofp_flow_stats_request_str(struct ofputil_flow_stats_request *fsr,
692 bool aggregate, char *string)
694 struct ofputil_flow_mod fm;
696 parse_ofp_str(&fm, -1, string, false);
697 fsr->aggregate = aggregate;
698 fsr->cookie = fm.cookie;
699 fsr->cookie_mask = fm.cookie_mask;
701 fsr->out_port = fm.out_port;
702 fsr->table_id = fm.table_id;