EXPORT
std::unique_ptr<rexgen::Iterator> regex_iterator(const char* regex, const rexgen::RexgenOptions& options) {
if (auto re = parse_regex(regex, options)) {
return std::make_unique<rexgen::TopIterator>(re);
}
return nullptr;
}
static int
set_record(struct _std_event *ev_ptr, char *response,struct _firewall_info *fw_info){
if(fw_info){
/* equals to NULL means its a key value firewall
* else a regular expression firewall
*/
if(fw_info->fw_regex == NULL) {
//printf(" key value type log \n");
if(parse_keyvalue(ev_ptr,response,fw_info->un.kv)<0){
//printf("Not able to parse kv_pair\n");
return -1;
}
}else{
#ifdef REGEX
if( regex_event_count++ < MAX_REGEX_EVENTS ){
char logid[50];
//int i_log_id;
struct _log_info *found_log_info=NULL;
//printf(" regex type log $log=%s\n",response);
sv_setpvf(sv , "$log='%s'" , response);
eval_sv(sv , G_SCALAR);
/* Apply fw_info->regex and get log id
* use that log id to get log_info struct from log_info_hash
*/
if(SvIV(eval_pv(fw_info->fw_regex,TRUE))){
strncpy(logid,SvPV(get_sv("logtype" , FALSE) , n_a), sizeof(logid)-1);
//printf(" logtype = -%s-\n" , logid);
//i_log_id=atoi(logid);
HASH_FIND_STR(fw_info->un.log_hash, logid , found_log_info);
if(found_log_info==NULL){
printf(" no log info found for logid %s\n",logid);
return -1;
}
if( parse_regex( ev_ptr, response, found_log_info )<0 ){
printf(" parsing regex error %s\n",logid);
return -1;
}
}else{
printf("fw_regex did not work \n");
}
}else{
regex_event_count=0;
perl_reset();
}
#endif
}
}else{
printf("fw_info for given ip address is blank.%s\n",response);
return -1;
}
return 1;
}
static t_reg *compile_regex(t_parse_reg *p)
{
t_reg *reg;
if (parse_regex(p, 0, ®, '\0') == REG_FAIL)
return (NULL);
p->capture_index = 0;
if (check_capture_indexes(p, reg))
return (reg);
return (F**K(destroy_reg(reg), NULL));
}
void parse_regex(Regex regex_result, char* regex_str, bool is_escaped)
{
if (*regex_str == '\0' )
{
regex_result[0] = NULL;
return;
}
if (is_escaped || !strchr(SPECIAL_CHARS, *regex_str))
{
generate_regex_struct(regex_result, regex_str, simple_char);
parse_regex(++regex_result, regex_str + 1, false);
}
else if (*regex_str == '\\')
parse_regex(regex_result, regex_str + 1, true);
else
{
switch (*regex_str) {
case '.':
generate_regex_struct(regex_result, regex_str, dot);
parse_regex(++regex_result, regex_str+1, false);
break;
case '[':
generate_regex_struct(regex_result, regex_str, brackets);
parse_regex(++regex_result, regex_str+4, false);
break;
case '(':
generate_regex_struct(regex_result, regex_str, parenthesis);
parse_regex(regex_result[0]->optionA, regex_str+1, false);
char *after_pipe = strchr(regex_str, '|') + 1;
parse_regex(regex_result[0]->optionB, after_pipe, false);
char *after_parents = strchr(regex_str, ')') + 1;
parse_regex(++regex_result, after_parents, false);
break;
case '|':
case '{':
case ']':
case '}':
case ')':
*regex_result = NULL;
break;
}
}
}
pattern_t* shre_compile(char* regex) {
assert(ptable);
assert(regex);
// look for pattern in hashtable
pattern_t* pattern = (pattern_t*) obhash_find(ptable, regex);
if (pattern)
return pattern;
// build a new pattern
obhash_t* names = NULL;
tlist_t* tokens = parse_regex(regex, &names);
if (!tokens)
return NULL; // bad regular expression; shre_er is tree
pattern = malloc(sizeof(pattern_t));
assert(pattern);
pattern->regex = strdup(regex);
pattern->names = names;
pattern->core = build_core(tokens);
obhash_add(ptable, pattern->regex, pattern); // add new pattern
return pattern;
}
static Command *command_parse(Vis *vis, const char **s, int level, enum SamError *err) {
if (!**s)
return NULL;
Command *cmd = command_new(NULL);
if (!cmd)
return NULL;
cmd->address = address_parse_compound(vis, s, err);
skip_spaces(s);
cmd->argv[0] = parse_cmdname(s);
if (!cmd->argv[0]) {
char name[2] = { **s ? **s : 'p', '\0' };
if (**s)
(*s)++;
if (!(cmd->argv[0] = strdup(name)))
goto fail;
}
const CommandDef *cmddef = command_lookup(vis, cmd->argv[0]);
if (!cmddef) {
*err = SAM_ERR_COMMAND;
goto fail;
}
cmd->cmddef = cmddef;
if (strcmp(cmd->argv[0], "{") == 0) {
Command *prev = NULL, *next;
do {
skip_spaces(s);
if (**s == '\n')
(*s)++;
next = command_parse(vis, s, level+1, err);
if (prev)
prev->next = next;
else
cmd->cmd = next;
} while ((prev = next));
} else if (strcmp(cmd->argv[0], "}") == 0) {
if (level == 0) {
*err = SAM_ERR_UNMATCHED_BRACE;
goto fail;
}
command_free(cmd);
return NULL;
}
if (cmddef->flags & CMD_ADDRESS_NONE && cmd->address) {
*err = SAM_ERR_NO_ADDRESS;
goto fail;
}
if (cmddef->flags & CMD_COUNT)
cmd->count = parse_number(s);
if (cmddef->flags & CMD_FORCE && **s == '!') {
cmd->flags = '!';
(*s)++;
}
if (cmddef->flags & CMD_FILE) {
if (!(cmd->argv[1] = parse_filename(s)) && cmd->argv[0][0] != 'w') {
*err = SAM_ERR_FILENAME;
goto fail;
}
}
if (cmddef->flags & CMD_REGEX) {
if ((cmddef->flags & CMD_REGEX_DEFAULT) && (!**s || **s == ' ')) {
skip_spaces(s);
} else if (!(cmd->regex = parse_regex(vis, s))) {
*err = SAM_ERR_REGEX;
goto fail;
}
}
if (cmddef->flags & CMD_SHELL && !(cmd->argv[1] = parse_shellcmd(s))) {
*err = SAM_ERR_SHELL;
goto fail;
}
if (cmddef->flags & CMD_TEXT && !(cmd->argv[1] = parse_text(s))) {
*err = SAM_ERR_TEXT;
goto fail;
}
if (cmddef->flags & CMD_ARGV) {
parse_argv(s, &cmd->argv[1], MAX_ARGV-2);
cmd->argv[MAX_ARGV-1] = NULL;
}
if (cmddef->flags & CMD_CMD) {
skip_spaces(s);
if (cmddef->defcmd && (**s == '\n' || **s == '\0')) {
if (**s == '\n')
(*s)++;
if (!(cmd->cmd = command_new(cmddef->defcmd)))
goto fail;
cmd->cmd->cmddef = command_lookup(vis, cmddef->defcmd);
} else {
if (!(cmd->cmd = command_parse(vis, s, level, err)))
goto fail;
if (strcmp(cmd->argv[0], "X") == 0 || strcmp(cmd->argv[0], "Y") == 0) {
Command *sel = command_new("s");
if (!sel)
goto fail;
sel->cmd = cmd->cmd;
sel->cmddef = &cmddef_select;
cmd->cmd = sel;
}
}
}
return cmd;
fail:
command_free(cmd);
return NULL;
}
static Address *address_parse_simple(Vis *vis, const char **s, enum SamError *err) {
skip_spaces(s);
Address addr = {
.type = **s,
.regex = NULL,
.number = 0,
.left = NULL,
.right = NULL,
};
switch (addr.type) {
case '#': /* character #n */
(*s)++;
addr.number = parse_number(s);
break;
case '0': case '1': case '2': case '3': case '4': /* line n */
case '5': case '6': case '7': case '8': case '9':
addr.type = 'l';
addr.number = parse_number(s);
break;
case '/': /* regexp forwards */
case '?': /* regexp backwards */
addr.regex = parse_regex(vis, s);
if (!addr.regex) {
*err = SAM_ERR_REGEX;
return NULL;
}
break;
case '$': /* end of file */
case '.':
case '+':
case '-':
case '%':
(*s)++;
break;
default:
return NULL;
}
if ((addr.right = address_parse_simple(vis, s, err))) {
switch (addr.right->type) {
case '.':
case '$':
return NULL;
case '#':
case 'l':
case '/':
case '?':
if (addr.type != '+' && addr.type != '-') {
Address *plus = address_new();
if (!plus) {
address_free(addr.right);
return NULL;
}
plus->type = '+';
plus->right = addr.right;
addr.right = plus;
}
break;
}
}
Address *ret = address_new();
if (!ret) {
address_free(addr.right);
return NULL;
}
*ret = addr;
return ret;
}
static Address *address_parse_compound(Vis *vis, const char **s, enum SamError *err) {
Address addr = { 0 }, *left = address_parse_simple(vis, s, err), *right = NULL;
skip_spaces(s);
addr.type = **s;
switch (addr.type) {
case ',': /* a1,a2 */
case ';': /* a1;a2 */
(*s)++;
right = address_parse_compound(vis, s, err);
if (right && (right->type == ',' || right->type == ';') && !right->left) {
*err = SAM_ERR_ADDRESS;
goto fail;
}
break;
default:
return left;
}
addr.left = left;
addr.right = right;
Address *ret = address_new();
if (ret) {
*ret = addr;
return ret;
}
fail:
address_free(left);
address_free(right);
return NULL;
}
