static void
update_ct_zones(struct sset *lports, struct simap *ct_zones,
unsigned long *ct_zone_bitmap)
{
struct simap_node *ct_zone, *ct_zone_next;
const char *iface_id;
int scan_start = 1;
/* xxx This is wasteful to assign a zone to each port--even if no
* xxx security policy is applied. */
/* Delete any zones that are associated with removed ports. */
SIMAP_FOR_EACH_SAFE(ct_zone, ct_zone_next, ct_zones) {
if (!sset_contains(lports, ct_zone->name)) {
bitmap_set0(ct_zone_bitmap, ct_zone->data);
simap_delete(ct_zones, ct_zone);
}
}
/* Assign a unique zone id for each logical port. */
SSET_FOR_EACH(iface_id, lports) {
size_t zone;
if (simap_contains(ct_zones, iface_id)) {
continue;
}
/* We assume that there are 64K zones and that we own them all. */
zone = bitmap_scan(ct_zone_bitmap, 0, scan_start, MAX_CT_ZONES + 1);
if (zone == MAX_CT_ZONES + 1) {
static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 1);
VLOG_WARN_RL(&rl, "exhausted all ct zones");
return;
}
scan_start = zone + 1;
bitmap_set1(ct_zone_bitmap, zone);
simap_put(ct_zones, iface_id, zone);
/* xxx We should erase any old entries for this
* xxx zone, but we need a generic interface to the conntrack
* xxx table. */
}
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;
}
