static void
test_vconn_main(int argc, char *argv[])
{
set_program_name(argv[0]);
vlog_set_levels(NULL, VLF_ANY_FACILITY, VLL_EMER);
vlog_set_levels(NULL, VLF_CONSOLE, VLL_DBG);
fatal_ignore_sigpipe();
time_alarm(10);
run_command(argc - 1, argv + 1, commands);
}
int
main(int argc, char *argv[])
{
set_program_name(argv[0]);
vlog_set_levels(NULL, VLF_ANY_FACILITY, VLL_EMER);
vlog_set_levels(NULL, VLF_CONSOLE, VLL_DBG);
signal(SIGPIPE, SIG_IGN);
time_alarm(10);
run_command(argc - 1, argv + 1, commands);
return 0;
}
int
main(int argc, char *argv[])
{
set_program_name(argv[0]);
vlog_set_levels(NULL, VLF_ANY_FACILITY, VLL_EMER);
parse_options(argc, argv);
run_command(argc - optind, argv + optind, get_all_commands());
return 0;
}
static void
test_vconn_main(int argc, char *argv[])
{
struct ovs_cmdl_context ctx = {
.argc = argc - 1,
.argv = argv + 1,
};
set_program_name(argv[0]);
vlog_set_levels(NULL, VLF_ANY_DESTINATION, VLL_EMER);
vlog_set_levels(NULL, VLF_CONSOLE, VLL_DBG);
fatal_ignore_sigpipe();
time_alarm(10);
ovs_cmdl_run_command(&ctx, commands);
}
OVSTEST_REGISTER("test-vconn", test_vconn_main);
int
main(int argc, char *argv[])
{
enum ofputil_protocol usable_protocols;
struct ofputil_flow_mod *fms = NULL;
static struct classifier cls;
struct cls_rule *rules;
size_t n_fms, i;
char *error;
set_program_name(argv[0]);
vlog_set_levels(NULL, VLF_ANY_FACILITY, VLL_DBG);
if (argc < 2) {
usage();
}
if (!strncmp(argv[1], "hsa", 3)) {
VLOG_DBG("Enabling HSA");
cls.enable_hsa = true;
}
VLOG_DBG("using file: %s", argv[2]);
error = parse_ofp_flow_mod_file(argv[2], OFPFC_ADD, &fms, &n_fms,
&usable_protocols);
if (error) {
ovs_fatal(0, "%s", error);
}
classifier_init(&cls, flow_segment_u32s);
fat_rwlock_wrlock(&cls.rwlock);
rules = xmalloc(n_fms * sizeof *rules);
for (i = 0; i < n_fms; i++) {
struct cls_rule *rule = &rules[i];
struct cls_rule *displaced_rule;
cls_rule_init(rule, &fms[i].match, fms[i].priority);
displaced_rule = classifier_replace(&cls, rule);
if (displaced_rule) {
cls_rule_destroy(displaced_rule);
VLOG_WARN("TODO");
}
}
fat_rwlock_unlock(&cls.rwlock);
benchmark(&cls);
free(rules);
free(fms);
return 0;
}
int
main(void)
{
extern struct vlog_module VLM_reconnect;
struct reconnect_stats prev;
unsigned int old_max_tries;
int old_time;
char line[128];
vlog_set_levels(&VLM_reconnect, VLF_ANY_FACILITY, VLL_OFF);
now = 1000;
reconnect = reconnect_create(now);
reconnect_set_name(reconnect, "remote");
reconnect_get_stats(reconnect, now, &prev);
printf("### t=%d ###\n", now);
old_time = now;
old_max_tries = reconnect_get_max_tries(reconnect);
while (fgets(line, sizeof line, stdin)) {
struct reconnect_stats cur;
struct svec args;
fputs(line, stdout);
if (line[0] == '#') {
continue;
}
svec_init(&args);
svec_parse_words(&args, line);
svec_terminate(&args);
if (!svec_is_empty(&args)) {
run_command(args.n, args.names, commands);
}
svec_destroy(&args);
if (old_time != now) {
printf("\n### t=%d ###\n", now);
}
reconnect_get_stats(reconnect, now, &cur);
diff_stats(&prev, &cur, now - old_time);
prev = cur;
if (reconnect_get_max_tries(reconnect) != old_max_tries) {
old_max_tries = reconnect_get_max_tries(reconnect);
printf(" %u tries left\n", old_max_tries);
}
old_time = now;
}
return 0;
}
/* Close stdin, stdout, stderr. If we're started from e.g. an SSH session,
* then this keeps us from holding that session open artificially. */
static void
close_standard_fds(void)
{
int null_fd = get_null_fd();
if (null_fd >= 0) {
dup2(null_fd, STDIN_FILENO);
dup2(null_fd, STDOUT_FILENO);
dup2(null_fd, STDERR_FILENO);
}
/* Disable logging to stderr to avoid wasting CPU time. */
vlog_set_levels(NULL, VLF_CONSOLE, VLL_OFF);
}
int
main(int argc, char *argv[])
{
struct ovs_cmdl_context ctx = { .argc = 0, };
set_program_name(argv[0]);
vlog_set_levels(NULL, VLF_ANY_DESTINATION, VLL_EMER);
parse_options(argc, argv);
ctx.argc = argc - optind;
ctx.argv = argv + optind;
ovs_cmdl_run_command(&ctx, get_all_commands());
return 0;
}
static void
parse_target(const char *s_, struct in_addr *addr,
unsigned short int *min, unsigned short int *max)
{
char *s = xstrdup(s_);
char *colon;
int error;
colon = strchr(s, ':');
if (colon) {
*colon = '\0';
}
if (*s != '\0') {
error = lookup_hostname(s, addr);
if (error) {
ovs_fatal(error, "failed to look up IP address for \"%s\"", s_);
}
} else {
addr->s_addr = htonl(INADDR_ANY);
}
*min = *max = 0;
if (colon && colon[1] != '\0') {
const char *ports = colon + 1;
if (ovs_scan(ports, "%hu-%hu", min, max)) {
if (*min > *max) {
ovs_fatal(0, "%s: minimum is greater than maximum", s_);
}
} else if (ovs_scan(ports, "%hu", min)) {
*max = *min;
} else {
ovs_fatal(0, "%s: number or range expected", s_);
}
}
free(s);
}
/* Close standard file descriptors (except any that the client has requested we
* leave open by calling daemon_save_fd()). If we're started from e.g. an SSH
* session, then this keeps us from holding that session open artificially. */
static void
close_standard_fds(void)
{
int null_fd = get_null_fd();
if (null_fd >= 0) {
int fd;
for (fd = 0; fd < 3; fd++) {
if (!save_fds[fd]) {
dup2(null_fd, fd);
}
}
}
/* Disable logging to stderr to avoid wasting CPU time. */
vlog_set_levels(NULL, VLF_CONSOLE, VLL_OFF);
}
static void
test_lockfile_main(int argc, char *argv[])
{
size_t i;
set_program_name(argv[0]);
vlog_set_pattern(VLF_CONSOLE, "%c|%p|%m");
vlog_set_levels(NULL, VLF_SYSLOG, VLL_OFF);
if (argc != 2) {
ovs_fatal(0, "exactly one argument required; use \"%s help\" for help",
program_name);
}
for (i = 0; tests[i].name; i++) {
if (!strcmp(argv[1], tests[i].name)) {
int n_children;
int status;
(tests[i].function)();
n_children = 0;
#ifndef _WIN32
while (wait(&status) > 0) {
if (WIFEXITED(status) && WEXITSTATUS(status) == 11) {
n_children++;
} else {
ovs_fatal(0, "child exited in unexpected way: %s",
process_status_msg(status));
}
}
if (errno != ECHILD) {
ovs_fatal(errno, "wait");
}
#endif /* _WIN32 */
printf("%s: success (%d child%s)\n",
tests[i].name, n_children, n_children != 1 ? "ren" : "");
exit(0);
}
}
ovs_fatal(0, "unknown test \"%s\"; use \"%s help\" for help",
argv[1], program_name);
}
int
main(int argc, char *argv[])
{
#ifdef _WIN32
WORD wVersionRequested;
WSADATA wsaData;
int err;
/* Use the MAKEWORD(lowbyte, highbyte) macro declared in Windef.h */
wVersionRequested = MAKEWORD(2, 2);
err = WSAStartup(wVersionRequested, &wsaData);
if (err != 0) {
/* Tell the user that we could not find a usable */
/* Winsock DLL. */
printf("WSAStartup failed with error: %d\n", err);
return 1;
}
#endif
set_program_name(argv[0]);
vlog_set_levels(NULL, VLF_ANY_FACILITY, VLL_EMER);
parse_options(argc, argv);
run_command(argc - optind, argv + optind, all_commands);
return 0;
}
int
main(int argc, char *argv[])
{
struct test_case *tc;
FILE *input_file;
int i;
vlog_set_pattern(VLF_CONSOLE, "%c|%p|%m");
vlog_set_levels(NULL, VLF_SYSLOG, VLL_OFF);
if (argc != 2) {
ovs_fatal(0, "usage: test-stp INPUT.STP\n");
}
file_name = argv[1];
input_file = fopen(file_name, "r");
if (!input_file) {
ovs_fatal(errno, "error opening \"%s\"", file_name);
}
tc = new_test_case();
for (i = 0; i < 26; i++) {
char name[2];
name[0] = 'a' + i;
name[1] = '\0';
new_lan(tc, name);
}
for (line_number = 1; fgets(line, sizeof line, input_file);
line_number++)
{
char *newline, *hash;
newline = strchr(line, '\n');
if (newline) {
*newline = '\0';
}
hash = strchr(line, '#');
if (hash) {
*hash = '\0';
}
pos = line;
if (!get_token()) {
continue;
}
if (match("bridge")) {
struct bridge *bridge;
int bridge_no, port_no;
bridge_no = must_get_int();
if (bridge_no < tc->n_bridges) {
bridge = tc->bridges[bridge_no];
} else if (bridge_no == tc->n_bridges) {
bridge = new_bridge(tc, must_get_int());
} else {
err("bridges must be numbered consecutively from 0");
}
if (match("^")) {
stp_set_bridge_priority(bridge->stp, must_get_int());
}
if (match("=")) {
for (port_no = 0; port_no < STP_MAX_PORTS; port_no++) {
struct stp_port *p = stp_get_port(bridge->stp, port_no);
if (!token || match("X")) {
stp_port_disable(p);
} else if (match("_")) {
/* Nothing to do. */
} else {
struct lan *lan;
int path_cost;
if (!strcmp(token, "0")) {
lan = NULL;
} else if (strlen(token) == 1
&& islower((unsigned char)*token)) {
lan = tc->lans[*token - 'a'];
} else {
err("%s is not a valid LAN name "
"(0 or a lowercase letter)", token);
}
get_token();
path_cost = match(":") ? must_get_int() : 10;
if (port_no < bridge->n_ports) {
stp_port_set_path_cost(p, path_cost);
stp_port_enable(p);
reconnect_port(bridge, port_no, lan);
} else if (port_no == bridge->n_ports) {
new_port(bridge, lan, path_cost);
} else {
err("ports must be numbered consecutively");
}
if (match("^")) {
stp_port_set_priority(p, must_get_int());
}
}
}
}
} else if (match("run")) {
simulate(tc, must_get_int());
} else if (match("dump")) {
dump(tc);
} else if (match("tree")) {
tree(tc);
} else if (match("check")) {
struct bridge *b;
struct stp *stp;
int bridge_no, port_no;
bridge_no = must_get_int();
if (bridge_no >= tc->n_bridges) {
err("no bridge numbered %d", bridge_no);
}
b = tc->bridges[bridge_no];
stp = b->stp;
must_match("=");
if (match("rootid")) {
uint64_t rootid;
must_match(":");
rootid = must_get_int();
if (match("^")) {
rootid |= (uint64_t) must_get_int() << 48;
} else {
rootid |= UINT64_C(0x8000) << 48;
}
if (stp_get_designated_root(stp) != rootid) {
warn("%s: root %"PRIx64", not %"PRIx64,
stp_get_name(stp), stp_get_designated_root(stp),
rootid);
}
}
if (match("root")) {
if (stp_get_root_path_cost(stp)) {
warn("%s: root path cost of root is %u but should be 0",
stp_get_name(stp), stp_get_root_path_cost(stp));
}
if (!stp_is_root_bridge(stp)) {
warn("%s: root is %"PRIx64", not %"PRIx64,
stp_get_name(stp),
stp_get_designated_root(stp), stp_get_bridge_id(stp));
}
for (port_no = 0; port_no < b->n_ports; port_no++) {
struct stp_port *p = stp_get_port(stp, port_no);
enum stp_state state = stp_port_get_state(p);
if (!(state & (STP_DISABLED | STP_FORWARDING))) {
warn("%s: root port %d in state %s",
stp_get_name(b->stp), port_no,
stp_state_name(state));
}
}
} else {
for (port_no = 0; port_no < STP_MAX_PORTS; port_no++) {
struct stp_port *p = stp_get_port(stp, port_no);
enum stp_state state;
if (token == NULL || match("D")) {
state = STP_DISABLED;
} else if (match("B")) {
state = STP_BLOCKING;
} else if (match("Li")) {
state = STP_LISTENING;
} else if (match("Le")) {
state = STP_LEARNING;
} else if (match("F")) {
state = STP_FORWARDING;
} else if (match("_")) {
continue;
} else {
err("unknown port state %s", token);
}
if (stp_port_get_state(p) != state) {
warn("%s port %d: state is %s but should be %s",
stp_get_name(stp), port_no,
stp_state_name(stp_port_get_state(p)),
stp_state_name(state));
}
if (state == STP_FORWARDING) {
struct stp_port *root_port = stp_get_root_port(stp);
if (match(":")) {
int root_path_cost = must_get_int();
if (p != root_port) {
warn("%s: port %d is not the root port",
stp_get_name(stp), port_no);
if (!root_port) {
warn("%s: (there is no root port)",
stp_get_name(stp));
} else {
warn("%s: (port %d is the root port)",
stp_get_name(stp),
stp_port_no(root_port));
}
} else if (root_path_cost
!= stp_get_root_path_cost(stp)) {
warn("%s: root path cost is %u, should be %d",
stp_get_name(stp),
stp_get_root_path_cost(stp),
root_path_cost);
}
} else if (p == root_port) {
warn("%s: port %d is the root port but "
"not expected to be",
stp_get_name(stp), port_no);
}
}
}
}
if (n_warnings) {
exit(EXIT_FAILURE);
}
}
if (get_token()) {
err("trailing garbage on line");
}
}
free(token);
for (i = 0; i < tc->n_lans; i++) {
struct lan *lan = tc->lans[i];
free(CONST_CAST(char *, lan->name));
free(lan);
}
for (i = 0; i < tc->n_bridges; i++) {
struct bridge *bridge = tc->bridges[i];
stp_destroy(bridge->stp);
free(bridge);
}
free(tc);
return 0;
}
static void
test_rstp_main(int argc, char *argv[])
{
struct test_case *tc;
FILE *input_file;
int i;
vlog_set_pattern(VLF_CONSOLE, "%c|%p|%m");
vlog_set_levels(NULL, VLF_SYSLOG, VLL_OFF);
if (argc != 2) {
ovs_fatal(0, "usage: test-rstp INPUT.RSTP\n");
}
file_name = argv[1];
input_file = fopen(file_name, "r");
if (!input_file) {
ovs_fatal(errno, "error opening \"%s\"", file_name);
}
tc = new_test_case();
for (i = 0; i < 26; i++) {
char name[2];
name[0] = 'a' + i;
name[1] = '\0';
new_lan(tc, name);
}
for (line_number = 1; fgets(line, sizeof line, input_file);
line_number++)
{
char *newline, *hash;
newline = strchr(line, '\n');
if (newline) {
*newline = '\0';
}
hash = strchr(line, '#');
if (hash) {
*hash = '\0';
}
pos = line;
if (!get_token()) {
continue;
}
if (match("bridge")) {
struct bridge *bridge;
int bridge_no, port_no;
bridge_no = must_get_int();
if (bridge_no < tc->n_bridges) {
bridge = tc->bridges[bridge_no];
} else if (bridge_no == tc->n_bridges) {
bridge = new_bridge(tc, must_get_int());
} else {
err("bridges must be numbered consecutively from 0");
}
if (match("^")) {
rstp_set_bridge_priority(bridge->rstp, must_get_int());
}
if (match("=")) {
for (port_no = 1; port_no < MAX_PORTS; port_no++) {
struct rstp_port *p = rstp_get_port(bridge->rstp, port_no);
if (!token || match("X")) {
/* Disable port. */
reinitialize_port(p);
rstp_port_set_state(p, RSTP_DISABLED);
rstp_port_set_mac_operational(p, false);
} else if (match("_")) {
/* Nothing to do. */
} else {
struct lan *lan;
uint32_t path_cost;
if (!strcmp(token, "0")) {
lan = NULL;
} else if (strlen(token) == 1
&& islower((unsigned char)*token)) {
lan = tc->lans[*token - 'a'];
} else {
err("%s is not a valid LAN name "
"(0 or a lowercase letter)", token);
}
get_token();
path_cost = match(":") ? must_get_int() :
RSTP_DEFAULT_PORT_PATH_COST;
if (port_no < bridge->n_ports) {
/* Enable port. */
reinitialize_port(p);
rstp_port_set_path_cost(p, path_cost);
rstp_port_set_state(p, RSTP_DISCARDING);
rstp_port_set_mac_operational(p, true);
reconnect_port(bridge, port_no, lan);
} else if (port_no == bridge->n_ports) {
new_port(bridge, lan, path_cost);
bridge->n_active_ports++;
} else {
err("ports must be numbered consecutively");
}
if (match("^")) {
rstp_port_set_priority(p, must_get_int());
}
}
}
}
} else if (match("run")) {
simulate(tc, must_get_int());
} else if (match("dump")) {
dump(tc);
} else if (match("tree")) {
tree(tc);
} else if (match("check")) {
struct bridge *b;
struct rstp *rstp;
int bridge_no, port_no;
uint32_t cost_value;
bridge_no = must_get_int();
if (bridge_no >= tc->n_bridges) {
err("no bridge numbered %d", bridge_no);
}
b = tc->bridges[bridge_no];
rstp = b->rstp;
must_match("=");
if (match("rootid")) {
uint64_t rootid;
must_match(":");
rootid = must_get_int();
if (match("^")) {
rootid |= (uint64_t) must_get_int() << 48;
} else {
rootid |= UINT64_C(0x8000) << 48;
}
if (rstp_get_designated_root(rstp) != rootid) {
warn("%s: root "RSTP_ID_FMT", not %"PRIx64,
rstp_get_name(rstp),
RSTP_ID_ARGS(rstp_get_designated_root(rstp)),
rootid);
}
}
cost_value = rstp_get_root_path_cost(rstp);
if (match("root")) {
if (cost_value != 0) {
warn("%s: root path cost of root is %d instead of 0 \n",
rstp_get_name(rstp), cost_value);
}
if (!rstp_is_root_bridge(rstp)) {
warn("%s: root is "RSTP_ID_FMT", not "RSTP_ID_FMT"",
rstp_get_name(rstp),
RSTP_ID_ARGS(rstp_get_designated_root(rstp)),
RSTP_ID_ARGS(rstp_get_bridge_id(rstp)));
}
for (port_no = 1; port_no < b->n_active_ports; port_no++) {
struct rstp_port *p = rstp_get_port(rstp, port_no);
enum rstp_state state = rstp_port_get_state(p);
if (state != RSTP_DISABLED && state != RSTP_FORWARDING) {
warn("%s: root port %d in state %s",
rstp_get_name(b->rstp), port_no,
rstp_state_name(state));
}
}
} else {
for (port_no = 1; port_no < b->n_active_ports; port_no++) {
struct rstp_port *p = rstp_get_port(rstp, port_no);
enum rstp_state state;
if (token == NULL || match("D")) {
state = RSTP_DISABLED;
} else if (match("Di")) {
state = RSTP_DISCARDING;
} else if (match("Le")) {
state = RSTP_LEARNING;
} else if (match("F")) {
state = RSTP_FORWARDING;
} else if (match("_")) {
continue;
} else {
err("unknown port state %s", token);
}
if (rstp_port_get_state(p) != state) {
warn("%s port %d: state is %s but should be %s",
rstp_get_name(rstp), port_no,
rstp_state_name(rstp_port_get_state(p)),
rstp_state_name(state));
}
if (state == RSTP_FORWARDING) {
struct rstp_port *root_port = rstp_get_root_port(rstp);
if (match(":")) {
int root_path_cost = must_get_int();
if (p != root_port) {
warn("%s: port %d is not the root port",
rstp_get_name(rstp), port_no);
if (!root_port) {
warn("%s: (there is no root port)",
rstp_get_name(rstp));
} else {
warn("%s: (port %d is the root port)",
rstp_get_name(rstp),
rstp_port_get_number(root_port));
}
} else if (cost_value != root_path_cost) {
warn("%s: root path cost is %d, should be %d",
rstp_get_name(rstp),
cost_value,
root_path_cost);
}
} else if (p == root_port) {
warn("%s: port %d is the root port but "
"not expected to be",
rstp_get_name(rstp), port_no);
}
}
}
}
if (n_warnings) {
printf("failing because of %d warnings\n", n_warnings);
exit(EXIT_FAILURE);
}
}
if (get_token()) {
printf("failing because of errors\n");
err("trailing garbage on line");
}
}
free(token);
fclose(input_file);
for (i = 0; i < tc->n_lans; i++) {
struct lan *lan = tc->lans[i];
free(CONST_CAST(char *, lan->name));
free(lan);
}
for (i = 0; i < tc->n_bridges; i++) {
struct bridge *bridge = tc->bridges[i];
int j;
for (j = 1; j < MAX_PORTS; j++) {
rstp_port_unref(rstp_get_port(bridge->rstp, j));
}
rstp_unref(bridge->rstp);
free(bridge);
}
free(tc);
}
int
main(int argc, char *argv[])
{
struct ovsdb_idl *idl;
struct ctl_command *commands;
struct shash local_options;
unsigned int seqno;
size_t n_commands;
char *args;
set_program_name(argv[0]);
fatal_ignore_sigpipe();
vlog_set_levels(NULL, VLF_CONSOLE, VLL_WARN);
vlog_set_levels_from_string_assert("reconnect:warn");
sbrec_init();
sbctl_cmd_init();
/* Log our arguments. This is often valuable for debugging systems. */
args = process_escape_args(argv);
VLOG(ctl_might_write_to_db(argv) ? VLL_INFO : VLL_DBG, "Called as %s", args);
/* Parse command line. */
shash_init(&local_options);
parse_options(argc, argv, &local_options);
commands = ctl_parse_commands(argc - optind, argv + optind, &local_options,
&n_commands);
if (timeout) {
time_alarm(timeout);
}
/* Initialize IDL. */
idl = the_idl = ovsdb_idl_create(db, &sbrec_idl_class, false, false);
run_prerequisites(commands, n_commands, idl);
/* Execute the commands.
*
* 'seqno' is the database sequence number for which we last tried to
* execute our transaction. There's no point in trying to commit more than
* once for any given sequence number, because if the transaction fails
* it's because the database changed and we need to obtain an up-to-date
* view of the database before we try the transaction again. */
seqno = ovsdb_idl_get_seqno(idl);
for (;;) {
ovsdb_idl_run(idl);
if (!ovsdb_idl_is_alive(idl)) {
int retval = ovsdb_idl_get_last_error(idl);
ctl_fatal("%s: database connection failed (%s)",
db, ovs_retval_to_string(retval));
}
if (seqno != ovsdb_idl_get_seqno(idl)) {
seqno = ovsdb_idl_get_seqno(idl);
if (do_sbctl(args, commands, n_commands, idl)) {
free(args);
exit(EXIT_SUCCESS);
}
}
if (seqno == ovsdb_idl_get_seqno(idl)) {
ovsdb_idl_wait(idl);
poll_block();
}
}
}
static void
parse_options(int argc, char *argv[], struct shash *local_options)
{
enum {
OPT_DB = UCHAR_MAX + 1,
OPT_ONELINE,
OPT_NO_SYSLOG,
OPT_DRY_RUN,
OPT_PEER_CA_CERT,
OPT_LOCAL,
OPT_COMMANDS,
OPT_OPTIONS,
VLOG_OPTION_ENUMS,
TABLE_OPTION_ENUMS
};
static const struct option global_long_options[] = {
{"db", required_argument, NULL, OPT_DB},
{"no-syslog", no_argument, NULL, OPT_NO_SYSLOG},
{"dry-run", no_argument, NULL, OPT_DRY_RUN},
{"oneline", no_argument, NULL, OPT_ONELINE},
{"timeout", required_argument, NULL, 't'},
{"help", no_argument, NULL, 'h'},
{"commands", no_argument, NULL, OPT_COMMANDS},
{"options", no_argument, NULL, OPT_OPTIONS},
{"version", no_argument, NULL, 'V'},
VLOG_LONG_OPTIONS,
STREAM_SSL_LONG_OPTIONS,
TABLE_LONG_OPTIONS,
{NULL, 0, NULL, 0},
};
const int n_global_long_options = ARRAY_SIZE(global_long_options) - 1;
char *tmp, *short_options;
struct option *options;
size_t allocated_options;
size_t n_options;
size_t i;
tmp = ovs_cmdl_long_options_to_short_options(global_long_options);
short_options = xasprintf("+%s", tmp);
free(tmp);
/* We want to parse both global and command-specific options here, but
* getopt_long() isn't too convenient for the job. We copy our global
* options into a dynamic array, then append all of the command-specific
* options. */
options = xmemdup(global_long_options, sizeof global_long_options);
allocated_options = ARRAY_SIZE(global_long_options);
n_options = n_global_long_options;
ctl_add_cmd_options(&options, &n_options, &allocated_options, OPT_LOCAL);
table_style.format = TF_LIST;
for (;;) {
int idx;
int c;
c = getopt_long(argc, argv, short_options, options, &idx);
if (c == -1) {
break;
}
switch (c) {
case OPT_DB:
db = optarg;
break;
case OPT_ONELINE:
oneline = true;
break;
case OPT_NO_SYSLOG:
vlog_set_levels(&this_module, VLF_SYSLOG, VLL_WARN);
break;
case OPT_DRY_RUN:
dry_run = true;
break;
case OPT_LOCAL:
if (shash_find(local_options, options[idx].name)) {
ctl_fatal("'%s' option specified multiple times",
options[idx].name);
}
shash_add_nocopy(local_options,
xasprintf("--%s", options[idx].name),
optarg ? xstrdup(optarg) : NULL);
break;
case 'h':
usage();
case OPT_COMMANDS:
ctl_print_commands();
case OPT_OPTIONS:
ctl_print_options(global_long_options);
case 'V':
ovs_print_version(0, 0);
printf("DB Schema %s\n", sbrec_get_db_version());
exit(EXIT_SUCCESS);
case 't':
timeout = strtoul(optarg, NULL, 10);
if (timeout < 0) {
ctl_fatal("value %s on -t or --timeout is invalid", optarg);
}
break;
VLOG_OPTION_HANDLERS
TABLE_OPTION_HANDLERS(&table_style)
STREAM_SSL_OPTION_HANDLERS
case '?':
exit(EXIT_FAILURE);
default:
abort();
}
}
free(short_options);
if (!db) {
db = sbctl_default_db();
}
for (i = n_global_long_options; options[i].name; i++) {
free(CONST_CAST(char *, options[i].name));
}
free(options);
}
int
main(int argc OVS_UNUSED, char *argv[])
{
uint64_t buf_stub[4096 / 64];
struct nl_sock *sock;
struct ofpbuf buf;
int error;
set_program_name(argv[0]);
vlog_set_levels(NULL, VLF_ANY_FACILITY, VLL_DBG);
error = nl_sock_create(NETLINK_ROUTE, &sock);
if (error) {
ovs_fatal(error, "could not create rtnetlink socket");
}
error = nl_sock_join_mcgroup(sock, RTNLGRP_LINK);
if (error) {
ovs_fatal(error, "could not join RTNLGRP_LINK multicast group");
}
ofpbuf_use_stub(&buf, buf_stub, sizeof buf_stub);
for (;;) {
error = nl_sock_recv(sock, &buf, false);
if (error == EAGAIN) {
/* Nothing to do. */
} else if (error == ENOBUFS) {
ovs_error(0, "network monitor socket overflowed");
} else if (error) {
ovs_fatal(error, "error on network monitor socket");
} else {
struct iff_flag {
unsigned int flag;
const char *name;
};
static const struct iff_flag flags[] = {
{ IFF_UP, "UP", },
{ IFF_BROADCAST, "BROADCAST", },
#ifndef _WIN32
{ IFF_DEBUG, "DEBUG", },
#endif
{ IFF_LOOPBACK, "LOOPBACK", },
#ifndef _WIN32
{ IFF_POINTOPOINT, "POINTOPOINT", },
{ IFF_NOTRAILERS, "NOTRAILERS", },
#endif
{ IFF_RUNNING, "RUNNING", },
#ifndef _WIN32
{ IFF_NOARP, "NOARP", },
#endif
{ IFF_PROMISC, "PROMISC", },
#ifndef _WIN32
{ IFF_ALLMULTI, "ALLMULTI", },
{ IFF_MASTER, "MASTER", },
{ IFF_SLAVE, "SLAVE", },
#endif
{ IFF_MULTICAST, "MULTICAST", },
#ifndef _WIN32
{ IFF_PORTSEL, "PORTSEL", },
{ IFF_AUTOMEDIA, "AUTOMEDIA", },
{ IFF_DYNAMIC, "DYNAMIC", },
#endif
};
struct nlattr *attrs[ARRAY_SIZE(rtnlgrp_link_policy)];
struct nlmsghdr *nlh;
struct ifinfomsg *iim;
int i;
nlh = ofpbuf_at(&buf, 0, NLMSG_HDRLEN);
iim = ofpbuf_at(&buf, NLMSG_HDRLEN, sizeof *iim);
if (!iim) {
ovs_error(0, "received bad rtnl message (no ifinfomsg)");
continue;
}
if (!nl_policy_parse(&buf, NLMSG_HDRLEN + sizeof(struct ifinfomsg),
rtnlgrp_link_policy,
attrs, ARRAY_SIZE(rtnlgrp_link_policy))) {
ovs_error(0, "received bad rtnl message (policy)");
continue;
}
printf("netdev %s changed (%s):\n",
nl_attr_get_string(attrs[IFLA_IFNAME]),
(nlh->nlmsg_type == RTM_NEWLINK ? "RTM_NEWLINK"
#ifndef _WIN32
: nlh->nlmsg_type == RTM_DELLINK ? "RTM_DELLINK"
#endif
: nlh->nlmsg_type == RTM_GETLINK ? "RTM_GETLINK"
#ifndef _WIN32
: nlh->nlmsg_type == RTM_SETLINK ? "RTM_SETLINK"
#endif
: "other"));
printf("\tflags:");
for (i = 0; i < ARRAY_SIZE(flags); i++) {
if (iim->ifi_flags & flags[i].flag) {
printf(" %s", flags[i].name);
}
}
printf("\n");
if (attrs[IFLA_MASTER]) {
uint32_t idx = nl_attr_get_u32(attrs[IFLA_MASTER]);
char ifname[IFNAMSIZ];
#ifndef _WIN32
if (!if_indextoname(idx, ifname)) {
strcpy(ifname, "unknown");
}
#endif
printf("\tmaster=%"PRIu32" (%s)\n", idx, ifname);
}
}
nl_sock_wait(sock, POLLIN);
poll_block();
}
}
