mir/ovs
2
0
Fork 0
mirror of https://github.com/openvswitch/ovs synced 2025-08-22 18:07:40 +00:00
Code Issues Releases Wiki Activity
ovs/utilities/ovs-ofctl.c
Vasu Dasari c3e64047d1 ofp-monitor: Support flow monitoring for OpenFlow 1.3, 1.4+. 
Extended OpenFlow monitoring support
* OpenFlow 1.3 with ONF extensions
* OpenFlow 1.4+ as defined in OpenFlow specification 1.4+.

ONF extensions are similar to Nicira extensions except for onf_flow_monitor_request{}
where out_port is defined as 32-bit number OF(1.1) number, oxm match formats are
used in update and request messages.

Flow monitoring support in 1.4+ is slightly different from Nicira and ONF
extensions.
 * More flow monitoring flags are defined.
 * Monitor add/modify/delete command is introduced in flow_monitor
   request message.
 * Addition of out_group as part of flow_monitor request message

Description of changes:
1. Generate ofp-msgs.inc to be able to support 1.3, 1.4+ flow Monitoring messages.
    include/openvswitch/ofp-msgs.h

2. Modify openflow header files with protocol specific headers.
    include/openflow/openflow-1.3.h
    include/openflow/openflow-1.4.h

3. Modify OvS abstraction of openflow headers. ofp-monitor.h leverages  enums
   from on nicira extensions for creating protocol abstraction headers. OF(1.4+)
   enums are superset of nicira extensions.
    include/openvswitch/ofp-monitor.h

4. Changes to these files reflect encoding and decoding of new protocol messages.
    lib/ofp-monitor.c

5. Changes to modules using ofp-monitor APIs. Most of the changes here are to
   migrate enums from nicira to OF 1.4+ versions.
    ofproto/connmgr.c
    ofproto/connmgr.h
    ofproto/ofproto-provider.h
    ofproto/ofproto.c

6. Extended protocol decoding tests to verify all protocol versions
        FLOW_MONITOR_CANCEL
        FLOW_MONITOR_PAUSED
        FLOW_MONITOR_RESUMED
        FLOW_MONITOR request
        FLOW_MONITOR reply
    tests/ofp-print.at

7. Modify flow monitoring tests to be able executed by all protocol versions.
    tests/ofproto.at

7. Modified documentation highlighting the change
    utilities/ovs-ofctl.8.in
    NEWS

Signed-off-by: Vasu Dasari <vdasari@gmail.com>
Reported-at: https://mail.openvswitch.org/pipermail/ovs-dev/2021-June/383915.html
Acked-by: Aaron Conole <aconole@redhat.com>
Signed-off-by: Ilya Maximets <i.maximets@ovn.org>
2022-04-28 21:27:11 +02:00

5130 lines
166 KiB
C
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/*
* Copyright (c) 2008-2017, 2019 Nicira, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <config.h>
#include <ctype.h>
#include <errno.h>
#include <getopt.h>
#include <inttypes.h>
#include <sys/socket.h>
#include <net/if.h>
#include <signal.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/time.h>
#include "byte-order.h"
#include "classifier.h"
#include "command-line.h"
#include "daemon.h"
#include "colors.h"
#include "compiler.h"
#include "dirs.h"
#include "dp-packet.h"
#include "fatal-signal.h"
#include "nx-match.h"
#include "odp-util.h"
#include "ofp-version-opt.h"
#include "ofproto/ofproto.h"
#include "openflow/nicira-ext.h"
#include "openflow/openflow.h"
#include "openvswitch/dynamic-string.h"
#include "openvswitch/meta-flow.h"
#include "openvswitch/ofp-actions.h"
#include "openvswitch/ofp-bundle.h"
#include "openvswitch/ofp-errors.h"
#include "openvswitch/ofp-group.h"
#include "openvswitch/ofp-match.h"
#include "openvswitch/ofp-meter.h"
#include "openvswitch/ofp-msgs.h"
#include "openvswitch/ofp-monitor.h"
#include "openvswitch/ofp-port.h"
#include "openvswitch/ofp-print.h"
#include "openvswitch/ofp-util.h"
#include "openvswitch/ofp-parse.h"
#include "openvswitch/ofp-queue.h"
#include "openvswitch/ofp-switch.h"
#include "openvswitch/ofp-table.h"
#include "openvswitch/ofpbuf.h"
#include "openvswitch/shash.h"
#include "openvswitch/vconn.h"
#include "openvswitch/vlog.h"
#include "packets.h"
#include "pcap-file.h"
#include "openvswitch/poll-loop.h"
#include "random.h"
#include "sort.h"
#include "stream-ssl.h"
#include "socket-util.h"
#include "timeval.h"
#include "unixctl.h"
#include "util.h"
VLOG_DEFINE_THIS_MODULE(ofctl);
/* --bundle: Use OpenFlow 1.3+ bundle for making the flow table change atomic.
* NOTE: If OpenFlow 1.3 or higher is not selected with the '-O' option,
* OpenFlow 1.4 will be implicitly selected. Also the flow mod will use
* OpenFlow 1.4, so the semantics may be different (see the comment in
* parse_options() for details).
*/
static bool bundle = false;
/* --color: Use color markers. */
static bool enable_color;
/* --read-only: Do not execute read only commands. */
static bool read_only;
/* --strict: Use strict matching for flow mod commands? Additionally governs
* use of nx_pull_match() instead of nx_pull_match_loose() in parse-nx-match.
*/
static bool strict;
/* --may-create: If true, the mod-group command creates a group that does not
* yet exist; otherwise, such a command has no effect. */
static bool may_create;
/* --readd: If true, on replace-flows, re-add even flows that have not changed
* (to reset flow counters). */
static bool readd;
/* -F, --flow-format: Allowed protocols. By default, any protocol is
* allowed. */
static enum ofputil_protocol allowed_protocols = OFPUTIL_P_ANY;
/* -P, --packet-in-format: Packet IN format to use in monitor and snoop
* commands. Either one of NXPIF_* to force a particular packet_in format, or
* -1 to let ovs-ofctl choose the default. */
static int preferred_packet_in_format = -1;
/* -m, --more: Additional verbosity for ofp-print functions. */
static int verbosity;
/* --timestamp: Print a timestamp before each received packet on "monitor" and
* "snoop" command? */
static bool timestamp;
/* --unixctl-path: Path to use for unixctl server, for "monitor" and "snoop"
commands. */
static char *unixctl_path;
/* --sort, --rsort: Sort order. */
enum sort_order { SORT_ASC, SORT_DESC };
struct sort_criterion {
const struct mf_field *field; /* NULL means to sort by priority. */
enum sort_order order;
};
static struct sort_criterion *criteria;
static size_t n_criteria, allocated_criteria;
/* --names, --no-names: Show port and table names in output and accept them in
* input. (When neither is specified, the default is to accept port names but,
* for backward compatibility, not to show them unless this is an interactive
* console session.) */
static int use_names = -1;
static const struct ofputil_port_map *ports_to_accept(const char *vconn_name);
static const struct ofputil_port_map *ports_to_show(const char *vconn_name);
static const struct ofputil_table_map *tables_to_accept(
const char *vconn_name);
static const struct ofputil_table_map *tables_to_show(const char *vconn_name);
static bool should_accept_names(void);
static bool should_show_names(void);
/* --stats, --no-stats: Show statistics in flow dumps? */
static int show_stats = 1;
/* --pcap: Makes "compose-packet" print a pcap on stdout. */
static int print_pcap = 0;
/* --raw: Makes "ofp-print" read binary data from stdin. */
static int raw = 0;
static const struct ovs_cmdl_command *get_all_commands(void);
OVS_NO_RETURN static void usage(void);
static void parse_options(int argc, char *argv[]);
int
main(int argc, char *argv[])
{
struct ovs_cmdl_context ctx = { .argc = 0, };
set_program_name(argv[0]);
service_start(&argc, &argv);
parse_options(argc, argv);
fatal_ignore_sigpipe();
ctx.argc = argc - optind;
ctx.argv = argv + optind;
daemon_become_new_user(false);
if (read_only) {
ovs_cmdl_run_command_read_only(&ctx, get_all_commands());
} else {
ovs_cmdl_run_command(&ctx, get_all_commands());
}
return 0;
}
static void
add_sort_criterion(enum sort_order order, const char *field)
{
struct sort_criterion *sc;
if (n_criteria >= allocated_criteria) {
criteria = x2nrealloc(criteria, &allocated_criteria, sizeof *criteria);
}
sc = &criteria[n_criteria++];
if (!field || !strcasecmp(field, "priority")) {
sc->field = NULL;
} else {
sc->field = mf_from_name(field);
if (!sc->field) {
ovs_fatal(0, "%s: unknown field name", field);
}
}
sc->order = order;
}
static void
parse_options(int argc, char *argv[])
{
enum {
OPT_STRICT = UCHAR_MAX + 1,
OPT_READD,
OPT_TIMESTAMP,
OPT_SORT,
OPT_RSORT,
OPT_UNIXCTL,
OPT_BUNDLE,
OPT_COLOR,
OPT_MAY_CREATE,
OPT_READ_ONLY,
DAEMON_OPTION_ENUMS,
OFP_VERSION_OPTION_ENUMS,
VLOG_OPTION_ENUMS,
SSL_OPTION_ENUMS,
};
static const struct option long_options[] = {
{"timeout", required_argument, NULL, 't'},
{"strict", no_argument, NULL, OPT_STRICT},
{"readd", no_argument, NULL, OPT_READD},
{"flow-format", required_argument, NULL, 'F'},
{"packet-in-format", required_argument, NULL, 'P'},
{"more", no_argument, NULL, 'm'},
{"timestamp", no_argument, NULL, OPT_TIMESTAMP},
{"sort", optional_argument, NULL, OPT_SORT},
{"rsort", optional_argument, NULL, OPT_RSORT},
{"names", no_argument, &use_names, 1},
{"no-names", no_argument, &use_names, 0},
{"stats", no_argument, &show_stats, 1},
{"no-stats", no_argument, &show_stats, 0},
{"unixctl", required_argument, NULL, OPT_UNIXCTL},
{"help", no_argument, NULL, 'h'},
{"option", no_argument, NULL, 'o'},
{"bundle", no_argument, NULL, OPT_BUNDLE},
{"color", optional_argument, NULL, OPT_COLOR},
{"may-create", no_argument, NULL, OPT_MAY_CREATE},
{"pcap", no_argument, &print_pcap, 1},
{"raw", no_argument, &raw, 1},
{"read-only", no_argument, NULL, OPT_READ_ONLY},
DAEMON_LONG_OPTIONS,
OFP_VERSION_LONG_OPTIONS,
VLOG_LONG_OPTIONS,
STREAM_SSL_LONG_OPTIONS,
{NULL, 0, NULL, 0},
};
char *short_options = ovs_cmdl_long_options_to_short_options(long_options);
uint32_t versions;
enum ofputil_protocol version_protocols;
unsigned int timeout = 0;
/* For now, ovs-ofctl only enables OpenFlow 1.0 by default. This is
* because ovs-ofctl implements command such as "add-flow" as raw OpenFlow
* requests, but those requests have subtly different semantics in
* different OpenFlow versions. For example:
*
* - In OpenFlow 1.0, a "mod-flow" operation that does not find any
* existing flow to modify adds a new flow.
*
* - In OpenFlow 1.1, a "mod-flow" operation that does not find any
* existing flow to modify adds a new flow, but only if the mod-flow
* did not match on the flow cookie.
*
* - In OpenFlow 1.2 and a later, a "mod-flow" operation never adds a
* new flow.
*/
set_allowed_ofp_versions("OpenFlow10");
for (;;) {
int c;
c = getopt_long(argc, argv, short_options, long_options, NULL);
if (c == -1) {
break;
}
switch (c) {
case 't':
if (!str_to_uint(optarg, 10, &timeout) || !timeout) {
ovs_fatal(0, "value %s on -t or --timeout is invalid", optarg);
}
break;
case 'F':
allowed_protocols = ofputil_protocols_from_string(optarg);
if (!allowed_protocols) {
ovs_fatal(0, "%s: invalid flow format(s)", optarg);
}
break;
case 'P':
preferred_packet_in_format =
ofputil_packet_in_format_from_string(optarg);
if (preferred_packet_in_format < 0) {
ovs_fatal(0, "unknown packet-in format `%s'", optarg);
}
break;
case 'm':
verbosity++;
break;
case 'h':
usage();
case 'o':
ovs_cmdl_print_options(long_options);
exit(EXIT_SUCCESS);
case OPT_BUNDLE:
bundle = true;
break;
case OPT_STRICT:
strict = true;
break;
case OPT_READ_ONLY:
read_only = true;
break;
case OPT_READD:
readd = true;
break;
case OPT_TIMESTAMP:
timestamp = true;
break;
case OPT_SORT:
add_sort_criterion(SORT_ASC, optarg);
break;
case OPT_RSORT:
add_sort_criterion(SORT_DESC, optarg);
break;
case OPT_UNIXCTL:
unixctl_path = optarg;
break;
case OPT_COLOR:
if (optarg) {
if (!strcasecmp(optarg, "always")
|| !strcasecmp(optarg, "yes")
|| !strcasecmp(optarg, "force")) {
enable_color = true;
} else if (!strcasecmp(optarg, "never")
|| !strcasecmp(optarg, "no")
|| !strcasecmp(optarg, "none")) {
enable_color = false;
} else if (!strcasecmp(optarg, "auto")
|| !strcasecmp(optarg, "tty")
|| !strcasecmp(optarg, "if-tty")) {
/* Determine whether we need colors, i.e. whether standard
* output is a tty. */
enable_color = is_stdout_a_tty();
} else {
ovs_fatal(0, "incorrect value `%s' for --color", optarg);
}
} else {
enable_color = is_stdout_a_tty();
}
break;
case OPT_MAY_CREATE:
may_create = true;
break;
DAEMON_OPTION_HANDLERS
OFP_VERSION_OPTION_HANDLERS
VLOG_OPTION_HANDLERS
STREAM_SSL_OPTION_HANDLERS
case '?':
exit(EXIT_FAILURE);
case 0:
break;
default:
abort();
}
}
ctl_timeout_setup(timeout);
if (n_criteria) {
/* Always do a final sort pass based on priority. */
add_sort_criterion(SORT_DESC, "priority");
}
free(short_options);
/* Implicit OpenFlow 1.4 with the '--bundle' option. */
if (bundle && !(get_allowed_ofp_versions() &
ofputil_protocols_to_version_bitmap(OFPUTIL_P_OF13_UP))) {
/* Add implicit allowance for OpenFlow 1.4. */
add_allowed_ofp_versions(ofputil_protocols_to_version_bitmap(
OFPUTIL_P_OF14_OXM));
/* Remove all versions that do not support bundles. */
mask_allowed_ofp_versions(ofputil_protocols_to_version_bitmap(
OFPUTIL_P_OF13_UP));
}
versions = get_allowed_ofp_versions();
version_protocols = ofputil_protocols_from_version_bitmap(versions);
if (!(allowed_protocols & version_protocols)) {
char *protocols = ofputil_protocols_to_string(allowed_protocols);
struct ds version_s = DS_EMPTY_INITIALIZER;
ofputil_format_version_bitmap_names(&version_s, versions);
ovs_fatal(0, "None of the enabled OpenFlow versions (%s) supports "
"any of the enabled flow formats (%s). (Use -O to enable "
"additional OpenFlow versions or -F to enable additional "
"flow formats.)", ds_cstr(&version_s), protocols);
}
allowed_protocols &= version_protocols;
mask_allowed_ofp_versions(ofputil_protocols_to_version_bitmap(
allowed_protocols));
colors_init(enable_color);
}
static void
usage(void)
{
printf("%s: OpenFlow switch management utility\n"
"usage: %s [OPTIONS] COMMAND [ARG...]\n"
"\nFor OpenFlow switches:\n"
" show SWITCH show OpenFlow information\n"
" dump-desc SWITCH print switch description\n"
" dump-tables SWITCH print table stats\n"
" dump-table-features SWITCH print table features\n"
" dump-table-desc SWITCH print table description (OF1.4+)\n"
" mod-port SWITCH IFACE ACT modify port behavior\n"
" mod-table SWITCH MOD modify flow table behavior\n"
" OF1.1/1.2 MOD: controller, continue, drop\n"
" OF1.4+ MOD: evict, noevict, vacancy:low,high, novacancy\n"
" get-frags SWITCH print fragment handling behavior\n"
" set-frags SWITCH FRAG_MODE set fragment handling behavior\n"
" FRAG_MODE: normal, drop, reassemble, nx-match\n"
" dump-ports SWITCH [PORT] print port statistics\n"
" dump-ports-desc SWITCH [PORT] print port descriptions\n"
" dump-flows SWITCH print all flow entries\n"
" dump-flows SWITCH FLOW print matching FLOWs\n"
" dump-aggregate SWITCH print aggregate flow statistics\n"
" dump-aggregate SWITCH FLOW print aggregate stats for FLOWs\n"
" queue-stats SWITCH [PORT [QUEUE]] dump queue stats\n"
" add-flow SWITCH FLOW add flow described by FLOW\n"
" add-flows SWITCH FILE add flows from FILE\n"
" mod-flows SWITCH FLOW modify actions of matching FLOWs\n"
" del-flows SWITCH [FLOW] delete matching FLOWs\n"
" replace-flows SWITCH FILE replace flows with those in FILE\n"
" diff-flows SOURCE1 SOURCE2 compare flows from two sources\n"
" packet-out SWITCH IN_PORT ACTIONS PACKET...\n"
" execute ACTIONS on PACKET\n"
" monitor SWITCH [MISSLEN] [invalid_ttl] [watch:[...]]\n"
" print packets received from SWITCH\n"
" snoop SWITCH snoop on SWITCH and its controller\n"
" add-group SWITCH GROUP add group described by GROUP\n"
" add-groups SWITCH FILE add group from FILE\n"
" [--may-create] mod-group SWITCH GROUP modify specific group\n"
" del-groups SWITCH [GROUP] delete matching GROUPs\n"
" insert-buckets SWITCH [GROUP] add buckets to GROUP\n"
" remove-buckets SWITCH [GROUP] remove buckets from GROUP\n"
" dump-group-features SWITCH print group features\n"
" dump-groups SWITCH [GROUP] print group description\n"
" dump-group-stats SWITCH [GROUP] print group statistics\n"
" queue-get-config SWITCH [PORT] print queue config for PORT\n"
" add-meter SWITCH METER add meter described by METER\n"
" mod-meter SWITCH METER modify specific METER\n"
" del-meters SWITCH [METER] delete meters matching METER\n"
" dump-meters SWITCH [METER] print METER configuration\n"
" meter-stats SWITCH [METER] print meter statistics\n"
" meter-features SWITCH print meter features\n"
" add-tlv-map SWITCH MAP add TLV option MAPpings\n"
" del-tlv-map SWITCH [MAP] delete TLV option MAPpings\n"
" dump-tlv-map SWITCH print TLV option mappings\n"
" dump-ipfix-bridge SWITCH print ipfix stats of bridge\n"
" dump-ipfix-flow SWITCH print flow ipfix of a bridge\n"
" ct-flush-zone SWITCH ZONE flush conntrack entries in ZONE\n"
"\nFor OpenFlow switches and controllers:\n"
" probe TARGET probe whether TARGET is up\n"
" ping TARGET [N] latency of N-byte echos\n"
" benchmark TARGET N COUNT bandwidth of COUNT N-byte echos\n"
"SWITCH or TARGET is an active OpenFlow connection method.\n"
"\nOther commands:\n"
" ofp-parse FILE print messages read from FILE\n"
" ofp-parse-pcap PCAP print OpenFlow read from PCAP\n",
program_name, program_name);
vconn_usage(true, false, false);
daemon_usage();
ofp_version_usage();
vlog_usage();
printf("\nOther options:\n"
" --strict use strict match for flow commands\n"
" --read-only do not execute read/write commands\n"
" --readd replace flows that haven't changed\n"
" -F, --flow-format=FORMAT force particular flow format\n"
" -P, --packet-in-format=FRMT force particular packet in format\n"
" -m, --more be more verbose printing OpenFlow\n"
" --timestamp (monitor, snoop) print timestamps\n"
" -t, --timeout=SECS give up after SECS seconds\n"
" --sort[=field] sort in ascending order\n"
" --rsort[=field] sort in descending order\n"
" --names show port names instead of numbers\n"
" --no-names show port numbers, but not names\n"
" --unixctl=SOCKET set control socket name\n"
" --color[=always|never|auto] control use of color in output\n"
" -h, --help display this help message\n"
" -V, --version display version information\n");
exit(EXIT_SUCCESS);
}
static void
ofctl_exit(struct unixctl_conn *conn, int argc OVS_UNUSED,
const char *argv[] OVS_UNUSED, void *exiting_)
{
bool *exiting = exiting_;
*exiting = true;
unixctl_command_reply(conn, NULL);
}
static void run(int retval, const char *message, ...)
OVS_PRINTF_FORMAT(2, 3);
static void
run(int retval, const char *message, ...)
{
if (retval) {
va_list args;
va_start(args, message);
ovs_fatal_valist(retval, message, args);
}
}
/* Generic commands. */
static int
open_vconn_socket(const char *name, struct vconn **vconnp)
{
char *vconn_name = xasprintf("unix:%s", name);
int error;
error = vconn_open(vconn_name, get_allowed_ofp_versions(), DSCP_DEFAULT,
vconnp);
if (error && error != ENOENT) {
ovs_fatal(0, "%s: failed to open socket (%s)", name,
ovs_strerror(error));
}
free(vconn_name);
return error;
}
enum open_target { MGMT, SNOOP };
static enum ofputil_protocol
open_vconn__(const char *name, enum open_target target,
struct vconn **vconnp)
{
const char *suffix = target == MGMT ? "mgmt" : "snoop";
char *datapath_name, *datapath_type, *socket_name;
enum ofputil_protocol protocol;
char *bridge_path;
int ofp_version;
int error;
bridge_path = xasprintf("%s/%s.%s", ovs_rundir(), name, suffix);
ofproto_parse_name(name, &datapath_name, &datapath_type);
socket_name = xasprintf("%s/%s.%s", ovs_rundir(), datapath_name, suffix);
free(datapath_name);
free(datapath_type);
if (strchr(name, ':')) {
run(vconn_open(name, get_allowed_ofp_versions(), DSCP_DEFAULT, vconnp),
"connecting to %s", name);
} else if (!open_vconn_socket(name, vconnp)) {
/* Fall Through. */
} else if (!open_vconn_socket(bridge_path, vconnp)) {
/* Fall Through. */
} else if (!open_vconn_socket(socket_name, vconnp)) {
/* Fall Through. */
} else {
free(bridge_path);
free(socket_name);
ovs_fatal(0, "%s is not a bridge or a socket", name);
}
if (target == SNOOP) {
vconn_set_recv_any_version(*vconnp);
}
free(bridge_path);
free(socket_name);
VLOG_DBG("connecting to %s", vconn_get_name(*vconnp));
error = vconn_connect_block(*vconnp, -1);
if (error) {
ovs_fatal(0, "%s: failed to connect to socket (%s)", name,
ovs_strerror(error));
}
ofp_version = vconn_get_version(*vconnp);
protocol = ofputil_protocol_from_ofp_version(ofp_version);
if (!protocol) {
ovs_fatal(0, "%s: unsupported OpenFlow version 0x%02x",
name, ofp_version);
}
return protocol;
}
static enum ofputil_protocol
open_vconn(const char *name, struct vconn **vconnp)
{
return open_vconn__(name, MGMT, vconnp);
}
static void
send_openflow_buffer(struct vconn *vconn, struct ofpbuf *buffer)
{
run(vconn_send_block(vconn, buffer), "failed to send packet to switch");
}
static void
dump_transaction(struct vconn *vconn, struct ofpbuf *request)
{
const struct ofp_header *oh = request->data;
if (ofpmsg_is_stat_request(oh)) {
ovs_be32 send_xid = oh->xid;
enum ofpraw request_raw;
enum ofpraw reply_raw;
bool done = false;
ofpraw_decode_partial(&request_raw, request->data, request->size);
reply_raw = ofpraw_stats_request_to_reply(request_raw, oh->version);
send_openflow_buffer(vconn, request);
while (!done) {
ovs_be32 recv_xid;
struct ofpbuf *reply;
run(vconn_recv_block(vconn, &reply),
"OpenFlow packet receive failed");
recv_xid = ((struct ofp_header *) reply->data)->xid;
if (send_xid == recv_xid) {
enum ofpraw ofpraw;
ofp_print(stdout, reply->data, reply->size,
ports_to_show(vconn_get_name(vconn)),
tables_to_show(vconn_get_name(vconn)),
verbosity + 1);
ofpraw_decode(&ofpraw, reply->data);
if (ofptype_from_ofpraw(ofpraw) == OFPTYPE_ERROR) {
done = true;
} else if (ofpraw == reply_raw) {
done = !ofpmp_more(reply->data);
} else {
ovs_fatal(0, "received bad reply: %s",
ofp_to_string(
reply->data, reply->size,
ports_to_show(vconn_get_name(vconn)),
tables_to_show(vconn_get_name(vconn)),
verbosity + 1));
}
} else {
VLOG_DBG("received reply with xid %08"PRIx32" "
"!= expected %08"PRIx32, recv_xid, send_xid);
}
ofpbuf_delete(reply);
}
} else {
struct ofpbuf *reply;
run(vconn_transact(vconn, request, &reply), "talking to %s",
vconn_get_name(vconn));
ofp_print(stdout, reply->data, reply->size,
ports_to_show(vconn_get_name(vconn)),
tables_to_show(vconn_get_name(vconn)),
verbosity + 1);
ofpbuf_delete(reply);
}
}
static void
dump_trivial_transaction(const char *vconn_name, enum ofpraw ofpraw)
{
struct ofpbuf *request;
struct vconn *vconn;
open_vconn(vconn_name, &vconn);
request = ofpraw_alloc(ofpraw, vconn_get_version(vconn), 0);
dump_transaction(vconn, request);
vconn_close(vconn);
}
/* Sends all of the 'requests', which should be requests that only have replies
* if an error occurs, and waits for them to succeed or fail. If an error does
* occur, prints it and exits with an error.
*
* Destroys all of the 'requests'. */
static void
transact_multiple_noreply(struct vconn *vconn, struct ovs_list *requests)
{
struct ofpbuf *reply;
run(vconn_transact_multiple_noreply(vconn, requests, &reply),
"talking to %s", vconn_get_name(vconn));
if (reply) {
ofp_print(stderr, reply->data, reply->size,
ports_to_show(vconn_get_name(vconn)),
tables_to_show(vconn_get_name(vconn)),
verbosity + 2);
exit(1);
}
ofpbuf_delete(reply);
}
/* Frees the error messages as they are printed. */
static void
bundle_print_errors(struct ovs_list *errors, struct ovs_list *requests,
const char *vconn_name)
{
struct ofpbuf *error;
struct ofpbuf *bmsg;
INIT_CONTAINER(bmsg, requests, list_node);
LIST_FOR_EACH_SAFE (error, list_node, errors) {
const struct ofp_header *error_oh = error->data;
ovs_be32 error_xid = error_oh->xid;
enum ofperr ofperr;
struct ofpbuf payload;
ofperr = ofperr_decode_msg(error_oh, &payload);
if (!ofperr) {
fprintf(stderr, "***decode error***");
} else {
/* Default to the likely truncated message. */
const struct ofp_header *ofp_msg = payload.data;
size_t msg_len = payload.size;
/* Find the failing message from the requests list to be able to
* dump the whole message. We assume the errors are returned in
* the same order as in which the messages are sent to get O(n)
* rather than O(n^2) processing here. If this heuristics fails we
* may print the truncated hexdumps instead. */
LIST_FOR_EACH_CONTINUE (bmsg, list_node, requests) {
const struct ofp_header *oh = bmsg->data;
if (oh->xid == error_xid) {
ofp_msg = oh;
msg_len = bmsg->size;
break;
}
}
fprintf(stderr, "Error %s for: ", ofperr_get_name(ofperr));
ofp_print(stderr, ofp_msg, msg_len, ports_to_show(vconn_name),
tables_to_show(vconn_name), verbosity + 1);
}
ofpbuf_uninit(&payload);
ofpbuf_delete(error);
}
fflush(stderr);
}
static void
bundle_transact(struct vconn *vconn, struct ovs_list *requests, uint16_t flags)
{
struct ovs_list errors;
int retval = vconn_bundle_transact(vconn, requests, flags, &errors);
bundle_print_errors(&errors, requests, vconn_get_name(vconn));
if (retval) {
ovs_fatal(retval, "talking to %s", vconn_get_name(vconn));
}
}
/* Sends 'request', which should be a request that only has a reply if an error
* occurs, and waits for it to succeed or fail. If an error does occur, prints
* it and exits with an error.
*
* Destroys 'request'. */
static void
transact_noreply(struct vconn *vconn, struct ofpbuf *request)
{
struct ovs_list requests;
ovs_list_init(&requests);
ovs_list_push_back(&requests, &request->list_node);
transact_multiple_noreply(vconn, &requests);
}
static void
fetch_switch_config(struct vconn *vconn, struct ofputil_switch_config *config)
{
struct ofpbuf *request;
struct ofpbuf *reply;
enum ofptype type;
request = ofpraw_alloc(OFPRAW_OFPT_GET_CONFIG_REQUEST,
vconn_get_version(vconn), 0);
run(vconn_transact(vconn, request, &reply),
"talking to %s", vconn_get_name(vconn));
if (ofptype_decode(&type, reply->data)
|| type != OFPTYPE_GET_CONFIG_REPLY) {
ovs_fatal(0, "%s: bad reply to config request", vconn_get_name(vconn));
}
ofputil_decode_get_config_reply(reply->data, config);
ofpbuf_delete(reply);
}
static void
set_switch_config(struct vconn *vconn,
const struct ofputil_switch_config *config)
{
enum ofp_version version = vconn_get_version(vconn);
transact_noreply(vconn, ofputil_encode_set_config(config, version));
}
static void
ofctl_show(struct ovs_cmdl_context *ctx)
{
const char *vconn_name = ctx->argv[1];
enum ofp_version version;
struct vconn *vconn;
struct ofpbuf *request;
struct ofpbuf *reply;
bool has_ports;
open_vconn(vconn_name, &vconn);
version = vconn_get_version(vconn);
request = ofpraw_alloc(OFPRAW_OFPT_FEATURES_REQUEST, version, 0);
run(vconn_transact(vconn, request, &reply), "talking to %s", vconn_name);
has_ports = ofputil_switch_features_has_ports(reply);
ofp_print(stdout, reply->data, reply->size, NULL, NULL, verbosity + 1);
ofpbuf_delete(reply);
if (!has_ports) {
request = ofputil_encode_port_desc_stats_request(version, OFPP_ANY);
dump_transaction(vconn, request);
}
dump_trivial_transaction(vconn_name, OFPRAW_OFPT_GET_CONFIG_REQUEST);
vconn_close(vconn);
}
static void
ofctl_dump_desc(struct ovs_cmdl_context *ctx)
{
dump_trivial_transaction(ctx->argv[1], OFPRAW_OFPST_DESC_REQUEST);
}
static void
ofctl_dump_tables(struct ovs_cmdl_context *ctx)
{
dump_trivial_transaction(ctx->argv[1], OFPRAW_OFPST_TABLE_REQUEST);
}
static void
ofctl_dump_table_features(struct ovs_cmdl_context *ctx)
{
struct ofpbuf *request;
struct vconn *vconn;
open_vconn(ctx->argv[1], &vconn);
request = ofputil_encode_table_features_request(vconn_get_version(vconn));
/* The following is similar to dump_trivial_transaction(), but it
* maintains the previous 'ofputil_table_features' from one stats reply
* message to the next, which allows duplication to be eliminated in the
* output across messages. Otherwise the output is much larger and harder
* to read, because only 17 or so ofputil_table_features elements fit in a
* single 64 kB OpenFlow message and therefore you get a ton of repetition
* (every 17th element is printed in full instead of abbreviated). */
const struct ofp_header *request_oh = request->data;
ovs_be32 send_xid = request_oh->xid;
bool done = false;
struct ofputil_table_features prev;
int first_ditto = -1, last_ditto = -1;
struct ds s = DS_EMPTY_INITIALIZER;
int n = 0;
send_openflow_buffer(vconn, request);
while (!done) {
ovs_be32 recv_xid;
struct ofpbuf *reply;
run(vconn_recv_block(vconn, &reply), "OpenFlow packet receive failed");
recv_xid = ((struct ofp_header *) reply->data)->xid;
if (send_xid == recv_xid) {
enum ofptype type;
enum ofperr error;
error = ofptype_decode(&type, reply->data);
if (error) {
ovs_fatal(0, "decode error: %s", ofperr_get_name(error));
} else if (type == OFPTYPE_ERROR) {
ofp_print(stdout, reply->data, reply->size, NULL, NULL,
verbosity + 1);
done = true;
} else if (type == OFPTYPE_TABLE_FEATURES_STATS_REPLY) {
done = !ofpmp_more(reply->data);
for (;;) {
struct ofputil_table_features tf;
struct ofpbuf raw_properties;
int retval = ofputil_decode_table_features(
reply, &tf, &raw_properties);
if (retval) {
if (retval != EOF) {
ovs_fatal(0, "decode error: %s",
ofperr_get_name(retval));
}
break;
}
ofputil_table_features_format(
&s, &tf, n ? &prev : NULL, NULL, NULL,
&first_ditto, &last_ditto);
prev = tf;
n++;
}
} else {
ovs_fatal(0, "received bad reply: %s",
ofp_to_string(reply->data, reply->size,
ports_to_show(ctx->argv[1]),
tables_to_show(ctx->argv[1]),
verbosity + 1));
}
} else {
VLOG_DBG("received reply with xid %08"PRIx32" "
"!= expected %08"PRIx32, recv_xid, send_xid);
}
ofpbuf_delete(reply);
}
ofputil_table_features_format_finish(&s, first_ditto, last_ditto);
const char *p = ds_cstr(&s);
puts(p + (*p == '\n'));
ds_destroy(&s);
vconn_close(vconn);
}
static void
ofctl_dump_table_desc(struct ovs_cmdl_context *ctx)
{
struct ofpbuf *request;
struct vconn *vconn;
open_vconn(ctx->argv[1], &vconn);
request = ofputil_encode_table_desc_request(vconn_get_version(vconn));
if (request) {
dump_transaction(vconn, request);
}
vconn_close(vconn);
}
static bool
str_to_ofp(const char *s, ofp_port_t *ofp_port)
{
bool ret;
uint32_t port_;
ret = str_to_uint(s, 10, &port_);
*ofp_port = u16_to_ofp(port_);
return ret;
}
struct port_iterator {
struct vconn *vconn;
enum { PI_FEATURES, PI_PORT_DESC } variant;
struct ofpbuf *reply;
ovs_be32 send_xid;
bool more;
};
static void
port_iterator_fetch_port_desc(struct port_iterator *pi)
{
pi->variant = PI_PORT_DESC;
pi->more = true;
struct ofpbuf *rq = ofputil_encode_port_desc_stats_request(
vconn_get_version(pi->vconn), OFPP_ANY);
pi->send_xid = ((struct ofp_header *) rq->data)->xid;
send_openflow_buffer(pi->vconn, rq);
}
static void
port_iterator_fetch_features(struct port_iterator *pi)
{
pi->variant = PI_FEATURES;
/* Fetch the switch's ofp_switch_features. */
enum ofp_version version = vconn_get_version(pi->vconn);
struct ofpbuf *rq = ofpraw_alloc(OFPRAW_OFPT_FEATURES_REQUEST, version, 0);
run(vconn_transact(pi->vconn, rq, &pi->reply),
"talking to %s", vconn_get_name(pi->vconn));
enum ofptype type;
if (ofptype_decode(&type, pi->reply->data)
|| type != OFPTYPE_FEATURES_REPLY) {
ovs_fatal(0, "%s: received bad features reply",
vconn_get_name(pi->vconn));
}
if (!ofputil_switch_features_has_ports(pi->reply)) {
/* The switch features reply does not contain a complete list of ports.
* Probably, there are more ports than will fit into a single 64 kB
* OpenFlow message. Use OFPST_PORT_DESC to get a complete list of
* ports. */
ofpbuf_delete(pi->reply);
pi->reply = NULL;
port_iterator_fetch_port_desc(pi);
return;
}
struct ofputil_switch_features features;
enum ofperr error = ofputil_pull_switch_features(pi->reply, &features);
if (error) {
ovs_fatal(0, "%s: failed to decode features reply (%s)",
vconn_get_name(pi->vconn), ofperr_to_string(error));
}
}
/* Initializes 'pi' to prepare for iterating through all of the ports on the
* OpenFlow switch to which 'vconn' is connected.
*
* During iteration, the client should not make other use of 'vconn', because
* that can cause other messages to be interleaved with the replies used by the
* iterator and thus some ports may be missed or a hang can occur. */
static void
port_iterator_init(struct port_iterator *pi, struct vconn *vconn)
{
memset(pi, 0, sizeof *pi);
pi->vconn = vconn;
if (vconn_get_version(vconn) < OFP13_VERSION) {
port_iterator_fetch_features(pi);
} else {
port_iterator_fetch_port_desc(pi);
}
}
/* Obtains the next port from 'pi'. On success, initializes '*pp' with the
* port's details and returns true, otherwise (if all the ports have already
* been seen), returns false. */
static bool
port_iterator_next(struct port_iterator *pi, struct ofputil_phy_port *pp)
{
for (;;) {
if (pi->reply) {
int retval = ofputil_pull_phy_port(vconn_get_version(pi->vconn),
pi->reply, pp);
if (!retval) {
return true;
} else if (retval != EOF) {
ovs_fatal(0, "received bad reply: %s",
ofp_to_string(pi->reply->data, pi->reply->size,
NULL, NULL, verbosity + 1));
}
}
if (pi->variant == PI_FEATURES || !pi->more) {
return false;
}
ovs_be32 recv_xid;
do {
ofpbuf_delete(pi->reply);
run(vconn_recv_block(pi->vconn, &pi->reply),
"OpenFlow receive failed");
recv_xid = ((struct ofp_header *) pi->reply->data)->xid;
} while (pi->send_xid != recv_xid);
struct ofp_header *oh = pi->reply->data;
enum ofptype type;
if (ofptype_pull(&type, pi->reply)
|| type != OFPTYPE_PORT_DESC_STATS_REPLY) {
ovs_fatal(0, "received bad reply: %s",
ofp_to_string(pi->reply->data, pi->reply->size, NULL,
NULL, verbosity + 1));
}
pi->more = (ofpmp_flags(oh) & OFPSF_REPLY_MORE) != 0;
}
}
/* Destroys iterator 'pi'. */
static void
port_iterator_destroy(struct port_iterator *pi)
{
if (pi) {
while (pi->variant == PI_PORT_DESC && pi->more) {
/* Drain vconn's queue of any other replies for this request. */
struct ofputil_phy_port pp;
port_iterator_next(pi, &pp);
}
ofpbuf_delete(pi->reply);
}
}
/* Opens a connection to 'vconn_name', fetches the port structure for
* 'port_name' (which may be a port name or number), and copies it into
* '*pp'. */
static void
fetch_ofputil_phy_port(const char *vconn_name, const char *port_name,
struct ofputil_phy_port *pp)
{
struct vconn *vconn;
ofp_port_t port_no;
bool found = false;
/* Try to interpret the argument as a port number. */
if (!str_to_ofp(port_name, &port_no)) {
port_no = OFPP_NONE;
}
/* OpenFlow 1.0, 1.1, and 1.2 put the list of ports in the
* OFPT_FEATURES_REPLY message. OpenFlow 1.3 and later versions put it
* into the OFPST_PORT_DESC reply. Try it the correct way. */
open_vconn(vconn_name, &vconn);
struct port_iterator pi;
for (port_iterator_init(&pi, vconn); port_iterator_next(&pi, pp); ) {
if (port_no != OFPP_NONE
? port_no == pp->port_no
: !strcmp(pp->name, port_name)) {
found = true;
break;
}
}
port_iterator_destroy(&pi);
vconn_close(vconn);
if (!found) {
ovs_fatal(0, "%s: couldn't find port `%s'", vconn_name, port_name);
}
}
static const struct ofputil_port_map *
get_port_map(const char *vconn_name)
{
static struct shash port_maps = SHASH_INITIALIZER(&port_maps);
struct ofputil_port_map *map = shash_find_data(&port_maps, vconn_name);
if (!map) {
map = xmalloc(sizeof *map);
ofputil_port_map_init(map);
shash_add(&port_maps, vconn_name, map);
if (!strchr(vconn_name, ':') || !vconn_verify_name(vconn_name)) {
/* For an active vconn (which includes a vconn constructed from a
* bridge name), connect to it and pull down the port name-number
* mapping. */
struct vconn *vconn;
open_vconn(vconn_name, &vconn);
struct port_iterator pi;
struct ofputil_phy_port pp;
for (port_iterator_init(&pi, vconn);
port_iterator_next(&pi, &pp); ) {
ofputil_port_map_put(map, pp.port_no, pp.name);
}
port_iterator_destroy(&pi);
vconn_close(vconn);
} else {
/* Don't bother with passive vconns, since it could take a long
* time for the remote to try to connect to us. Don't bother with
* invalid vconn names either. */
}
}
return map;
}
static const struct ofputil_port_map *
ports_to_accept(const char *vconn_name)
{
return should_accept_names() ? get_port_map(vconn_name) : NULL;
}
static const struct ofputil_port_map *
ports_to_show(const char *vconn_name)
{
return should_show_names() ? get_port_map(vconn_name) : NULL;
}
struct table_iterator {
struct vconn *vconn;
enum { TI_STATS, TI_FEATURES } variant;
struct ofpbuf *reply;
ovs_be32 send_xid;
bool more;
struct ofputil_table_features features;
struct ofpbuf raw_properties;
};
/* Initializes 'ti' to prepare for iterating through all of the tables on the
* OpenFlow switch to which 'vconn' is connected.
*
* During iteration, the client should not make other use of 'vconn', because
* that can cause other messages to be interleaved with the replies used by the
* iterator and thus some tables may be missed or a hang can occur. */
static void
table_iterator_init(struct table_iterator *ti, struct vconn *vconn)
{
memset(ti, 0, sizeof *ti);
ti->vconn = vconn;
ti->variant = (vconn_get_version(vconn) < OFP13_VERSION
? TI_STATS : TI_FEATURES);
ti->more = true;
enum ofpraw ofpraw = (ti->variant == TI_STATS
? OFPRAW_OFPST_TABLE_REQUEST
: OFPRAW_OFPST13_TABLE_FEATURES_REQUEST);
struct ofpbuf *rq = ofpraw_alloc(ofpraw, vconn_get_version(vconn), 0);
ti->send_xid = ((struct ofp_header *) rq->data)->xid;
send_openflow_buffer(ti->vconn, rq);
}
/* Obtains the next table from 'ti'. On success, returns the next table's
* features; on failure, returns NULL. */
static const struct ofputil_table_features *
table_iterator_next(struct table_iterator *ti)
{
for (;;) {
if (ti->reply) {
int retval;
if (ti->variant == TI_STATS) {
struct ofputil_table_stats ts;
retval = ofputil_decode_table_stats_reply(ti->reply,
&ts, &ti->features);
} else {
ovs_assert(ti->variant == TI_FEATURES);
retval = ofputil_decode_table_features(ti->reply,
&ti->features,
&ti->raw_properties);
}
if (!retval) {
return &ti->features;
} else if (retval != EOF) {
ovs_fatal(0, "received bad reply: %s",
ofp_to_string(ti->reply->data, ti->reply->size,
NULL, NULL, verbosity + 1));
}
}
if (!ti->more) {
return NULL;
}
ovs_be32 recv_xid;
do {
ofpbuf_delete(ti->reply);
run(vconn_recv_block(ti->vconn, &ti->reply),
"OpenFlow receive failed");
recv_xid = ((struct ofp_header *) ti->reply->data)->xid;
} while (ti->send_xid != recv_xid);
struct ofp_header *oh = ti->reply->data;
enum ofptype type;
if (ofptype_pull(&type, ti->reply)
|| type != (ti->variant == TI_STATS
? OFPTYPE_TABLE_STATS_REPLY
: OFPTYPE_TABLE_FEATURES_STATS_REPLY)) {
ovs_fatal(0, "received bad reply: %s",
ofp_to_string(ti->reply->data, ti->reply->size, NULL,
NULL, verbosity + 1));
}
ti->more = (ofpmp_flags(oh) & OFPSF_REPLY_MORE) != 0;
}
}
/* Destroys iterator 'ti'. */
static void
table_iterator_destroy(struct table_iterator *ti)
{
if (ti) {
while (ti->more) {
/* Drain vconn's queue of any other replies for this request. */
table_iterator_next(ti);
}
ofpbuf_delete(ti->reply);
}
}
static const struct ofputil_table_map *
get_table_map(const char *vconn_name)
{
static struct shash table_maps = SHASH_INITIALIZER(&table_maps);
struct ofputil_table_map *map = shash_find_data(&table_maps, vconn_name);
if (!map) {
map = xmalloc(sizeof *map);
ofputil_table_map_init(map);
shash_add(&table_maps, vconn_name, map);
if (!strchr(vconn_name, ':') || !vconn_verify_name(vconn_name)) {
/* For an active vconn (which includes a vconn constructed from a
* bridge name), connect to it and pull down the port name-number
* mapping. */
struct vconn *vconn;
open_vconn(vconn_name, &vconn);
struct table_iterator ti;
table_iterator_init(&ti, vconn);
for (;;) {
const struct ofputil_table_features *tf
= table_iterator_next(&ti);
if (!tf) {
break;
}
if (tf->name[0]) {
ofputil_table_map_put(map, tf->table_id, tf->name);
}
}
table_iterator_destroy(&ti);
vconn_close(vconn);
} else {
/* Don't bother with passive vconns, since it could take a long
* time for the remote to try to connect to us. Don't bother with
* invalid vconn names either. */
}
}
return map;
}
static const struct ofputil_table_map *
tables_to_accept(const char *vconn_name)
{
return should_accept_names() ? get_table_map(vconn_name) : NULL;
}
static const struct ofputil_table_map *
tables_to_show(const char *vconn_name)
{
return should_show_names() ? get_table_map(vconn_name) : NULL;
}
/* We accept port and table names unless the feature is turned off
* explicitly. */
static bool
should_accept_names(void)
{
return use_names != 0;
}
/* We show port and table names only if the feature is turned on explicitly, or
* if we're interacting with a user on the console. */
static bool
should_show_names(void)
{
static int interactive = -1;
if (interactive == -1) {
interactive = isatty(STDOUT_FILENO);
}
return use_names > 0 || (use_names == -1 && interactive);
}
/* Returns the port number corresponding to 'port_name' (which may be a port
* name or number) within the switch 'vconn_name'. */
static ofp_port_t
str_to_port_no(const char *vconn_name, const char *port_name)
{
ofp_port_t port_no;
if (ofputil_port_from_string(port_name, NULL, &port_no) ||
ofputil_port_from_string(port_name, ports_to_accept(vconn_name),
&port_no)) {
return port_no;
}
ovs_fatal(0, "%s: unknown port `%s'", vconn_name, port_name);
}
static bool
try_set_protocol(struct vconn *vconn, enum ofputil_protocol want,
enum ofputil_protocol *cur)
{
for (;;) {
struct ofpbuf *request, *reply;
enum ofputil_protocol next;
request = ofputil_encode_set_protocol(*cur, want, &next);
if (!request) {
return *cur == want;
}
run(vconn_transact_noreply(vconn, request, &reply),
"talking to %s", vconn_get_name(vconn));
if (reply) {
char *s = ofp_to_string(reply->data, reply->size, NULL, NULL, 2);
VLOG_DBG("%s: failed to set protocol, switch replied: %s",
vconn_get_name(vconn), s);
free(s);
ofpbuf_delete(reply);
return false;
}
*cur = next;
}
}
static enum ofputil_protocol
set_protocol_for_flow_dump(struct vconn *vconn,
enum ofputil_protocol cur_protocol,
enum ofputil_protocol usable_protocols)
{
char *usable_s;
int i;
for (i = 0; i < ofputil_n_flow_dump_protocols; i++) {
enum ofputil_protocol f = ofputil_flow_dump_protocols[i];
if (f & usable_protocols & allowed_protocols
&& try_set_protocol(vconn, f, &cur_protocol)) {
return f;
}
}
usable_s = ofputil_protocols_to_string(usable_protocols);
if (usable_protocols & allowed_protocols) {
ovs_fatal(0, "switch does not support any of the usable flow "
"formats (%s)", usable_s);
} else {
char *allowed_s = ofputil_protocols_to_string(allowed_protocols);
ovs_fatal(0, "none of the usable flow formats (%s) is among the "
"allowed flow formats (%s)", usable_s, allowed_s);
}
}
static struct vconn *
prepare_dump_flows(int argc, char *argv[], bool aggregate,
struct ofputil_flow_stats_request *fsr,
enum ofputil_protocol *protocolp)
{
const char *vconn_name = argv[1];
enum ofputil_protocol usable_protocols, protocol;
struct vconn *vconn;
char *error;
const char *match = argc > 2 ? argv[2] : "";
const struct ofputil_port_map *port_map
= *match ? ports_to_accept(vconn_name) : NULL;
const struct ofputil_table_map *table_map
= *match ? tables_to_accept(vconn_name) : NULL;
error = parse_ofp_flow_stats_request_str(fsr, aggregate, match,
port_map, table_map,
&usable_protocols);
if (error) {
ovs_fatal(0, "%s", error);
}
protocol = open_vconn(vconn_name, &vconn);
*protocolp = set_protocol_for_flow_dump(vconn, protocol, usable_protocols);
return vconn;
}
static void
ofctl_dump_flows__(int argc, char *argv[], bool aggregate)
{
struct ofputil_flow_stats_request fsr;
enum ofputil_protocol protocol;
struct vconn *vconn;
vconn = prepare_dump_flows(argc, argv, aggregate, &fsr, &protocol);
dump_transaction(vconn, ofputil_encode_flow_stats_request(&fsr, protocol));
vconn_close(vconn);
}
static void
get_match_field(const struct mf_field *field, const struct match *match,
union mf_value *value)
{
if (!match->tun_md.valid || (field->id < MFF_TUN_METADATA0 ||
field->id >= MFF_TUN_METADATA0 +
TUN_METADATA_NUM_OPTS)) {
mf_get_value(field, &match->flow, value);
} else {
const struct tun_metadata_loc *loc = &match->tun_md.entry[field->id -
MFF_TUN_METADATA0].loc;
/* Since we don't have a tunnel mapping table, extract the value
* from the locally allocated location in the match. */
memset(value, 0, field->n_bytes - loc->len);
memcpy(value->tun_metadata + field->n_bytes - loc->len,
match->flow.tunnel.metadata.opts.u8 + loc->c.offset, loc->len);
}
}
static int
compare_flows(const void *afs_, const void *bfs_)
{
const struct ofputil_flow_stats *afs = afs_;
const struct ofputil_flow_stats *bfs = bfs_;
const struct match *a = &afs->match;
const struct match *b = &bfs->match;
const struct sort_criterion *sc;
for (sc = criteria; sc < &criteria[n_criteria]; sc++) {
const struct mf_field *f = sc->field;
int ret;
if (!f) {
int a_pri = afs->priority;
int b_pri = bfs->priority;
ret = a_pri < b_pri ? -1 : a_pri > b_pri;
} else {
bool ina, inb;
ina = mf_are_prereqs_ok(f, &a->flow, NULL)
&& !mf_is_all_wild(f, &a->wc);
inb = mf_are_prereqs_ok(f, &b->flow, NULL)
&& !mf_is_all_wild(f, &b->wc);
if (ina != inb) {
/* Skip the test for sc->order, so that missing fields always
* sort to the end whether we're sorting in ascending or
* descending order. */
return ina ? -1 : 1;
} else {
union mf_value aval, bval;
get_match_field(f, a, &aval);
get_match_field(f, b, &bval);
ret = memcmp(&aval, &bval, f->n_bytes);
}
}
if (ret) {
return sc->order == SORT_ASC ? ret : -ret;
}
}
return a < b ? -1 : 1;
}
static void
ofctl_dump_flows(struct ovs_cmdl_context *ctx)
{
if (!n_criteria && !should_show_names() && show_stats) {
ofctl_dump_flows__(ctx->argc, ctx->argv, false);
return;
} else {
struct ofputil_flow_stats_request fsr;
enum ofputil_protocol protocol;
struct vconn *vconn;
vconn = prepare_dump_flows(ctx->argc, ctx->argv, false,
&fsr, &protocol);
struct ofputil_flow_stats *fses;
size_t n_fses;
run(vconn_dump_flows(vconn, &fsr, protocol, &fses, &n_fses),
"dump flows");
if (n_criteria) {
qsort(fses, n_fses, sizeof *fses, compare_flows);
}
struct ds s = DS_EMPTY_INITIALIZER;
for (size_t i = 0; i < n_fses; i++) {
ds_clear(&s);
ofputil_flow_stats_format(&s, &fses[i],
ports_to_show(ctx->argv[1]),
tables_to_show(ctx->argv[1]),
show_stats);
printf(" %s\n", ds_cstr(&s));
}
ds_destroy(&s);
for (size_t i = 0; i < n_fses; i++) {
free(CONST_CAST(struct ofpact *, fses[i].ofpacts));
}
free(fses);
vconn_close(vconn);
}
}
static void
ofctl_dump_aggregate(struct ovs_cmdl_context *ctx)
{
ofctl_dump_flows__(ctx->argc, ctx->argv, true);
}
static void
ofctl_queue_stats(struct ovs_cmdl_context *ctx)
{
struct ofpbuf *request;
struct vconn *vconn;
struct ofputil_queue_stats_request oqs;
open_vconn(ctx->argv[1], &vconn);
if (ctx->argc > 2 && ctx->argv[2][0] && strcasecmp(ctx->argv[2], "all")) {
oqs.port_no = str_to_port_no(ctx->argv[1], ctx->argv[2]);
} else {
oqs.port_no = OFPP_ANY;
}
if (ctx->argc > 3 && ctx->argv[3][0] && strcasecmp(ctx->argv[3], "all")) {
oqs.queue_id = atoi(ctx->argv[3]);
} else {
oqs.queue_id = OFPQ_ALL;
}
request = ofputil_encode_queue_stats_request(vconn_get_version(vconn), &oqs);
dump_transaction(vconn, request);
vconn_close(vconn);
}
static void
ofctl_queue_get_config(struct ovs_cmdl_context *ctx)
{
const char *vconn_name = ctx->argv[1];
const char *port_name = ctx->argc > 2 ? ctx->argv[2] : "any";
ofp_port_t port = str_to_port_no(vconn_name, port_name);
const char *queue_name = ctx->argc > 3 ? ctx->argv[3] : "all";
uint32_t queue = (!strcasecmp(queue_name, "all")
? OFPQ_ALL
: atoi(queue_name));
struct vconn *vconn;
enum ofputil_protocol protocol = open_vconn(vconn_name, &vconn);
enum ofp_version version = ofputil_protocol_to_ofp_version(protocol);
if (port == OFPP_ANY && version == OFP10_VERSION) {
/* The user requested all queues on all ports. OpenFlow 1.0 only
* supports getting queues for an individual port, so to implement the
* user's request we have to get a list of all the ports.
*
* We use a second vconn to avoid having to accumulate a list of all of
* the ports. */
struct vconn *vconn2;
enum ofputil_protocol protocol2 = open_vconn(vconn_name, &vconn2);
enum ofp_version version2 = ofputil_protocol_to_ofp_version(protocol2);
struct port_iterator pi;
struct ofputil_phy_port pp;
for (port_iterator_init(&pi, vconn); port_iterator_next(&pi, &pp); ) {
if (ofp_to_u16(pp.port_no) < ofp_to_u16(OFPP_MAX)) {
dump_transaction(vconn2,
ofputil_encode_queue_get_config_request(
version2, pp.port_no, queue));
}
}
port_iterator_destroy(&pi);
vconn_close(vconn2);
} else {
dump_transaction(vconn, ofputil_encode_queue_get_config_request(
version, port, queue));
}
vconn_close(vconn);
}
static enum ofputil_protocol
open_vconn_for_flow_mod(const char *remote, struct vconn **vconnp,
enum ofputil_protocol usable_protocols)
{
enum ofputil_protocol cur_protocol;
char *usable_s;
int i;
if (!(usable_protocols & allowed_protocols)) {
char *allowed_s = ofputil_protocols_to_string(allowed_protocols);
usable_s = ofputil_protocols_to_string(usable_protocols);
ovs_fatal(0, "none of the usable flow formats (%s) is among the "
"allowed flow formats (%s)", usable_s, allowed_s);
}
/* If the initial flow format is allowed and usable, keep it. */
cur_protocol = open_vconn(remote, vconnp);
if (usable_protocols & allowed_protocols & cur_protocol) {
return cur_protocol;
}
/* Otherwise try each flow format in turn. */
for (i = 0; i < sizeof(enum ofputil_protocol) * CHAR_BIT; i++) {
enum ofputil_protocol f = 1 << i;
if (f != cur_protocol
&& f & usable_protocols & allowed_protocols
&& try_set_protocol(*vconnp, f, &cur_protocol)) {
return f;
}
}
usable_s = ofputil_protocols_to_string(usable_protocols);
ovs_fatal(0, "switch does not support any of the usable flow "
"formats (%s)", usable_s);
}
static void
bundle_flow_mod__(const char *remote, struct ofputil_flow_mod *fms,
size_t n_fms, enum ofputil_protocol usable_protocols)
{
enum ofputil_protocol protocol;
struct vconn *vconn;
struct ovs_list requests;
size_t i;
ovs_list_init(&requests);
/* Bundles need OpenFlow 1.3+. */
usable_protocols &= OFPUTIL_P_OF13_UP;
protocol = open_vconn_for_flow_mod(remote, &vconn, usable_protocols);
for (i = 0; i < n_fms; i++) {
struct ofputil_flow_mod *fm = &fms[i];
struct ofpbuf *request = ofputil_encode_flow_mod(fm, protocol);
ovs_list_push_back(&requests, &request->list_node);
free(CONST_CAST(struct ofpact *, fm->ofpacts));
minimatch_destroy(&fm->match);
}
bundle_transact(vconn, &requests, OFPBF_ORDERED | OFPBF_ATOMIC);
ofpbuf_list_delete(&requests);
vconn_close(vconn);
}
static void
ofctl_flow_mod__(const char *remote, struct ofputil_flow_mod *fms,
size_t n_fms, enum ofputil_protocol usable_protocols)
{
enum ofputil_protocol protocol;
struct vconn *vconn;
struct ds ds = DS_EMPTY_INITIALIZER;
size_t i;
if (bundle) {
bundle_flow_mod__(remote, fms, n_fms, usable_protocols);
return;
}
protocol = open_vconn_for_flow_mod(remote, &vconn, usable_protocols);
for (i = 0; i < n_fms; i++) {
struct ofputil_flow_mod *fm = &fms[i];
struct ofpbuf *buf = ofputil_encode_flow_mod(fm, protocol);
/* If user has opted for verbosity of 5 or more dump the
* constructed OpenFlow packet in hex format */
if (verbosity == 5) {
ds_put_hex_dump(&ds, buf->data, buf->size, 0, true);
} else if (verbosity > 5) {
ds_put_hex(&ds, buf->data, buf->size);
ds_put_char(&ds, '\n');
}
transact_noreply(vconn, buf);
free(CONST_CAST(struct ofpact *, fm->ofpacts));
minimatch_destroy(&fm->match);
}
fputs(ds_cstr(&ds), stdout);
ds_destroy(&ds);
vconn_close(vconn);
}
static void
ofctl_flow_mod_file(int argc OVS_UNUSED, char *argv[], int command)
{
enum ofputil_protocol usable_protocols;
struct ofputil_flow_mod *fms = NULL;
size_t n_fms = 0;
char *error;
if (command == OFPFC_ADD) {
/* Allow the file to specify a mix of commands. If none specified at
* the beginning of any given line, then the default is OFPFC_ADD, so
* this is backwards compatible. */
command = -2;
}
error = parse_ofp_flow_mod_file(argv[2], ports_to_accept(argv[1]),
tables_to_accept(argv[1]), command,
&fms, &n_fms, &usable_protocols);
if (error) {
ovs_fatal(0, "%s", error);
}
ofctl_flow_mod__(argv[1], fms, n_fms, usable_protocols);
free(fms);
}
static void
ofctl_flow_mod(int argc, char *argv[], uint16_t command)
{
if (argc > 2 && !strcmp(argv[2], "-")) {
ofctl_flow_mod_file(argc, argv, command);
} else {
struct ofputil_flow_mod fm;
char *error;
enum ofputil_protocol usable_protocols;
error = parse_ofp_flow_mod_str(&fm, argc > 2 ? argv[2] : "",
ports_to_accept(argv[1]),
tables_to_accept(argv[1]), command,
&usable_protocols);
if (error) {
ovs_fatal(0, "%s", error);
}
ofctl_flow_mod__(argv[1], &fm, 1, usable_protocols);
}
}
static void
ofctl_add_flow(struct ovs_cmdl_context *ctx)
{
ofctl_flow_mod(ctx->argc, ctx->argv, OFPFC_ADD);
}
static void
ofctl_add_flows(struct ovs_cmdl_context *ctx)
{
ofctl_flow_mod_file(ctx->argc, ctx->argv, OFPFC_ADD);
}
static void
ofctl_mod_flows(struct ovs_cmdl_context *ctx)
{
ofctl_flow_mod(ctx->argc, ctx->argv, strict ? OFPFC_MODIFY_STRICT : OFPFC_MODIFY);
}
static void
ofctl_del_flows(struct ovs_cmdl_context *ctx)
{
ofctl_flow_mod(ctx->argc, ctx->argv, strict ? OFPFC_DELETE_STRICT : OFPFC_DELETE);
}
static bool
set_packet_in_format(struct vconn *vconn,
enum ofputil_packet_in_format packet_in_format,
bool must_succeed)
{
struct ofpbuf *spif;
spif = ofputil_encode_set_packet_in_format(vconn_get_version(vconn),
packet_in_format);
if (must_succeed) {
transact_noreply(vconn, spif);
} else {
struct ofpbuf *reply;
run(vconn_transact_noreply(vconn, spif, &reply),
"talking to %s", vconn_get_name(vconn));
if (reply) {
char *s = ofp_to_string(reply->data, reply->size, NULL, NULL, 2);
VLOG_DBG("%s: failed to set packet in format to nx_packet_in, "
"controller replied: %s.",
vconn_get_name(vconn), s);
free(s);
ofpbuf_delete(reply);
return false;
} else {
VLOG_DBG("%s: using user-specified packet in format %s",
vconn_get_name(vconn),
ofputil_packet_in_format_to_string(packet_in_format));
}
}
return true;
}
static int
monitor_set_invalid_ttl_to_controller(struct vconn *vconn)
{
struct ofputil_switch_config config;
fetch_switch_config(vconn, &config);
if (!config.invalid_ttl_to_controller) {
config.invalid_ttl_to_controller = 1;
set_switch_config(vconn, &config);
/* Then retrieve the configuration to see if it really took. OpenFlow
* has ill-defined error reporting for bad flags, so this is about the
* best we can do. */
fetch_switch_config(vconn, &config);
if (!config.invalid_ttl_to_controller) {
ovs_fatal(0, "setting invalid_ttl_to_controller failed (this "
"switch probably doesn't support this flag)");
}
}
return 0;
}
/* Converts hex digits in 'hex' to an OpenFlow message in '*msgp'. The
* caller must free '*msgp'. On success, returns NULL. On failure, returns
* an error message and stores NULL in '*msgp'. */
static const char *
openflow_from_hex(const char *hex, struct ofpbuf **msgp)
{
struct ofp_header *oh;
struct ofpbuf *msg;
msg = ofpbuf_new(strlen(hex) / 2);
*msgp = NULL;
if (ofpbuf_put_hex(msg, hex, NULL)[0] != '\0') {
ofpbuf_delete(msg);
return "Trailing garbage in hex data";
}
if (msg->size < sizeof(struct ofp_header)) {
ofpbuf_delete(msg);
return "Message too short for OpenFlow";
}
oh = msg->data;
if (msg->size != ntohs(oh->length)) {
ofpbuf_delete(msg);
return "Message size does not match length in OpenFlow header";
}
*msgp = msg;
return NULL;
}
static void
ofctl_send(struct unixctl_conn *conn, int argc,
const char *argv[], void *vconn_)
{
struct vconn *vconn = vconn_;
struct ds reply;
bool ok;
int i;
ok = true;
ds_init(&reply);
for (i = 1; i < argc; i++) {
const char *error_msg;
struct ofpbuf *msg;
int error;
error_msg = openflow_from_hex(argv[i], &msg);
if (error_msg) {
ds_put_format(&reply, "%s\n", error_msg);
ok = false;
continue;
}
fprintf(stderr, "send: ");
ofp_print(stderr, msg->data, msg->size,
ports_to_show(vconn_get_name(vconn)),
tables_to_show(vconn_get_name(vconn)), verbosity);
error = vconn_send_block(vconn, msg);
if (error) {
ofpbuf_delete(msg);
ds_put_format(&reply, "%s\n", ovs_strerror(error));
ok = false;
} else {
ds_put_cstr(&reply, "sent\n");
}
}
if (ok) {
unixctl_command_reply(conn, ds_cstr(&reply));
} else {
unixctl_command_reply_error(conn, ds_cstr(&reply));
}
ds_destroy(&reply);
}
static void
unixctl_packet_out(struct unixctl_conn *conn, int OVS_UNUSED argc,
const char *argv[], void *vconn_)
{
struct vconn *vconn = vconn_;
enum ofputil_protocol protocol
= ofputil_protocol_from_ofp_version(vconn_get_version(vconn));
struct ds reply = DS_EMPTY_INITIALIZER;
bool ok = true;
enum ofputil_protocol usable_protocols;
struct ofputil_packet_out po;
char *error_msg;
error_msg = parse_ofp_packet_out_str(
&po, argv[1], ports_to_accept(vconn_get_name(vconn)),
tables_to_accept(vconn_get_name(vconn)), &usable_protocols);
if (error_msg) {
ds_put_format(&reply, "%s\n", error_msg);
free(error_msg);
ok = false;
}
if (ok && !(usable_protocols & protocol)) {
ds_put_format(&reply, "PACKET_OUT actions are incompatible with the OpenFlow connection.\n");
ok = false;
}
if (ok) {
struct ofpbuf *msg = ofputil_encode_packet_out(&po, protocol);
ofp_print(stderr, msg->data, msg->size,
ports_to_show(vconn_get_name(vconn)),
tables_to_show(vconn_get_name(vconn)), verbosity);
int error = vconn_send_block(vconn, msg);
if (error) {
ofpbuf_delete(msg);
ds_put_format(&reply, "%s\n", ovs_strerror(error));
ok = false;
}
}
if (ok) {
unixctl_command_reply(conn, ds_cstr(&reply));
} else {
unixctl_command_reply_error(conn, ds_cstr(&reply));
}
ds_destroy(&reply);
if (!error_msg) {
free(CONST_CAST(void *, po.packet));
free(po.ofpacts);
}
}
struct barrier_aux {
struct vconn *vconn; /* OpenFlow connection for sending barrier. */
struct unixctl_conn *conn; /* Connection waiting for barrier response. */
};
static void
ofctl_barrier(struct unixctl_conn *conn, int argc OVS_UNUSED,
const char *argv[] OVS_UNUSED, void *aux_)
{
struct barrier_aux *aux = aux_;
struct ofpbuf *msg;
int error;
if (aux->conn) {
unixctl_command_reply_error(conn, "already waiting for barrier reply");
return;
}
msg = ofputil_encode_barrier_request(vconn_get_version(aux->vconn));
error = vconn_send_block(aux->vconn, msg);
if (error) {
ofpbuf_delete(msg);
unixctl_command_reply_error(conn, ovs_strerror(error));
} else {
aux->conn = conn;
}
}
static void
ofctl_set_output_file(struct unixctl_conn *conn, int argc OVS_UNUSED,
const char *argv[], void *aux OVS_UNUSED)
{
int fd;
fd = open(argv[1], O_CREAT | O_TRUNC | O_WRONLY, 0666);
if (fd < 0) {
unixctl_command_reply_error(conn, ovs_strerror(errno));
return;
}
fflush(stderr);
dup2(fd, STDERR_FILENO);
close(fd);
unixctl_command_reply(conn, NULL);
}
static void
ofctl_block(struct unixctl_conn *conn, int argc OVS_UNUSED,
const char *argv[] OVS_UNUSED, void *blocked_)
{
bool *blocked = blocked_;
if (!*blocked) {
*blocked = true;
unixctl_command_reply(conn, NULL);
} else {
unixctl_command_reply(conn, "already blocking");
}
}
static void
ofctl_unblock(struct unixctl_conn *conn, int argc OVS_UNUSED,
const char *argv[] OVS_UNUSED, void *blocked_)
{
bool *blocked = blocked_;
if (*blocked) {
*blocked = false;
unixctl_command_reply(conn, NULL);
} else {
unixctl_command_reply(conn, "already unblocked");
}
}
/* Prints to stderr all of the messages received on 'vconn'.
*
* Iff 'reply_to_echo_requests' is true, sends a reply to any echo request
* received on 'vconn'.
*
* If 'resume_continuations' is true, sends an NXT_RESUME in reply to any
* NXT_PACKET_IN2 that includes a continuation. */
static void
monitor_vconn(struct vconn *vconn, bool reply_to_echo_requests,
bool resume_continuations)
{
struct barrier_aux barrier_aux = { vconn, NULL };
struct unixctl_server *server;
bool exiting = false;
bool blocked = false;
int error;
daemon_save_fd(STDERR_FILENO);
daemonize_start(false);
error = unixctl_server_create(unixctl_path, &server);
if (error) {
ovs_fatal(error, "failed to create unixctl server");
}
unixctl_command_register("exit", "", 0, 0, ofctl_exit, &exiting);
unixctl_command_register("ofctl/send", "OFMSG...", 1, INT_MAX,
ofctl_send, vconn);
unixctl_command_register("ofctl/packet-out", "\"in_port=<port> packet=<hex data> actions=...\"", 1, 1,
unixctl_packet_out, vconn);
unixctl_command_register("ofctl/barrier", "", 0, 0,
ofctl_barrier, &barrier_aux);
unixctl_command_register("ofctl/set-output-file", "FILE", 1, 1,
ofctl_set_output_file, NULL);
unixctl_command_register("ofctl/block", "", 0, 0, ofctl_block, &blocked);
unixctl_command_register("ofctl/unblock", "", 0, 0, ofctl_unblock,
&blocked);
daemonize_complete();
enum ofp_version version = vconn_get_version(vconn);
enum ofputil_protocol protocol
= ofputil_protocol_from_ofp_version(version);
for (;;) {
struct ofpbuf *b;
int retval;
unixctl_server_run(server);
while (!blocked) {
enum ofptype type;
retval = vconn_recv(vconn, &b);
if (retval == EAGAIN) {
break;
}
run(retval, "vconn_recv");
if (timestamp) {
char *s = xastrftime_msec("%Y-%m-%d %H:%M:%S.###: ",
time_wall_msec(), true);
fputs(s, stderr);
free(s);
}
ofptype_decode(&type, b->data);
ofp_print(stderr, b->data, b->size,
ports_to_show(vconn_get_name(vconn)),
tables_to_show(vconn_get_name(vconn)), verbosity + 2);
fflush(stderr);
switch ((int) type) {
case OFPTYPE_BARRIER_REPLY:
if (barrier_aux.conn) {
unixctl_command_reply(barrier_aux.conn, NULL);
barrier_aux.conn = NULL;
}
break;
case OFPTYPE_ECHO_REQUEST:
if (reply_to_echo_requests) {
struct ofpbuf *reply;
reply = ofputil_encode_echo_reply(b->data);
retval = vconn_send_block(vconn, reply);
if (retval) {
ovs_fatal(retval, "failed to send echo reply");
}
}
break;
case OFPTYPE_PACKET_IN:
if (resume_continuations) {
struct ofputil_packet_in pin;
struct ofpbuf continuation;
error = ofputil_decode_packet_in(b->data, true, NULL, NULL,
&pin, NULL, NULL,
&continuation);
if (error) {
fprintf(stderr, "decoding packet-in failed: %s",
ofperr_to_string(error));
} else if (continuation.size) {
struct ofpbuf *reply;
reply = ofputil_encode_resume(&pin, &continuation,
protocol);
fprintf(stderr, "send: ");
ofp_print(stderr, reply->data, reply->size,
ports_to_show(vconn_get_name(vconn)),
tables_to_show(vconn_get_name(vconn)),
verbosity + 2);
fflush(stderr);
retval = vconn_send_block(vconn, reply);
if (retval) {
ovs_fatal(retval, "failed to send NXT_RESUME");
}
}
}
break;
}
ofpbuf_delete(b);
}
if (exiting) {
break;
}
vconn_run(vconn);
vconn_run_wait(vconn);
if (!blocked) {
vconn_recv_wait(vconn);
}
unixctl_server_wait(server);
poll_block();
}
vconn_close(vconn);
unixctl_server_destroy(server);
}
static void
ofctl_monitor(struct ovs_cmdl_context *ctx)
{
struct vconn *vconn;
int i;
enum ofputil_protocol protocol;
enum ofputil_protocol usable_protocols;
/* If the user wants the invalid_ttl_to_controller feature, limit the
* OpenFlow versions to those that support that feature. (Support in
* OpenFlow 1.0 is an Open vSwitch extension.) */
for (i = 2; i < ctx->argc; i++) {
if (!strcmp(ctx->argv[i], "invalid_ttl")) {
uint32_t usable_versions = ((1u << OFP10_VERSION) |
(1u << OFP11_VERSION) |
(1u << OFP12_VERSION));
uint32_t allowed_versions = get_allowed_ofp_versions();
if (!(allowed_versions & usable_versions)) {
struct ds versions = DS_EMPTY_INITIALIZER;
ofputil_format_version_bitmap_names(&versions,
usable_versions);
ovs_fatal(0, "invalid_ttl requires one of the OpenFlow "
"versions %s but none is enabled (use -O)",
ds_cstr(&versions));
}
mask_allowed_ofp_versions(usable_versions);
break;
}
}
protocol = open_vconn(ctx->argv[1], &vconn);
bool resume_continuations = false;
for (i = 2; i < ctx->argc; i++) {
const char *arg = ctx->argv[i];
if (isdigit((unsigned char) *arg)) {
struct ofputil_switch_config config;
fetch_switch_config(vconn, &config);
config.miss_send_len = atoi(arg);
set_switch_config(vconn, &config);
} else if (!strcmp(arg, "invalid_ttl")) {
monitor_set_invalid_ttl_to_controller(vconn);
} else if (!strncmp(arg, "watch:", 6)) {
struct ofputil_flow_monitor_request fmr;
struct ofpbuf *msg;
char *error;
error = parse_flow_monitor_request(&fmr, arg + 6,
ports_to_accept(ctx->argv[1]),
tables_to_accept(ctx->argv[1]),
&usable_protocols);
if (error) {
ovs_fatal(0, "%s", error);
}
if (!(usable_protocols & allowed_protocols)) {
char *allowed_s =
ofputil_protocols_to_string(allowed_protocols);
char *usable_s = ofputil_protocols_to_string(usable_protocols);
ovs_fatal(0, "none of the usable flow formats (%s) is among "
"the allowed flow formats (%s)", usable_s, allowed_s);
}
msg = ofpbuf_new(0);
ofputil_append_flow_monitor_request(&fmr, msg, protocol);
if (verbosity) {
ofpmsg_update_length(msg);
ofp_print(stdout, msg->data, msg->size, NULL,
NULL, verbosity + 2);
}
dump_transaction(vconn, msg);
fflush(stdout);
} else if (!strcmp(arg, "resume")) {
/* This option is intentionally undocumented because it is meant
* only for testing. */
resume_continuations = true;
/* Set miss_send_len to ensure that we get packet-ins. */
struct ofputil_switch_config config;
fetch_switch_config(vconn, &config);
config.miss_send_len = UINT16_MAX;
set_switch_config(vconn, &config);
} else {
ovs_fatal(0, "%s: unsupported \"monitor\" argument", arg);
}
}
if (preferred_packet_in_format >= 0) {
/* A particular packet-in format was requested, so we must set it. */
set_packet_in_format(vconn, preferred_packet_in_format, true);
} else {
/* Otherwise, we always prefer NXT_PACKET_IN2. */
if (!set_packet_in_format(vconn, OFPUTIL_PACKET_IN_NXT2, false)) {
/* We can't get NXT_PACKET_IN2. For OpenFlow 1.0 only, request
* NXT_PACKET_IN. (Before 2.6, Open vSwitch will accept a request
* for NXT_PACKET_IN with OF1.1+, but even after that it still
* sends packet-ins in the OpenFlow native format.) */
if (vconn_get_version(vconn) == OFP10_VERSION) {
set_packet_in_format(vconn, OFPUTIL_PACKET_IN_NXT, false);
}
}
}
monitor_vconn(vconn, true, resume_continuations);
}
static void
ofctl_snoop(struct ovs_cmdl_context *ctx)
{
struct vconn *vconn;
/* We can't use the snoop vconn to send table features request or port
* description request messages to show names, because ovs-vswitchd will
* not respond to these messages on snoop vconn. */
use_names = 0;
open_vconn__(ctx->argv[1], SNOOP, &vconn);
monitor_vconn(vconn, false, false);
}
static void
ofctl_dump_ports(struct ovs_cmdl_context *ctx)
{
struct ofpbuf *request;
struct vconn *vconn;
ofp_port_t port;
open_vconn(ctx->argv[1], &vconn);
port = ctx->argc > 2 ? str_to_port_no(ctx->argv[1], ctx->argv[2]) : OFPP_ANY;
request = ofputil_encode_dump_ports_request(vconn_get_version(vconn), port);
dump_transaction(vconn, request);
vconn_close(vconn);
}
static void
ofctl_dump_ports_desc(struct ovs_cmdl_context *ctx)
{
struct ofpbuf *request;
struct vconn *vconn;
ofp_port_t port;
open_vconn(ctx->argv[1], &vconn);
port = ctx->argc > 2 ? str_to_port_no(ctx->argv[1], ctx->argv[2]) : OFPP_ANY;
request = ofputil_encode_port_desc_stats_request(vconn_get_version(vconn),
port);
dump_transaction(vconn, request);
vconn_close(vconn);
}
static void
ofctl_probe(struct ovs_cmdl_context *ctx)
{
struct ofpbuf *request;
struct vconn *vconn;
struct ofpbuf *reply;
open_vconn(ctx->argv[1], &vconn);
request = ofputil_encode_echo_request(vconn_get_version(vconn));
run(vconn_transact(vconn, request, &reply), "talking to %s", ctx->argv[1]);
if (reply->size != sizeof(struct ofp_header)) {
ovs_fatal(0, "reply does not match request");
}
ofpbuf_delete(reply);
vconn_close(vconn);
}
static void
ofctl_packet_out(struct ovs_cmdl_context *ctx)
{
enum ofputil_protocol usable_protocols;
enum ofputil_protocol protocol;
struct ofputil_packet_out po;
struct vconn *vconn;
struct ofpbuf *opo;
char *error;
match_init_catchall(&po.flow_metadata);
/* Use the old syntax when more than 4 arguments are given. */
if (ctx->argc > 4) {
struct ofpbuf ofpacts;
int i;
ofpbuf_init(&ofpacts, 64);
struct ofpact_parse_params pp = {
.port_map = ports_to_accept(ctx->argv[1]),
.table_map = tables_to_accept(ctx->argv[1]),
.ofpacts = &ofpacts,
.usable_protocols = &usable_protocols
};
error = ofpacts_parse_actions(ctx->argv[3], &pp);
if (error) {
ovs_fatal(0, "%s", error);
}
po.buffer_id = UINT32_MAX;
match_set_in_port(&po.flow_metadata,
str_to_port_no(ctx->argv[1], ctx->argv[2]));
po.ofpacts = ofpacts.data;
po.ofpacts_len = ofpacts.size;
po.flow_metadata.flow.packet_type = htonl(PT_ETH);
protocol = open_vconn_for_flow_mod(ctx->argv[1], &vconn,
usable_protocols);
for (i = 4; i < ctx->argc; i++) {
struct dp_packet *packet;
const char *error_msg;
error_msg = eth_from_hex(ctx->argv[i], &packet);
if (error_msg) {
ovs_fatal(0, "%s", error_msg);
}
po.packet = dp_packet_data(packet);
po.packet_len = dp_packet_size(packet);
opo = ofputil_encode_packet_out(&po, protocol);
transact_noreply(vconn, opo);
dp_packet_delete(packet);
}
vconn_close(vconn);
ofpbuf_uninit(&ofpacts);
} else if (ctx->argc == 3) {
error = parse_ofp_packet_out_str(&po, ctx->argv[2],
ports_to_accept(ctx->argv[1]),
tables_to_accept(ctx->argv[1]),
&usable_protocols);
if (error) {
ovs_fatal(0, "%s", error);
}
protocol = open_vconn_for_flow_mod(ctx->argv[1], &vconn,
usable_protocols);
opo = ofputil_encode_packet_out(&po, protocol);
transact_noreply(vconn, opo);
vconn_close(vconn);
free(CONST_CAST(void *, po.packet));
free(po.ofpacts);
} else {
ovs_fatal(0, "Too many arguments (%d)", ctx->argc);
}
}
static void
ofctl_mod_port(struct ovs_cmdl_context *ctx)
{
struct ofp_config_flag {
const char *name; /* The flag's name. */
enum ofputil_port_config bit; /* Bit to turn on or off. */
bool on; /* Value to set the bit to. */
};
static const struct ofp_config_flag flags[] = {
{ "up", OFPUTIL_PC_PORT_DOWN, false },
{ "down", OFPUTIL_PC_PORT_DOWN, true },
{ "stp", OFPUTIL_PC_NO_STP, false },
{ "receive", OFPUTIL_PC_NO_RECV, false },
{ "receive-stp", OFPUTIL_PC_NO_RECV_STP, false },
{ "flood", OFPUTIL_PC_NO_FLOOD, false },
{ "forward", OFPUTIL_PC_NO_FWD, false },
{ "packet-in", OFPUTIL_PC_NO_PACKET_IN, false },
};
const struct ofp_config_flag *flag;
enum ofputil_protocol protocol;
struct ofputil_port_mod pm;
struct ofputil_phy_port pp;
struct vconn *vconn;
const char *command;
bool not;
fetch_ofputil_phy_port(ctx->argv[1], ctx->argv[2], &pp);
pm.port_no = pp.port_no;
pm.hw_addr = pp.hw_addr;
pm.config = 0;
pm.mask = 0;
pm.advertise = 0;
if (!strncasecmp(ctx->argv[3], "no-", 3)) {
command = ctx->argv[3] + 3;
not = true;
} else if (!strncasecmp(ctx->argv[3], "no", 2)) {
command = ctx->argv[3] + 2;
not = true;
} else {
command = ctx->argv[3];
not = false;
}
for (flag = flags; flag < &flags[ARRAY_SIZE(flags)]; flag++) {
if (!strcasecmp(command, flag->name)) {
pm.mask = flag->bit;
pm.config = flag->on ^ not ? flag->bit : 0;
goto found;
}
}
ovs_fatal(0, "unknown mod-port command '%s'", ctx->argv[3]);
found:
protocol = open_vconn(ctx->argv[1], &vconn);
transact_noreply(vconn, ofputil_encode_port_mod(&pm, protocol));
vconn_close(vconn);
}
/* This function uses OFPMP14_TABLE_DESC request to get the current
* table configuration from switch. The function then modifies
* only that table-config property, which has been requested. */
static void
fetch_table_desc(struct vconn *vconn, struct ofputil_table_mod *tm,
struct ofputil_table_desc *td)
{
struct ofpbuf *request;
ovs_be32 send_xid;
bool done = false;
bool found = false;
request = ofputil_encode_table_desc_request(vconn_get_version(vconn));
send_xid = ((struct ofp_header *) request->data)->xid;
send_openflow_buffer(vconn, request);
while (!done) {
ovs_be32 recv_xid;
struct ofpbuf *reply;
run(vconn_recv_block(vconn, &reply), "OpenFlow packet receive failed");
recv_xid = ((struct ofp_header *) reply->data)->xid;
if (send_xid == recv_xid) {
struct ofp_header *oh = reply->data;
struct ofpbuf b = ofpbuf_const_initializer(oh, ntohs(oh->length));
enum ofptype type;
if (ofptype_pull(&type, &b)
|| type != OFPTYPE_TABLE_DESC_REPLY) {
ovs_fatal(0, "received bad reply: %s",
ofp_to_string(reply->data, reply->size, NULL, NULL,
verbosity + 1));
}
uint16_t flags = ofpmp_flags(oh);
done = !(flags & OFPSF_REPLY_MORE);
if (found) {
/* We've already found the table desc consisting of current
* table configuration, but we need to drain the queue of
* any other replies for this request. */
continue;
}
while (!ofputil_decode_table_desc(&b, td, oh->version)) {
if (td->table_id == tm->table_id) {
found = true;
break;
}
}
} else {
VLOG_DBG("received reply with xid %08"PRIx32" "
"!= expected %08"PRIx32, recv_xid, send_xid);
}
ofpbuf_delete(reply);
}
if (tm->eviction != OFPUTIL_TABLE_EVICTION_DEFAULT) {
tm->vacancy = td->vacancy;
tm->table_vacancy.vacancy_down = td->table_vacancy.vacancy_down;
tm->table_vacancy.vacancy_up = td->table_vacancy.vacancy_up;
} else if (tm->vacancy != OFPUTIL_TABLE_VACANCY_DEFAULT) {
tm->eviction = td->eviction;
tm->eviction_flags = td->eviction_flags;
}
}
static void
change_table_name(struct vconn *vconn, uint8_t table_id, const char *new_name)
{
/* Get all tables' features and properties. */
struct table {
struct ofputil_table_features tf;
struct ofpbuf *raw_properties;
} *tables[256];
memset(tables, 0, sizeof tables);
struct table_iterator ti;
table_iterator_init(&ti, vconn);
while (table_iterator_next(&ti)) {
struct table *t = tables[ti.features.table_id] = xmalloc(sizeof *t);
t->tf = ti.features;
t->raw_properties = ofpbuf_clone(&ti.raw_properties);
}
table_iterator_destroy(&ti);
/* Change the name for table 'table_id'. */
struct table *t = tables[table_id];
if (!t) {
ovs_fatal(0, "switch does not have table %"PRIu8, table_id);
}
ovs_strlcpy(t->tf.name, new_name, OFP_MAX_TABLE_NAME_LEN);
/* Compose the transaction. */
enum ofp_version version = vconn_get_version(vconn);
struct ovs_list requests = OVS_LIST_INITIALIZER(&requests);
struct ofpbuf *tfr = ofputil_encode_table_features_request(version);
ovs_list_push_back(&requests, &tfr->list_node);
if (version >= OFP15_VERSION) {
/* For OpenFlow 1.5, we can use a single OFPTFC15_MODIFY without any
* properties. */
t->tf.command = OFPTFC15_MODIFY;
t->tf.any_properties = false;
ofputil_append_table_features(&t->tf, NULL, &requests);
} else {
/* For OpenFlow 1.3 and 1.4, we have to regurgitate all of the tables
* and their properties. */
for (size_t i = 0; i < 256; i++) {
if (tables[i]) {
ofputil_append_table_features(&tables[i]->tf,
tables[i]->raw_properties,
&requests);
}
}
}
/* Transact.
*
* The reply repeats the entire new configuration of the tables, so we
* don't bother printing it unless there's an error. */
struct ovs_list replies;
struct ofpbuf *reply;
vconn_transact_multipart(vconn, &requests, &replies);
LIST_FOR_EACH (reply, list_node, &replies) {
enum ofptype type;
enum ofperr error = ofptype_decode(&type, reply->data);
if (error) {
ovs_fatal(0, "decode error: %s", ofperr_get_name(error));
} else if (type == OFPTYPE_ERROR) {
ofp_print(stderr, reply->data, reply->size, NULL, NULL,
verbosity + 1);
exit(1);
}
}
ofpbuf_list_delete(&replies);
/* Clean up. */
for (size_t i = 0; i < ARRAY_SIZE(tables); i++) {
if (tables[i]) {
ofpbuf_delete(tables[i]->raw_properties);
free(tables[i]);
}
}
}
static void
ofctl_mod_table(struct ovs_cmdl_context *ctx)
{
uint32_t usable_versions;
struct ofputil_table_mod tm;
const char *name;
struct vconn *vconn;
char *error;
int i;
error = parse_ofp_table_mod(&tm, &name, ctx->argv[2], ctx->argv[3],
tables_to_accept(ctx->argv[1]),
&usable_versions);
if (error) {
ovs_fatal(0, "%s", error);
}
uint32_t allowed_versions = get_allowed_ofp_versions();
if (!(allowed_versions & usable_versions)) {
struct ds versions = DS_EMPTY_INITIALIZER;
ofputil_format_version_bitmap_names(&versions, usable_versions);
ovs_fatal(0, "table_mod '%s' requires one of the OpenFlow "
"versions %s",
ctx->argv[3], ds_cstr(&versions));
}
mask_allowed_ofp_versions(usable_versions);
enum ofputil_protocol protocol = open_vconn(ctx->argv[1], &vconn);
if (name) {
change_table_name(vconn, tm.table_id, name);
} else {
/* For OpenFlow 1.4+, ovs-ofctl mod-table should not affect
* table-config properties that the user didn't ask to change, so it is
* necessary to restore the current configuration of table-config
* parameters using OFPMP14_TABLE_DESC request. */
if (allowed_versions & ((1u << OFP14_VERSION) |
(1u << OFP15_VERSION))) {
struct ofputil_table_desc td;
if (tm.table_id == OFPTT_ALL) {
for (i = 0; i < OFPTT_MAX; i++) {
tm.table_id = i;
fetch_table_desc(vconn, &tm, &td);
transact_noreply(vconn,
ofputil_encode_table_mod(&tm, protocol));
}
} else {
fetch_table_desc(vconn, &tm, &td);
transact_noreply(vconn, ofputil_encode_table_mod(&tm,
protocol));
}
} else {
transact_noreply(vconn, ofputil_encode_table_mod(&tm, protocol));
}
}
vconn_close(vconn);
}
static void
ofctl_get_frags(struct ovs_cmdl_context *ctx)
{
struct ofputil_switch_config config;
struct vconn *vconn;
open_vconn(ctx->argv[1], &vconn);
fetch_switch_config(vconn, &config);
puts(ofputil_frag_handling_to_string(config.frag));
vconn_close(vconn);
}
static void
ofctl_set_frags(struct ovs_cmdl_context *ctx)
{
struct ofputil_switch_config config;
enum ofputil_frag_handling frag;
struct vconn *vconn;
if (!ofputil_frag_handling_from_string(ctx->argv[2], &frag)) {
ovs_fatal(0, "%s: unknown fragment handling mode", ctx->argv[2]);
}
open_vconn(ctx->argv[1], &vconn);
fetch_switch_config(vconn, &config);
if (frag != config.frag) {
/* Set the configuration. */
config.frag = frag;
set_switch_config(vconn, &config);
/* Then retrieve the configuration to see if it really took. OpenFlow
* has ill-defined error reporting for bad flags, so this is about the
* best we can do. */
fetch_switch_config(vconn, &config);
if (frag != config.frag) {
ovs_fatal(0, "%s: setting fragment handling mode failed (this "
"switch probably doesn't support mode \"%s\")",
ctx->argv[1], ofputil_frag_handling_to_string(frag));
}
}
vconn_close(vconn);
}
static void
ofctl_ofp_parse(struct ovs_cmdl_context *ctx)
{
const char *filename = ctx->argv[1];
struct ofpbuf b;
FILE *file;
file = !strcmp(filename, "-") ? stdin : fopen(filename, "r");
if (file == NULL) {
ovs_fatal(errno, "%s: open", filename);
}
ofpbuf_init(&b, 65536);
for (;;) {
struct ofp_header *oh;
size_t length, tail_len;
void *tail;
size_t n;
ofpbuf_clear(&b);
oh = ofpbuf_put_uninit(&b, sizeof *oh);
n = fread(oh, 1, sizeof *oh, file);
if (n == 0) {
break;
} else if (n < sizeof *oh) {
ovs_fatal(0, "%s: unexpected end of file mid-message", filename);
}
length = ntohs(oh->length);
if (length < sizeof *oh) {
ovs_fatal(0, "%s: %"PRIuSIZE"-byte message is too short for OpenFlow",
filename, length);
}
tail_len = length - sizeof *oh;
tail = ofpbuf_put_uninit(&b, tail_len);
n = fread(tail, 1, tail_len, file);
if (n < tail_len) {
ovs_fatal(0, "%s: unexpected end of file mid-message", filename);
}
ofp_print(stdout, b.data, b.size, NULL, NULL, verbosity + 2);
}
ofpbuf_uninit(&b);
if (file != stdin) {
fclose(file);
}
}
static bool
is_openflow_port(ovs_be16 port_, char *ports[])
{
uint16_t port = ntohs(port_);
if (ports[0]) {
int i;
for (i = 0; ports[i]; i++) {
if (port == atoi(ports[i])) {
return true;
}
}
return false;
} else {
return port == OFP_PORT || port == OFP_OLD_PORT;
}
}
static void
ofctl_ofp_parse_pcap(struct ovs_cmdl_context *ctx)
{
struct tcp_reader *reader;
struct pcap_file *p_file;
int error;
bool first;
p_file = ovs_pcap_open(ctx->argv[1], "rb");
if (!p_file) {
ovs_fatal(errno, "%s: open failed", ctx->argv[1]);
}
reader = tcp_reader_open();
first = true;
for (;;) {
struct dp_packet *packet;
long long int when;
struct flow flow;
error = ovs_pcap_read(p_file, &packet, &when);
if (error) {
break;
}
pkt_metadata_init(&packet->md, ODPP_NONE);
flow_extract(packet, &flow);
if (flow.dl_type == htons(ETH_TYPE_IP)
&& flow.nw_proto == IPPROTO_TCP
&& (is_openflow_port(flow.tp_src, ctx->argv + 2) ||
is_openflow_port(flow.tp_dst, ctx->argv + 2))) {
struct dp_packet *payload = tcp_reader_run(reader, &flow, packet);
if (payload) {
while (dp_packet_size(payload) >= sizeof(struct ofp_header)) {
const struct ofp_header *oh;
void *data = dp_packet_data(payload);
int length;
/* Align OpenFlow on 8-byte boundary for safe access. */
dp_packet_shift(payload, -((intptr_t) data & 7));
oh = dp_packet_data(payload);
length = ntohs(oh->length);
if (dp_packet_size(payload) < length
|| length < sizeof *oh) {
break;
}
if (!first) {
putchar('\n');
}
first = false;
if (timestamp) {
char *s = xastrftime_msec("%H:%M:%S.### ", when, true);
fputs(s, stdout);
free(s);
}
printf(IP_FMT".%"PRIu16" > "IP_FMT".%"PRIu16":\n",
IP_ARGS(flow.nw_src), ntohs(flow.tp_src),
IP_ARGS(flow.nw_dst), ntohs(flow.tp_dst));
ofp_print(stdout, dp_packet_data(payload), length,
NULL, NULL, verbosity + 1);
dp_packet_pull(payload, length);
}
}
}
dp_packet_delete(packet);
}
tcp_reader_close(reader);
ovs_pcap_close(p_file);
}
static void
ofctl_ping(struct ovs_cmdl_context *ctx)
{
size_t max_payload = 65535 - sizeof(struct ofp_header);
unsigned int payload;
struct vconn *vconn;
int i;
payload = ctx->argc > 2 ? atoi(ctx->argv[2]) : 64;
if (payload > max_payload) {
ovs_fatal(0, "payload must be between 0 and %"PRIuSIZE" bytes", max_payload);
}
open_vconn(ctx->argv[1], &vconn);
for (i = 0; i < 10; i++) {
struct timeval start, end;
struct ofpbuf *request, *reply;
const struct ofp_header *rpy_hdr;
enum ofptype type;
request = ofpraw_alloc(OFPRAW_OFPT_ECHO_REQUEST,
vconn_get_version(vconn), payload);
random_bytes(ofpbuf_put_uninit(request, payload), payload);
xgettimeofday(&start);
run(vconn_transact(vconn, ofpbuf_clone(request), &reply), "transact");
xgettimeofday(&end);
rpy_hdr = reply->data;
if (ofptype_pull(&type, reply)
|| type != OFPTYPE_ECHO_REPLY
|| reply->size != payload
|| memcmp(request->msg, reply->msg, payload)) {
printf("Reply does not match request. Request:\n");
ofp_print(stdout, request, request->size, NULL, NULL,
verbosity + 2);
printf("Reply:\n");
ofp_print(stdout, reply, reply->size, NULL, NULL, verbosity + 2);
}
printf("%"PRIu32" bytes from %s: xid=%08"PRIx32" time=%.1f ms\n",
reply->size, ctx->argv[1], ntohl(rpy_hdr->xid),
(1000*(double)(end.tv_sec - start.tv_sec))
+ (.001*(end.tv_usec - start.tv_usec)));
ofpbuf_delete(request);
ofpbuf_delete(reply);
}
vconn_close(vconn);
}
static void
ofctl_benchmark(struct ovs_cmdl_context *ctx)
{
size_t max_payload = 65535 - sizeof(struct ofp_header);
struct timeval start, end;
unsigned int payload_size, message_size;
struct vconn *vconn;
double duration;
int count;
int i;
payload_size = atoi(ctx->argv[2]);
if (payload_size > max_payload) {
ovs_fatal(0, "payload must be between 0 and %"PRIuSIZE" bytes", max_payload);
}
message_size = sizeof(struct ofp_header) + payload_size;
count = atoi(ctx->argv[3]);
printf("Sending %d packets * %u bytes (with header) = %u bytes total\n",
count, message_size, count * message_size);
open_vconn(ctx->argv[1], &vconn);
xgettimeofday(&start);
for (i = 0; i < count; i++) {
struct ofpbuf *request, *reply;
request = ofpraw_alloc(OFPRAW_OFPT_ECHO_REQUEST,
vconn_get_version(vconn), payload_size);
ofpbuf_put_zeros(request, payload_size);
run(vconn_transact(vconn, request, &reply), "transact");
ofpbuf_delete(reply);
}
xgettimeofday(&end);
vconn_close(vconn);
duration = ((1000*(double)(end.tv_sec - start.tv_sec))
+ (.001*(end.tv_usec - start.tv_usec)));
printf("Finished in %.1f ms (%.0f packets/s) (%.0f bytes/s)\n",
duration, count / (duration / 1000.0),
count * message_size / (duration / 1000.0));
}
static void
ofctl_dump_ipfix_bridge(struct ovs_cmdl_context *ctx)
{
dump_trivial_transaction(ctx->argv[1], OFPRAW_NXST_IPFIX_BRIDGE_REQUEST);
}
static void
ofctl_ct_flush_zone(struct ovs_cmdl_context *ctx)
{
uint16_t zone_id;
char *error = str_to_u16(ctx->argv[2], "zone_id", &zone_id);
if (error) {
ovs_fatal(0, "%s", error);
}
struct vconn *vconn;
open_vconn(ctx->argv[1], &vconn);
enum ofp_version version = vconn_get_version(vconn);
struct ofpbuf *msg = ofpraw_alloc(OFPRAW_NXT_CT_FLUSH_ZONE, version, 0);
struct nx_zone_id *nzi = ofpbuf_put_zeros(msg, sizeof *nzi);
nzi->zone_id = htons(zone_id);
transact_noreply(vconn, msg);
vconn_close(vconn);
}
static void
ofctl_dump_ipfix_flow(struct ovs_cmdl_context *ctx)
{
dump_trivial_transaction(ctx->argv[1], OFPRAW_NXST_IPFIX_FLOW_REQUEST);
}
static void
bundle_group_mod__(const char *remote, struct ofputil_group_mod *gms,
size_t n_gms, enum ofputil_protocol usable_protocols)
{
enum ofputil_protocol protocol;
enum ofp_version version;
struct vconn *vconn;
struct ovs_list requests;
size_t i;
ovs_list_init(&requests);
/* Bundles need OpenFlow 1.3+. */
usable_protocols &= OFPUTIL_P_OF13_UP;
protocol = open_vconn_for_flow_mod(remote, &vconn, usable_protocols);
version = ofputil_protocol_to_ofp_version(protocol);
for (i = 0; i < n_gms; i++) {
struct ofputil_group_mod *gm = &gms[i];
struct ofpbuf *request = ofputil_encode_group_mod(version, gm,
NULL, -1);
ovs_list_push_back(&requests, &request->list_node);
ofputil_uninit_group_mod(gm);
}
bundle_transact(vconn, &requests, OFPBF_ORDERED | OFPBF_ATOMIC);
ofpbuf_list_delete(&requests);
vconn_close(vconn);
}
static void
ofctl_group_mod__(const char *remote, struct ofputil_group_mod *gms,
size_t n_gms, enum ofputil_protocol usable_protocols)
{
enum ofputil_protocol protocol;
struct ofputil_group_mod *gm;
enum ofp_version version;
struct ofpbuf *request;
struct vconn *vconn;
size_t i;
if (bundle) {
bundle_group_mod__(remote, gms, n_gms, usable_protocols);
return;
}
protocol = open_vconn_for_flow_mod(remote, &vconn, usable_protocols);
version = ofputil_protocol_to_ofp_version(protocol);
for (i = 0; i < n_gms; i++) {
gm = &gms[i];
request = ofputil_encode_group_mod(version, gm, NULL, -1);
transact_noreply(vconn, request);
ofputil_uninit_group_mod(gm);
}
vconn_close(vconn);
}
static void
ofctl_group_mod_file(int argc OVS_UNUSED, char *argv[], int command)
{
struct ofputil_group_mod *gms = NULL;
enum ofputil_protocol usable_protocols;
size_t n_gms = 0;
char *error;
if (command == OFPGC11_ADD) {
/* Allow the file to specify a mix of commands. If none specified at
* the beginning of any given line, then the default is OFPGC11_ADD, so
* this is backwards compatible. */
command = -2;
}
error = parse_ofp_group_mod_file(argv[2], ports_to_accept(argv[1]),
tables_to_accept(argv[1]),
command, &gms, &n_gms, &usable_protocols);
if (error) {
ovs_fatal(0, "%s", error);
}
ofctl_group_mod__(argv[1], gms, n_gms, usable_protocols);
free(gms);
}
static void
ofctl_group_mod(int argc, char *argv[], uint16_t command)
{
if (argc > 2 && !strcmp(argv[2], "-")) {
ofctl_group_mod_file(argc, argv, command);
} else {
enum ofputil_protocol usable_protocols;
struct ofputil_group_mod gm;
char *error;
error = parse_ofp_group_mod_str(&gm, command, argc > 2 ? argv[2] : "",
ports_to_accept(argv[1]),
tables_to_accept(argv[1]),
&usable_protocols);
if (error) {
ovs_fatal(0, "%s", error);
}
ofctl_group_mod__(argv[1], &gm, 1, usable_protocols);
}
}
static void
ofctl_add_group(struct ovs_cmdl_context *ctx)
{
ofctl_group_mod(ctx->argc, ctx->argv, OFPGC11_ADD);
}
static void
ofctl_add_groups(struct ovs_cmdl_context *ctx)
{
ofctl_group_mod_file(ctx->argc, ctx->argv, OFPGC11_ADD);
}
static void
ofctl_mod_group(struct ovs_cmdl_context *ctx)
{
ofctl_group_mod(ctx->argc, ctx->argv,
may_create ? OFPGC11_ADD_OR_MOD : OFPGC11_MODIFY);
}
static void
ofctl_del_groups(struct ovs_cmdl_context *ctx)
{
ofctl_group_mod(ctx->argc, ctx->argv, OFPGC11_DELETE);
}
static void
ofctl_insert_bucket(struct ovs_cmdl_context *ctx)
{
ofctl_group_mod(ctx->argc, ctx->argv, OFPGC15_INSERT_BUCKET);
}
static void
ofctl_remove_bucket(struct ovs_cmdl_context *ctx)
{
ofctl_group_mod(ctx->argc, ctx->argv, OFPGC15_REMOVE_BUCKET);
}
static void
ofctl_dump_group_stats(struct ovs_cmdl_context *ctx)
{
enum ofputil_protocol usable_protocols;
struct ofputil_group_mod gm;
struct ofpbuf *request;
struct vconn *vconn;
uint32_t group_id;
char *error;
memset(&gm, 0, sizeof gm);
error = parse_ofp_group_mod_str(&gm, OFPGC11_DELETE,
ctx->argc > 2 ? ctx->argv[2] : "",
ports_to_accept(ctx->argv[1]),
tables_to_accept(ctx->argv[1]),
&usable_protocols);
if (error) {
ovs_fatal(0, "%s", error);
}
group_id = gm.group_id;
open_vconn(ctx->argv[1], &vconn);
request = ofputil_encode_group_stats_request(vconn_get_version(vconn),
group_id);
if (request) {
dump_transaction(vconn, request);
}
vconn_close(vconn);
}
static void
ofctl_dump_group_desc(struct ovs_cmdl_context *ctx)
{
struct ofpbuf *request;
struct vconn *vconn;
uint32_t group_id;
open_vconn(ctx->argv[1], &vconn);
if (ctx->argc < 3 || !ofputil_group_from_string(ctx->argv[2], &group_id)) {
group_id = OFPG_ALL;
}
request = ofputil_encode_group_desc_request(vconn_get_version(vconn),
group_id);
if (request) {
dump_transaction(vconn, request);
}
vconn_close(vconn);
}
static void
ofctl_dump_group_features(struct ovs_cmdl_context *ctx)
{
struct ofpbuf *request;
struct vconn *vconn;
open_vconn(ctx->argv[1], &vconn);
request = ofputil_encode_group_features_request(vconn_get_version(vconn));
if (request) {
dump_transaction(vconn, request);
}
vconn_close(vconn);
}
static void
ofctl_bundle(struct ovs_cmdl_context *ctx)
{
enum ofputil_protocol protocol, usable_protocols;
struct ofputil_bundle_msg *bms;
struct ovs_list requests;
struct vconn *vconn;
size_t n_bms;
char *error;
error = parse_ofp_bundle_file(ctx->argv[2], ports_to_accept(ctx->argv[1]),
tables_to_accept(ctx->argv[1]),
&bms, &n_bms, &usable_protocols);
if (error) {
ovs_fatal(0, "%s", error);
}
/* Implicit OpenFlow 1.4. */
if (!(get_allowed_ofp_versions() &
ofputil_protocols_to_version_bitmap(OFPUTIL_P_OF13_UP))) {
/* Add implicit allowance for OpenFlow 1.4. */
add_allowed_ofp_versions(ofputil_protocols_to_version_bitmap(
OFPUTIL_P_OF14_OXM));
/* Remove all versions that do not support bundles. */
mask_allowed_ofp_versions(ofputil_protocols_to_version_bitmap(
OFPUTIL_P_OF13_UP));
allowed_protocols = ofputil_protocols_from_version_bitmap(
get_allowed_ofp_versions());
}
/* Bundles need OpenFlow 1.3+. */
usable_protocols &= OFPUTIL_P_OF13_UP;
protocol = open_vconn_for_flow_mod(ctx->argv[1], &vconn, usable_protocols);
ovs_list_init(&requests);
ofputil_encode_bundle_msgs(bms, n_bms, &requests, protocol);
ofputil_free_bundle_msgs(bms, n_bms);
bundle_transact(vconn, &requests, OFPBF_ORDERED | OFPBF_ATOMIC);
ofpbuf_list_delete(&requests);
vconn_close(vconn);
}
static void
ofctl_tlv_mod(struct ovs_cmdl_context *ctx, uint16_t command)
{
enum ofputil_protocol usable_protocols;
enum ofputil_protocol protocol;
struct ofputil_tlv_table_mod ttm;
char *error;
enum ofp_version version;
struct ofpbuf *request;
struct vconn *vconn;
error = parse_ofp_tlv_table_mod_str(&ttm, command, ctx->argc > 2 ?
ctx->argv[2] : "",
&usable_protocols);
if (error) {
ovs_fatal(0, "%s", error);
}
protocol = open_vconn_for_flow_mod(ctx->argv[1], &vconn, usable_protocols);
version = ofputil_protocol_to_ofp_version(protocol);
request = ofputil_encode_tlv_table_mod(version, &ttm);
if (request) {
transact_noreply(vconn, request);
}
vconn_close(vconn);
ofputil_uninit_tlv_table(&ttm.mappings);
}
static void
ofctl_add_tlv_map(struct ovs_cmdl_context *ctx)
{
ofctl_tlv_mod(ctx, NXTTMC_ADD);
}
static void
ofctl_del_tlv_map(struct ovs_cmdl_context *ctx)
{
ofctl_tlv_mod(ctx, ctx->argc > 2 ? NXTTMC_DELETE : NXTTMC_CLEAR);
}
static void
ofctl_dump_tlv_map(struct ovs_cmdl_context *ctx)
{
dump_trivial_transaction(ctx->argv[1], OFPRAW_NXT_TLV_TABLE_REQUEST);
}
static void
ofctl_help(struct ovs_cmdl_context *ctx OVS_UNUSED)
{
usage();
}
static void
ofctl_list_commands(struct ovs_cmdl_context *ctx OVS_UNUSED)
{
ovs_cmdl_print_commands(get_all_commands());
}
/* replace-flows and diff-flows commands. */
struct flow_tables {
struct classifier tables[OFPTT_MAX + 1];
};
#define FOR_EACH_TABLE(CLS, TABLES) \
for ((CLS) = (TABLES)->tables; \
(CLS) < &(TABLES)->tables[ARRAY_SIZE((TABLES)->tables)]; \
(CLS)++)
static void
flow_tables_init(struct flow_tables *tables)
{
struct classifier *cls;
FOR_EACH_TABLE (cls, tables) {
classifier_init(cls, NULL);
}
}
static void
flow_tables_defer(struct flow_tables *tables)
{
struct classifier *cls;
FOR_EACH_TABLE (cls, tables) {
classifier_defer(cls);
}
}
static void
flow_tables_publish(struct flow_tables *tables)
{
struct classifier *cls;
FOR_EACH_TABLE (cls, tables) {
classifier_publish(cls);
}
}
/* A flow table entry, possibly with two different versions. */
struct fte {
struct cls_rule rule; /* Within a "struct classifier". */
struct fte_version *versions[2];
};
/* One version of a Flow Table Entry. */
struct fte_version {
ovs_be64 cookie;
uint16_t idle_timeout;
uint16_t hard_timeout;
uint16_t importance;
uint16_t flags;
struct ofpact *ofpacts;
size_t ofpacts_len;
uint8_t table_id;
};
/* A FTE entry that has been queued for later insertion after all
* flows have been scanned to correctly allocation tunnel metadata. */
struct fte_pending {
struct minimatch match;
int priority;
struct fte_version *version;
int index;
struct ovs_list list_node;
};
/* Processing state during two stage processing of flow table entries.
* Tracks the maximum size seen for each tunnel metadata entry as well
* as a list of the pending FTE entries. */
struct fte_state {
int tun_metadata_size[TUN_METADATA_NUM_OPTS];
struct ovs_list fte_pending_list;
/* The final metadata table that we have constructed. */
struct tun_table *tun_tab;
/* Port and table map. There is only one of each, not one per source,
* because it only makes sense to display a single name for a given port
* or table number. */
const struct ofputil_port_map *port_map;
const struct ofputil_table_map *table_map;
};
/* Frees 'version' and the data that it owns. */
static void
fte_version_free(struct fte_version *version)
{
if (version) {
free(CONST_CAST(struct ofpact *, version->ofpacts));
free(version);
}
}
/* Returns true if 'a' and 'b' are the same, false if they differ.
*
* Ignores differences in 'flags' because there's no way to retrieve flags from
* an OpenFlow switch. We have to assume that they are the same. */
static bool
fte_version_equals(const struct fte_version *a, const struct fte_version *b)
{
return (a->cookie == b->cookie
&& a->idle_timeout == b->idle_timeout
&& a->hard_timeout == b->hard_timeout
&& a->importance == b->importance
&& a->table_id == b->table_id
&& ofpacts_equal_stringwise(a->ofpacts, a->ofpacts_len,
b->ofpacts, b->ofpacts_len));
}
/* Clears 's', then if 's' has a version 'index', formats 'fte' and version
* 'index' into 's', followed by a new-line. */
static void
fte_version_format(const struct fte_state *fte_state, const struct fte *fte,
int index, struct ds *s)
{
const struct fte_version *version = fte->versions[index];
ds_clear(s);
if (!version) {
return;
}
if (version->table_id) {
ds_put_format(s, "table=%"PRIu8" ", version->table_id);
}
cls_rule_format(&fte->rule, fte_state->tun_tab, fte_state->port_map, s);
if (version->cookie != htonll(0)) {
ds_put_format(s, " cookie=0x%"PRIx64, ntohll(version->cookie));
}
if (version->idle_timeout != OFP_FLOW_PERMANENT) {
ds_put_format(s, " idle_timeout=%"PRIu16, version->idle_timeout);
}
if (version->hard_timeout != OFP_FLOW_PERMANENT) {
ds_put_format(s, " hard_timeout=%"PRIu16, version->hard_timeout);
}
if (version->importance != 0) {
ds_put_format(s, " importance=%"PRIu16, version->importance);
}
ds_put_cstr(s, " actions=");
struct ofpact_format_params fp = {
.port_map = fte_state->port_map,
.s = s,
};
ofpacts_format(version->ofpacts, version->ofpacts_len, &fp);
ds_put_char(s, '\n');
}
static struct fte *
fte_from_cls_rule(const struct cls_rule *cls_rule)
{
return cls_rule ? CONTAINER_OF(cls_rule, struct fte, rule) : NULL;
}
/* Frees 'fte' and its versions. */
static void
fte_free(struct fte *fte)
{
if (fte) {
fte_version_free(fte->versions[0]);
fte_version_free(fte->versions[1]);
cls_rule_destroy(&fte->rule);
free(fte);
}
}
/* Frees all of the FTEs within 'tables'. */
static void
fte_free_all(struct flow_tables *tables)
{
struct classifier *cls;
FOR_EACH_TABLE (cls, tables) {
struct fte *fte;
classifier_defer(cls);
CLS_FOR_EACH (fte, rule, cls) {
classifier_remove_assert(cls, &fte->rule);
ovsrcu_postpone(fte_free, fte);
}
classifier_destroy(cls);
}
}
/* Searches 'tables' for an FTE matching 'rule', inserting a new one if
* necessary. Sets 'version' as the version of that rule with the given
* 'index', replacing any existing version, if any.
*
* Takes ownership of 'version'. */
static void
fte_insert(struct flow_tables *tables, const struct minimatch *match,
int priority, struct fte_version *version, int index)
{
struct classifier *cls = &tables->tables[version->table_id];
struct fte *old, *fte;
fte = xzalloc(sizeof *fte);
cls_rule_init_from_minimatch(&fte->rule, match, priority);
fte->versions[index] = version;
old = fte_from_cls_rule(classifier_replace(cls, &fte->rule,
OVS_VERSION_MIN, NULL, 0));
if (old) {
fte->versions[!index] = old->versions[!index];
old->versions[!index] = NULL;
ovsrcu_postpone(fte_free, old);
}
}
/* Given a list of the field sizes for each tunnel metadata entry, install
* a mapping table for later operations. */
static void
generate_tun_metadata(struct fte_state *state)
{
struct ofputil_tlv_table_mod ttm;
int i;
ttm.command = NXTTMC_ADD;
ovs_list_init(&ttm.mappings);
for (i = 0; i < TUN_METADATA_NUM_OPTS; i++) {
if (state->tun_metadata_size[i] != -1) {
struct ofputil_tlv_map *map = xmalloc(sizeof *map);
ovs_list_push_back(&ttm.mappings, &map->list_node);
/* We don't care about the actual option class and type since there
* won't be any lookup. We just need to make them unique. */
map->option_class = i / UINT8_MAX;
map->option_type = i;
map->option_len = ROUND_UP(state->tun_metadata_size[i], 4);
map->index = i;
}
}
tun_metadata_table_mod(&ttm, NULL, &state->tun_tab);
ofputil_uninit_tlv_table(&ttm.mappings);
}
/* Once we have created a tunnel mapping table with a consistent overall
* allocation, we need to remap each flow to use this table from its own
* allocation. Since the mapping table has already been installed, we
* can just read the data from the match and rewrite it. On rewrite, it
* will use the new table. */
static void
remap_match(struct fte_state *state, struct minimatch *minimatch)
{
int i;
if (!minimatch->tun_md || !minimatch->tun_md->valid) {
return;
}
struct match match;
minimatch_expand(minimatch, &match);
struct tun_metadata flow = match.flow.tunnel.metadata;
struct tun_metadata flow_mask = match.wc.masks.tunnel.metadata;
memset(&match.flow.tunnel.metadata, 0, sizeof match.flow.tunnel.metadata);
memset(&match.wc.masks.tunnel.metadata, 0,
sizeof match.wc.masks.tunnel.metadata);
match.tun_md.valid = false;
match.flow.tunnel.metadata.tab = state->tun_tab;
match.wc.masks.tunnel.metadata.tab = match.flow.tunnel.metadata.tab;
ULLONG_FOR_EACH_1 (i, flow_mask.present.map) {
const struct mf_field *field = mf_from_id(MFF_TUN_METADATA0 + i);
int offset = match.tun_md.entry[i].loc.c.offset;
int len = match.tun_md.entry[i].loc.len;
union mf_value value, mask;
memset(&value, 0, field->n_bytes - len);
memset(&mask, match.tun_md.entry[i].masked ? 0 : 0xff,
field->n_bytes - len);
memcpy(value.tun_metadata + field->n_bytes - len,
flow.opts.u8 + offset, len);
memcpy(mask.tun_metadata + field->n_bytes - len,
flow_mask.opts.u8 + offset, len);
mf_set(field, &value, &mask, &match, NULL);
}
minimatch_destroy(minimatch);
minimatch_init(minimatch, &match);
}
/* In order to correctly handle tunnel metadata, we need to have
* two passes over the flows. This happens because tunnel metadata
* doesn't have fixed locations in a flow entry but is instead dynamically
* allocated space. In the case of flows coming from a file, we don't
* even know the size of each field when we need to do the allocation.
* When the flows come in, each flow has an individual allocation based
* on its own fields. However, this allocation is not the same across
* different flows and therefore fields are not directly comparable.
*
* In the first pass, we record the maximum size of each tunnel metadata
* field as well as queue FTE entries for later processing.
*
* In the second pass, we use the metadata size information to create a
* tunnel mapping table and set that through the tunnel metadata processing
* code. We then remap all individual flows to use this common allocation
* scheme. Finally, we load the queued entries into the classifier for
* comparison.
*
* fte_state_init() should be called before processing any flows. */
static void
fte_state_init(struct fte_state *state)
{
int i;
for (i = 0; i < TUN_METADATA_NUM_OPTS; i++) {
state->tun_metadata_size[i] = -1;
}
ovs_list_init(&state->fte_pending_list);
state->tun_tab = NULL;
state->port_map = NULL;
state->table_map = NULL;
}
static void
fte_state_destroy(struct fte_state *state)
{
tun_metadata_free(state->tun_tab);
}
/* The first pass of the processing described in the comment about
* fte_state_init(). fte_queue() is the first pass to be called as each
* flow is read from its source. */
static void
fte_queue(struct fte_state *state, const struct minimatch *match,
int priority, struct fte_version *version, int index)
{
struct fte_pending *pending = xmalloc(sizeof *pending);
int i;
minimatch_clone(&pending->match, match);
pending->priority = priority;
pending->version = version;
pending->index = index;
ovs_list_push_back(&state->fte_pending_list, &pending->list_node);
if (!match->tun_md || !match->tun_md->valid) {
return;
}
uint64_t map = miniflow_get_tun_metadata_present_map(&match->mask->masks);
ULLONG_FOR_EACH_1 (i, map) {
if (match->tun_md->entry[i].loc.len > state->tun_metadata_size[i]) {
state->tun_metadata_size[i] = match->tun_md->entry[i].loc.len;
}
}
}
/* The second pass of the processing described in the comment about
* fte_state_init(). This should be called once all flows (from both
* sides of the comparison) have been added through fte_queue(). */
static void
fte_fill(struct fte_state *state, struct flow_tables *tables)
{
struct fte_pending *pending;
generate_tun_metadata(state);
flow_tables_init(tables);
flow_tables_defer(tables);
LIST_FOR_EACH_POP(pending, list_node, &state->fte_pending_list) {
remap_match(state, &pending->match);
fte_insert(tables, &pending->match, pending->priority,
pending->version, pending->index);
minimatch_destroy(&pending->match);
free(pending);
}
flow_tables_publish(tables);
}
/* Reads the flows in 'filename' as flow table entries in 'tables' for the
* version with the specified 'index'. Returns the flow formats able to
* represent the flows that were read. */
static enum ofputil_protocol
read_flows_from_file(const char *filename, struct fte_state *state, int index)
{
enum ofputil_protocol usable_protocols;
int line_number;
struct ds s;
FILE *file;
file = !strcmp(filename, "-") ? stdin : fopen(filename, "r");
if (file == NULL) {
ovs_fatal(errno, "%s: open", filename);
}
ds_init(&s);
usable_protocols = OFPUTIL_P_ANY;
line_number = 0;
while (!ds_get_preprocessed_line(&s, file, &line_number)) {
struct fte_version *version;
struct ofputil_flow_mod fm;
char *error;
enum ofputil_protocol usable;
error = parse_ofp_str(&fm, OFPFC_ADD, ds_cstr(&s), state->port_map,
state->table_map, &usable);
if (error) {
ovs_fatal(0, "%s:%d: %s", filename, line_number, error);
}
usable_protocols &= usable;
version = xmalloc(sizeof *version);
version->cookie = fm.new_cookie;
version->idle_timeout = fm.idle_timeout;
version->hard_timeout = fm.hard_timeout;
version->importance = fm.importance;
version->flags = fm.flags & (OFPUTIL_FF_SEND_FLOW_REM
| OFPUTIL_FF_EMERG);
version->ofpacts = fm.ofpacts;
version->ofpacts_len = fm.ofpacts_len;
version->table_id = fm.table_id != OFPTT_ALL ? fm.table_id : 0;
fte_queue(state, &fm.match, fm.priority, version, index);
minimatch_destroy(&fm.match);
}
ds_destroy(&s);
if (file != stdin) {
fclose(file);
}
return usable_protocols;
}
/* Reads the OpenFlow flow table from 'vconn', which has currently active flow
* format 'protocol', and adds them as flow table entries in 'tables' for the
* version with the specified 'index'. */
static void
read_flows_from_switch(struct vconn *vconn,
enum ofputil_protocol protocol,
struct fte_state *state, int index)
{
struct ofputil_flow_stats_request fsr;
fsr.aggregate = false;
match_init_catchall(&fsr.match);
fsr.out_port = OFPP_ANY;
fsr.out_group = OFPG_ANY;
fsr.table_id = 0xff;
fsr.cookie = fsr.cookie_mask = htonll(0);
struct ofputil_flow_stats *fses;
size_t n_fses;
run(vconn_dump_flows(vconn, &fsr, protocol, &fses, &n_fses),
"dump flows");
for (size_t i = 0; i < n_fses; i++) {
const struct ofputil_flow_stats *fs = &fses[i];
struct fte_version *version;
version = xmalloc(sizeof *version);
version->cookie = fs->cookie;
version->idle_timeout = fs->idle_timeout;
version->hard_timeout = fs->hard_timeout;
version->importance = fs->importance;
version->flags = 0;
version->ofpacts_len = fs->ofpacts_len;
version->ofpacts = xmemdup(fs->ofpacts, fs->ofpacts_len);
version->table_id = fs->table_id;
struct minimatch match;
minimatch_init(&match, &fs->match);
fte_queue(state, &match, fs->priority, version, index);
minimatch_destroy(&match);
}
for (size_t i = 0; i < n_fses; i++) {
free(CONST_CAST(struct ofpact *, fses[i].ofpacts));
}
free(fses);
}
static void
fte_make_flow_mod(const struct fte *fte, int index, uint16_t command,
enum ofputil_protocol protocol, struct ovs_list *packets)
{
const struct fte_version *version = fte->versions[index];
struct ofpbuf *ofm;
struct ofputil_flow_mod fm = {
.priority = fte->rule.priority,
.new_cookie = version->cookie,
.modify_cookie = true,
.table_id = version->table_id,
.command = command,
.idle_timeout = version->idle_timeout,
.hard_timeout = version->hard_timeout,
.importance = version->importance,
.buffer_id = UINT32_MAX,
.out_port = OFPP_ANY,
.out_group = OFPG_ANY,
.flags = version->flags,
};
minimatch_clone(&fm.match, &fte->rule.match);
if (command == OFPFC_ADD || command == OFPFC_MODIFY ||
command == OFPFC_MODIFY_STRICT) {
fm.ofpacts = version->ofpacts;
fm.ofpacts_len = version->ofpacts_len;
} else {
fm.ofpacts = NULL;
fm.ofpacts_len = 0;
}
ofm = ofputil_encode_flow_mod(&fm, protocol);
minimatch_destroy(&fm.match);
ovs_list_push_back(packets, &ofm->list_node);
}
static void
ofctl_replace_flows(struct ovs_cmdl_context *ctx)
{
enum { FILE_IDX = 0, SWITCH_IDX = 1 };
enum ofputil_protocol usable_protocols, protocol;
struct fte_state fte_state;
struct flow_tables tables;
struct classifier *cls;
struct ovs_list requests;
struct vconn *vconn;
struct fte *fte;
fte_state_init(&fte_state);
fte_state.port_map = ports_to_accept(ctx->argv[1]);
fte_state.table_map = tables_to_accept(ctx->argv[1]);
usable_protocols = read_flows_from_file(ctx->argv[2], &fte_state, FILE_IDX);
protocol = open_vconn(ctx->argv[1], &vconn);
protocol = set_protocol_for_flow_dump(vconn, protocol, usable_protocols);
read_flows_from_switch(vconn, protocol, &fte_state, SWITCH_IDX);
fte_fill(&fte_state, &tables);
ovs_list_init(&requests);
FOR_EACH_TABLE (cls, &tables) {
/* Delete flows that exist on the switch but not in the file. */
CLS_FOR_EACH (fte, rule, cls) {
struct fte_version *file_ver = fte->versions[FILE_IDX];
struct fte_version *sw_ver = fte->versions[SWITCH_IDX];
if (sw_ver && !file_ver) {
fte_make_flow_mod(fte, SWITCH_IDX, OFPFC_DELETE_STRICT,
protocol, &requests);
}
}
/* Add flows that exist in the file but not on the switch.
* Update flows that exist in both places but differ. */
CLS_FOR_EACH (fte, rule, cls) {
struct fte_version *file_ver = fte->versions[FILE_IDX];
struct fte_version *sw_ver = fte->versions[SWITCH_IDX];
if (file_ver &&
(readd || !sw_ver || !fte_version_equals(sw_ver, file_ver))) {
fte_make_flow_mod(fte, FILE_IDX, OFPFC_ADD, protocol,
&requests);
}
}
}
if (bundle) {
bundle_transact(vconn, &requests, OFPBF_ORDERED | OFPBF_ATOMIC);
} else {
transact_multiple_noreply(vconn, &requests);
}
ofpbuf_list_delete(&requests);
vconn_close(vconn);
fte_free_all(&tables);
fte_state_destroy(&fte_state);
}
static void
read_flows_from_source(const char *source, struct fte_state *state, int index)
{
struct stat s;
if (source[0] == '/' || source[0] == '.'
|| (!strchr(source, ':') && !stat(source, &s))) {
read_flows_from_file(source, state, index);
} else {
enum ofputil_protocol protocol;
struct vconn *vconn;
protocol = open_vconn(source, &vconn);
protocol = set_protocol_for_flow_dump(vconn, protocol, OFPUTIL_P_ANY);
read_flows_from_switch(vconn, protocol, state, index);
vconn_close(vconn);
if (!state->port_map) {
state->port_map = ports_to_show(source);
}
}
}
static void
ofctl_diff_flows(struct ovs_cmdl_context *ctx)
{
bool differences = false;
struct fte_state fte_state;
struct flow_tables tables;
struct classifier *cls;
struct ds a_s, b_s;
struct fte *fte;
fte_state_init(&fte_state);
read_flows_from_source(ctx->argv[1], &fte_state, 0);
read_flows_from_source(ctx->argv[2], &fte_state, 1);
fte_fill(&fte_state, &tables);
ds_init(&a_s);
ds_init(&b_s);
FOR_EACH_TABLE (cls, &tables) {
CLS_FOR_EACH (fte, rule, cls) {
struct fte_version *a = fte->versions[0];
struct fte_version *b = fte->versions[1];
if (!a || !b || !fte_version_equals(a, b)) {
fte_version_format(&fte_state, fte, 0, &a_s);
fte_version_format(&fte_state, fte, 1, &b_s);
if (a_s.length) {
printf("-%s", ds_cstr(&a_s));
}
if (b_s.length) {
printf("+%s", ds_cstr(&b_s));
}
differences = true;
}
}
}
ds_destroy(&a_s);
ds_destroy(&b_s);
fte_free_all(&tables);
fte_state_destroy(&fte_state);
if (differences) {
exit(2);
}
}
static void
ofctl_meter_mod__(const char *bridge, const char *str, int command)
{
struct ofputil_meter_mod mm;
struct vconn *vconn;
enum ofputil_protocol protocol;
enum ofputil_protocol usable_protocols;
enum ofp_version version;
memset(&mm, 0, sizeof mm);
if (str) {
char *error;
error = parse_ofp_meter_mod_str(&mm, str, command, &usable_protocols);
if (error) {
ovs_fatal(0, "%s", error);
}
} else {
usable_protocols = OFPUTIL_P_OF13_UP;
mm.command = command;
mm.meter.meter_id = OFPM13_ALL;
}
protocol = open_vconn_for_flow_mod(bridge, &vconn, usable_protocols);
version = ofputil_protocol_to_ofp_version(protocol);
transact_noreply(vconn, ofputil_encode_meter_mod(version, &mm));
free(mm.meter.bands);
vconn_close(vconn);
}
static void
ofctl_meter_request__(const char *bridge, const char *str,
enum ofputil_meter_request_type type)
{
struct ofputil_meter_mod mm;
struct vconn *vconn;
enum ofputil_protocol usable_protocols;
enum ofputil_protocol protocol;
enum ofp_version version;
memset(&mm, 0, sizeof mm);
if (str) {
char *error;
error = parse_ofp_meter_mod_str(&mm, str, -1, &usable_protocols);
if (error) {
ovs_fatal(0, "%s", error);
}
} else {
usable_protocols = OFPUTIL_P_OF13_UP;
mm.meter.meter_id = OFPM13_ALL;
}
protocol = open_vconn_for_flow_mod(bridge, &vconn, usable_protocols);
version = ofputil_protocol_to_ofp_version(protocol);
dump_transaction(vconn, ofputil_encode_meter_request(version, type,
mm.meter.meter_id));
free(mm.meter.bands);
vconn_close(vconn);
}
static void
ofctl_add_meter(struct ovs_cmdl_context *ctx)
{
ofctl_meter_mod__(ctx->argv[1], ctx->argv[2], OFPMC13_ADD);
}
static void
ofctl_mod_meter(struct ovs_cmdl_context *ctx)
{
ofctl_meter_mod__(ctx->argv[1], ctx->argv[2], OFPMC13_MODIFY);
}
static void
ofctl_del_meters(struct ovs_cmdl_context *ctx)
{
ofctl_meter_mod__(ctx->argv[1], ctx->argc > 2 ? ctx->argv[2] : NULL, OFPMC13_DELETE);
}
static void
ofctl_dump_meters(struct ovs_cmdl_context *ctx)
{
ofctl_meter_request__(ctx->argv[1], ctx->argc > 2 ? ctx->argv[2] : NULL,
OFPUTIL_METER_CONFIG);
}
static void
ofctl_meter_stats(struct ovs_cmdl_context *ctx)
{
ofctl_meter_request__(ctx->argv[1], ctx->argc > 2 ? ctx->argv[2] : NULL,
OFPUTIL_METER_STATS);
}
static void
ofctl_meter_features(struct ovs_cmdl_context *ctx)
{
ofctl_meter_request__(ctx->argv[1], NULL, OFPUTIL_METER_FEATURES);
}
/* Undocumented commands for unit testing. */
static void
ofctl_parse_flows__(struct ofputil_flow_mod *fms, size_t n_fms,
enum ofputil_protocol usable_protocols)
{
enum ofputil_protocol protocol = 0;
char *usable_s;
size_t i;
usable_s = ofputil_protocols_to_string(usable_protocols);
printf("usable protocols: %s\n", usable_s);
free(usable_s);
if (!(usable_protocols & allowed_protocols)) {
ovs_fatal(0, "no usable protocol");
}
for (i = 0; i < sizeof(enum ofputil_protocol) * CHAR_BIT; i++) {
protocol = 1 << i;
if (protocol & usable_protocols & allowed_protocols) {
break;
}
}
ovs_assert(is_pow2(protocol));
printf("chosen protocol: %s\n", ofputil_protocol_to_string(protocol));
for (i = 0; i < n_fms; i++) {
struct ofputil_flow_mod *fm = &fms[i];
struct ofpbuf *msg;
msg = ofputil_encode_flow_mod(fm, protocol);
ofp_print(stdout, msg->data, msg->size, NULL, NULL, verbosity);
ofpbuf_delete(msg);
free(CONST_CAST(struct ofpact *, fm->ofpacts));
minimatch_destroy(&fm->match);
}
}
/* "parse-flow FLOW": parses the argument as a flow (like add-flow) and prints
* it back to stdout. */
static void
ofctl_parse_flow(struct ovs_cmdl_context *ctx)
{
enum ofputil_protocol usable_protocols;
struct ofputil_flow_mod fm;
char *error;
error = parse_ofp_flow_mod_str(&fm, ctx->argv[1], NULL, NULL,
OFPFC_ADD, &usable_protocols);
if (error) {
ovs_fatal(0, "%s", error);
}
ofctl_parse_flows__(&fm, 1, usable_protocols);
}
/* "parse-flows FILENAME": reads the named file as a sequence of flows (like
* add-flows) and prints each of the flows back to stdout. */
static void
ofctl_parse_flows(struct ovs_cmdl_context *ctx)
{
enum ofputil_protocol usable_protocols;
struct ofputil_flow_mod *fms = NULL;
size_t n_fms = 0;
char *error;
error = parse_ofp_flow_mod_file(ctx->argv[1], NULL, NULL, OFPFC_ADD,
&fms, &n_fms, &usable_protocols);
if (error) {
ovs_fatal(0, "%s", error);
}
ofctl_parse_flows__(fms, n_fms, usable_protocols);
free(fms);
}
/* "parse-group GROUP": parses the argument as a group (like add-group) and
* prints it back to stdout. */
static void
ofctl_parse_group(struct ovs_cmdl_context *ctx)
{
enum ofputil_protocol usable_protocols;
struct ofputil_group_mod gm;
char *error = parse_ofp_group_mod_str(&gm, OFPGC11_ADD, ctx->argv[1], NULL,
NULL, &usable_protocols);
if (error) {
ovs_fatal(0, "%s", error);
}
char *usable_s = ofputil_protocols_to_string(usable_protocols);
printf("usable protocols: %s\n", usable_s);
free(usable_s);
if (!(usable_protocols & allowed_protocols)) {
ovs_fatal(0, "no usable protocol");
}
enum ofputil_protocol protocol = 0;
for (int i = 0; i < sizeof(enum ofputil_protocol) * CHAR_BIT; i++) {
protocol = 1 << i;
if (protocol & usable_protocols & allowed_protocols) {
break;
}
}
enum ofp_version version = ofputil_protocol_to_ofp_version(protocol);
printf("chosen version: %s\n", ofputil_version_to_string(version));
struct ofpbuf *msg = ofputil_encode_group_mod(version, &gm, NULL, false);
ofp_print(stdout, msg->data, msg->size, NULL, NULL, verbosity);
ofpbuf_delete(msg);
ofputil_uninit_group_mod(&gm);
}
static void
ofctl_parse_nxm__(bool oxm, enum ofp_version version)
{
struct ds in;
ds_init(&in);
while (!ds_get_test_line(&in, stdin)) {
struct ofpbuf nx_match;
struct match match;
ovs_be64 cookie, cookie_mask;
enum ofperr error;
int match_len;
/* Convert string to nx_match. */
ofpbuf_init(&nx_match, 0);
if (oxm) {
match_len = oxm_match_from_string(ds_cstr(&in), &nx_match);
} else {
match_len = nx_match_from_string(ds_cstr(&in), &nx_match);
}
/* Convert nx_match to match. */
if (strict) {
if (oxm) {
error = oxm_pull_match(&nx_match, false, NULL, NULL, &match);
} else {
error = nx_pull_match(&nx_match, match_len, &match, &cookie,
&cookie_mask, false, NULL, NULL);
}
} else {
if (oxm) {
error = oxm_pull_match_loose(&nx_match, false, NULL, &match);
} else {
error = nx_pull_match_loose(&nx_match, match_len, &match,
&cookie, &cookie_mask, false,
NULL);
}
}
if (!error) {
char *out;
/* Convert match back to nx_match. */
ofpbuf_uninit(&nx_match);
ofpbuf_init(&nx_match, 0);
if (oxm) {
match_len = oxm_put_match(&nx_match, &match, version);
out = oxm_match_to_string(&nx_match, match_len);
} else {
match_len = nx_put_match(&nx_match, &match,
cookie, cookie_mask);
out = nx_match_to_string(nx_match.data, match_len);
}
puts(out);
free(out);
if (verbosity > 0) {
ovs_hex_dump(stdout, nx_match.data, nx_match.size, 0, false);
}
} else {
printf("nx_pull_match() returned error %s\n",
ofperr_get_name(error));
}
ofpbuf_uninit(&nx_match);
}
ds_destroy(&in);
}
/* "parse-nxm": reads a series of NXM nx_match specifications as strings from
* stdin, does some internal fussing with them, and then prints them back as
* strings on stdout. */
static void
ofctl_parse_nxm(struct ovs_cmdl_context *ctx OVS_UNUSED)
{
ofctl_parse_nxm__(false, 0);
}
/* "parse-oxm VERSION": reads a series of OXM nx_match specifications as
* strings from stdin, does some internal fussing with them, and then prints
* them back as strings on stdout. VERSION must specify an OpenFlow version,
* e.g. "OpenFlow12". */
static void
ofctl_parse_oxm(struct ovs_cmdl_context *ctx)
{
enum ofp_version version = ofputil_version_from_string(ctx->argv[1]);
if (version < OFP12_VERSION) {
ovs_fatal(0, "%s: not a valid version for OXM", ctx->argv[1]);
}
ofctl_parse_nxm__(true, version);
}
static void
print_differences(const char *prefix,
const void *a_, size_t a_len,
const void *b_, size_t b_len)
{
const uint8_t *a = a_;
const uint8_t *b = b_;
size_t i;
for (i = 0; i < MIN(a_len, b_len); i++) {
if (a[i] != b[i]) {
printf("%s%2"PRIuSIZE": %02"PRIx8" -> %02"PRIx8"\n",
prefix, i, a[i], b[i]);
}
}
for (i = a_len; i < b_len; i++) {
printf("%s%2"PRIuSIZE": (none) -> %02"PRIx8"\n", prefix, i, b[i]);
}
for (i = b_len; i < a_len; i++) {
printf("%s%2"PRIuSIZE": %02"PRIx8" -> (none)\n", prefix, i, a[i]);
}
}
static void
ofctl_parse_actions__(const char *version_s, bool instructions)
{
enum ofp_version version;
struct ds in;
version = ofputil_version_from_string(version_s);
if (!version) {
ovs_fatal(0, "%s: not a valid OpenFlow version", version_s);
}
ds_init(&in);
while (!ds_get_preprocessed_line(&in, stdin, NULL)) {
struct ofpbuf of_out;
struct ofpbuf of_in;
struct ofpbuf ofpacts;
const char *table_id;
char *actions;
enum ofperr error;
size_t size;
struct ds s;
/* Parse table_id separated with the follow-up actions by ",", if
* any. */
actions = ds_cstr(&in);
table_id = NULL;
if (strstr(actions, ",")) {
table_id = strsep(&actions, ",");
}
/* Parse hex bytes. */
ofpbuf_init(&of_in, 0);
if (ofpbuf_put_hex(&of_in, actions, NULL)[0] != '\0') {
ovs_fatal(0, "Trailing garbage in hex data");
}
/* Convert to ofpacts. */
ofpbuf_init(&ofpacts, 0);
size = of_in.size;
error = (instructions
? ofpacts_pull_openflow_instructions
: ofpacts_pull_openflow_actions)(
&of_in, of_in.size, version, NULL, NULL, &ofpacts);
if (!error && instructions) {
/* Verify actions, enforce consistency. */
struct match match = MATCH_CATCHALL_INITIALIZER;
struct ofpact_check_params cp = {
.match = &match,
.max_ports = OFPP_MAX,
.table_id = table_id ? atoi(table_id) : 0,
.n_tables = OFPTT_MAX + 1,
};
error = ofpacts_check_consistency(
ofpacts.data, ofpacts.size,
ofputil_protocols_from_ofp_version(version), &cp);
}
if (error) {
printf("bad %s %s: %s\n\n",
version_s, instructions ? "instructions" : "actions",
ofperr_get_name(error));
ofpbuf_uninit(&ofpacts);
ofpbuf_uninit(&of_in);
continue;
}
ofpbuf_push_uninit(&of_in, size);
/* Print cls_rule. */
ds_init(&s);
ds_put_cstr(&s, "actions=");
struct ofpact_format_params fp = { .s = &s };
ofpacts_format(ofpacts.data, ofpacts.size, &fp);
puts(ds_cstr(&s));
ds_destroy(&s);
/* Convert back to ofp10 actions and print differences from input. */
ofpbuf_init(&of_out, 0);
if (instructions) {
ofpacts_put_openflow_instructions(ofpacts.data, ofpacts.size,
&of_out, version);
} else {
ofpacts_put_openflow_actions(ofpacts.data, ofpacts.size,
&of_out, version);
}
print_differences("", of_in.data, of_in.size,
of_out.data, of_out.size);
putchar('\n');
ofpbuf_uninit(&ofpacts);
ofpbuf_uninit(&of_in);
ofpbuf_uninit(&of_out);
}
ds_destroy(&in);
}
/* "parse-actions VERSION": reads a series of action specifications for the
* given OpenFlow VERSION as hex bytes from stdin, converts them to ofpacts,
* prints them as strings on stdout, and then converts them back to hex bytes
* and prints any differences from the input. */
static void
ofctl_parse_actions(struct ovs_cmdl_context *ctx)
{
ofctl_parse_actions__(ctx->argv[1], false);
}
/* "parse-actions VERSION": reads a series of instruction specifications for
* the given OpenFlow VERSION as hex bytes from stdin, converts them to
* ofpacts, prints them as strings on stdout, and then converts them back to
* hex bytes and prints any differences from the input. */
static void
ofctl_parse_instructions(struct ovs_cmdl_context *ctx)
{
ofctl_parse_actions__(ctx->argv[1], true);
}
/* "parse-ofp10-match": reads a series of ofp10_match specifications as hex
* bytes from stdin, converts them to cls_rules, prints them as strings on
* stdout, and then converts them back to hex bytes and prints any differences
* from the input.
*
* The input hex bytes may contain "x"s to represent "don't-cares", bytes whose
* values are ignored in the input and will be set to zero when OVS converts
* them back to hex bytes. ovs-ofctl actually sets "x"s to random bits when
* it does the conversion to hex, to ensure that in fact they are ignored. */
static void
ofctl_parse_ofp10_match(struct ovs_cmdl_context *ctx OVS_UNUSED)
{
struct ds expout;
struct ds in;
ds_init(&in);
ds_init(&expout);
while (!ds_get_preprocessed_line(&in, stdin, NULL)) {
struct ofpbuf match_in, match_expout;
struct ofp10_match match_out;
struct ofp10_match match_normal;
struct match match;
char *p;
/* Parse hex bytes to use for expected output. */
ds_clear(&expout);
ds_put_cstr(&expout, ds_cstr(&in));
for (p = ds_cstr(&expout); *p; p++) {
if (*p == 'x') {
*p = '0';
}
}
ofpbuf_init(&match_expout, 0);
if (ofpbuf_put_hex(&match_expout, ds_cstr(&expout), NULL)[0] != '\0') {
ovs_fatal(0, "Trailing garbage in hex data");
}
if (match_expout.size != sizeof(struct ofp10_match)) {
ovs_fatal(0, "Input is %"PRIu32" bytes, expected %"PRIuSIZE,
match_expout.size, sizeof(struct ofp10_match));
}
/* Parse hex bytes for input. */
for (p = ds_cstr(&in); *p; p++) {
if (*p == 'x') {
*p = "0123456789abcdef"[random_uint32() & 0xf];
}
}
ofpbuf_init(&match_in, 0);
if (ofpbuf_put_hex(&match_in, ds_cstr(&in), NULL)[0] != '\0') {
ovs_fatal(0, "Trailing garbage in hex data");
}
if (match_in.size != sizeof(struct ofp10_match)) {
ovs_fatal(0, "Input is %"PRIu32" bytes, expected %"PRIuSIZE,
match_in.size, sizeof(struct ofp10_match));
}
/* Convert to cls_rule and print. */
ofputil_match_from_ofp10_match(match_in.data, &match);
match_print(&match, NULL);
/* Convert back to ofp10_match and print differences from input. */
ofputil_match_to_ofp10_match(&match, &match_out);
print_differences("", match_expout.data, match_expout.size,
&match_out, sizeof match_out);
/* Normalize, then convert and compare again. */
ofputil_normalize_match(&match);
ofputil_match_to_ofp10_match(&match, &match_normal);
print_differences("normal: ", &match_out, sizeof match_out,
&match_normal, sizeof match_normal);
putchar('\n');
ofpbuf_uninit(&match_in);
ofpbuf_uninit(&match_expout);
}
ds_destroy(&in);
ds_destroy(&expout);
}
/* "parse-ofp11-match": reads a series of ofp11_match specifications as hex
* bytes from stdin, converts them to "struct match"es, prints them as strings
* on stdout, and then converts them back to hex bytes and prints any
* differences from the input. */
static void
ofctl_parse_ofp11_match(struct ovs_cmdl_context *ctx OVS_UNUSED)
{
struct ds in;
ds_init(&in);
while (!ds_get_preprocessed_line(&in, stdin, NULL)) {
struct ofpbuf match_in;
struct ofp11_match match_out;
struct match match;
enum ofperr error;
/* Parse hex bytes. */
ofpbuf_init(&match_in, 0);
if (ofpbuf_put_hex(&match_in, ds_cstr(&in), NULL)[0] != '\0') {
ovs_fatal(0, "Trailing garbage in hex data");
}
if (match_in.size != sizeof(struct ofp11_match)) {
ovs_fatal(0, "Input is %"PRIu32" bytes, expected %"PRIuSIZE,
match_in.size, sizeof(struct ofp11_match));
}
/* Convert to match. */
error = ofputil_match_from_ofp11_match(match_in.data, &match);
if (error) {
printf("bad ofp11_match: %s\n\n", ofperr_get_name(error));
ofpbuf_uninit(&match_in);
continue;
}
/* Print match. */
match_print(&match, NULL);
/* Convert back to ofp11_match and print differences from input. */
ofputil_match_to_ofp11_match(&match, &match_out);
print_differences("", match_in.data, match_in.size,
&match_out, sizeof match_out);
putchar('\n');
ofpbuf_uninit(&match_in);
}
ds_destroy(&in);
}
/* "parse-pcap PCAP...": read packets from each PCAP file and print their
* flows. */
static void
ofctl_parse_pcap(struct ovs_cmdl_context *ctx)
{
int error = 0;
for (int i = 1; i < ctx->argc; i++) {
const char *filename = ctx->argv[i];
struct pcap_file *pcap = ovs_pcap_open(filename, "rb");
if (!pcap) {
error = errno;
ovs_error(error, "%s: open failed", filename);
continue;
}
for (;;) {
struct dp_packet *packet;
struct flow flow;
int retval;
retval = ovs_pcap_read(pcap, &packet, NULL);
if (retval == EOF) {
break;
} else if (retval) {
error = retval;
ovs_error(error, "%s: read failed", filename);
break;
}
pkt_metadata_init(&packet->md, u32_to_odp(ofp_to_u16(OFPP_ANY)));
flow_extract(packet, &flow);
flow_print(stdout, &flow, NULL);
putchar('\n');
dp_packet_delete(packet);
}
ovs_pcap_close(pcap);
}
exit(error);
}
/* "check-vlan VLAN_TCI VLAN_TCI_MASK": converts the specified vlan_tci and
* mask values to and from various formats and prints the results. */
static void
ofctl_check_vlan(struct ovs_cmdl_context *ctx)
{
struct match match;
char *string_s;
struct ofputil_flow_mod fm;
struct ofpbuf nxm;
struct match nxm_match;
int nxm_match_len;
char *nxm_s;
struct ofp10_match of10_raw;
struct match of10_match;
struct ofp11_match of11_raw;
struct match of11_match;
enum ofperr error;
char *error_s;
enum ofputil_protocol usable_protocols; /* Unused for now. */
match_init_catchall(&match);
match.flow.vlans[0].tci = htons(strtoul(ctx->argv[1], NULL, 16));
match.wc.masks.vlans[0].tci = htons(strtoul(ctx->argv[2], NULL, 16));
/* Convert to and from string. */
string_s = match_to_string(&match, NULL, OFP_DEFAULT_PRIORITY);
printf("%s -> ", string_s);
fflush(stdout);
error_s = parse_ofp_str(&fm, -1, string_s, NULL, NULL, &usable_protocols);
if (error_s) {
ovs_fatal(0, "%s", error_s);
}
struct match fm_match;
minimatch_expand(&fm.match, &fm_match);
printf("%04"PRIx16"/%04"PRIx16"\n",
ntohs(fm_match.flow.vlans[0].tci),
ntohs(fm_match.wc.masks.vlans[0].tci));
free(string_s);
minimatch_destroy(&fm.match);
/* Convert to and from NXM. */
ofpbuf_init(&nxm, 0);
nxm_match_len = nx_put_match(&nxm, &match, htonll(0), htonll(0));
nxm_s = nx_match_to_string(nxm.data, nxm_match_len);
error = nx_pull_match(&nxm, nxm_match_len, &nxm_match, NULL, NULL, false,
NULL, NULL);
printf("NXM: %s -> ", nxm_s);
if (error) {
printf("%s\n", ofperr_to_string(error));
} else {
printf("%04"PRIx16"/%04"PRIx16"\n",
ntohs(nxm_match.flow.vlans[0].tci),
ntohs(nxm_match.wc.masks.vlans[0].tci));
}
free(nxm_s);
ofpbuf_uninit(&nxm);
/* Convert to and from OXM. */
ofpbuf_init(&nxm, 0);
nxm_match_len = oxm_put_match(&nxm, &match, OFP12_VERSION);
nxm_s = oxm_match_to_string(&nxm, nxm_match_len);
error = oxm_pull_match(&nxm, false, NULL, NULL, &nxm_match);
printf("OXM: %s -> ", nxm_s);
if (error) {
printf("%s\n", ofperr_to_string(error));
} else {
uint16_t vid = ntohs(nxm_match.flow.vlans[0].tci) &
(VLAN_VID_MASK | VLAN_CFI);
uint16_t mask = ntohs(nxm_match.wc.masks.vlans[0].tci) &
(VLAN_VID_MASK | VLAN_CFI);
printf("%04"PRIx16"/%04"PRIx16",", vid, mask);
if (vid && vlan_tci_to_pcp(nxm_match.wc.masks.vlans[0].tci)) {
printf("%02d\n", vlan_tci_to_pcp(nxm_match.flow.vlans[0].tci));
} else {
printf("--\n");
}
}
free(nxm_s);
ofpbuf_uninit(&nxm);
/* Convert to and from OpenFlow 1.0. */
ofputil_match_to_ofp10_match(&match, &of10_raw);
ofputil_match_from_ofp10_match(&of10_raw, &of10_match);
printf("OF1.0: %04"PRIx16"/%d,%02"PRIx8"/%d -> %04"PRIx16"/%04"PRIx16"\n",
ntohs(of10_raw.dl_vlan),
(of10_raw.wildcards & htonl(OFPFW10_DL_VLAN)) != 0,
of10_raw.dl_vlan_pcp,
(of10_raw.wildcards & htonl(OFPFW10_DL_VLAN_PCP)) != 0,
ntohs(of10_match.flow.vlans[0].tci),
ntohs(of10_match.wc.masks.vlans[0].tci));
/* Convert to and from OpenFlow 1.1. */
ofputil_match_to_ofp11_match(&match, &of11_raw);
ofputil_match_from_ofp11_match(&of11_raw, &of11_match);
printf("OF1.1: %04"PRIx16"/%d,%02"PRIx8"/%d -> %04"PRIx16"/%04"PRIx16"\n",
ntohs(of11_raw.dl_vlan),
(of11_raw.wildcards & htonl(OFPFW11_DL_VLAN)) != 0,
of11_raw.dl_vlan_pcp,
(of11_raw.wildcards & htonl(OFPFW11_DL_VLAN_PCP)) != 0,
ntohs(of11_match.flow.vlans[0].tci),
ntohs(of11_match.wc.masks.vlans[0].tci));
}
/* "print-error ENUM": Prints the type and code of ENUM for every OpenFlow
* version. */
static void
ofctl_print_error(struct ovs_cmdl_context *ctx)
{
enum ofperr error;
int version;
error = ofperr_from_name(ctx->argv[1]);
if (!error) {
ovs_fatal(0, "unknown error \"%s\"", ctx->argv[1]);
}
for (version = 0; version <= UINT8_MAX; version++) {
const char *name = ofperr_domain_get_name(version);
if (name) {
int vendor = ofperr_get_vendor(error, version);
int type = ofperr_get_type(error, version);
int code = ofperr_get_code(error, version);
if (vendor != -1 || type != -1 || code != -1) {
printf("%s: vendor %#x, type %d, code %d\n",
name, vendor, type, code);
}
}
}
}
/* "encode-error-reply ENUM REQUEST": Encodes an error reply to REQUEST for the
* error named ENUM and prints the error reply in hex. */
static void
ofctl_encode_error_reply(struct ovs_cmdl_context *ctx)
{
const struct ofp_header *oh;
struct ofpbuf request, *reply;
enum ofperr error;
error = ofperr_from_name(ctx->argv[1]);
if (!error) {
ovs_fatal(0, "unknown error \"%s\"", ctx->argv[1]);
}
ofpbuf_init(&request, 0);
if (ofpbuf_put_hex(&request, ctx->argv[2], NULL)[0] != '\0') {
ovs_fatal(0, "Trailing garbage in hex data");
}
if (request.size < sizeof(struct ofp_header)) {
ovs_fatal(0, "Request too short");
}
oh = request.data;
if (request.size != ntohs(oh->length)) {
ovs_fatal(0, "Request size inconsistent");
}
reply = ofperr_encode_reply(error, request.data);
ofpbuf_uninit(&request);
ovs_hex_dump(stdout, reply->data, reply->size, 0, false);
ofpbuf_delete(reply);
}
/* Usage:
* ofp-print HEXSTRING [VERBOSITY]
* ofp-print - [VERBOSITY] < HEXSTRING_FILE
* ofp-print --raw - [VERBOSITY] < RAW_FILE
*
* Converts the hex digits in HEXSTRING into binary data, interpreting them as
* an OpenFlow message, and prints the OpenFlow message on stdout, at VERBOSITY
* (level 2 by default). With -, hex data is read from HEXSTRING_FILE, and
* with --raw -, raw binary data is read from RAW_FILE. */
static void
ofctl_ofp_print(struct ovs_cmdl_context *ctx)
{
int verbosity_ = ctx->argc > 2 ? atoi(ctx->argv[2]) : 2;
struct ofpbuf packet;
ofpbuf_init(&packet, 0);
char *buffer = NULL;
if (!strcmp(ctx->argv[1], "-")) {
if (raw) {
for (;;) {
int c = getchar();
if (c == EOF) {
break;
}
ofpbuf_put(&packet, &c, 1);
}
} else {
struct ds line = DS_EMPTY_INITIALIZER;
if (ds_get_line(&line, stdin)) {
VLOG_FATAL("Failed to read stdin");
}
buffer = ds_steal_cstr(&line);
}
} else {
buffer = xstrdup(ctx->argv[1]);
}
if (buffer && ofpbuf_put_hex(&packet, buffer, NULL)[0] != '\0') {
ovs_fatal(0, "trailing garbage following hex bytes");
}
free(buffer);
ofp_print(stdout, packet.data, packet.size, NULL, NULL, verbosity_);
ofpbuf_uninit(&packet);
}
/* "encode-hello BITMAP...": Encodes each BITMAP as an OpenFlow hello message
* and dumps each message in hex. */
static void
ofctl_encode_hello(struct ovs_cmdl_context *ctx)
{
uint32_t bitmap = strtol(ctx->argv[1], NULL, 0);
struct ofpbuf *hello;
hello = ofputil_encode_hello(bitmap);
ovs_hex_dump(stdout, hello->data, hello->size, 0, false);
ofp_print(stdout, hello->data, hello->size, NULL, NULL, verbosity);
ofpbuf_delete(hello);
}
static void
ofctl_parse_key_value(struct ovs_cmdl_context *ctx)
{
for (size_t i = 1; i < ctx->argc; i++) {
char *s = ctx->argv[i];
char *key, *value;
int j = 0;
while (ofputil_parse_key_value(&s, &key, &value)) {
if (j++) {
fputs(", ", stdout);
}
fputs(key, stdout);
if (value[0]) {
printf("=%s", value);
}
}
putchar('\n');
}
}
/* "compose-packet [--pcap] FLOW [L7]": Converts the OpenFlow flow
* specification FLOW to a packet with flow_compose() and prints the hex bytes
* in the packet on stdout. Also verifies that the flow extracted from that
* packet matches the original FLOW.
*
* With --pcap, prints the packet to stdout instead as a pcap file, so that you
* can do something like "ovs-ofctl --pcap compose-packet udp | tcpdump -vvvv
* -r-" to use another tool to dump the packet contents.
*
* If L7 is specified, draws the L7 payload data from it, otherwise defaults to
* 64 bytes of payload. */
static void
ofctl_compose_packet(struct ovs_cmdl_context *ctx)
{
if (print_pcap && isatty(STDOUT_FILENO)) {
ovs_fatal(1, "not writing pcap data to stdout; redirect to a file "
"or pipe to tcpdump instead");
}
struct flow flow1;
char *error = parse_ofp_exact_flow(&flow1, NULL, NULL, ctx->argv[1], NULL);
if (error) {
ovs_fatal(0, "%s", error);
}
struct dp_packet p;
memset(&p, 0, sizeof p);
dp_packet_init(&p, 0);
void *l7 = NULL;
size_t l7_len = 64;
if (ctx->argc > 2) {
struct dp_packet payload;
memset(&payload, 0, sizeof payload);
dp_packet_init(&payload, 0);
if (dp_packet_put_hex(&payload, ctx->argv[2], NULL)[0] != '\0') {
ovs_fatal(0, "%s: trailing garbage in packet data", ctx->argv[2]);
}
l7_len = dp_packet_size(&payload);
l7 = dp_packet_steal_data(&payload);
}
flow_compose(&p, &flow1, l7, l7_len);
free(l7);
if (print_pcap) {
struct pcap_file *p_file = ovs_pcap_stdout();
ovs_pcap_write_header(p_file);
ovs_pcap_write(p_file, &p);
ovs_pcap_close(p_file);
} else {
ovs_hex_dump(stdout, dp_packet_data(&p), dp_packet_size(&p), 0, false);
}
struct flow flow2;
flow_extract(&p, &flow2);
flow2.in_port.ofp_port = OFPP_ANY;
dp_packet_uninit(&p);
if (!flow_equal(&flow1, &flow2)) {
fprintf(stderr, "specified and extracted flows differ:\n");
fputs("specified: ", stderr);
flow_print(stderr, &flow1, NULL);
fputs("\nextracted: ", stderr);
flow_print(stderr, &flow2, NULL);
exit(1);
}
}
/* "parse-packet" reads an Ethernet packet from stdin and prints it out its
* extracted flow fields. */
static void
ofctl_parse_packet(struct ovs_cmdl_context *ctx OVS_UNUSED)
{
char packet[65535];
ssize_t size = read(STDIN_FILENO, packet, sizeof packet);
if (size < 0) {
ovs_fatal(errno, "failed to read packet from stdin");
}
/* Make a copy of the packet in allocated memory to better allow Valgrind
* and Address Sanitizer to catch out-of-range access. */
void *packet_copy = xmemdup(packet, size);
ofp_print_packet(stdout, packet_copy, size, 0);
free(packet_copy);
}
static const struct ovs_cmdl_command all_commands[] = {
{ "show", "switch",
1, 1, ofctl_show, OVS_RO },
{ "monitor", "switch [misslen] [invalid_ttl] [watch:[...]]",
1, 3, ofctl_monitor, OVS_RO },
{ "snoop", "switch",
1, 1, ofctl_snoop, OVS_RO },
{ "dump-desc", "switch",
1, 1, ofctl_dump_desc, OVS_RO },
{ "dump-tables", "switch",
1, 1, ofctl_dump_tables, OVS_RO },
{ "dump-table-features", "switch",
1, 1, ofctl_dump_table_features, OVS_RO },
{ "dump-table-desc", "switch",
1, 1, ofctl_dump_table_desc, OVS_RO },
{ "dump-flows", "switch",
1, 2, ofctl_dump_flows, OVS_RO },
{ "dump-aggregate", "switch",
1, 2, ofctl_dump_aggregate, OVS_RO },
{ "queue-stats", "switch [port [queue]]",
1, 3, ofctl_queue_stats, OVS_RO },
{ "queue-get-config", "switch [port [queue]]",
1, 3, ofctl_queue_get_config, OVS_RO },
{ "add-flow", "switch flow",
2, 2, ofctl_add_flow, OVS_RW },
{ "add-flows", "switch file",
2, 2, ofctl_add_flows, OVS_RW },
{ "mod-flows", "switch flow",
2, 2, ofctl_mod_flows, OVS_RW },
{ "del-flows", "switch [flow]",
1, 2, ofctl_del_flows, OVS_RW },
{ "replace-flows", "switch file",
2, 2, ofctl_replace_flows, OVS_RW },
{ "diff-flows", "source1 source2",
2, 2, ofctl_diff_flows, OVS_RW },
{ "add-meter", "switch meter",
2, 2, ofctl_add_meter, OVS_RW },
{ "mod-meter", "switch meter",
2, 2, ofctl_mod_meter, OVS_RW },
{ "del-meter", "switch meter",
1, 2, ofctl_del_meters, OVS_RW },
{ "del-meters", "switch",
1, 2, ofctl_del_meters, OVS_RW },
{ "dump-meter", "switch meter",
1, 2, ofctl_dump_meters, OVS_RO },
{ "dump-meters", "switch",
1, 2, ofctl_dump_meters, OVS_RO },
{ "meter-stats", "switch [meter]",
1, 2, ofctl_meter_stats, OVS_RO },
{ "meter-features", "switch",
1, 1, ofctl_meter_features, OVS_RO },
{ "packet-out", "switch \"in_port=<port> packet=<hex data> actions=...\"",
2, INT_MAX, ofctl_packet_out, OVS_RW },
{ "dump-ports", "switch [port]",
1, 2, ofctl_dump_ports, OVS_RO },
{ "dump-ports-desc", "switch [port]",
1, 2, ofctl_dump_ports_desc, OVS_RO },
{ "mod-port", "switch iface act",
3, 3, ofctl_mod_port, OVS_RW },
{ "mod-table", "switch mod",
3, 3, ofctl_mod_table, OVS_RW },
{ "get-frags", "switch",
1, 1, ofctl_get_frags, OVS_RO },
{ "set-frags", "switch frag_mode",
2, 2, ofctl_set_frags, OVS_RW },
{ "probe", "target",
1, 1, ofctl_probe, OVS_RO },
{ "ping", "target [n]",
1, 2, ofctl_ping, OVS_RO },
{ "benchmark", "target n count",
3, 3, ofctl_benchmark, OVS_RO },
{ "dump-ipfix-bridge", "switch",
1, 1, ofctl_dump_ipfix_bridge, OVS_RO },
{ "dump-ipfix-flow", "switch",
1, 1, ofctl_dump_ipfix_flow, OVS_RO },
{ "ct-flush-zone", "switch zone",
2, 2, ofctl_ct_flush_zone, OVS_RO },
{ "ofp-parse", "file",
1, 1, ofctl_ofp_parse, OVS_RW },
{ "ofp-parse-pcap", "pcap",
1, INT_MAX, ofctl_ofp_parse_pcap, OVS_RW },
{ "add-group", "switch group",
1, 2, ofctl_add_group, OVS_RW },
{ "add-groups", "switch file",
2, 2, ofctl_add_groups, OVS_RW },
{ "mod-group", "switch group",
1, 2, ofctl_mod_group, OVS_RW },
{ "del-groups", "switch [group]",
1, 2, ofctl_del_groups, OVS_RW },
{ "insert-buckets", "switch [group]",
1, 2, ofctl_insert_bucket, OVS_RW },
{ "remove-buckets", "switch [group]",
1, 2, ofctl_remove_bucket, OVS_RW },
{ "dump-groups", "switch [group]",
1, 2, ofctl_dump_group_desc, OVS_RO },
{ "dump-group-stats", "switch [group]",
1, 2, ofctl_dump_group_stats, OVS_RO },
{ "dump-group-features", "switch",
1, 1, ofctl_dump_group_features, OVS_RO },
{ "bundle", "switch file",
2, 2, ofctl_bundle, OVS_RW },
{ "add-tlv-map", "switch map",
2, 2, ofctl_add_tlv_map, OVS_RO },
{ "del-tlv-map", "switch [map]",
1, 2, ofctl_del_tlv_map, OVS_RO },
{ "dump-tlv-map", "switch",
1, 1, ofctl_dump_tlv_map, OVS_RO },
{ "help", NULL, 0, INT_MAX, ofctl_help, OVS_RO },
{ "list-commands", NULL, 0, INT_MAX, ofctl_list_commands, OVS_RO },
/* Undocumented commands for testing. */
{ "parse-flow", NULL, 1, 1, ofctl_parse_flow, OVS_RW },
{ "parse-flows", NULL, 1, 1, ofctl_parse_flows, OVS_RW },
{ "parse-group", NULL, 1, 1, ofctl_parse_group, OVS_RW },
{ "parse-nx-match", NULL, 0, 0, ofctl_parse_nxm, OVS_RW },
{ "parse-nxm", NULL, 0, 0, ofctl_parse_nxm, OVS_RW },
{ "parse-oxm", NULL, 1, 1, ofctl_parse_oxm, OVS_RW },
{ "parse-actions", NULL, 1, 1, ofctl_parse_actions, OVS_RW },
{ "parse-instructions", NULL, 1, 1, ofctl_parse_instructions, OVS_RW },
{ "parse-ofp10-match", NULL, 0, 0, ofctl_parse_ofp10_match, OVS_RW },
{ "parse-ofp11-match", NULL, 0, 0, ofctl_parse_ofp11_match, OVS_RW },
{ "parse-pcap", NULL, 1, INT_MAX, ofctl_parse_pcap, OVS_RW },
{ "check-vlan", NULL, 2, 2, ofctl_check_vlan, OVS_RW },
{ "print-error", NULL, 1, 1, ofctl_print_error, OVS_RW },
{ "encode-error-reply", NULL, 2, 2, ofctl_encode_error_reply, OVS_RW },
{ "ofp-print", NULL, 1, 2, ofctl_ofp_print, OVS_RW },
{ "encode-hello", NULL, 1, 1, ofctl_encode_hello, OVS_RW },
{ "parse-key-value", NULL, 1, INT_MAX, ofctl_parse_key_value, OVS_RW },
{ "compose-packet", NULL, 1, 2, ofctl_compose_packet, OVS_RO },
{ "parse-packet", NULL, 0, 0, ofctl_parse_packet, OVS_RO },
{ NULL, NULL, 0, 0, NULL, OVS_RO },
};
static const struct ovs_cmdl_command *get_all_commands(void)
{
return all_commands;
}
Reference in New Issue View Git Blame Copy Permalink