int
LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
{
/* Bail out if we cannot construct at least a 1 char string. */
const char *input = (const char *) data;
if (size < 2 || input[size - 1] != '\0' || strchr(input, '\n') ||
strlen(input) != size - 1) {
return 0;
}
/* Disable logging to avoid write to disk. */
static bool isInit = false;
if (!isInit) {
vlog_set_verbosity("off");
isInit = true;
}
/* Parse keys and wc keys. */
parse_keys(false, input);
parse_keys(true, input);
/* Parse actions. */
parse_actions(input);
return 0;
}
static void
parse_options(int argc, char *argv[])
{
enum {
OPT_BOOTSTRAP_CA_CERT = UCHAR_MAX + 1,
DAEMON_OPTION_ENUMS
};
static struct option long_options[] = {
{"verbose", optional_argument, NULL, 'v'},
{"help", no_argument, NULL, 'h'},
DAEMON_LONG_OPTIONS,
{"bootstrap-ca-cert", required_argument, NULL, OPT_BOOTSTRAP_CA_CERT},
STREAM_SSL_LONG_OPTIONS,
{NULL, 0, NULL, 0},
};
char *short_options = long_options_to_short_options(long_options);
for (;;) {
int c = getopt_long(argc, argv, short_options, long_options, NULL);
if (c == -1) {
break;
}
switch (c) {
case 'h':
usage();
case 'v':
vlog_set_verbosity(optarg);
break;
DAEMON_OPTION_HANDLERS
STREAM_SSL_OPTION_HANDLERS
case OPT_BOOTSTRAP_CA_CERT:
stream_ssl_set_ca_cert_file(optarg, true);
break;
case '?':
exit(EXIT_FAILURE);
default:
abort();
}
}
free(short_options);
}
int main(int argc, char **argv)
{
uint8_t *buf ,*buf0;
size_t buf_len = 0;
ofl_err err;
struct ofl_msg_header *msg = NULL;
uint32_t xid;
FILE *msg_file;
struct ofp_header *oh;
if (argc < 2) {
fprintf(stderr, "Expecting msg file.\n");
return 1;
}
time_init();
vlog_init();
vlog_set_verbosity(NULL);
msg_file = fopen(argv[1], "r");
if (msg_file == NULL) {
fprintf(stderr, "Cannot open msg file.\n");
return 1;
}
buf_len = read_all(msg_file, &buf);
buf0 = buf;
while (buf_len > 0) {
oh = (struct ofp_header *)buf;
err = ofl_msg_unpack(buf, ntohs(oh->length), &msg, &xid, NULL);
if (err == 0) {
//printf("Success!\n");
ofl_msg_print(stdout, msg, NULL);
printf("\n\n");
ofl_msg_free(msg, NULL);
} else {
free(buf);
printf("Failed :-( error type: %d code %d\n", ofl_error_type(err), ofl_error_code(err));
return 1;
}
buf_len -= ntohs(oh->length);
buf += ntohs(oh->length);
}
free(buf0);
return 0;
}
int
LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
{
if (size < sizeof(struct ofp_header)) {
return 0;
}
static bool isInit = false;
if (!isInit) {
vlog_set_verbosity("off");
isInit = true;
}
struct ofpbuf b;
ofpbuf_use_const(&b, data, size);
for (;;) {
/* Check if ofpbuf contains ofp header. */
struct ofp_header *oh = ofpbuf_at(&b, 0, sizeof *oh);
if (!oh) {
break;
}
/* Check if length is geq than lower bound. */
size_t length = ntohs(oh->length);
if (length < sizeof *oh) {
break;
}
/* Check if ofpbuf contains payload. */
size_t tail_len = length - sizeof *oh;
void *tail = ofpbuf_at(&b, sizeof *oh, tail_len);
if (!tail) {
break;
}
ofp_print(stdout, ofpbuf_pull(&b, length), length, NULL, NULL, 2);
}
ofpbuf_uninit(&b);
return 0;
}
static void
parse_options(int argc, char *argv[])
{
static const struct option long_options[] = {
{"help", no_argument, NULL, 'h'},
{"version", no_argument, NULL, 'V'},
{"verbose", optional_argument, NULL, 'v'},
{NULL, 0, NULL, 0},
};
char *short_options = "hVv";
for (;;) {
int c;
c = getopt_long(argc, argv, short_options, long_options, NULL);
if (c == -1) {
break;
}
switch (c) {
case 'V':
show_version();
break;
case 'h':
usage();
break;
case 'v':
vlog_set_verbosity(optarg);
break;
case '?':
exit(EXIT_FAILURE);
default:
abort();
}
}
}
static void
parse_options(int argc, char *argv[])
{
enum {
DAEMON_OPTION_ENUMS
};
static struct option long_options[] = {
{"verbose", optional_argument, NULL, 'v'},
{"help", no_argument, NULL, 'h'},
DAEMON_LONG_OPTIONS,
{NULL, 0, NULL, 0},
};
char *short_options = long_options_to_short_options(long_options);
for (;;) {
int c = getopt_long(argc, argv, short_options, long_options, NULL);
if (c == -1) {
break;
}
switch (c) {
case 'h':
usage();
case 'v':
vlog_set_verbosity(optarg);
break;
DAEMON_OPTION_HANDLERS
case '?':
exit(EXIT_FAILURE);
default:
abort();
}
}
free(short_options);
}
static void
parse_options(struct datapath *dp, int argc, char *argv[])
{
enum {
OPT_MFR_DESC = UCHAR_MAX + 1,
OPT_HW_DESC,
OPT_SW_DESC,
OPT_DP_DESC,
OPT_SERIAL_NUM,
OPT_BOOTSTRAP_CA_CERT,
OPT_NO_LOCAL_PORT,
OPT_NO_SLICING
};
static struct option long_options[] = {
{"interfaces", required_argument, 0, 'i'},
{"local-port", required_argument, 0, 'L'},
{"no-local-port", no_argument, 0, OPT_NO_LOCAL_PORT},
{"datapath-id", required_argument, 0, 'd'},
{"multiconn", no_argument, 0, 'm'},
{"verbose", optional_argument, 0, 'v'},
{"help", no_argument, 0, 'h'},
{"version", no_argument, 0, 'V'},
{"no-slicing", no_argument, 0, OPT_NO_SLICING},
{"mfr-desc", required_argument, 0, OPT_MFR_DESC},
{"hw-desc", required_argument, 0, OPT_HW_DESC},
{"sw-desc", required_argument, 0, OPT_SW_DESC},
{"dp_desc", required_argument, 0, OPT_DP_DESC},
{"serial_num", required_argument, 0, OPT_SERIAL_NUM},
DAEMON_LONG_OPTIONS,
#ifdef HAVE_OPENSSL
VCONN_SSL_LONG_OPTIONS
{"bootstrap-ca-cert", required_argument, 0, OPT_BOOTSTRAP_CA_CERT},
#endif
{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 'd': {
uint64_t dpid;
if (strlen(optarg) != 12
|| strspn(optarg, "0123456789abcdefABCDEF") != 12) {
ofp_fatal(0, "argument to -d or --datapath-id must be "
"exactly 12 hex digits");
}
dpid = strtoll(optarg, NULL, 16);
if (!dpid) {
ofp_fatal(0, "argument to -d or --datapath-id must "
"be nonzero");
}
dp_set_dpid(dp, dpid);
break;
}
case 'm': {
use_multiple_connections = true;
break;
}
case 'h':
usage();
case 'V':
printf("%s %s compiled "__DATE__" "__TIME__"\n",
program_name, VERSION BUILDNR);
exit(EXIT_SUCCESS);
case 'v':
vlog_set_verbosity(optarg);
break;
case 'i':
if (!port_list) {
port_list = optarg;
} else {
port_list = xasprintf("%s,%s", port_list, optarg);
}
break;
case 'L':
local_port = optarg;
break;
case OPT_NO_LOCAL_PORT:
local_port = NULL;
break;
case OPT_MFR_DESC:
dp_set_mfr_desc(dp, optarg);
break;
case OPT_HW_DESC:
dp_set_hw_desc(dp, optarg);
break;
case OPT_SW_DESC:
dp_set_sw_desc(dp, optarg);
break;
case OPT_DP_DESC:
dp_set_dp_desc(dp, optarg);
break;
case OPT_SERIAL_NUM:
dp_set_serial_num(dp, optarg);
break;
case OPT_NO_SLICING:
dp_set_max_queues(dp, 0);
break;
DAEMON_OPTION_HANDLERS
#ifdef HAVE_OPENSSL
VCONN_SSL_OPTION_HANDLERS
case OPT_BOOTSTRAP_CA_CERT:
vconn_ssl_set_ca_cert_file(optarg, true);
break;
#endif
case '?':
exit(EXIT_FAILURE);
default:
abort();
}
}
free(short_options);
}
static void
test_jsonrpc_main(int argc, char *argv[])
{
struct ovs_cmdl_context ctx = { .argc = 0, };
ovs_cmdl_proctitle_init(argc, argv);
set_program_name(argv[0]);
service_start(&argc, &argv);
parse_options(argc, argv);
ctx.argc = argc - optind;
ctx.argv = argv + optind;
ovs_cmdl_run_command(&ctx, get_all_commands());
}
static void
parse_options(int argc, char *argv[])
{
enum {
OPT_BOOTSTRAP_CA_CERT = UCHAR_MAX + 1,
DAEMON_OPTION_ENUMS
};
static const struct option long_options[] = {
{"verbose", optional_argument, NULL, 'v'},
{"help", no_argument, NULL, 'h'},
DAEMON_LONG_OPTIONS,
{"bootstrap-ca-cert", required_argument, NULL, OPT_BOOTSTRAP_CA_CERT},
STREAM_SSL_LONG_OPTIONS,
{NULL, 0, NULL, 0},
};
char *short_options = ovs_cmdl_long_options_to_short_options(long_options);
for (;;) {
int c = getopt_long(argc, argv, short_options, long_options, NULL);
if (c == -1) {
break;
}
switch (c) {
case 'h':
usage();
case 'v':
vlog_set_verbosity(optarg);
break;
DAEMON_OPTION_HANDLERS
STREAM_SSL_OPTION_HANDLERS
case OPT_BOOTSTRAP_CA_CERT:
stream_ssl_set_ca_cert_file(optarg, true);
break;
case '?':
exit(EXIT_FAILURE);
default:
abort();
}
}
free(short_options);
}
static void
usage(void)
{
printf("%s: JSON-RPC test utility\n"
"usage: %s [OPTIONS] COMMAND [ARG...]\n"
" listen LOCAL listen for connections on LOCAL\n"
" request REMOTE METHOD PARAMS send request, print reply\n"
" notify REMOTE METHOD PARAMS send notification and exit\n",
program_name, program_name);
stream_usage("JSON-RPC", true, true, true);
daemon_usage();
vlog_usage();
printf("\nOther options:\n"
" -h, --help display this help message\n");
exit(EXIT_SUCCESS);
}
static void
parse_options(int argc, char *argv[])
{
char dpid_str[17];
int dpid_len;
enum {
OPT_MFR_DESC = UCHAR_MAX + 1,
OPT_HW_DESC,
OPT_SW_DESC,
OPT_DP_DESC,
OPT_SERIAL_NUM,
OPT_BOOTSTRAP_CA_CERT,
OPT_NO_LOCAL_PORT,
OPT_NO_SLICING,
OPT_DP_MGMT,
OPT_DP_MGMT_OOB,
OPT_DP_MGMT_PORT,
OPT_DP_MGMT_VID,
OPT_PORT_ADD_STATE
};
static struct option long_options[] = {
{"interfaces", required_argument, 0, 'i'},
{"local-port", required_argument, 0, 'L'},
{"no-local-port", no_argument, 0, OPT_NO_LOCAL_PORT},
{"datapath-id", required_argument, 0, 'd'},
{"mgmt-mac", required_argument, 0, 'e'}, /* for ether addr */
{"verbose", optional_argument, 0, 'v'},
{"help", no_argument, 0, 'h'},
{"version", no_argument, 0, 'V'},
{"no-slicing", no_argument, 0, OPT_NO_SLICING},
{"mfr-desc", required_argument, 0, OPT_MFR_DESC},
{"hw-desc", required_argument, 0, OPT_HW_DESC},
{"sw-desc", required_argument, 0, OPT_SW_DESC},
{"dp_desc", required_argument, 0, OPT_DP_DESC},
{"serial_num", required_argument, 0, OPT_SERIAL_NUM},
{"min-port", required_argument, 0, 'm'},
{"max-port", required_argument, 0, 'M'},
{"dp-mgmt", no_argument, 0, OPT_DP_MGMT},
{"dp-mgmt-oob", no_argument, 0, OPT_DP_MGMT_OOB},
{"dp-mgmt-port", required_argument, 0, OPT_DP_MGMT_PORT},
{"dp-mgmt-vid", required_argument, 0, OPT_DP_MGMT_VID},
{"add-port-state", required_argument, 0, OPT_PORT_ADD_STATE},
WATCHDOG_LONG_OPTIONS
DAEMON_LONG_OPTIONS,
#ifdef HAVE_OPENSSL
VCONN_SSL_LONG_OPTIONS
{"bootstrap-ca-cert", required_argument, 0, OPT_BOOTSTRAP_CA_CERT},
#endif
{0, 0, 0, 0},
};
char *short_options = long_options_to_short_options(long_options);
for (;;) {
int indexptr;
int c;
uint8_t *ea;
c = getopt_long(argc, argv, short_options, long_options, &indexptr);
if (c == -1) {
break;
}
switch (c) {
case 'e': /* Management mac address */
if (str_to_mac(optarg, dp_mac) != 0) {
printf("Warning: Could not parse mac address %s\n", optarg);
} else {
got_mac = true;
}
ea = dp_mac;
printf("Datapath MAC: %02x:%02x:%02x:%02x:%02x:%02x\n",
ea[0], ea[1], ea[2], ea[3], ea[4], ea[5]);
break;
case 'd':
dpid_len = strlen(optarg);
if (dpid_len > 16) {
/* If leading 0, truncate left; else truncate right */
if (optarg[0] == '0') {
strncpy(dpid_str, &optarg[dpid_len-16], sizeof(dpid_str));
} else {
strncpy(dpid_str, optarg, sizeof(dpid_str));
}
dpid_str[17] = 0;
printf("Warning: Truncating dpid string to %s\n", dpid_str);
} else {
strncpy(dpid_str, optarg, sizeof(dpid_str));
}
if (strspn(dpid_str, "0123456789abcdefABCDEF") !=
strlen(dpid_str)) {
printf("Warning: Illegal DPID string %s. Will generate\n",
optarg);
} else {
dpid = strtoll(dpid_str, NULL, 16);
if (dpid != 0) {
printf("Using dpid: %s\n", dpid_str);
} else {
printf("DPID is 0. Will generate\n");
}
}
break;
case 'h':
usage();
case 'V':
printf("%s %s compiled "__DATE__" "__TIME__"\n",
program_name, VERSION BUILDNR);
exit(EXIT_SUCCESS);
case 'v':
vlog_set_verbosity(optarg);
break;
case 'i':
if (!port_list) {
port_list = optarg;
} else {
port_list = xasprintf("%s,%s", port_list, optarg);
}
break;
case 'L':
local_port = optarg;
break;
/* Support specifying a range of ports */
case 'm':
min_port = strtoul(optarg, NULL, 10);
break;
case 'M':
max_port = strtoul(optarg, NULL, 10);
max_port_set = true;
break;
#if defined(WATCHDOG_SUPPORT)
case 'w':
watchdog_active = 1;
break;
#endif
case OPT_NO_LOCAL_PORT:
local_port = NULL;
break;
case OPT_MFR_DESC:
strncpy(mfr_desc, optarg, sizeof mfr_desc);
break;
case OPT_HW_DESC:
hw_desc_set = true;
strncpy(hw_desc, optarg, sizeof hw_desc);
break;
case OPT_SW_DESC:
strncpy(sw_desc, optarg, sizeof sw_desc);
break;
case OPT_DP_DESC:
dp_desc_set = true;
strncpy(dp_desc, optarg, sizeof dp_desc);
break;
case OPT_SERIAL_NUM:
strncpy(serial_num, optarg, sizeof serial_num);
break;
case OPT_NO_SLICING:
num_queues = 0;
break;
case OPT_DP_MGMT:
dp_mgmt = true;
break;
case OPT_DP_MGMT_OOB:
dp_mgmt_oob = true;
dp_mgmt = true;
break;
case OPT_DP_MGMT_PORT:
dp_mgmt_port = strtoul(optarg, NULL, 10);
dp_mgmt_port_fixed = true;
dp_mgmt = true;
break;
case OPT_DP_MGMT_VID:
dp_mgmt_vid = strtoul(optarg, NULL, 10);
dp_mgmt_vid_fixed = true;
dp_mgmt = true;
break;
case OPT_PORT_ADD_STATE:
port_add_state = strtoul(optarg, NULL, 10);
if (port_add_state == PORT_ADD_STATE_DOWN) {
printf("Warning: Add port state is disabled\n");
}
break;
DAEMON_OPTION_HANDLERS
#ifdef HAVE_OPENSSL
VCONN_SSL_OPTION_HANDLERS
case OPT_BOOTSTRAP_CA_CERT:
vconn_ssl_set_ca_cert_file(optarg, true);
break;
#endif
case '?':
exit(EXIT_FAILURE);
default:
abort();
}
}
free(short_options);
}
static void
test_parse_actions(const char *input)
{
struct shash symtab;
struct hmap dhcp_opts;
struct hmap dhcpv6_opts;
struct hmap nd_ra_opts;
struct simap ports;
create_symtab(&symtab);
create_gen_opts(&dhcp_opts, &dhcpv6_opts, &nd_ra_opts);
/* Initialize group ids. */
struct ovn_extend_table group_table;
ovn_extend_table_init(&group_table);
/* Initialize meter ids for QoS. */
struct ovn_extend_table meter_table;
ovn_extend_table_init(&meter_table);
simap_init(&ports);
simap_put(&ports, "eth0", 5);
simap_put(&ports, "eth1", 6);
simap_put(&ports, "LOCAL", ofp_to_u16(OFPP_LOCAL));
struct ofpbuf ovnacts;
struct expr *prereqs;
char *error;
puts(input);
ofpbuf_init(&ovnacts, 0);
const struct ovnact_parse_params pp = {
.symtab = &symtab,
.dhcp_opts = &dhcp_opts,
.dhcpv6_opts = &dhcpv6_opts,
.nd_ra_opts = &nd_ra_opts,
.n_tables = 24,
.cur_ltable = 10,
};
error = ovnacts_parse_string(input, &pp, &ovnacts, &prereqs);
if (!error) {
/* Convert the parsed representation back to a string and print it,
* if it's different from the input. */
struct ds ovnacts_s = DS_EMPTY_INITIALIZER;
ovnacts_format(ovnacts.data, ovnacts.size, &ovnacts_s);
if (strcmp(input, ds_cstr(&ovnacts_s))) {
printf(" formats as %s\n", ds_cstr(&ovnacts_s));
}
/* Encode the actions into OpenFlow and print. */
const struct ovnact_encode_params ep = {
.lookup_port = lookup_port_cb,
.aux = &ports,
.is_switch = true,
.group_table = &group_table,
.meter_table = &meter_table,
.pipeline = OVNACT_P_INGRESS,
.ingress_ptable = 8,
.egress_ptable = 40,
.output_ptable = 64,
.mac_bind_ptable = 65,
};
struct ofpbuf ofpacts;
ofpbuf_init(&ofpacts, 0);
ovnacts_encode(ovnacts.data, ovnacts.size, &ep, &ofpacts);
struct ds ofpacts_s = DS_EMPTY_INITIALIZER;
struct ofpact_format_params fp = { .s = &ofpacts_s };
ofpacts_format(ofpacts.data, ofpacts.size, &fp);
printf(" encodes as %s\n", ds_cstr(&ofpacts_s));
ds_destroy(&ofpacts_s);
ofpbuf_uninit(&ofpacts);
/* Print prerequisites if any. */
if (prereqs) {
struct ds prereqs_s = DS_EMPTY_INITIALIZER;
expr_format(prereqs, &prereqs_s);
printf(" has prereqs %s\n", ds_cstr(&prereqs_s));
ds_destroy(&prereqs_s);
}
/* Now re-parse and re-format the string to verify that it's
* round-trippable. */
struct ofpbuf ovnacts2;
struct expr *prereqs2;
ofpbuf_init(&ovnacts2, 0);
error = ovnacts_parse_string(ds_cstr(&ovnacts_s), &pp, &ovnacts2,
&prereqs2);
if (!error) {
struct ds ovnacts2_s = DS_EMPTY_INITIALIZER;
ovnacts_format(ovnacts2.data, ovnacts2.size, &ovnacts2_s);
if (strcmp(ds_cstr(&ovnacts_s), ds_cstr(&ovnacts2_s))) {
printf(" bad reformat: %s\n", ds_cstr(&ovnacts2_s));
}
ds_destroy(&ovnacts2_s);
} else {
printf(" reparse error: %s\n", error);
free(error);
}
expr_destroy(prereqs2);
ovnacts_free(ovnacts2.data, ovnacts2.size);
ofpbuf_uninit(&ovnacts2);
ds_destroy(&ovnacts_s);
} else {
printf(" %s\n", error);
free(error);
}
expr_destroy(prereqs);
ovnacts_free(ovnacts.data, ovnacts.size);
ofpbuf_uninit(&ovnacts);
simap_destroy(&ports);
expr_symtab_destroy(&symtab);
shash_destroy(&symtab);
dhcp_opts_destroy(&dhcp_opts);
dhcp_opts_destroy(&dhcpv6_opts);
nd_ra_opts_destroy(&nd_ra_opts);
ovn_extend_table_destroy(&group_table);
ovn_extend_table_destroy(&meter_table);
}
static void
test_parse_expr(const char *input)
{
struct shash symtab;
struct shash addr_sets;
struct shash port_groups;
struct simap ports;
struct expr *expr;
char *error;
create_symtab(&symtab);
create_addr_sets(&addr_sets);
create_port_groups(&port_groups);
simap_init(&ports);
simap_put(&ports, "eth0", 5);
simap_put(&ports, "eth1", 6);
simap_put(&ports, "LOCAL", ofp_to_u16(OFPP_LOCAL));
simap_put(&ports, "lsp1", 0x11);
simap_put(&ports, "lsp2", 0x12);
simap_put(&ports, "lsp3", 0x13);
expr = expr_parse_string(input, &symtab, &addr_sets,
&port_groups, &error);
if (!error) {
expr = expr_annotate(expr, &symtab, &error);
}
if (!error) {
expr = expr_simplify(expr, is_chassis_resident_cb, &ports);
expr = expr_normalize(expr);
ovs_assert(expr_is_normalized(expr));
}
if (!error) {
struct hmap matches;
expr_to_matches(expr, lookup_port_cb, &ports, &matches);
expr_matches_print(&matches, stdout);
expr_matches_destroy(&matches);
} else {
puts(error);
free(error);
}
expr_destroy(expr);
simap_destroy(&ports);
expr_symtab_destroy(&symtab);
shash_destroy(&symtab);
expr_const_sets_destroy(&addr_sets);
shash_destroy(&addr_sets);
expr_const_sets_destroy(&port_groups);
shash_destroy(&port_groups);
}
static bool
lookup_atoi_cb(const void *aux OVS_UNUSED, const char *port_name,
unsigned int *portp)
{
*portp = atoi(port_name);
return true;
}
static void
test_expr_to_packets(const char *input)
{
struct shash symtab;
create_symtab(&symtab);
struct flow uflow;
char *error = expr_parse_microflow(input, &symtab, NULL, NULL,
lookup_atoi_cb, NULL, &uflow);
if (error) {
puts(error);
free(error);
expr_symtab_destroy(&symtab);
shash_destroy(&symtab);
return;
}
uint64_t packet_stub[128 / 8];
struct dp_packet packet;
dp_packet_use_stub(&packet, packet_stub, sizeof packet_stub);
flow_compose(&packet, &uflow, NULL, 64);
struct ds output = DS_EMPTY_INITIALIZER;
const uint8_t *buf = dp_packet_data(&packet);
for (int i = 0; i < dp_packet_size(&packet); i++) {
uint8_t val = buf[i];
ds_put_format(&output, "%02"PRIx8, val);
}
puts(ds_cstr(&output));
ds_destroy(&output);
dp_packet_uninit(&packet);
expr_symtab_destroy(&symtab);
shash_destroy(&symtab);
}
int
LLVMFuzzerTestOneInput(const uint8_t *input_, size_t size)
{
/* Bail out if we cannot construct at least a 1 char string. */
const char *input = (const char *) input_;
if (size < 2 || input[size - 1] != '\0' || strchr(input, '\n') ||
strlen(input) != size - 1) {
return 0;
}
/* Disable logging to avoid write to disk. */
static bool isInit = false;
if (!isInit) {
vlog_set_verbosity("off");
isInit = true;
}
/* Parse, annotate, simplify, normalize expr and convert to flows. */
test_parse_expr(input);
/* Parse actions. */
test_parse_actions(input);
/* Test OVN lexer. */
test_lex(input);
/* Expr to packets. */
test_expr_to_packets(input);
return 0;
}
static void
parse_options(int argc, char *argv[])
{
enum {
OPT_MAX_BACKOFF = UCHAR_MAX + 1,
OPT_MFR_DESC,
OPT_HW_DESC,
OPT_SW_DESC,
OPT_SERIAL_NUM,
OPT_BOOTSTRAP_CA_CERT
};
static struct option long_options[] = {
{"interfaces", required_argument, 0, 'i'},
{"datapath-id", required_argument, 0, 'd'},
{"max-backoff", required_argument, 0, OPT_MAX_BACKOFF},
{"listen", required_argument, 0, 'l'},
{"verbose", optional_argument, 0, 'v'},
{"help", no_argument, 0, 'h'},
{"version", no_argument, 0, 'V'},
{"mfr-desc", required_argument, 0, OPT_MFR_DESC},
{"hw-desc", required_argument, 0, OPT_HW_DESC},
{"sw-desc", required_argument, 0, OPT_SW_DESC},
{"serial_num", required_argument, 0, OPT_SERIAL_NUM},
DAEMON_LONG_OPTIONS,
#ifdef HAVE_OPENSSL
VCONN_SSL_LONG_OPTIONS
{"bootstrap-ca-cert", required_argument, 0, OPT_BOOTSTRAP_CA_CERT},
#endif
{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 'd':
if (strlen(optarg) != 12
|| strspn(optarg, "0123456789abcdefABCDEF") != 12) {
ofp_fatal(0, "argument to -d or --datapath-id must be "
"exactly 12 hex digits");
}
dpid = strtoll(optarg, NULL, 16);
if (!dpid) {
ofp_fatal(0, "argument to -d or --datapath-id must "
"be nonzero");
}
break;
case 'h':
usage();
case 'V':
printf("%s %s compiled "__DATE__" "__TIME__"\n",
program_name, VERSION BUILDNR);
exit(EXIT_SUCCESS);
case 'v':
vlog_set_verbosity(optarg);
break;
case 'i':
if (!port_list) {
port_list = optarg;
} else {
port_list = xasprintf("%s,%s", port_list, optarg);
}
break;
case OPT_MAX_BACKOFF:
max_backoff = atoi(optarg);
if (max_backoff < 1) {
ofp_fatal(0, "--max-backoff argument must be at least 1");
} else if (max_backoff > 3600) {
max_backoff = 3600;
}
break;
case OPT_MFR_DESC:
strncpy(mfr_desc, optarg, sizeof mfr_desc);
break;
case OPT_HW_DESC:
strncpy(hw_desc, optarg, sizeof hw_desc);
break;
case OPT_SW_DESC:
strncpy(sw_desc, optarg, sizeof sw_desc);
break;
case OPT_SERIAL_NUM:
strncpy(serial_num, optarg, sizeof serial_num);
break;
case 'l':
if (listen_pvconn_name) {
ofp_fatal(0, "-l or --listen may be only specified once");
}
listen_pvconn_name = optarg;
break;
DAEMON_OPTION_HANDLERS
#ifdef HAVE_OPENSSL
VCONN_SSL_OPTION_HANDLERS
case OPT_BOOTSTRAP_CA_CERT:
vconn_ssl_set_ca_cert_file(optarg, true);
break;
#endif
case '?':
exit(EXIT_FAILURE);
default:
abort();
}
}
free(short_options);
}