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);
367 str_to_action(const struct flow *flow, char *str, struct ofpbuf *b)
369 char *pos, *act, *arg;
374 while (ofputil_parse_key_value(&pos, &act, &arg)) {
378 code = ofputil_action_code_from_name(act);
380 parse_named_action(code, flow, b, arg);
381 } else if (!strcasecmp(act, "drop")) {
382 /* A drop action in OpenFlow occurs by just not setting
385 ovs_fatal(0, "Drop actions must not be preceded by other "
387 } else if (ofputil_parse_key_value(&pos, &act, &arg)) {
388 ovs_fatal(0, "Drop actions must not be followed by other "
392 } else if (!strcasecmp(act, "CONTROLLER")) {
393 struct ofp_action_output *oao;
394 oao = put_output_action(b, OFPP_CONTROLLER);
396 /* Unless a numeric argument is specified, we send the whole
397 * packet to the controller. */
398 if (arg[0] && (strspn(arg, "0123456789") == strlen(arg))) {
399 oao->max_len = htons(str_to_u32(arg));
401 oao->max_len = htons(UINT16_MAX);
403 } else if (ofputil_port_from_string(act, &port)) {
404 put_output_action(b, port);
406 ovs_fatal(0, "Unknown action: %s", act);
419 parse_protocol(const char *name, const struct protocol **p_out)
421 static const struct protocol protocols[] = {
422 { "ip", ETH_TYPE_IP, 0 },
423 { "arp", ETH_TYPE_ARP, 0 },
424 { "icmp", ETH_TYPE_IP, IPPROTO_ICMP },
425 { "tcp", ETH_TYPE_IP, IPPROTO_TCP },
426 { "udp", ETH_TYPE_IP, IPPROTO_UDP },
427 { "ipv6", ETH_TYPE_IPV6, 0 },
428 { "ip6", ETH_TYPE_IPV6, 0 },
429 { "icmp6", ETH_TYPE_IPV6, IPPROTO_ICMPV6 },
430 { "tcp6", ETH_TYPE_IPV6, IPPROTO_TCP },
431 { "udp6", ETH_TYPE_IPV6, IPPROTO_UDP },
433 const struct protocol *p;
435 for (p = protocols; p < &protocols[ARRAY_SIZE(protocols)]; p++) {
436 if (!strcmp(p->name, name)) {
446 ofp_fatal(const char *flow, bool verbose, const char *format, ...)
451 fprintf(stderr, "%s:\n", flow);
454 va_start(args, format);
455 ovs_fatal_valist(0, format, args);
459 parse_field(const struct mf_field *mf, const char *s, struct cls_rule *rule)
461 union mf_value value, mask;
464 error = mf_parse(mf, s, &value, &mask);
466 ovs_fatal(0, "%s", error);
469 mf_set(mf, &value, &mask, rule);
472 /* Convert 'str_' (as described in the Flow Syntax section of the ovs-ofctl man
473 * page) into 'fm' for sending the specified flow_mod 'command' to a switch.
474 * If 'actions' is specified, an action must be in 'string' and may be expanded
477 * To parse syntax for an OFPT_FLOW_MOD (or NXT_FLOW_MOD), use an OFPFC_*
478 * constant for 'command'. To parse syntax for an OFPST_FLOW or
479 * OFPST_AGGREGATE (or NXST_FLOW or NXST_AGGREGATE), use -1 for 'command'. */
481 parse_ofp_str(struct ofputil_flow_mod *fm, int command, const char *str_,
491 char *string = xstrdup(str_);
492 char *save_ptr = NULL;
493 char *act_str = NULL;
502 fields = F_ACTIONS | F_COOKIE | F_TIMEOUT | F_PRIORITY;
509 case OFPFC_DELETE_STRICT:
510 fields = F_OUT_PORT | F_PRIORITY;
514 fields = F_ACTIONS | F_COOKIE;
517 case OFPFC_MODIFY_STRICT:
518 fields = F_ACTIONS | F_COOKIE | F_PRIORITY;
525 cls_rule_init_catchall(&fm->cr, OFP_DEFAULT_PRIORITY);
526 fm->cookie = htonll(0);
528 fm->command = command;
529 fm->idle_timeout = OFP_FLOW_PERMANENT;
530 fm->hard_timeout = OFP_FLOW_PERMANENT;
531 fm->buffer_id = UINT32_MAX;
532 fm->out_port = OFPP_NONE;
534 if (fields & F_ACTIONS) {
535 act_str = strstr(string, "action");
537 ofp_fatal(str_, verbose, "must specify an action");
541 act_str = strchr(act_str + 1, '=');
543 ofp_fatal(str_, verbose, "must specify an action");
548 for (name = strtok_r(string, "=, \t\r\n", &save_ptr); name;
549 name = strtok_r(NULL, "=, \t\r\n", &save_ptr)) {
550 const struct protocol *p;
552 if (parse_protocol(name, &p)) {
553 cls_rule_set_dl_type(&fm->cr, htons(p->dl_type));
555 cls_rule_set_nw_proto(&fm->cr, p->nw_proto);
560 value = strtok_r(NULL, ", \t\r\n", &save_ptr);
562 ofp_fatal(str_, verbose, "field %s missing value", name);
565 if (!strcmp(name, "table")) {
566 fm->table_id = str_to_table_id(value);
567 } else if (!strcmp(name, "out_port")) {
568 fm->out_port = atoi(value);
569 } else if (fields & F_PRIORITY && !strcmp(name, "priority")) {
570 fm->cr.priority = str_to_u16(value, name);
571 } else if (fields & F_TIMEOUT && !strcmp(name, "idle_timeout")) {
572 fm->idle_timeout = str_to_u16(value, name);
573 } else if (fields & F_TIMEOUT && !strcmp(name, "hard_timeout")) {
574 fm->hard_timeout = str_to_u16(value, name);
575 } else if (fields & F_COOKIE && !strcmp(name, "cookie")) {
576 fm->cookie = htonll(str_to_u64(value));
577 } else if (mf_from_name(name)) {
578 parse_field(mf_from_name(name), value, &fm->cr);
579 } else if (!strcmp(name, "duration")
580 || !strcmp(name, "n_packets")
581 || !strcmp(name, "n_bytes")) {
582 /* Ignore these, so that users can feed the output of
583 * "ovs-ofctl dump-flows" back into commands that parse
586 ofp_fatal(str_, verbose, "unknown keyword %s", name);
590 if (fields & F_ACTIONS) {
591 struct ofpbuf actions;
593 ofpbuf_init(&actions, sizeof(union ofp_action));
594 str_to_action(&fm->cr.flow, act_str, &actions);
595 fm->actions = ofpbuf_steal_data(&actions);
596 fm->n_actions = actions.size / sizeof(union ofp_action);
605 /* Parses 'string' as an OFPT_FLOW_MOD or NXT_FLOW_MOD with command 'command'
606 * (one of OFPFC_*) and appends the parsed OpenFlow message to 'packets'.
607 * '*cur_format' should initially contain the flow format currently configured
608 * on the connection; this function will add a message to change the flow
609 * format and update '*cur_format', if this is necessary to add the parsed
612 parse_ofp_flow_mod_str(struct list *packets, enum nx_flow_format *cur_format,
613 bool *flow_mod_table_id, char *string, uint16_t command,
616 enum nx_flow_format min_format, next_format;
617 struct cls_rule rule_copy;
619 struct ofputil_flow_mod fm;
621 parse_ofp_str(&fm, command, string, verbose);
623 min_format = ofputil_min_flow_format(&fm.cr);
624 next_format = MAX(*cur_format, min_format);
625 if (next_format != *cur_format) {
626 struct ofpbuf *sff = ofputil_make_set_flow_format(next_format);
627 list_push_back(packets, &sff->list_node);
628 *cur_format = next_format;
631 /* Normalize a copy of the rule. This ensures that non-normalized flows
632 * get logged but doesn't affect what gets sent to the switch, so that the
633 * switch can do whatever it likes with the flow. */
635 ofputil_normalize_rule(&rule_copy, next_format);
637 if (fm.table_id != 0xff && !*flow_mod_table_id) {
638 struct ofpbuf *sff = ofputil_make_flow_mod_table_id(true);
639 list_push_back(packets, &sff->list_node);
640 *flow_mod_table_id = true;
643 ofm = ofputil_encode_flow_mod(&fm, *cur_format, *flow_mod_table_id);
644 list_push_back(packets, &ofm->list_node);
647 /* Similar to parse_ofp_flow_mod_str(), except that the string is read from
648 * 'stream' and the command is always OFPFC_ADD. Returns false if end-of-file
649 * is reached before reading a flow, otherwise true. */
651 parse_ofp_flow_mod_file(struct list *packets,
652 enum nx_flow_format *cur, bool *flow_mod_table_id,
653 FILE *stream, uint16_t command)
659 ok = ds_get_preprocessed_line(&s, stream) == 0;
661 parse_ofp_flow_mod_str(packets, cur, flow_mod_table_id,
662 ds_cstr(&s), command, true);
670 parse_ofp_flow_stats_request_str(struct ofputil_flow_stats_request *fsr,
671 bool aggregate, char *string)
673 struct ofputil_flow_mod fm;
675 parse_ofp_str(&fm, -1, string, false);
676 fsr->aggregate = aggregate;
678 fsr->out_port = fm.out_port;
679 fsr->table_id = fm.table_id;