[ovs.git] / utilities / ovs-controller.c

/*
 * Copyright (c) 2008, 2009, 2010, 2011 Nicira Networks.
 *
 * 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 <errno.h>
#include <getopt.h>
#include <limits.h>
#include <signal.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#include "command-line.h"
#include "compiler.h"
#include "daemon.h"
#include "learning-switch.h"
#include "ofp-parse.h"
#include "ofpbuf.h"
#include "openflow/openflow.h"
#include "poll-loop.h"
#include "rconn.h"
#include "shash.h"
#include "stream-ssl.h"
#include "timeval.h"
#include "unixctl.h"
#include "util.h"
#include "vconn.h"
#include "vlog.h"

VLOG_DEFINE_THIS_MODULE(controller);

#define MAX_SWITCHES 16
#define MAX_LISTENERS 16

struct switch_ {
    struct lswitch *lswitch;
    struct rconn *rconn;
};

/* -H, --hub: Learn the ports on which MAC addresses appear? */
static bool learn_macs = true;

/* -n, --noflow: Set up flows?  (If not, every packet is processed at the
 * controller.) */
static bool set_up_flows = true;

/* -N, --normal: Use "NORMAL" action instead of explicit port? */
static bool action_normal = false;

/* -w, --wildcard: Set up exact match or wildcard flow entries? */
static bool exact_flows = true;

/* --max-idle: Maximum idle time, in seconds, before flows expire. */
static int max_idle = 60;

/* --mute: If true, accept connections from switches but do not reply to any
 * of their messages (for debugging fail-open mode). */
static bool mute = false;

/* -q, --queue: default OpenFlow queue, none if UINT32_MAX. */
static uint32_t default_queue = UINT32_MAX;

/* -Q, --port-queue: map from port name to port number (cast to void *). */
static struct shash port_queues = SHASH_INITIALIZER(&port_queues);

/* --with-flows: Flows to send to switch, or an empty list not to send any
 * default flows. */
static struct list default_flows = LIST_INITIALIZER(&default_flows);

/* --unixctl: Name of unixctl socket, or null to use the default. */
static char *unixctl_path = NULL;

static int do_switching(struct switch_ *);
static void new_switch(struct switch_ *, struct vconn *);
static void parse_options(int argc, char *argv[]);
static void usage(void) NO_RETURN;

int
main(int argc, char *argv[])
{
    struct unixctl_server *unixctl;
    struct switch_ switches[MAX_SWITCHES];
    struct pvconn *listeners[MAX_LISTENERS];
    int n_switches, n_listeners;
    int retval;
    int i;

    proctitle_init(argc, argv);
    set_program_name(argv[0]);
    parse_options(argc, argv);
    signal(SIGPIPE, SIG_IGN);

    if (argc - optind < 1) {
        ovs_fatal(0, "at least one vconn argument required; "
                  "use --help for usage");
    }

    n_switches = n_listeners = 0;
    for (i = optind; i < argc; i++) {
        const char *name = argv[i];
        struct vconn *vconn;

        retval = vconn_open(name, OFP_VERSION, &vconn);
        if (!retval) {
            if (n_switches >= MAX_SWITCHES) {
                ovs_fatal(0, "max %d switch connections", n_switches);
            }
            new_switch(&switches[n_switches++], vconn);
            continue;
        } else if (retval == EAFNOSUPPORT) {
            struct pvconn *pvconn;
            retval = pvconn_open(name, &pvconn);
            if (!retval) {
                if (n_listeners >= MAX_LISTENERS) {
                    ovs_fatal(0, "max %d passive connections", n_listeners);
                }
                listeners[n_listeners++] = pvconn;
            }
        }
        if (retval) {
            VLOG_ERR("%s: connect: %s", name, strerror(retval));
        }
    }
    if (n_switches == 0 && n_listeners == 0) {
        ovs_fatal(0, "no active or passive switch connections");
    }

    daemonize_start();

    retval = unixctl_server_create(unixctl_path, &unixctl);
    if (retval) {
        exit(EXIT_FAILURE);
    }

    daemonize_complete();

    while (n_switches > 0 || n_listeners > 0) {
        int iteration;

        /* Accept connections on listening vconns. */
        for (i = 0; i < n_listeners && n_switches < MAX_SWITCHES; ) {
            struct vconn *new_vconn;

            retval = pvconn_accept(listeners[i], OFP_VERSION, &new_vconn);
            if (!retval || retval == EAGAIN) {
                if (!retval) {
                    new_switch(&switches[n_switches++], new_vconn);
                }
                i++;
            } else {
                pvconn_close(listeners[i]);
                listeners[i] = listeners[--n_listeners];
            }
        }

        /* Do some switching work.  Limit the number of iterations so that
         * callbacks registered with the poll loop don't starve. */
        for (iteration = 0; iteration < 50; iteration++) {
            bool progress = false;
            for (i = 0; i < n_switches; ) {
                struct switch_ *this = &switches[i];

                retval = do_switching(this);
                if (!retval || retval == EAGAIN) {
                    if (!retval) {
                        progress = true;
                    }
                    i++;
                } else {
                    rconn_destroy(this->rconn);
                    lswitch_destroy(this->lswitch);
                    switches[i] = switches[--n_switches];
                }
            }
            if (!progress) {
                break;
            }
        }
        for (i = 0; i < n_switches; i++) {
            struct switch_ *this = &switches[i];
            lswitch_run(this->lswitch);
        }

        unixctl_server_run(unixctl);

        /* Wait for something to happen. */
        if (n_switches < MAX_SWITCHES) {
            for (i = 0; i < n_listeners; i++) {
                pvconn_wait(listeners[i]);
            }
        }
        for (i = 0; i < n_switches; i++) {
            struct switch_ *sw = &switches[i];
            rconn_run_wait(sw->rconn);
            rconn_recv_wait(sw->rconn);
            lswitch_wait(sw->lswitch);
        }
        unixctl_server_wait(unixctl);
        poll_block();
    }

    return 0;
}

static void
new_switch(struct switch_ *sw, struct vconn *vconn)
{
    struct lswitch_config cfg;

    sw->rconn = rconn_create(60, 0);
    rconn_connect_unreliably(sw->rconn, vconn, NULL);

    cfg.mode = (action_normal ? LSW_NORMAL
                : learn_macs ? LSW_LEARN
                : LSW_FLOOD);
    cfg.max_idle = set_up_flows ? max_idle : -1;
    cfg.default_flows = &default_flows;
    cfg.default_queue = default_queue;
    cfg.port_queues = &port_queues;
    sw->lswitch = lswitch_create(sw->rconn, &cfg);
}

static int
do_switching(struct switch_ *sw)
{
    unsigned int packets_sent;
    struct ofpbuf *msg;

    packets_sent = rconn_packets_sent(sw->rconn);

    msg = rconn_recv(sw->rconn);
    if (msg) {
        if (!mute) {
            lswitch_process_packet(sw->lswitch, sw->rconn, msg);
        }
        ofpbuf_delete(msg);
    }
    rconn_run(sw->rconn);

    return (!rconn_is_alive(sw->rconn) ? EOF
            : rconn_packets_sent(sw->rconn) != packets_sent ? 0
            : EAGAIN);
}

static void
read_flow_file(const char *name)
{
    enum nx_flow_format flow_format;
    FILE *stream;

    stream = fopen(optarg, "r");
    if (!stream) {
        ovs_fatal(errno, "%s: open", name);
    }

    flow_format = NXFF_OPENFLOW10;
    while (parse_ofp_flow_mod_file(&default_flows, &flow_format, stream,
                                   OFPFC_ADD)) {
        continue;
    }

    fclose(stream);
}

static void
add_port_queue(char *s)
{
    char *save_ptr = NULL;
    char *port_name;
    char *queue_id;

    port_name = strtok_r(s, ":", &save_ptr);
    queue_id = strtok_r(NULL, "", &save_ptr);
    if (!queue_id) {
        ovs_fatal(0, "argument to -Q or --port-queue should take the form "
                  "\"<port-name>:<queue-id>\"");
    }

    if (!shash_add_once(&port_queues, port_name,
                        (void *) (uintptr_t) atoi(queue_id))) {
        ovs_fatal(0, "<port-name> arguments for -Q or --port-queue must "
                  "be unique");
    }
}

static void
parse_options(int argc, char *argv[])
{
    enum {
        OPT_MAX_IDLE = UCHAR_MAX + 1,
        OPT_PEER_CA_CERT,
        OPT_MUTE,
        OPT_WITH_FLOWS,
        OPT_UNIXCTL,
        VLOG_OPTION_ENUMS,
        DAEMON_OPTION_ENUMS
    };
    static struct option long_options[] = {
        {"hub",         no_argument, 0, 'H'},
        {"noflow",      no_argument, 0, 'n'},
        {"normal",      no_argument, 0, 'N'},
        {"wildcard",    no_argument, 0, 'w'},
        {"max-idle",    required_argument, 0, OPT_MAX_IDLE},
        {"mute",        no_argument, 0, OPT_MUTE},
        {"queue",       required_argument, 0, 'q'},
        {"port-queue",  required_argument, 0, 'Q'},
        {"with-flows",  required_argument, 0, OPT_WITH_FLOWS},
        {"unixctl",     required_argument, 0, OPT_UNIXCTL},
        {"help",        no_argument, 0, 'h'},
        {"version",     no_argument, 0, 'V'},
        DAEMON_LONG_OPTIONS,
        VLOG_LONG_OPTIONS,
        STREAM_SSL_LONG_OPTIONS,
        {"peer-ca-cert", required_argument, 0, OPT_PEER_CA_CERT},
        {0, 0, 0, 0},
    };
    char *short_options = long_options_to_short_options(long_options);

    for (;;) {
        int indexptr;
        int c;

        c = getopt_long(argc, argv, short_options, long_options, &indexptr);
        if (c == -1) {
            break;
        }

        switch (c) {
        case 'H':
            learn_macs = false;
            break;

        case 'n':
            set_up_flows = false;
            break;

        case OPT_MUTE:
            mute = true;
            break;

        case 'N':
            action_normal = true;
            break;

        case 'w':
            exact_flows = false;
            break;

        case OPT_MAX_IDLE:
            if (!strcmp(optarg, "permanent")) {
                max_idle = OFP_FLOW_PERMANENT;
            } else {
                max_idle = atoi(optarg);
                if (max_idle < 1 || max_idle > 65535) {
                    ovs_fatal(0, "--max-idle argument must be between 1 and "
                              "65535 or the word 'permanent'");
                }
            }
            break;

        case 'q':
            default_queue = atoi(optarg);
            break;

        case 'Q':
            add_port_queue(optarg);
            break;

        case OPT_WITH_FLOWS:
            read_flow_file(optarg);
            break;

        case OPT_UNIXCTL:
            unixctl_path = optarg;
            break;

        case 'h':
            usage();

        case 'V':
            OVS_PRINT_VERSION(OFP_VERSION, OFP_VERSION);
            exit(EXIT_SUCCESS);

        VLOG_OPTION_HANDLERS
        DAEMON_OPTION_HANDLERS

        STREAM_SSL_OPTION_HANDLERS

        case OPT_PEER_CA_CERT:
            stream_ssl_set_peer_ca_cert_file(optarg);
            break;

        case '?':
            exit(EXIT_FAILURE);

        default:
            abort();
        }
    }
    free(short_options);

    if (!shash_is_empty(&port_queues) || default_queue != UINT32_MAX) {
        if (action_normal) {
            ovs_error(0, "queue IDs are incompatible with -N or --normal; "
                      "not using OFPP_NORMAL");
            action_normal = false;
        }

        if (!learn_macs) {
            ovs_error(0, "queue IDs are incompatible with -H or --hub; "
                      "not acting as hub");
            learn_macs = true;
        }
    }
}

static void
usage(void)
{
    printf("%s: OpenFlow controller\n"
           "usage: %s [OPTIONS] METHOD\n"
           "where METHOD is any OpenFlow connection method.\n",
           program_name, program_name);
    vconn_usage(true, true, false);
    daemon_usage();
    vlog_usage();
    printf("\nOther options:\n"
           "  -H, --hub               act as hub instead of learning switch\n"
           "  -n, --noflow            pass traffic, but don't add flows\n"
           "  --max-idle=SECS         max idle time for new flows\n"
           "  -N, --normal            use OFPP_NORMAL action\n"
           "  -w, --wildcard          use wildcards, not exact-match rules\n"
           "  -q, --queue=QUEUE-ID    OpenFlow queue ID to use for output\n"
           "  -Q PORT-NAME:QUEUE-ID   use QUEUE-ID for frames from PORT-NAME\n"
           "  --with-flows FILE       use the flows from FILE\n"
           "  --unixctl=SOCKET        override default control socket name\n"
           "  -h, --help              display this help message\n"
           "  -V, --version           display version information\n");
    exit(EXIT_SUCCESS);
}
Commit	Line	Data
064af421	1	/*
8274ae95	2	* Copyright (c) 2008, 2009, 2010, 2011 Nicira Networks.
064af421	3	*
a14bc59f BP	4	* Licensed under the Apache License, Version 2.0 (the "License");
	5	* you may not use this file except in compliance with the License.
	6	* You may obtain a copy of the License at:
064af421	7	*
a14bc59f BP	8	* http://www.apache.org/licenses/LICENSE-2.0
	9	*
	10	* Unless required by applicable law or agreed to in writing, software
	11	* distributed under the License is distributed on an "AS IS" BASIS,
	12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	13	* See the License for the specific language governing permissions and
	14	* limitations under the License.
064af421 BP	15	*/
	16
	17	#include <config.h>
	18
	19	#include <errno.h>
	20	#include <getopt.h>
	21	#include <limits.h>
	22	#include <signal.h>
	23	#include <stdlib.h>
882c2399	24	#include <stdio.h>
064af421 BP	25	#include <string.h>
	26
	27	#include "command-line.h"
	28	#include "compiler.h"
	29	#include "daemon.h"
064af421	30	#include "learning-switch.h"
09913dfd	31	#include "ofp-parse.h"
064af421 BP	32	#include "ofpbuf.h"
	33	#include "openflow/openflow.h"
	34	#include "poll-loop.h"
	35	#include "rconn.h"
d4cdc6b4	36	#include "shash.h"
fe55ad15	37	#include "stream-ssl.h"
064af421 BP	38	#include "timeval.h"
	39	#include "unixctl.h"
	40	#include "util.h"
064af421	41	#include "vconn.h"
064af421	42	#include "vlog.h"
5136ce49	43
d98e6007	44	VLOG_DEFINE_THIS_MODULE(controller);
064af421 BP	45
	46	#define MAX_SWITCHES 16
	47	#define MAX_LISTENERS 16
	48
	49	struct switch_ {
	50	struct lswitch *lswitch;
	51	struct rconn *rconn;
	52	};
	53
d4cdc6b4	54	/* -H, --hub: Learn the ports on which MAC addresses appear? */
064af421 BP	55	static bool learn_macs = true;
064af421 BP	56
d4cdc6b4 BP	57	/* -n, --noflow: Set up flows? (If not, every packet is processed at the
d4cdc6b4 BP	58	* controller.) */
d6fbec6d	59	static bool set_up_flows = true;
064af421	60
9af9e2e8 JT	61	/* -N, --normal: Use "NORMAL" action instead of explicit port? */
	62	static bool action_normal = false;
	63
	64	/* -w, --wildcard: Set up exact match or wildcard flow entries? */
	65	static bool exact_flows = true;
	66
064af421 BP	67	/* --max-idle: Maximum idle time, in seconds, before flows expire. */
	68	static int max_idle = 60;
	69
7778bd15 BP	70	/* --mute: If true, accept connections from switches but do not reply to any
	71	* of their messages (for debugging fail-open mode). */
	72	static bool mute = false;
	73
d4cdc6b4 BP	74	/* -q, --queue: default OpenFlow queue, none if UINT32_MAX. */
	75	static uint32_t default_queue = UINT32_MAX;
	76
	77	/* -Q, --port-queue: map from port name to port number (cast to void ). /
	78	static struct shash port_queues = SHASH_INITIALIZER(&port_queues);
611e9a35	79
b3907fbc BP	80	/* --with-flows: Flows to send to switch, or an empty list not to send any
	81	* default flows. */
	82	static struct list default_flows = LIST_INITIALIZER(&default_flows);
882c2399	83
b66bdf30 BP	84	/* --unixctl: Name of unixctl socket, or null to use the default. */
	85	static char *unixctl_path = NULL;
	86
064af421	87	static int do_switching(struct switch_ *);
58bdd092	88	static void new_switch(struct switch_ , struct vconn );
064af421 BP	89	static void parse_options(int argc, char *argv[]);
	90	static void usage(void) NO_RETURN;
	91
	92	int
	93	main(int argc, char *argv[])
	94	{
	95	struct unixctl_server *unixctl;
	96	struct switch_ switches[MAX_SWITCHES];
	97	struct pvconn *listeners[MAX_LISTENERS];
	98	int n_switches, n_listeners;
	99	int retval;
	100	int i;
	101
40f0707c	102	proctitle_init(argc, argv);
064af421	103	set_program_name(argv[0]);
064af421 BP	104	parse_options(argc, argv);
	105	signal(SIGPIPE, SIG_IGN);
	106
	107	if (argc - optind < 1) {
	108	ovs_fatal(0, "at least one vconn argument required; "
	109	"use --help for usage");
	110	}
	111
	112	n_switches = n_listeners = 0;
	113	for (i = optind; i < argc; i++) {
	114	const char *name = argv[i];
	115	struct vconn *vconn;
064af421 BP	116
	117	retval = vconn_open(name, OFP_VERSION, &vconn);
	118	if (!retval) {
	119	if (n_switches >= MAX_SWITCHES) {
	120	ovs_fatal(0, "max %d switch connections", n_switches);
	121	}
58bdd092	122	new_switch(&switches[n_switches++], vconn);
064af421 BP	123	continue;
	124	} else if (retval == EAFNOSUPPORT) {
	125	struct pvconn *pvconn;
	126	retval = pvconn_open(name, &pvconn);
	127	if (!retval) {
	128	if (n_listeners >= MAX_LISTENERS) {
	129	ovs_fatal(0, "max %d passive connections", n_listeners);
	130	}
	131	listeners[n_listeners++] = pvconn;
	132	}
	133	}
	134	if (retval) {
	135	VLOG_ERR("%s: connect: %s", name, strerror(retval));
	136	}
	137	}
	138	if (n_switches == 0 && n_listeners == 0) {
	139	ovs_fatal(0, "no active or passive switch connections");
	140	}
	141
95440284	142	daemonize_start();
064af421	143
b66bdf30	144	retval = unixctl_server_create(unixctl_path, &unixctl);
064af421	145	if (retval) {
4d12270a	146	exit(EXIT_FAILURE);
064af421 BP	147	}
064af421 BP	148
95440284 BP	149	daemonize_complete();
95440284 BP	150
064af421 BP	151	while (n_switches > 0 \|\| n_listeners > 0) {
064af421 BP	152	int iteration;
064af421 BP	153
	154	/* Accept connections on listening vconns. */
	155	for (i = 0; i < n_listeners && n_switches < MAX_SWITCHES; ) {
	156	struct vconn *new_vconn;
064af421 BP	157
	158	retval = pvconn_accept(listeners[i], OFP_VERSION, &new_vconn);
	159	if (!retval \|\| retval == EAGAIN) {
	160	if (!retval) {
58bdd092	161	new_switch(&switches[n_switches++], new_vconn);
064af421 BP	162	}
	163	i++;
	164	} else {
	165	pvconn_close(listeners[i]);
	166	listeners[i] = listeners[--n_listeners];
	167	}
	168	}
	169
	170	/* Do some switching work. Limit the number of iterations so that
	171	* callbacks registered with the poll loop don't starve. */
	172	for (iteration = 0; iteration < 50; iteration++) {
	173	bool progress = false;
	174	for (i = 0; i < n_switches; ) {
	175	struct switch_ *this = &switches[i];
2a022368 BP	176
2a022368 BP	177	retval = do_switching(this);
064af421 BP	178	if (!retval \|\| retval == EAGAIN) {
	179	if (!retval) {
	180	progress = true;
	181	}
	182	i++;
	183	} else {
	184	rconn_destroy(this->rconn);
	185	lswitch_destroy(this->lswitch);
	186	switches[i] = switches[--n_switches];
	187	}
	188	}
	189	if (!progress) {
	190	break;
	191	}
	192	}
	193	for (i = 0; i < n_switches; i++) {
	194	struct switch_ *this = &switches[i];
ba186119	195	lswitch_run(this->lswitch);
064af421 BP	196	}
	197
	198	unixctl_server_run(unixctl);
	199
	200	/* Wait for something to happen. */
	201	if (n_switches < MAX_SWITCHES) {
	202	for (i = 0; i < n_listeners; i++) {
	203	pvconn_wait(listeners[i]);
	204	}
	205	}
	206	for (i = 0; i < n_switches; i++) {
	207	struct switch_ *sw = &switches[i];
	208	rconn_run_wait(sw->rconn);
	209	rconn_recv_wait(sw->rconn);
	210	lswitch_wait(sw->lswitch);
	211	}
	212	unixctl_server_wait(unixctl);
	213	poll_block();
	214	}
	215
	216	return 0;
	217	}
	218
	219	static void
58bdd092	220	new_switch(struct switch_ sw, struct vconn vconn)
064af421	221	{
ad67e568 BP	222	struct lswitch_config cfg;
ad67e568 BP	223
9794e806	224	sw->rconn = rconn_create(60, 0);
eb15cdbb	225	rconn_connect_unreliably(sw->rconn, vconn, NULL);
882c2399	226
ad67e568 BP	227	cfg.mode = (action_normal ? LSW_NORMAL
	228	: learn_macs ? LSW_LEARN
	229	: LSW_FLOOD);
	230	cfg.max_idle = set_up_flows ? max_idle : -1;
b3907fbc	231	cfg.default_flows = &default_flows;
d4cdc6b4 BP	232	cfg.default_queue = default_queue;
d4cdc6b4 BP	233	cfg.port_queues = &port_queues;
ad67e568	234	sw->lswitch = lswitch_create(sw->rconn, &cfg);
064af421 BP	235	}
	236
	237	static int
	238	do_switching(struct switch_ *sw)
	239	{
	240	unsigned int packets_sent;
	241	struct ofpbuf *msg;
	242
	243	packets_sent = rconn_packets_sent(sw->rconn);
	244
	245	msg = rconn_recv(sw->rconn);
	246	if (msg) {
7778bd15 BP	247	if (!mute) {
	248	lswitch_process_packet(sw->lswitch, sw->rconn, msg);
	249	}
064af421 BP	250	ofpbuf_delete(msg);
	251	}
	252	rconn_run(sw->rconn);
	253
	254	return (!rconn_is_alive(sw->rconn) ? EOF
	255	: rconn_packets_sent(sw->rconn) != packets_sent ? 0
	256	: EAGAIN);
	257	}
	258
09913dfd BP	259	static void
	260	read_flow_file(const char *name)
	261	{
88ca35ee	262	enum nx_flow_format flow_format;
09913dfd BP	263	FILE *stream;
	264
	265	stream = fopen(optarg, "r");
	266	if (!stream) {
	267	ovs_fatal(errno, "%s: open", name);
	268	}
	269
88ca35ee	270	flow_format = NXFF_OPENFLOW10;
02c5617b BP	271	while (parse_ofp_flow_mod_file(&default_flows, &flow_format, stream,
02c5617b BP	272	OFPFC_ADD)) {
88ca35ee	273	continue;
09913dfd BP	274	}
	275
	276	fclose(stream);
	277	}
	278
d4cdc6b4 BP	279	static void
	280	add_port_queue(char *s)
	281	{
	282	char *save_ptr = NULL;
	283	char *port_name;
	284	char *queue_id;
	285
	286	port_name = strtok_r(s, ":", &save_ptr);
	287	queue_id = strtok_r(NULL, "", &save_ptr);
	288	if (!queue_id) {
	289	ovs_fatal(0, "argument to -Q or --port-queue should take the form "
	290	"\"<port-name>:<queue-id>\"");
	291	}
	292
	293	if (!shash_add_once(&port_queues, port_name,
	294	(void *) (uintptr_t) atoi(queue_id))) {
	295	ovs_fatal(0, "<port-name> arguments for -Q or --port-queue must "
	296	"be unique");
	297	}
	298	}
	299
064af421 BP	300	static void
	301	parse_options(int argc, char *argv[])
	302	{
	303	enum {
	304	OPT_MAX_IDLE = UCHAR_MAX + 1,
	305	OPT_PEER_CA_CERT,
7778bd15	306	OPT_MUTE,
882c2399	307	OPT_WITH_FLOWS,
b66bdf30	308	OPT_UNIXCTL,
8274ae95 BP	309	VLOG_OPTION_ENUMS,
8274ae95 BP	310	DAEMON_OPTION_ENUMS
064af421 BP	311	};
	312	static struct option long_options[] = {
	313	{"hub", no_argument, 0, 'H'},
	314	{"noflow", no_argument, 0, 'n'},
9af9e2e8 JT	315	{"normal", no_argument, 0, 'N'},
9af9e2e8 JT	316	{"wildcard", no_argument, 0, 'w'},
064af421	317	{"max-idle", required_argument, 0, OPT_MAX_IDLE},
7778bd15	318	{"mute", no_argument, 0, OPT_MUTE},
611e9a35	319	{"queue", required_argument, 0, 'q'},
d4cdc6b4	320	{"port-queue", required_argument, 0, 'Q'},
882c2399	321	{"with-flows", required_argument, 0, OPT_WITH_FLOWS},
b66bdf30	322	{"unixctl", required_argument, 0, OPT_UNIXCTL},
064af421 BP	323	{"help", no_argument, 0, 'h'},
	324	{"version", no_argument, 0, 'V'},
	325	DAEMON_LONG_OPTIONS,
	326	VLOG_LONG_OPTIONS,
bf8f2167	327	STREAM_SSL_LONG_OPTIONS,
064af421	328	{"peer-ca-cert", required_argument, 0, OPT_PEER_CA_CERT},
064af421 BP	329	{0, 0, 0, 0},
	330	};
	331	char *short_options = long_options_to_short_options(long_options);
	332
	333	for (;;) {
	334	int indexptr;
	335	int c;
	336
	337	c = getopt_long(argc, argv, short_options, long_options, &indexptr);
	338	if (c == -1) {
	339	break;
	340	}
	341
	342	switch (c) {
	343	case 'H':
	344	learn_macs = false;
	345	break;
	346
	347	case 'n':
d6fbec6d	348	set_up_flows = false;
064af421 BP	349	break;
064af421 BP	350
7778bd15 BP	351	case OPT_MUTE:
	352	mute = true;
	353	break;
	354
9af9e2e8 JT	355	case 'N':
	356	action_normal = true;
	357	break;
	358
	359	case 'w':
	360	exact_flows = false;
	361	break;
	362
064af421 BP	363	case OPT_MAX_IDLE:
	364	if (!strcmp(optarg, "permanent")) {
	365	max_idle = OFP_FLOW_PERMANENT;
	366	} else {
	367	max_idle = atoi(optarg);
	368	if (max_idle < 1 \|\| max_idle > 65535) {
	369	ovs_fatal(0, "--max-idle argument must be between 1 and "
	370	"65535 or the word 'permanent'");
	371	}
	372	}
	373	break;
	374
611e9a35	375	case 'q':
d4cdc6b4 BP	376	default_queue = atoi(optarg);
	377	break;
	378
	379	case 'Q':
	380	add_port_queue(optarg);
611e9a35 BP	381	break;
611e9a35 BP	382
882c2399	383	case OPT_WITH_FLOWS:
09913dfd	384	read_flow_file(optarg);
882c2399 JP	385	break;
882c2399 JP	386
b66bdf30 BP	387	case OPT_UNIXCTL:
	388	unixctl_path = optarg;
	389	break;
	390
064af421 BP	391	case 'h':
	392	usage();
	393
	394	case 'V':
	395	OVS_PRINT_VERSION(OFP_VERSION, OFP_VERSION);
	396	exit(EXIT_SUCCESS);
	397
	398	VLOG_OPTION_HANDLERS
	399	DAEMON_OPTION_HANDLERS
	400
fe55ad15	401	STREAM_SSL_OPTION_HANDLERS
064af421 BP	402
064af421 BP	403	case OPT_PEER_CA_CERT:
fe55ad15	404	stream_ssl_set_peer_ca_cert_file(optarg);
064af421	405	break;
064af421 BP	406
	407	case '?':
	408	exit(EXIT_FAILURE);
	409
	410	default:
	411	abort();
	412	}
	413	}
	414	free(short_options);
d4cdc6b4 BP	415
	416	if (!shash_is_empty(&port_queues) \|\| default_queue != UINT32_MAX) {
	417	if (action_normal) {
	418	ovs_error(0, "queue IDs are incompatible with -N or --normal; "
	419	"not using OFPP_NORMAL");
	420	action_normal = false;
	421	}
	422
	423	if (!learn_macs) {
	424	ovs_error(0, "queue IDs are incompatible with -H or --hub; "
	425	"not acting as hub");
	426	learn_macs = true;
	427	}
	428	}
064af421 BP	429	}
	430
	431	static void
	432	usage(void)
	433	{
	434	printf("%s: OpenFlow controller\n"
	435	"usage: %s [OPTIONS] METHOD\n"
	436	"where METHOD is any OpenFlow connection method.\n",
	437	program_name, program_name);
	438	vconn_usage(true, true, false);
	439	daemon_usage();
	440	vlog_usage();
	441	printf("\nOther options:\n"
	442	" -H, --hub act as hub instead of learning switch\n"
	443	" -n, --noflow pass traffic, but don't add flows\n"
	444	" --max-idle=SECS max idle time for new flows\n"
d4cdc6b4	445	" -N, --normal use OFPP_NORMAL action\n"
9af9e2e8	446	" -w, --wildcard use wildcards, not exact-match rules\n"
d4cdc6b4 BP	447	" -q, --queue=QUEUE-ID OpenFlow queue ID to use for output\n"
d4cdc6b4 BP	448	" -Q PORT-NAME:QUEUE-ID use QUEUE-ID for frames from PORT-NAME\n"
882c2399	449	" --with-flows FILE use the flows from FILE\n"
b66bdf30	450	" --unixctl=SOCKET override default control socket name\n"
064af421 BP	451	" -h, --help display this help message\n"
	452	" -V, --version display version information\n");
	453	exit(EXIT_SUCCESS);
	454	}