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_u32(const char *str)
51 ovs_fatal(0, "missing required numeric argument");
55 value = strtoul(str, &tail, 0);
56 if (errno == EINVAL || errno == ERANGE || *tail) {
57 ovs_fatal(0, "invalid numeric format %s", str);
63 str_to_u64(const char *str)
69 ovs_fatal(0, "missing required numeric argument");
73 value = strtoull(str, &tail, 0);
74 if (errno == EINVAL || errno == ERANGE || *tail) {
75 ovs_fatal(0, "invalid numeric format %s", str);
81 str_to_mac(const char *str, uint8_t mac[6])
83 if (sscanf(str, ETH_ADDR_SCAN_FMT, ETH_ADDR_SCAN_ARGS(mac))
84 != ETH_ADDR_SCAN_COUNT) {
85 ovs_fatal(0, "invalid mac address %s", str);
90 str_to_ip(const char *str, ovs_be32 *ip)
92 struct in_addr in_addr;
94 if (lookup_ip(str, &in_addr)) {
95 ovs_fatal(0, "%s: could not convert to IP address", str);
100 static struct ofp_action_output *
101 put_output_action(struct ofpbuf *b, uint16_t port)
103 struct ofp_action_output *oao;
105 oao = ofputil_put_OFPAT_OUTPUT(b);
106 oao->port = htons(port);
111 parse_enqueue(struct ofpbuf *b, char *arg)
114 char *port = strtok_r(arg, ":q", &sp);
115 char *queue = strtok_r(NULL, "", &sp);
116 struct ofp_action_enqueue *oae;
118 if (port == NULL || queue == NULL) {
119 ovs_fatal(0, "\"enqueue\" syntax is \"enqueue:PORT:QUEUE\"");
122 oae = ofputil_put_OFPAT_ENQUEUE(b);
123 oae->port = htons(str_to_u32(port));
124 oae->queue_id = htonl(str_to_u32(queue));
128 parse_output(struct ofpbuf *b, char *arg)
130 if (strchr(arg, '[')) {
131 struct nx_action_output_reg *naor;
135 nxm_parse_field_bits(arg, &src, &ofs, &n_bits);
137 naor = ofputil_put_NXAST_OUTPUT_REG(b);
138 naor->ofs_nbits = nxm_encode_ofs_nbits(ofs, n_bits);
139 naor->src = htonl(src);
140 naor->max_len = htons(UINT16_MAX);
142 put_output_action(b, str_to_u32(arg));
147 parse_resubmit(struct ofpbuf *b, char *arg)
149 struct nx_action_resubmit *nar;
150 char *in_port_s, *table_s;
154 in_port_s = strsep(&arg, ",");
155 if (in_port_s && in_port_s[0]) {
156 if (!ofputil_port_from_string(in_port_s, &in_port)) {
157 in_port = str_to_u32(in_port_s);
160 in_port = OFPP_IN_PORT;
163 table_s = strsep(&arg, ",");
164 table = table_s && table_s[0] ? str_to_u32(table_s) : 255;
166 if (in_port == OFPP_IN_PORT && table == 255) {
167 ovs_fatal(0, "at least one \"in_port\" or \"table\" must be specified "
171 if (in_port != OFPP_IN_PORT && table == 255) {
172 nar = ofputil_put_NXAST_RESUBMIT(b);
174 nar = ofputil_put_NXAST_RESUBMIT_TABLE(b);
177 nar->in_port = htons(in_port);
181 parse_set_tunnel(struct ofpbuf *b, const char *arg)
183 uint64_t tun_id = str_to_u64(arg);
184 if (tun_id > UINT32_MAX) {
185 ofputil_put_NXAST_SET_TUNNEL64(b)->tun_id = htonll(tun_id);
187 ofputil_put_NXAST_SET_TUNNEL(b)->tun_id = htonl(tun_id);
192 parse_note(struct ofpbuf *b, const char *arg)
194 size_t start_ofs = b->size;
195 struct nx_action_note *nan;
199 nan = ofputil_put_NXAST_NOTE(b);
201 b->size -= sizeof nan->note;
202 while (*arg != '\0') {
213 byte = hexits_value(arg, 2, &ok);
215 ovs_fatal(0, "bad hex digit in `note' argument");
217 ofpbuf_put(b, &byte, 1);
222 len = b->size - start_ofs;
223 remainder = len % OFP_ACTION_ALIGN;
225 ofpbuf_put_zeros(b, OFP_ACTION_ALIGN - remainder);
227 nan = (struct nx_action_note *)((char *)b->data + start_ofs);
228 nan->len = htons(b->size - start_ofs);
232 parse_named_action(enum ofputil_action_code code, const struct flow *flow,
233 struct ofpbuf *b, char *arg)
235 struct ofp_action_dl_addr *oada;
236 struct ofp_action_vlan_pcp *oavp;
237 struct ofp_action_vlan_vid *oavv;
238 struct ofp_action_nw_addr *oana;
239 struct ofp_action_tp_port *oata;
242 case OFPUTIL_OFPAT_OUTPUT:
243 parse_output(b, arg);
246 case OFPUTIL_OFPAT_SET_VLAN_VID:
247 oavv = ofputil_put_OFPAT_SET_VLAN_VID(b);
248 oavv->vlan_vid = htons(str_to_u32(arg));
251 case OFPUTIL_OFPAT_SET_VLAN_PCP:
252 oavp = ofputil_put_OFPAT_SET_VLAN_PCP(b);
253 oavp->vlan_pcp = str_to_u32(arg);
256 case OFPUTIL_OFPAT_STRIP_VLAN:
257 ofputil_put_OFPAT_STRIP_VLAN(b);
260 case OFPUTIL_OFPAT_SET_DL_SRC:
261 case OFPUTIL_OFPAT_SET_DL_DST:
262 oada = ofputil_put_action(code, b);
263 str_to_mac(arg, oada->dl_addr);
266 case OFPUTIL_OFPAT_SET_NW_SRC:
267 case OFPUTIL_OFPAT_SET_NW_DST:
268 oana = ofputil_put_action(code, b);
269 str_to_ip(arg, &oana->nw_addr);
272 case OFPUTIL_OFPAT_SET_NW_TOS:
273 ofputil_put_OFPAT_SET_NW_TOS(b)->nw_tos = str_to_u32(arg);
276 case OFPUTIL_OFPAT_SET_TP_SRC:
277 case OFPUTIL_OFPAT_SET_TP_DST:
278 oata = ofputil_put_action(code, b);
279 oata->tp_port = htons(str_to_u32(arg));
282 case OFPUTIL_OFPAT_ENQUEUE:
283 parse_enqueue(b, arg);
286 case OFPUTIL_NXAST_RESUBMIT:
287 parse_resubmit(b, arg);
290 case OFPUTIL_NXAST_SET_TUNNEL:
291 parse_set_tunnel(b, arg);
294 case OFPUTIL_NXAST_SET_QUEUE:
295 ofputil_put_NXAST_SET_QUEUE(b)->queue_id = htonl(str_to_u32(arg));
298 case OFPUTIL_NXAST_POP_QUEUE:
299 ofputil_put_NXAST_POP_QUEUE(b);
302 case OFPUTIL_NXAST_REG_MOVE:
303 nxm_parse_reg_move(ofputil_put_NXAST_REG_MOVE(b), arg);
306 case OFPUTIL_NXAST_REG_LOAD:
307 nxm_parse_reg_load(ofputil_put_NXAST_REG_LOAD(b), arg);
310 case OFPUTIL_NXAST_NOTE:
314 case OFPUTIL_NXAST_SET_TUNNEL64:
315 ofputil_put_NXAST_SET_TUNNEL64(b)->tun_id = htonll(str_to_u64(arg));
318 case OFPUTIL_NXAST_MULTIPATH:
319 multipath_parse(ofputil_put_NXAST_MULTIPATH(b), arg);
322 case OFPUTIL_NXAST_AUTOPATH:
323 autopath_parse(ofputil_put_NXAST_AUTOPATH(b), arg);
326 case OFPUTIL_NXAST_BUNDLE:
327 bundle_parse(b, arg);
330 case OFPUTIL_NXAST_BUNDLE_LOAD:
331 bundle_parse_load(b, arg);
334 case OFPUTIL_NXAST_RESUBMIT_TABLE:
335 case OFPUTIL_NXAST_OUTPUT_REG:
338 case OFPUTIL_NXAST_LEARN:
339 learn_parse(b, arg, flow);
345 str_to_action(const struct flow *flow, char *str, struct ofpbuf *b)
347 char *pos, *act, *arg;
352 while (ofputil_parse_key_value(&pos, &act, &arg)) {
356 code = ofputil_action_code_from_name(act);
358 parse_named_action(code, flow, b, arg);
359 } else if (!strcasecmp(act, "drop")) {
360 /* A drop action in OpenFlow occurs by just not setting
363 ovs_fatal(0, "Drop actions must not be preceded by other "
365 } else if (ofputil_parse_key_value(&pos, &act, &arg)) {
366 ovs_fatal(0, "Drop actions must not be followed by other "
370 } else if (!strcasecmp(act, "CONTROLLER")) {
371 struct ofp_action_output *oao;
372 oao = put_output_action(b, OFPP_CONTROLLER);
374 /* Unless a numeric argument is specified, we send the whole
375 * packet to the controller. */
376 if (arg[0] && (strspn(arg, "0123456789") == strlen(arg))) {
377 oao->max_len = htons(str_to_u32(arg));
379 oao->max_len = htons(UINT16_MAX);
381 } else if (ofputil_port_from_string(act, &port)) {
382 put_output_action(b, port);
384 ovs_fatal(0, "Unknown action: %s", act);
397 parse_protocol(const char *name, const struct protocol **p_out)
399 static const struct protocol protocols[] = {
400 { "ip", ETH_TYPE_IP, 0 },
401 { "arp", ETH_TYPE_ARP, 0 },
402 { "icmp", ETH_TYPE_IP, IPPROTO_ICMP },
403 { "tcp", ETH_TYPE_IP, IPPROTO_TCP },
404 { "udp", ETH_TYPE_IP, IPPROTO_UDP },
405 { "ipv6", ETH_TYPE_IPV6, 0 },
406 { "ip6", ETH_TYPE_IPV6, 0 },
407 { "icmp6", ETH_TYPE_IPV6, IPPROTO_ICMPV6 },
408 { "tcp6", ETH_TYPE_IPV6, IPPROTO_TCP },
409 { "udp6", ETH_TYPE_IPV6, IPPROTO_UDP },
411 const struct protocol *p;
413 for (p = protocols; p < &protocols[ARRAY_SIZE(protocols)]; p++) {
414 if (!strcmp(p->name, name)) {
424 ofp_fatal(const char *flow, bool verbose, const char *format, ...)
429 fprintf(stderr, "%s:\n", flow);
432 va_start(args, format);
433 ovs_fatal_valist(0, format, args);
437 parse_field(const struct mf_field *mf, const char *s, struct cls_rule *rule)
439 union mf_value value, mask;
442 error = mf_parse(mf, s, &value, &mask);
444 ovs_fatal(0, "%s", error);
447 mf_set(mf, &value, &mask, rule);
450 /* Convert 'str_' (as described in the Flow Syntax section of the ovs-ofctl man
451 * page) into 'fm' for sending the specified flow_mod 'command' to a switch.
452 * If 'actions' is specified, an action must be in 'string' and may be expanded
455 * To parse syntax for an OFPT_FLOW_MOD (or NXT_FLOW_MOD), use an OFPFC_*
456 * constant for 'command'. To parse syntax for an OFPST_FLOW or
457 * OFPST_AGGREGATE (or NXST_FLOW or NXST_AGGREGATE), use -1 for 'command'. */
459 parse_ofp_str(struct ofputil_flow_mod *fm, int command, const char *str_,
469 char *string = xstrdup(str_);
470 char *save_ptr = NULL;
471 char *act_str = NULL;
480 fields = F_ACTIONS | F_COOKIE | F_TIMEOUT | F_PRIORITY;
487 case OFPFC_DELETE_STRICT:
488 fields = F_OUT_PORT | F_PRIORITY;
492 fields = F_ACTIONS | F_COOKIE;
495 case OFPFC_MODIFY_STRICT:
496 fields = F_ACTIONS | F_COOKIE | F_PRIORITY;
503 cls_rule_init_catchall(&fm->cr, OFP_DEFAULT_PRIORITY);
504 fm->cookie = htonll(0);
506 fm->command = command;
507 fm->idle_timeout = OFP_FLOW_PERMANENT;
508 fm->hard_timeout = OFP_FLOW_PERMANENT;
509 fm->buffer_id = UINT32_MAX;
510 fm->out_port = OFPP_NONE;
512 if (fields & F_ACTIONS) {
513 act_str = strstr(string, "action");
515 ofp_fatal(str_, verbose, "must specify an action");
519 act_str = strchr(act_str + 1, '=');
521 ofp_fatal(str_, verbose, "must specify an action");
526 for (name = strtok_r(string, "=, \t\r\n", &save_ptr); name;
527 name = strtok_r(NULL, "=, \t\r\n", &save_ptr)) {
528 const struct protocol *p;
530 if (parse_protocol(name, &p)) {
531 cls_rule_set_dl_type(&fm->cr, htons(p->dl_type));
533 cls_rule_set_nw_proto(&fm->cr, p->nw_proto);
538 value = strtok_r(NULL, ", \t\r\n", &save_ptr);
540 ofp_fatal(str_, verbose, "field %s missing value", name);
543 if (!strcmp(name, "table")) {
544 fm->table_id = atoi(value);
545 } else if (!strcmp(name, "out_port")) {
546 fm->out_port = atoi(value);
547 } else if (fields & F_PRIORITY && !strcmp(name, "priority")) {
548 fm->cr.priority = atoi(value);
549 } else if (fields & F_TIMEOUT && !strcmp(name, "idle_timeout")) {
550 fm->idle_timeout = atoi(value);
551 } else if (fields & F_TIMEOUT && !strcmp(name, "hard_timeout")) {
552 fm->hard_timeout = atoi(value);
553 } else if (fields & F_COOKIE && !strcmp(name, "cookie")) {
554 fm->cookie = htonll(str_to_u64(value));
555 } else if (mf_from_name(name)) {
556 parse_field(mf_from_name(name), value, &fm->cr);
557 } else if (!strcmp(name, "duration")
558 || !strcmp(name, "n_packets")
559 || !strcmp(name, "n_bytes")) {
560 /* Ignore these, so that users can feed the output of
561 * "ovs-ofctl dump-flows" back into commands that parse
564 ofp_fatal(str_, verbose, "unknown keyword %s", name);
568 if (fields & F_ACTIONS) {
569 struct ofpbuf actions;
571 ofpbuf_init(&actions, sizeof(union ofp_action));
572 str_to_action(&fm->cr.flow, act_str, &actions);
573 fm->actions = ofpbuf_steal_data(&actions);
574 fm->n_actions = actions.size / sizeof(union ofp_action);
583 /* Parses 'string' as an OFPT_FLOW_MOD or NXT_FLOW_MOD with command 'command'
584 * (one of OFPFC_*) and appends the parsed OpenFlow message to 'packets'.
585 * '*cur_format' should initially contain the flow format currently configured
586 * on the connection; this function will add a message to change the flow
587 * format and update '*cur_format', if this is necessary to add the parsed
590 parse_ofp_flow_mod_str(struct list *packets, enum nx_flow_format *cur_format,
591 bool *flow_mod_table_id, char *string, uint16_t command,
594 enum nx_flow_format min_format, next_format;
595 struct cls_rule rule_copy;
597 struct ofputil_flow_mod fm;
599 parse_ofp_str(&fm, command, string, verbose);
601 min_format = ofputil_min_flow_format(&fm.cr);
602 next_format = MAX(*cur_format, min_format);
603 if (next_format != *cur_format) {
604 struct ofpbuf *sff = ofputil_make_set_flow_format(next_format);
605 list_push_back(packets, &sff->list_node);
606 *cur_format = next_format;
609 /* Normalize a copy of the rule. This ensures that non-normalized flows
610 * get logged but doesn't affect what gets sent to the switch, so that the
611 * switch can do whatever it likes with the flow. */
613 ofputil_normalize_rule(&rule_copy, next_format);
615 if (fm.table_id != 0xff && !*flow_mod_table_id) {
616 struct ofpbuf *sff = ofputil_make_flow_mod_table_id(true);
617 list_push_back(packets, &sff->list_node);
618 *flow_mod_table_id = true;
621 ofm = ofputil_encode_flow_mod(&fm, *cur_format, *flow_mod_table_id);
622 list_push_back(packets, &ofm->list_node);
625 /* Similar to parse_ofp_flow_mod_str(), except that the string is read from
626 * 'stream' and the command is always OFPFC_ADD. Returns false if end-of-file
627 * is reached before reading a flow, otherwise true. */
629 parse_ofp_flow_mod_file(struct list *packets,
630 enum nx_flow_format *cur, bool *flow_mod_table_id,
631 FILE *stream, uint16_t command)
637 ok = ds_get_preprocessed_line(&s, stream) == 0;
639 parse_ofp_flow_mod_str(packets, cur, flow_mod_table_id,
640 ds_cstr(&s), command, true);
648 parse_ofp_flow_stats_request_str(struct ofputil_flow_stats_request *fsr,
649 bool aggregate, char *string)
651 struct ofputil_flow_mod fm;
653 parse_ofp_str(&fm, -1, string, false);
654 fsr->aggregate = aggregate;
656 fsr->out_port = fm.out_port;
657 fsr->table_id = fm.table_id;