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;
}
/* Parses OVN actions, in the format described for the "actions" column in the
* Logical_Flow table in ovn-sb(5), and appends the parsed versions of the
* actions to 'ofpacts' as "struct ofpact"s.
*
* 'symtab' provides a table of "struct expr_symbol"s to support (as one would
* provide to expr_parse()).
*
* 'ports' must be a map from strings (presumably names of ports) to integers
* (as one would provide to expr_to_matches()). Strings used in the actions
* that are not in 'ports' are translated to zero.
*
* 'ct_zones' provides a map from a port name to its connection tracking zone.
*
* OVN maps each logical flow table (ltable), one-to-one, onto a physical
* OpenFlow flow table (ptable). A number of parameters describe this mapping
* and data related to flow tables:
*
* - 'first_ptable' and 'n_tables' define the range of OpenFlow tables to
* which the logical "next" action should be able to jump. Logical table
* 0 maps to OpenFlow table 'first_ptable', logical table 1 to
* 'first_ptable + 1', and so on. If 'n_tables' is 0 then "next" is
* disallowed entirely.
*
* - 'cur_ltable' is an offset from 'first_ptable' (e.g. 0 <= cur_ltable <
* n_ptables) of the logical flow that contains the actions. If
* cur_ltable + 1 < n_tables, then this defines the default table that
* "next" will jump to.
*
* 'next_table_id' should be the OpenFlow table to which the "next" action will
* resubmit, or 0 to disable "next".
*
* - 'output_ptable' should be the OpenFlow table to which the logical
* "output" action will resubmit
*
* Some actions add extra requirements (prerequisites) to the flow's match. If
* so, this function sets '*prereqsp' to the actions' prerequisites; otherwise,
* it sets '*prereqsp' to NULL. The caller owns '*prereqsp' and must
* eventually free it.
*
* Returns NULL on success, otherwise a malloc()'d error message that the
* caller must free. On failure, 'ofpacts' has the same contents and
* '*prereqsp' is set to NULL, but some tokens may have been consumed from
* 'lexer'.
*/
char * OVS_WARN_UNUSED_RESULT
actions_parse(struct lexer *lexer, const struct shash *symtab,
const struct simap *ports, const struct simap *ct_zones,
uint8_t first_ptable, uint8_t n_tables, uint8_t cur_ltable,
uint8_t output_ptable, struct ofpbuf *ofpacts,
struct expr **prereqsp)
{
size_t ofpacts_start = ofpacts->size;
struct action_context ctx;
ctx.lexer = lexer;
ctx.symtab = symtab;
ctx.ports = ports;
ctx.ct_zones = ct_zones;
ctx.first_ptable = first_ptable;
ctx.n_tables = n_tables;
ctx.cur_ltable = cur_ltable;
ctx.output_ptable = output_ptable;
ctx.error = NULL;
ctx.ofpacts = ofpacts;
ctx.prereqs = NULL;
parse_actions(&ctx);
if (!ctx.error) {
*prereqsp = ctx.prereqs;
return NULL;
} else {
ofpacts->size = ofpacts_start;
expr_destroy(ctx.prereqs);
*prereqsp = NULL;
return ctx.error;
}
}
/* Parses OVN actions, in the format described for the "actions" column in the
* Logical_Flow table in ovn-sb(5), and appends the parsed versions of the
* actions to 'ofpacts' as "struct ofpact"s.
*
* 'ap' provides most of the parameters for translation.
*
* Some actions add extra requirements (prerequisites) to the flow's match. If
* so, this function sets '*prereqsp' to the actions' prerequisites; otherwise,
* it sets '*prereqsp' to NULL. The caller owns '*prereqsp' and must
* eventually free it.
*
* Returns NULL on success, otherwise a malloc()'d error message that the
* caller must free. On failure, 'ofpacts' has the same contents and
* '*prereqsp' is set to NULL, but some tokens may have been consumed from
* 'lexer'.
*/
char * OVS_WARN_UNUSED_RESULT
actions_parse(struct lexer *lexer, const struct action_params *ap,
struct ofpbuf *ofpacts, struct expr **prereqsp)
{
size_t ofpacts_start = ofpacts->size;
struct action_context ctx = {
.ap = ap,
.lexer = lexer,
.error = NULL,
.ofpacts = ofpacts,
.prereqs = NULL,
};
parse_actions(&ctx);
if (!ctx.error) {
*prereqsp = ctx.prereqs;
return NULL;
} else {
ofpacts->size = ofpacts_start;
expr_destroy(ctx.prereqs);
*prereqsp = NULL;
return ctx.error;
}
}
void parse_config()
{
FILE *f = NULL;
fprintf(stderr,"Reading configuration file: \"%s\" ...\n",config_path);
if( (f=fopen (config_path, "r")) == NULL )
{
perror("fopen");
exit(1);
}
LIBXML_TEST_VERSION;
/* create a parser context */
ctxt = xmlNewParserCtxt();
if (ctxt == NULL)
{
fprintf(stderr, "Failed to allocate parser context\n");
fclose(f);
return;
}
/* parse the file, activating the DTD validation option */
doc = xmlCtxtReadFile(ctxt, config_path, NULL, XML_PARSE_DTDVALID);
/* check if parsing suceeded */
if (doc == NULL)
{
fprintf(stderr, "Failed to parse %s\n", config_path);
}
else
{
/* check if validation suceeded */
if (ctxt->valid == 0)
fprintf(stderr, "Failed to validate %s\n", config_path);
/* free up the resulting document */
else
{
xmlXPathInit();
xpctxt= xmlXPathNewContext(doc);
}
}
autoconf();
get_mail();
init_syslog();
parse_routers();
parse_actions();
#ifdef _COUNTERMEASURES_
parse_countermeasures();
#endif
free_xml();
fclose(f);
fprintf(stderr," Done.\n");
}
int
main(int argc, char *argv[])
{
if (argc == 2 &&!strcmp(argv[1], "parse-keys")) {
return parse_keys(false);
} else if (argc == 2 &&!strcmp(argv[1], "parse-wc-keys")) {
return parse_keys(true);
} else if (argc == 2 && !strcmp(argv[1], "parse-actions")) {
return parse_actions();
} else {
ovs_fatal(0, "usage: %s parse-keys | parse-wc-keys | parse-actions", argv[0]);
}
}
void make_parser() {
register int i;
parser = NEW2(nstates, action *);
for (i = 0; i < nstates; i++)
parser[i] = parse_actions(i);
find_final_state();
remove_conflicts();
unused_rules();
if (SRtotal + RRtotal > 0) total_conflicts();
defreds();
}
static void
test_odp_main(int argc, char *argv[])
{
int exit_code = 0;
set_program_name(argv[0]);
if (argc == 2 &&!strcmp(argv[1], "parse-keys")) {
exit_code =parse_keys(false);
} else if (argc == 2 &&!strcmp(argv[1], "parse-wc-keys")) {
exit_code =parse_keys(true);
} else if (argc == 2 && !strcmp(argv[1], "parse-actions")) {
exit_code = parse_actions();
} else if (argc == 3 && !strcmp(argv[1], "parse-filter")) {
exit_code =parse_filter(argv[2]);
} else {
ovs_fatal(0, "usage: %s parse-keys | parse-wc-keys | parse-actions", argv[0]);
}
exit(exit_code);
}
static int
parse_keys(bool wc_keys)
{
int exit_code = 0;
struct ds in;
ds_init(&in);
vlog_set_levels_from_string_assert("odp_util:console:dbg");
while (!ds_get_test_line(&in, stdin)) {
enum odp_key_fitness fitness;
struct ofpbuf odp_key;
struct ofpbuf odp_mask;
struct flow flow;
struct ds out;
int error;
/* Convert string to OVS DP key. */
ofpbuf_init(&odp_key, 0);
ofpbuf_init(&odp_mask, 0);
error = odp_flow_from_string(ds_cstr(&in), NULL,
&odp_key, &odp_mask);
if (error) {
printf("odp_flow_from_string: error\n");
goto next;
}
if (!wc_keys) {
struct odp_flow_key_parms odp_parms = {
.flow = &flow,
.recirc = true,
};
/* Convert odp_key to flow. */
fitness = odp_flow_key_to_flow(odp_key.data, odp_key.size, &flow);
switch (fitness) {
case ODP_FIT_PERFECT:
break;
case ODP_FIT_TOO_LITTLE:
printf("ODP_FIT_TOO_LITTLE: ");
break;
case ODP_FIT_TOO_MUCH:
printf("ODP_FIT_TOO_MUCH: ");
break;
case ODP_FIT_ERROR:
printf("odp_flow_key_to_flow: error\n");
goto next;
}
/* Convert cls_rule back to odp_key. */
ofpbuf_uninit(&odp_key);
ofpbuf_init(&odp_key, 0);
odp_parms.odp_in_port = flow.in_port.odp_port;
odp_flow_key_from_flow(&odp_parms, &odp_key);
if (odp_key.size > ODPUTIL_FLOW_KEY_BYTES) {
printf ("too long: %"PRIu32" > %d\n",
odp_key.size, ODPUTIL_FLOW_KEY_BYTES);
exit_code = 1;
}
}
/* Convert odp_key to string. */
ds_init(&out);
if (wc_keys) {
odp_flow_format(odp_key.data, odp_key.size,
odp_mask.data, odp_mask.size, NULL, &out, false);
} else {
odp_flow_key_format(odp_key.data, odp_key.size, &out);
}
puts(ds_cstr(&out));
ds_destroy(&out);
next:
ofpbuf_uninit(&odp_key);
}
ds_destroy(&in);
return exit_code;
}
static int
parse_actions(void)
{
struct ds in;
ds_init(&in);
vlog_set_levels_from_string_assert("odp_util:console:dbg");
while (!ds_get_test_line(&in, stdin)) {
struct ofpbuf odp_actions;
struct ds out;
int error;
/* Convert string to OVS DP actions. */
ofpbuf_init(&odp_actions, 0);
error = odp_actions_from_string(ds_cstr(&in), NULL, &odp_actions);
if (error) {
printf("odp_actions_from_string: error\n");
goto next;
}
/* Convert odp_actions back to string. */
ds_init(&out);
format_odp_actions(&out, odp_actions.data, odp_actions.size);
puts(ds_cstr(&out));
ds_destroy(&out);
next:
ofpbuf_uninit(&odp_actions);
}
ds_destroy(&in);
return 0;
}
static int
parse_filter(char *filter_parse)
{
struct ds in;
struct flow flow_filter;
struct flow_wildcards wc_filter;
char *error, *filter = NULL;
vlog_set_levels_from_string_assert("odp_util:console:dbg");
if (filter_parse && !strncmp(filter_parse, "filter=", 7)) {
filter = xstrdup(filter_parse + 7);
memset(&flow_filter, 0, sizeof(flow_filter));
memset(&wc_filter, 0, sizeof(wc_filter));
error = parse_ofp_exact_flow(&flow_filter, &wc_filter.masks, filter,
NULL);
if (error) {
ovs_fatal(0, "Failed to parse filter (%s)", error);
}
} else {
ovs_fatal(0, "No filter to parse.");
}
ds_init(&in);
while (!ds_get_test_line(&in, stdin)) {
struct ofpbuf odp_key;
struct ofpbuf odp_mask;
struct ds out;
int error;
/* Convert string to OVS DP key. */
ofpbuf_init(&odp_key, 0);
ofpbuf_init(&odp_mask, 0);
error = odp_flow_from_string(ds_cstr(&in), NULL,
&odp_key, &odp_mask);
if (error) {
printf("odp_flow_from_string: error\n");
goto next;
}
if (filter) {
struct flow flow;
struct flow_wildcards wc;
struct match match, match_filter;
struct minimatch minimatch;
odp_flow_key_to_flow(odp_key.data, odp_key.size, &flow);
odp_flow_key_to_mask(odp_mask.data, odp_mask.size, &wc.masks,
&flow);
match_init(&match, &flow, &wc);
match_init(&match_filter, &flow_filter, &wc);
match_init(&match_filter, &match_filter.flow, &wc_filter);
minimatch_init(&minimatch, &match_filter);
if (!minimatch_matches_flow(&minimatch, &match.flow)) {
minimatch_destroy(&minimatch);
goto next;
}
minimatch_destroy(&minimatch);
}
/* Convert odp_key to string. */
ds_init(&out);
odp_flow_format(odp_key.data, odp_key.size,
odp_mask.data, odp_mask.size, NULL, &out, false);
puts(ds_cstr(&out));
ds_destroy(&out);
next:
ofpbuf_uninit(&odp_key);
ofpbuf_uninit(&odp_mask);
}
ds_destroy(&in);
free(filter);
return 0;
}
static void
test_odp_main(int argc, char *argv[])
{
int exit_code = 0;
set_program_name(argv[0]);
if (argc == 2 &&!strcmp(argv[1], "parse-keys")) {
exit_code =parse_keys(false);
} else if (argc == 2 &&!strcmp(argv[1], "parse-wc-keys")) {
exit_code =parse_keys(true);
} else if (argc == 2 && !strcmp(argv[1], "parse-actions")) {
exit_code = parse_actions();
} else if (argc == 3 && !strcmp(argv[1], "parse-filter")) {
exit_code =parse_filter(argv[2]);
} else {
ovs_fatal(0, "usage: %s parse-keys | parse-wc-keys | parse-actions", argv[0]);
}
exit(exit_code);
}
Parser::Parser(string fileName) {
//INITIALIZTIONS
ifstream dataFile;
string line;
string data;
start_idx = 0;
element_counter=0;
elements[17]=new Element(">$<");
elements[18]=new Element(">$<");
for(int i=0 ; i < 141; i++) locations[i] = NULL; //Thanks Charlie
int section = 0;
dataFile.open(fileName.c_str());
if(!dataFile.eof()){
while(getline(dataFile,line)){
data += line + END_LINE;
int first_number = getFirstNumberOf(line);
if(SEPARATOR == first_number){
section++;
}
switch(section){
case LONG_DESC_SECTION:
parse_locations(line, first_number);
break;
case SHORT_DESC_SECTION:
break;
case TRAVEL_TABLE:
parse_travel_table(line, first_number);
break;
case VOCABULARY:
parse_vocabulary(line);
break;
case ELEMENT_DESC:
parse_element_desc(line);
break;
case ELEMENT_LOCATION:
parse_element_location(line);
break;
case ABBR_MSG:
parse_abbr_msg(line);
break;
case ACTIONS:
parse_actions(line);
break;
case LIQUID_ASSET:
break;
case CLASS_MSG:
parse_player_classification(line);
break;
case HINTS:
break;
case MAGIC_WORDS:
break;
}//endSwitch
}//endWhile
dataFile.close();
}
}
