X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=ovsdb%2Fovsdb-server.c;h=8412cbb91655013769c9b46085a215529dc12ed3;hb=a890678229e7e72703ef3b27d8a98ccd9d7c4446;hp=7c4b73306cfcba2ca1a45eb0615d0d3b1147794c;hpb=ada496b5cc123fca2913be8b73097934f528cec8;p=openvswitch diff --git a/ovsdb/ovsdb-server.c b/ovsdb/ovsdb-server.c index 7c4b7330..8412cbb9 100644 --- a/ovsdb/ovsdb-server.c +++ b/ovsdb/ovsdb-server.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2009, 2010 Nicira Networks +/* Copyright (c) 2009, 2010, 2011, 2012 Nicira, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -15,8 +15,7 @@ #include -#include "ovsdb.h" - +#include #include #include #include @@ -25,40 +24,58 @@ #include "column.h" #include "command-line.h" #include "daemon.h" +#include "dirs.h" #include "file.h" +#include "hash.h" #include "json.h" #include "jsonrpc.h" #include "jsonrpc-server.h" #include "leak-checker.h" #include "list.h" +#include "memory.h" +#include "ovsdb.h" #include "ovsdb-data.h" #include "ovsdb-types.h" #include "ovsdb-error.h" #include "poll-loop.h" #include "process.h" #include "row.h" +#include "simap.h" #include "stream-ssl.h" #include "stream.h" -#include "svec.h" +#include "stress.h" +#include "sset.h" #include "table.h" #include "timeval.h" +#include "transaction.h" #include "trigger.h" #include "util.h" #include "unixctl.h" - #include "vlog.h" -#define THIS_MODULE VLM_ovsdb_server + +VLOG_DEFINE_THIS_MODULE(ovsdb_server); + +/* SSL configuration. */ +static char *private_key_file; +static char *certificate_file; +static char *ca_cert_file; +static bool bootstrap_ca_cert; static unixctl_cb_func ovsdb_server_exit; static unixctl_cb_func ovsdb_server_compact; +static unixctl_cb_func ovsdb_server_reconnect; static void parse_options(int argc, char *argv[], char **file_namep, - struct shash *remotes, char **unixctl_pathp, + struct sset *remotes, char **unixctl_pathp, char **run_command); static void usage(void) NO_RETURN; -static void set_remotes(struct ovsdb_jsonrpc_server *jsonrpc, - const struct ovsdb *db, struct shash *remotes); +static void reconfigure_from_db(struct ovsdb_jsonrpc_server *jsonrpc, + const struct ovsdb *db, struct sset *remotes); + +static void update_remote_status(const struct ovsdb_jsonrpc_server *jsonrpc, + const struct sset *remotes, + struct ovsdb *db); int main(int argc, char *argv[]) @@ -67,7 +84,7 @@ main(int argc, char *argv[]) char *run_command = NULL; struct unixctl_server *unixctl; struct ovsdb_jsonrpc_server *jsonrpc; - struct shash remotes; + struct sset remotes; struct ovsdb_error *error; struct ovsdb_file *file; struct ovsdb *db; @@ -75,27 +92,29 @@ main(int argc, char *argv[]) char *file_name; bool exiting; int retval; + long long int status_timer = LLONG_MIN; proctitle_init(argc, argv); set_program_name(argv[0]); - time_init(); - vlog_init(); + stress_init_command(); signal(SIGPIPE, SIG_IGN); process_init(); parse_options(argc, argv, &file_name, &remotes, &unixctl_path, &run_command); - die_if_already_running(); daemonize_start(); + VLOG_INFO("%s (Open vSwitch) %s", program_name, VERSION); + error = ovsdb_file_open(file_name, false, &db, &file); if (error) { ovs_fatal(0, "%s", ovsdb_error_to_string(error)); } + free(file_name); jsonrpc = ovsdb_jsonrpc_server_create(db); - set_remotes(jsonrpc, db, &remotes); + reconfigure_from_db(jsonrpc, db, &remotes); retval = unixctl_server_create(unixctl_path, &unixctl); if (retval) { @@ -120,13 +139,26 @@ main(int argc, char *argv[]) daemonize_complete(); - unixctl_command_register("exit", ovsdb_server_exit, &exiting); - unixctl_command_register("ovsdb-server/compact", ovsdb_server_compact, - file); + unixctl_command_register("exit", "", 0, 0, ovsdb_server_exit, &exiting); + unixctl_command_register("ovsdb-server/compact", "", 0, 0, + ovsdb_server_compact, file); + unixctl_command_register("ovsdb-server/reconnect", "", 0, 0, + ovsdb_server_reconnect, jsonrpc); exiting = false; while (!exiting) { - set_remotes(jsonrpc, db, &remotes); + memory_run(); + if (memory_should_report()) { + struct simap usage; + + simap_init(&usage); + ovsdb_jsonrpc_server_get_memory_usage(jsonrpc, &usage); + ovsdb_get_memory_usage(db, &usage); + memory_report(&usage); + simap_destroy(&usage); + } + + reconfigure_from_db(jsonrpc, db, &remotes); ovsdb_jsonrpc_server_run(jsonrpc); unixctl_server_run(unixctl); ovsdb_trigger_run(db, time_msec()); @@ -134,17 +166,28 @@ main(int argc, char *argv[]) exiting = true; } + /* update Manager status(es) every 5 seconds */ + if (time_msec() >= status_timer) { + status_timer = time_msec() + 5000; + update_remote_status(jsonrpc, &remotes, db); + } + + memory_wait(); ovsdb_jsonrpc_server_wait(jsonrpc); unixctl_server_wait(unixctl); ovsdb_trigger_wait(db, time_msec()); if (run_process) { process_wait(run_process); } + if (exiting) { + poll_immediate_wake(); + } + poll_timer_wait_until(status_timer); poll_block(); } ovsdb_jsonrpc_server_destroy(jsonrpc); ovsdb_destroy(db); - shash_destroy(&remotes); + sset_destroy(&remotes); unixctl_server_destroy(unixctl); if (run_process && process_exited(run_process)) { @@ -159,13 +202,14 @@ main(int argc, char *argv[]) } static void -query_db_remotes(const char *name_, const struct ovsdb *db, - struct shash *remotes) +parse_db_column(const struct ovsdb *db, + const char *name_, + const struct ovsdb_table **tablep, + const struct ovsdb_column **columnp) { char *name, *table_name, *column_name; const struct ovsdb_column *column; const struct ovsdb_table *table; - const struct ovsdb_row *row; char *save_ptr = NULL; name = xstrdup(name_); @@ -173,74 +217,467 @@ query_db_remotes(const char *name_, const struct ovsdb *db, table_name = strtok_r(NULL, ",", &save_ptr); column_name = strtok_r(NULL, ",", &save_ptr); if (!table_name || !column_name) { - ovs_fatal(0, "remote \"%s\": invalid syntax", name_); + ovs_fatal(0, "\"%s\": invalid syntax", name_); } table = ovsdb_get_table(db, table_name); if (!table) { - ovs_fatal(0, "remote \"%s\": no table named %s", name_, table_name); + ovs_fatal(0, "\"%s\": no table named %s", name_, table_name); } column = ovsdb_table_schema_get_column(table->schema, column_name); if (!column) { - ovs_fatal(0, "remote \"%s\": table \"%s\" has no column \"%s\"", + ovs_fatal(0, "\"%s\": table \"%s\" has no column \"%s\"", name_, table_name, column_name); } + free(name); + + *columnp = column; + *tablep = table; +} + +static void +parse_db_string_column(const struct ovsdb *db, + const char *name, + const struct ovsdb_table **tablep, + const struct ovsdb_column **columnp) +{ + const struct ovsdb_column *column; + const struct ovsdb_table *table; + + parse_db_column(db, name, &table, &column); if (column->type.key.type != OVSDB_TYPE_STRING || column->type.value.type != OVSDB_TYPE_VOID) { - ovs_fatal(0, "remote \"%s\": type of table \"%s\" column \"%s\" is " + ovs_fatal(0, "\"%s\": table \"%s\" column \"%s\" is " "not string or set of strings", - name_, table_name, column_name); + name, table->schema->name, column->name); + } + + *columnp = column; + *tablep = table; +} + +static OVS_UNUSED const char * +query_db_string(const struct ovsdb *db, const char *name) +{ + if (!name || strncmp(name, "db:", 3)) { + return name; + } else { + const struct ovsdb_column *column; + const struct ovsdb_table *table; + const struct ovsdb_row *row; + + parse_db_string_column(db, name, &table, &column); + + HMAP_FOR_EACH (row, hmap_node, &table->rows) { + const struct ovsdb_datum *datum; + size_t i; + + datum = &row->fields[column->index]; + for (i = 0; i < datum->n; i++) { + if (datum->keys[i].string[0]) { + return datum->keys[i].string; + } + } + } + return NULL; + } +} + +static struct ovsdb_jsonrpc_options * +add_remote(struct shash *remotes, const char *target) +{ + struct ovsdb_jsonrpc_options *options; + + options = shash_find_data(remotes, target); + if (!options) { + options = ovsdb_jsonrpc_default_options(target); + shash_add(remotes, target, options); + } + + return options; +} + +static struct ovsdb_datum * +get_datum(struct ovsdb_row *row, const char *column_name, + const enum ovsdb_atomic_type key_type, + const enum ovsdb_atomic_type value_type, + const size_t n_max) +{ + static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 1); + const struct ovsdb_table_schema *schema = row->table->schema; + const struct ovsdb_column *column; + + column = ovsdb_table_schema_get_column(schema, column_name); + if (!column) { + VLOG_DBG_RL(&rl, "Table `%s' has no `%s' column", + schema->name, column_name); + return NULL; + } + + if (column->type.key.type != key_type + || column->type.value.type != value_type + || column->type.n_max != n_max) { + if (!VLOG_DROP_DBG(&rl)) { + char *type_name = ovsdb_type_to_english(&column->type); + VLOG_DBG("Table `%s' column `%s' has type %s, not expected " + "key type %s, value type %s, max elements %zd.", + schema->name, column_name, type_name, + ovsdb_atomic_type_to_string(key_type), + ovsdb_atomic_type_to_string(value_type), + n_max); + free(type_name); + } + return NULL; + } + + return &row->fields[column->index]; +} + +/* Read string-string key-values from a map. Returns the value associated with + * 'key', if found, or NULL */ +static const char * +read_map_string_column(const struct ovsdb_row *row, const char *column_name, + const char *key) +{ + const struct ovsdb_datum *datum; + union ovsdb_atom *atom_key = NULL, *atom_value = NULL; + size_t i; + + datum = get_datum((struct ovsdb_row *) row, column_name, OVSDB_TYPE_STRING, + OVSDB_TYPE_STRING, UINT_MAX); + + if (!datum) { + return NULL; + } + + for (i = 0; i < datum->n; i++) { + atom_key = &datum->keys[i]; + if (!strcmp(atom_key->string, key)){ + atom_value = &datum->values[i]; + break; + } + } + + return atom_value ? atom_value->string : NULL; +} + +static const union ovsdb_atom * +read_column(const struct ovsdb_row *row, const char *column_name, + enum ovsdb_atomic_type type) +{ + const struct ovsdb_datum *datum; + + datum = get_datum((struct ovsdb_row *) row, column_name, type, OVSDB_TYPE_VOID, + 1); + return datum && datum->n ? datum->keys : NULL; +} + +static bool +read_integer_column(const struct ovsdb_row *row, const char *column_name, + long long int *integerp) +{ + const union ovsdb_atom *atom; + + atom = read_column(row, column_name, OVSDB_TYPE_INTEGER); + *integerp = atom ? atom->integer : 0; + return atom != NULL; +} + +static bool +read_string_column(const struct ovsdb_row *row, const char *column_name, + const char **stringp) +{ + const union ovsdb_atom *atom; + + atom = read_column(row, column_name, OVSDB_TYPE_STRING); + *stringp = atom ? atom->string : NULL; + return atom != NULL; +} + +static void +write_bool_column(struct ovsdb_row *row, const char *column_name, bool value) +{ + struct ovsdb_datum *datum = get_datum(row, column_name, OVSDB_TYPE_BOOLEAN, + OVSDB_TYPE_VOID, 1); + + if (!datum) { + return; + } + datum->keys[0].boolean = value; +} + +static void +write_string_string_column(struct ovsdb_row *row, const char *column_name, + char **keys, char **values, size_t n) +{ + const struct ovsdb_column *column; + struct ovsdb_datum *datum; + size_t i; + + column = ovsdb_table_schema_get_column(row->table->schema, column_name); + datum = get_datum(row, column_name, OVSDB_TYPE_STRING, OVSDB_TYPE_STRING, + UINT_MAX); + if (!datum) { + return; + } + + /* Free existing data. */ + ovsdb_datum_destroy(datum, &column->type); + + /* Allocate space for new values. */ + datum->n = n; + datum->keys = xmalloc(n * sizeof *datum->keys); + datum->values = xmalloc(n * sizeof *datum->values); + + for (i = 0; i < n; ++i) { + datum->keys[i].string = keys[i]; + datum->values[i].string = values[i]; + } + + /* Sort and check constraints. */ + ovsdb_datum_sort_assert(datum, column->type.key.type); +} + +/* Adds a remote and options to 'remotes', based on the Manager table row in + * 'row'. */ +static void +add_manager_options(struct shash *remotes, const struct ovsdb_row *row) +{ + static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 1); + struct ovsdb_jsonrpc_options *options; + long long int max_backoff, probe_interval; + const char *target, *dscp_string; + + if (!read_string_column(row, "target", &target) || !target) { + VLOG_INFO_RL(&rl, "Table `%s' has missing or invalid `target' column", + row->table->schema->name); + return; + } + + options = add_remote(remotes, target); + if (read_integer_column(row, "max_backoff", &max_backoff)) { + options->max_backoff = max_backoff; + } + if (read_integer_column(row, "inactivity_probe", &probe_interval)) { + options->probe_interval = probe_interval; + } + + options->dscp = DSCP_DEFAULT; + dscp_string = read_map_string_column(row, "other_config", "dscp"); + if (dscp_string) { + int dscp = atoi(dscp_string); + if (dscp >= 0 && dscp <= 63) { + options->dscp = dscp; + } + } +} + +static void +query_db_remotes(const char *name, const struct ovsdb *db, + struct shash *remotes) +{ + const struct ovsdb_column *column; + const struct ovsdb_table *table; + const struct ovsdb_row *row; + + parse_db_column(db, name, &table, &column); + + if (column->type.key.type == OVSDB_TYPE_STRING + && column->type.value.type == OVSDB_TYPE_VOID) { + HMAP_FOR_EACH (row, hmap_node, &table->rows) { + const struct ovsdb_datum *datum; + size_t i; + + datum = &row->fields[column->index]; + for (i = 0; i < datum->n; i++) { + add_remote(remotes, datum->keys[i].string); + } + } + } else if (column->type.key.type == OVSDB_TYPE_UUID + && column->type.key.u.uuid.refTable + && column->type.value.type == OVSDB_TYPE_VOID) { + const struct ovsdb_table *ref_table = column->type.key.u.uuid.refTable; + HMAP_FOR_EACH (row, hmap_node, &table->rows) { + const struct ovsdb_datum *datum; + size_t i; + + datum = &row->fields[column->index]; + for (i = 0; i < datum->n; i++) { + const struct ovsdb_row *ref_row; + + ref_row = ovsdb_table_get_row(ref_table, &datum->keys[i].uuid); + if (ref_row) { + add_manager_options(remotes, ref_row); + } + } + } + } +} + +static void +update_remote_row(const struct ovsdb_row *row, struct ovsdb_txn *txn, + const struct ovsdb_jsonrpc_server *jsonrpc) +{ + struct ovsdb_jsonrpc_remote_status status; + struct ovsdb_row *rw_row; + const char *target; + char *keys[8], *values[8]; + size_t n = 0; + + /* Get the "target" (protocol/host/port) spec. */ + if (!read_string_column(row, "target", &target)) { + /* Bad remote spec or incorrect schema. */ + return; + } + rw_row = ovsdb_txn_row_modify(txn, row); + ovsdb_jsonrpc_server_get_remote_status(jsonrpc, target, &status); + + /* Update status information columns. */ + write_bool_column(rw_row, "is_connected", status.is_connected); + + if (status.state) { + keys[n] = xstrdup("state"); + values[n++] = xstrdup(status.state); + } + if (status.sec_since_connect != UINT_MAX) { + keys[n] = xstrdup("sec_since_connect"); + values[n++] = xasprintf("%u", status.sec_since_connect); + } + if (status.sec_since_disconnect != UINT_MAX) { + keys[n] = xstrdup("sec_since_disconnect"); + values[n++] = xasprintf("%u", status.sec_since_disconnect); + } + if (status.last_error) { + keys[n] = xstrdup("last_error"); + values[n++] = + xstrdup(ovs_retval_to_string(status.last_error)); + } + if (status.locks_held && status.locks_held[0]) { + keys[n] = xstrdup("locks_held"); + values[n++] = xstrdup(status.locks_held); + } + if (status.locks_waiting && status.locks_waiting[0]) { + keys[n] = xstrdup("locks_waiting"); + values[n++] = xstrdup(status.locks_waiting); + } + if (status.locks_lost && status.locks_lost[0]) { + keys[n] = xstrdup("locks_lost"); + values[n++] = xstrdup(status.locks_lost); + } + if (status.n_connections > 1) { + keys[n] = xstrdup("n_connections"); + values[n++] = xasprintf("%d", status.n_connections); } + write_string_string_column(rw_row, "status", keys, values, n); - HMAP_FOR_EACH (row, struct ovsdb_row, hmap_node, &table->rows) { + ovsdb_jsonrpc_server_free_remote_status(&status); +} + +static void +update_remote_rows(const struct ovsdb *db, struct ovsdb_txn *txn, + const char *remote_name, + const struct ovsdb_jsonrpc_server *jsonrpc) +{ + const struct ovsdb_table *table, *ref_table; + const struct ovsdb_column *column; + const struct ovsdb_row *row; + + if (strncmp("db:", remote_name, 3)) { + return; + } + + parse_db_column(db, remote_name, &table, &column); + + if (column->type.key.type != OVSDB_TYPE_UUID + || !column->type.key.u.uuid.refTable + || column->type.value.type != OVSDB_TYPE_VOID) { + return; + } + + ref_table = column->type.key.u.uuid.refTable; + + HMAP_FOR_EACH (row, hmap_node, &table->rows) { const struct ovsdb_datum *datum; size_t i; datum = &row->fields[column->index]; for (i = 0; i < datum->n; i++) { - shash_add_once(remotes, datum->keys[i].string, NULL); + const struct ovsdb_row *ref_row; + + ref_row = ovsdb_table_get_row(ref_table, &datum->keys[i].uuid); + if (ref_row) { + update_remote_row(ref_row, txn, jsonrpc); + } } } +} - free(name); +static void +update_remote_status(const struct ovsdb_jsonrpc_server *jsonrpc, + const struct sset *remotes, struct ovsdb *db) +{ + static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 1); + struct ovsdb_txn *txn; + const bool durable_txn = false; + struct ovsdb_error *error; + const char *remote; + + txn = ovsdb_txn_create(db); + + /* Iterate over --remote arguments given on command line. */ + SSET_FOR_EACH (remote, remotes) { + update_remote_rows(db, txn, remote, jsonrpc); + } + + error = ovsdb_txn_commit(txn, durable_txn); + if (error) { + VLOG_ERR_RL(&rl, "Failed to update remote status: %s", + ovsdb_error_to_string(error)); + } } +/* Reconfigures ovsdb-server based on information in the database. */ static void -set_remotes(struct ovsdb_jsonrpc_server *jsonrpc, - const struct ovsdb *db, struct shash *remotes) +reconfigure_from_db(struct ovsdb_jsonrpc_server *jsonrpc, + const struct ovsdb *db, struct sset *remotes) { struct shash resolved_remotes; - struct shash_node *node; + const char *name; + /* Configure remotes. */ shash_init(&resolved_remotes); - SHASH_FOR_EACH (node, remotes) { - const char *name = node->name; - + SSET_FOR_EACH (name, remotes) { if (!strncmp(name, "db:", 3)) { query_db_remotes(name, db, &resolved_remotes); } else { - shash_add_once(&resolved_remotes, name, NULL); + add_remote(&resolved_remotes, name); } } ovsdb_jsonrpc_server_set_remotes(jsonrpc, &resolved_remotes); - shash_destroy(&resolved_remotes); -} + shash_destroy_free_data(&resolved_remotes); + /* Configure SSL. */ + stream_ssl_set_key_and_cert(query_db_string(db, private_key_file), + query_db_string(db, certificate_file)); + stream_ssl_set_ca_cert_file(query_db_string(db, ca_cert_file), + bootstrap_ca_cert); +} static void -ovsdb_server_exit(struct unixctl_conn *conn, const char *args OVS_UNUSED, +ovsdb_server_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, 200, NULL); + unixctl_command_reply(conn, NULL); } static void -ovsdb_server_compact(struct unixctl_conn *conn, const char *args OVS_UNUSED, - void *file_) +ovsdb_server_compact(struct unixctl_conn *conn, int argc OVS_UNUSED, + const char *argv[] OVS_UNUSED, void *file_) { struct ovsdb_file *file = file_; struct ovsdb_error *error; @@ -248,18 +685,30 @@ ovsdb_server_compact(struct unixctl_conn *conn, const char *args OVS_UNUSED, VLOG_INFO("compacting database by user request"); error = ovsdb_file_compact(file); if (!error) { - unixctl_command_reply(conn, 200, NULL); + unixctl_command_reply(conn, NULL); } else { char *s = ovsdb_error_to_string(error); ovsdb_error_destroy(error); - unixctl_command_reply(conn, 503, s); + unixctl_command_reply_error(conn, s); free(s); } } +/* "ovsdb-server/reconnect": makes ovsdb-server drop all of its JSON-RPC + * connections and reconnect. */ +static void +ovsdb_server_reconnect(struct unixctl_conn *conn, int argc OVS_UNUSED, + const char *argv[] OVS_UNUSED, void *jsonrpc_) +{ + struct ovsdb_jsonrpc_server *jsonrpc = jsonrpc_; + + ovsdb_jsonrpc_server_reconnect(jsonrpc); + unixctl_command_reply(conn, NULL); +} + static void parse_options(int argc, char *argv[], char **file_namep, - struct shash *remotes, char **unixctl_pathp, + struct sset *remotes, char **unixctl_pathp, char **run_command) { enum { @@ -269,26 +718,27 @@ parse_options(int argc, char *argv[], char **file_namep, OPT_RUN, OPT_BOOTSTRAP_CA_CERT, VLOG_OPTION_ENUMS, - LEAK_CHECKER_OPTION_ENUMS + LEAK_CHECKER_OPTION_ENUMS, + DAEMON_OPTION_ENUMS }; static struct option long_options[] = { - {"remote", required_argument, 0, OPT_REMOTE}, - {"unixctl", required_argument, 0, OPT_UNIXCTL}, - {"run", required_argument, 0, OPT_RUN}, - {"help", no_argument, 0, 'h'}, - {"version", no_argument, 0, 'V'}, + {"remote", required_argument, NULL, OPT_REMOTE}, + {"unixctl", required_argument, NULL, OPT_UNIXCTL}, + {"run", required_argument, NULL, OPT_RUN}, + {"help", no_argument, NULL, 'h'}, + {"version", no_argument, NULL, 'V'}, DAEMON_LONG_OPTIONS, VLOG_LONG_OPTIONS, LEAK_CHECKER_LONG_OPTIONS, -#ifdef HAVE_OPENSSL - {"bootstrap-ca-cert", required_argument, 0, OPT_BOOTSTRAP_CA_CERT}, - STREAM_SSL_LONG_OPTIONS -#endif - {0, 0, 0, 0}, + {"bootstrap-ca-cert", required_argument, NULL, OPT_BOOTSTRAP_CA_CERT}, + {"private-key", required_argument, NULL, 'p'}, + {"certificate", required_argument, NULL, 'c'}, + {"ca-cert", required_argument, NULL, 'C'}, + {NULL, 0, NULL, 0}, }; char *short_options = long_options_to_short_options(long_options); - shash_init(remotes); + sset_init(remotes); for (;;) { int c; @@ -299,7 +749,7 @@ parse_options(int argc, char *argv[], char **file_namep, switch (c) { case OPT_REMOTE: - shash_add_once(remotes, optarg, NULL); + sset_add(remotes, optarg); break; case OPT_UNIXCTL: @@ -314,21 +764,30 @@ parse_options(int argc, char *argv[], char **file_namep, usage(); case 'V': - OVS_PRINT_VERSION(0, 0); + ovs_print_version(0, 0); exit(EXIT_SUCCESS); VLOG_OPTION_HANDLERS DAEMON_OPTION_HANDLERS LEAK_CHECKER_OPTION_HANDLERS -#ifdef HAVE_OPENSSL - STREAM_SSL_OPTION_HANDLERS + case 'p': + private_key_file = optarg; + break; - case OPT_BOOTSTRAP_CA_CERT: - stream_ssl_set_ca_cert_file(optarg, true); + case 'c': + certificate_file = optarg; + break; + + case 'C': + ca_cert_file = optarg; + bootstrap_ca_cert = false; break; -#endif + case OPT_BOOTSTRAP_CA_CERT: + ca_cert_file = optarg; + bootstrap_ca_cert = true; + break; case '?': exit(EXIT_FAILURE); @@ -342,14 +801,19 @@ parse_options(int argc, char *argv[], char **file_namep, argc -= optind; argv += optind; - if (argc > 1) { + switch (argc) { + case 0: + *file_namep = xasprintf("%s/openvswitch/conf.db", ovs_sysconfdir()); + break; + + case 1: + *file_namep = xstrdup(argv[0]); + break; + + default: ovs_fatal(0, "database file is only non-option argument; " "use --help for usage"); - } else if (argc < 1) { - ovs_fatal(0, "missing database file argument; use --help for usage"); } - - *file_namep = argv[0]; } static void @@ -366,6 +830,7 @@ usage(void) vlog_usage(); printf("\nOther options:\n" " --run COMMAND run COMMAND as subprocess then exit\n" + " --unixctl=SOCKET override default control socket name\n" " -h, --help display this help message\n" " -V, --version display version information\n"); leak_checker_usage();