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
;