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
;