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
);
363 case OFPUTIL_NXAST_EXIT
:
364 ofputil_put_NXAST_EXIT(b
);
370 str_to_action(const struct flow
*flow
, char *str
, struct ofpbuf
*b
)
372 char *pos
, *act
, *arg
;
377 while (ofputil_parse_key_value(&pos
, &act
, &arg
)) {
381 code
= ofputil_action_code_from_name(act
);
383 parse_named_action(code
, flow
, b
, arg
);
384 } else if (!strcasecmp(act
, "drop")) {
385 /* A drop action in OpenFlow occurs by just not setting
388 ovs_fatal(0, "Drop actions must not be preceded by other "
390 } else if (ofputil_parse_key_value(&pos
, &act
, &arg
)) {
391 ovs_fatal(0, "Drop actions must not be followed by other "
395 } else if (!strcasecmp(act
, "CONTROLLER")) {
396 struct ofp_action_output
*oao
;
397 oao
= put_output_action(b
, OFPP_CONTROLLER
);
399 /* Unless a numeric argument is specified, we send the whole
400 * packet to the controller. */
401 if (arg
[0] && (strspn(arg
, "0123456789") == strlen(arg
))) {
402 oao
->max_len
= htons(str_to_u32(arg
));
404 oao
->max_len
= htons(UINT16_MAX
);
406 } else if (ofputil_port_from_string(act
, &port
)) {
407 put_output_action(b
, port
);
409 ovs_fatal(0, "Unknown action: %s", act
);
422 parse_protocol(const char *name
, const struct protocol
**p_out
)
424 static const struct protocol protocols
[] = {
425 { "ip", ETH_TYPE_IP
, 0 },
426 { "arp", ETH_TYPE_ARP
, 0 },
427 { "icmp", ETH_TYPE_IP
, IPPROTO_ICMP
},
428 { "tcp", ETH_TYPE_IP
, IPPROTO_TCP
},
429 { "udp", ETH_TYPE_IP
, IPPROTO_UDP
},
430 { "ipv6", ETH_TYPE_IPV6
, 0 },
431 { "ip6", ETH_TYPE_IPV6
, 0 },
432 { "icmp6", ETH_TYPE_IPV6
, IPPROTO_ICMPV6
},
433 { "tcp6", ETH_TYPE_IPV6
, IPPROTO_TCP
},
434 { "udp6", ETH_TYPE_IPV6
, IPPROTO_UDP
},
436 const struct protocol
*p
;
438 for (p
= protocols
; p
< &protocols
[ARRAY_SIZE(protocols
)]; p
++) {
439 if (!strcmp(p
->name
, name
)) {
449 ofp_fatal(const char *flow
, bool verbose
, const char *format
, ...)
454 fprintf(stderr
, "%s:\n", flow
);
457 va_start(args
, format
);
458 ovs_fatal_valist(0, format
, args
);
462 parse_field(const struct mf_field
*mf
, const char *s
, struct cls_rule
*rule
)
464 union mf_value value
, mask
;
467 error
= mf_parse(mf
, s
, &value
, &mask
);
469 ovs_fatal(0, "%s", error
);
472 mf_set(mf
, &value
, &mask
, rule
);
475 /* Convert 'str_' (as described in the Flow Syntax section of the ovs-ofctl man
476 * page) into 'fm' for sending the specified flow_mod 'command' to a switch.
477 * If 'actions' is specified, an action must be in 'string' and may be expanded
480 * To parse syntax for an OFPT_FLOW_MOD (or NXT_FLOW_MOD), use an OFPFC_*
481 * constant for 'command'. To parse syntax for an OFPST_FLOW or
482 * OFPST_AGGREGATE (or NXST_FLOW or NXST_AGGREGATE), use -1 for 'command'. */
484 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_COOKIE
| F_TIMEOUT
| F_PRIORITY
;
512 case OFPFC_DELETE_STRICT
:
513 fields
= F_OUT_PORT
| F_PRIORITY
;
517 fields
= F_ACTIONS
| F_COOKIE
;
520 case OFPFC_MODIFY_STRICT
:
521 fields
= F_ACTIONS
| F_COOKIE
| F_PRIORITY
;
528 cls_rule_init_catchall(&fm
->cr
, OFP_DEFAULT_PRIORITY
);
529 fm
->cookie
= htonll(0);
531 fm
->command
= command
;
532 fm
->idle_timeout
= OFP_FLOW_PERMANENT
;
533 fm
->hard_timeout
= OFP_FLOW_PERMANENT
;
534 fm
->buffer_id
= UINT32_MAX
;
535 fm
->out_port
= OFPP_NONE
;
537 if (fields
& F_ACTIONS
) {
538 act_str
= strstr(string
, "action");
540 ofp_fatal(str_
, verbose
, "must specify an action");
544 act_str
= strchr(act_str
+ 1, '=');
546 ofp_fatal(str_
, verbose
, "must specify an action");
551 for (name
= strtok_r(string
, "=, \t\r\n", &save_ptr
); name
;
552 name
= strtok_r(NULL
, "=, \t\r\n", &save_ptr
)) {
553 const struct protocol
*p
;
555 if (parse_protocol(name
, &p
)) {
556 cls_rule_set_dl_type(&fm
->cr
, htons(p
->dl_type
));
558 cls_rule_set_nw_proto(&fm
->cr
, p
->nw_proto
);
563 value
= strtok_r(NULL
, ", \t\r\n", &save_ptr
);
565 ofp_fatal(str_
, verbose
, "field %s missing value", name
);
568 if (!strcmp(name
, "table")) {
569 fm
->table_id
= str_to_table_id(value
);
570 } else if (!strcmp(name
, "out_port")) {
571 fm
->out_port
= atoi(value
);
572 } else if (fields
& F_PRIORITY
&& !strcmp(name
, "priority")) {
573 fm
->cr
.priority
= str_to_u16(value
, name
);
574 } else if (fields
& F_TIMEOUT
&& !strcmp(name
, "idle_timeout")) {
575 fm
->idle_timeout
= str_to_u16(value
, name
);
576 } else if (fields
& F_TIMEOUT
&& !strcmp(name
, "hard_timeout")) {
577 fm
->hard_timeout
= str_to_u16(value
, name
);
578 } else if (fields
& F_COOKIE
&& !strcmp(name
, "cookie")) {
579 fm
->cookie
= htonll(str_to_u64(value
));
580 } else if (mf_from_name(name
)) {
581 parse_field(mf_from_name(name
), value
, &fm
->cr
);
582 } else if (!strcmp(name
, "duration")
583 || !strcmp(name
, "n_packets")
584 || !strcmp(name
, "n_bytes")) {
585 /* Ignore these, so that users can feed the output of
586 * "ovs-ofctl dump-flows" back into commands that parse
589 ofp_fatal(str_
, verbose
, "unknown keyword %s", name
);
593 if (fields
& F_ACTIONS
) {
594 struct ofpbuf actions
;
596 ofpbuf_init(&actions
, sizeof(union ofp_action
));
597 str_to_action(&fm
->cr
.flow
, act_str
, &actions
);
598 fm
->actions
= ofpbuf_steal_data(&actions
);
599 fm
->n_actions
= actions
.size
/ sizeof(union ofp_action
);
608 /* Parses 'string' as an OFPT_FLOW_MOD or NXT_FLOW_MOD with command 'command'
609 * (one of OFPFC_*) and appends the parsed OpenFlow message to 'packets'.
610 * '*cur_format' should initially contain the flow format currently configured
611 * on the connection; this function will add a message to change the flow
612 * format and update '*cur_format', if this is necessary to add the parsed
615 parse_ofp_flow_mod_str(struct list
*packets
, enum nx_flow_format
*cur_format
,
616 bool *flow_mod_table_id
, char *string
, uint16_t command
,
619 enum nx_flow_format min_format
, next_format
;
620 struct cls_rule rule_copy
;
622 struct ofputil_flow_mod fm
;
624 parse_ofp_str(&fm
, command
, string
, verbose
);
626 min_format
= ofputil_min_flow_format(&fm
.cr
);
627 next_format
= MAX(*cur_format
, min_format
);
628 if (next_format
!= *cur_format
) {
629 struct ofpbuf
*sff
= ofputil_make_set_flow_format(next_format
);
630 list_push_back(packets
, &sff
->list_node
);
631 *cur_format
= next_format
;
634 /* Normalize a copy of the rule. This ensures that non-normalized flows
635 * get logged but doesn't affect what gets sent to the switch, so that the
636 * switch can do whatever it likes with the flow. */
638 ofputil_normalize_rule(&rule_copy
, next_format
);
640 if (fm
.table_id
!= 0xff && !*flow_mod_table_id
) {
641 struct ofpbuf
*sff
= ofputil_make_flow_mod_table_id(true);
642 list_push_back(packets
, &sff
->list_node
);
643 *flow_mod_table_id
= true;
646 ofm
= ofputil_encode_flow_mod(&fm
, *cur_format
, *flow_mod_table_id
);
647 list_push_back(packets
, &ofm
->list_node
);
650 /* Similar to parse_ofp_flow_mod_str(), except that the string is read from
651 * 'stream' and the command is always OFPFC_ADD. Returns false if end-of-file
652 * is reached before reading a flow, otherwise true. */
654 parse_ofp_flow_mod_file(struct list
*packets
,
655 enum nx_flow_format
*cur
, bool *flow_mod_table_id
,
656 FILE *stream
, uint16_t command
)
662 ok
= ds_get_preprocessed_line(&s
, stream
) == 0;
664 parse_ofp_flow_mod_str(packets
, cur
, flow_mod_table_id
,
665 ds_cstr(&s
), command
, true);
673 parse_ofp_flow_stats_request_str(struct ofputil_flow_stats_request
*fsr
,
674 bool aggregate
, char *string
)
676 struct ofputil_flow_mod fm
;
678 parse_ofp_str(&fm
, -1, string
, false);
679 fsr
->aggregate
= aggregate
;
681 fsr
->out_port
= fm
.out_port
;
682 fsr
->table_id
= fm
.table_id
;