fincy new scanner/parser for config rules + fixed a few bugs along the way + fixed related unittests

1 files changed, 159 insertions, 146 deletions

diff --git a/src/sp_config.c b/src/sp_config.c
index 37c749b..4d96bbe 100644
--- a/src/sp_config.c
+++ b/src/sp_config.c
@@ -4,102 +4,140 @@
 
 #include "php_snuffleupagus.h"
 
-size_t sp_line_no;
 
-static sp_config_tokens const sp_func[] = {
-    {.func = parse_unserialize, .token = SP_TOKEN_UNSERIALIZE_HMAC},
-    {.func = parse_random, .token = SP_TOKEN_HARDEN_RANDOM},
-    {.func = parse_log_media, .token = SP_TOKEN_LOG_MEDIA},
-    {.func = parse_disabled_functions, .token = SP_TOKEN_DISABLE_FUNC},
-    {.func = parse_readonly_exec, .token = SP_TOKEN_READONLY_EXEC},
-    {.func = parse_global_strict, .token = SP_TOKEN_GLOBAL_STRICT},
-    {.func = parse_upload_validation, .token = SP_TOKEN_UPLOAD_VALIDATION},
-    {.func = parse_cookie, .token = SP_TOKEN_COOKIE_ENCRYPTION},
-    {.func = parse_global, .token = SP_TOKEN_GLOBAL},
-    {.func = parse_auto_cookie_secure, .token = SP_TOKEN_AUTO_COOKIE_SECURE},
-    {.func = parse_disable_xxe, .token = SP_TOKEN_DISABLE_XXE},
-    {.func = parse_eval_blacklist, .token = SP_TOKEN_EVAL_BLACKLIST},
-    {.func = parse_eval_whitelist, .token = SP_TOKEN_EVAL_WHITELIST},
-    {.func = parse_session, .token = SP_TOKEN_SESSION_ENCRYPTION},
-    {.func = parse_sloppy_comparison, .token = SP_TOKEN_SLOPPY_COMPARISON},
-    {.func = parse_wrapper_whitelist, .token = SP_TOKEN_ALLOW_WRAPPERS},
-    {.func = parse_ini_protection, .token = ".ini_protection"},
-    {.func = parse_ini_entry, .token = ".ini"},
-    {NULL, NULL}};
+static zend_result sp_process_config_root(sp_parsed_keyword *parsed_rule) {
+  sp_config_keyword sp_func[] = {
+    {parse_unserialize,         SP_TOKEN_UNSERIALIZE_HMAC, SNUFFLEUPAGUS_G(config).config_unserialize},
+    {parse_enable,              SP_TOKEN_HARDEN_RANDOM, &(SNUFFLEUPAGUS_G(config).config_random->enable)},
+    {parse_log_media,           SP_TOKEN_LOG_MEDIA, &(SNUFFLEUPAGUS_G(config).log_media)},
+    {parse_disabled_functions,  SP_TOKEN_DISABLE_FUNC, NULL},
+    {parse_readonly_exec,       SP_TOKEN_READONLY_EXEC, SNUFFLEUPAGUS_G(config).config_readonly_exec},
+    {parse_enable,              SP_TOKEN_GLOBAL_STRICT, &(SNUFFLEUPAGUS_G(config).config_global_strict->enable)},
+    {parse_upload_validation,   SP_TOKEN_UPLOAD_VALIDATION, SNUFFLEUPAGUS_G(config).config_upload_validation},
+    {parse_cookie,              SP_TOKEN_COOKIE_ENCRYPTION, NULL},
+    {parse_global,              SP_TOKEN_GLOBAL, NULL},
+    {parse_enable,              SP_TOKEN_AUTO_COOKIE_SECURE, &(SNUFFLEUPAGUS_G(config).config_auto_cookie_secure->enable)},
+    {parse_enable,              SP_TOKEN_DISABLE_XXE, &(SNUFFLEUPAGUS_G(config).config_disable_xxe->enable)},
+    {parse_eval_filter_conf,    SP_TOKEN_EVAL_BLACKLIST, &(SNUFFLEUPAGUS_G(config).config_eval->blacklist)},
+    {parse_eval_filter_conf,    SP_TOKEN_EVAL_WHITELIST, &(SNUFFLEUPAGUS_G(config).config_eval->whitelist)},
+    {parse_session,             SP_TOKEN_SESSION_ENCRYPTION, SNUFFLEUPAGUS_G(config).config_session},
+    {parse_enable,              SP_TOKEN_SLOPPY_COMPARISON, &(SNUFFLEUPAGUS_G(config).config_sloppy->enable)},
+    {parse_wrapper_whitelist,   SP_TOKEN_ALLOW_WRAPPERS, SNUFFLEUPAGUS_G(config).config_wrapper},
+    {parse_ini_protection,      SP_TOKEN_INI_PROTECTION, SNUFFLEUPAGUS_G(config).config_ini},
+    {parse_ini_entry,           SP_TOKEN_INI, SNUFFLEUPAGUS_G(config).config_unserialize},
+    {NULL, NULL, NULL}};
+  return sp_process_rule(parsed_rule, sp_func);
+}
 
-/* Top level keyword parsing */
+zend_result sp_parse_config(const char *filename) {
+  FILE *fd = fopen(filename, "rb");
+  if (fd == NULL) {
+    sp_log_err("config", "Could not open configuration file %s : %s", filename, strerror(errno));
+    return FAILURE;
+  }
 
-static int parse_line(char *line) {
-  char *ptr = line;
+  size_t step = 8192;
+  size_t max_len = step, len = 0;
+  zend_string *data = zend_string_alloc(max_len, 0);
+  char *ptr = ZSTR_VAL(data);
 
-  while (*ptr == ' ' || *ptr == '\t') {
-    ++ptr;
+  size_t bytes;
+  while ((bytes = fread(ptr, 1, max_len - len, fd))) {
+    len += bytes;
+    if (max_len - len <= 0) {
+      max_len += step;
+      data = zend_string_extend(data, max_len, 0);
+      ptr = ZSTR_VAL(data) + len;
+    } else {
+      ptr += bytes;
+    }
   }
+  fclose(fd);
 
-  if (!*ptr || *ptr == '#' || *ptr == ';') {
-    return 0;
-  }
+  data = zend_string_truncate(data, len, 0);
+  ZSTR_VAL(data)[len] = 0;
+
+  int ret = sp_config_scan(ZSTR_VAL(data), sp_process_config_root);
+
+  zend_string_release_ex(data, 0);
+
+  return ret;
+}
 
-  if (strncmp(ptr, SP_TOKEN_BASE, strlen(SP_TOKEN_BASE))) {
-    sp_log_err("config", "Invalid configuration prefix for '%s' on line %zu",
-               line, sp_line_no);
-    return -1;
-  }
-  ptr += strlen(SP_TOKEN_BASE);
 
-  for (size_t i = 0; sp_func[i].func; i++) {
-    if (!strncmp(sp_func[i].token, ptr, strlen(sp_func[i].token))) {
-      return sp_func[i].func(ptr + strlen(sp_func[i].token));
+zend_result sp_process_rule(sp_parsed_keyword *parsed_rule, sp_config_keyword *config_keywords) {
+  for (sp_parsed_keyword *kw = parsed_rule; kw->kw; kw++) {
+    bool found_kw = false;
+    for (sp_config_keyword *ckw = config_keywords; ckw->func; ckw++) {
+      if (kw->kwlen == strlen(ckw->token) && !strncmp(kw->kw, ckw->token, kw->kwlen)) {
+        if (ckw->func) {
+          int ret = ckw->func(ckw->token, kw, ckw->retval);
+          switch (ret) {
+            case SP_PARSER_SUCCESS:
+              break;
+            case SP_PARSER_ERROR:
+              return FAILURE;
+            case SP_PARSER_STOP:
+              return SUCCESS;
+          }
+        }
+        found_kw = true;
+        break;
+      }
+    }
+
+    if (!found_kw) {
+      zend_string *kwname = zend_string_init(kw->kw, kw->kwlen, 0);
+      sp_log_err("config", "Unexpected keyword '%s' on line %d", ZSTR_VAL(kwname), kw->lineno);
+      zend_string_release_ex(kwname, 0);
+      return FAILURE;
     }
   }
-  sp_log_err("config", "Invalid configuration section '%s' on line %zu", line,
-             sp_line_no);
-  return -1;
+  return SUCCESS;
 }
 
-/* keyword parsing */
 #define CHECK_DUPLICATE_KEYWORD(retval) \
   if (*(void**)(retval)) { \
-    sp_log_err("config", "duplicate %s) on line %zu near `%s`", keyword, sp_line_no, line); \
-    return -1; }
+    sp_log_err("config", "duplicate keyword '%s' on line %zu", token, kw->lineno); \
+    return SP_PARSER_ERROR; }
 
 
-int parse_empty(char *restrict line, char *restrict keyword, void *retval) {
+SP_PARSEKW_FN(parse_empty) {
+  if (kw->arglen) {
+    sp_log_err("config", "Unexpected argument for keyword '%s' - it should be '%s()' on line %zu", token, token, kw->lineno);
+    return SP_PARSER_ERROR;
+  }
+  if (kw->argtype != SP_ARGTYPE_EMPTY) {
+    sp_log_err("config", "Missing paranthesis for keyword '%s' - it should be '%s()' on line %zu", token, token, kw->lineno);
+    return SP_PARSER_ERROR;
+  }
   *(bool *)retval = true;
-  return 0;
+  return SP_PARSER_SUCCESS;
 }
 
-int parse_list(char *restrict line, char *restrict keyword, void *list_ptr) {
-  CHECK_DUPLICATE_KEYWORD(list_ptr);
-  zend_string *value = NULL;
-  sp_list_node **list = list_ptr;
-  char *token, *tmp;
+SP_PARSEKW_FN(parse_list) {
+  CHECK_DUPLICATE_KEYWORD(retval);
 
-  size_t consumed = 0;
-  value = get_param(&consumed, line, SP_TYPE_STR, keyword);
-  if (!value) {
-    return -1;
-  }
+  sp_list_node **list = retval;
+  char *tok, *tmp;
+
+  SP_PARSE_ARG(value);
 
   tmp = ZSTR_VAL(value);
   while (1) {
-    token = strsep(&tmp, ",");
-    if (token == NULL) {
+    tok = strsep(&tmp, ",");
+    if (tok == NULL) {
       break;
     }
-    *list = sp_list_insert(*list, zend_string_init(token, strlen(token), 1));
+    *list = sp_list_insert(*list, zend_string_init(tok, strlen(tok), 1));
   }
+  zend_string_release(value);
 
-  pefree(value, 1);
-  return consumed;
+  return SP_PARSER_SUCCESS;
 }
 
-int parse_php_type(char *restrict line, char *restrict keyword, void *retval) {
-  size_t consumed = 0;
-  zend_string *value = get_param(&consumed, line, SP_TYPE_STR, keyword);
-  if (!value) {
-    return -1;
-  }
+SP_PARSEKW_FN(parse_php_type) {
+  SP_PARSE_ARG(value);
 
   if (zend_string_equals_literal_ci(value, "undef")) {
     *(sp_php_type *)retval = SP_PHP_TYPE_UNDEF;
@@ -124,113 +162,88 @@ int parse_php_type(char *restrict line, char *restrict keyword, void *retval) {
   } else if (zend_string_equals_literal_ci(value, "reference")) {
     *(sp_php_type *)retval = SP_PHP_TYPE_REFERENCE;
   } else {
-    pefree(value, 1);
-    sp_log_err("error",
-                "%s) is expecting a valid php type ('false', 'true',"
+    zend_string_release(value);
+    sp_log_err("error", ".%s() is expecting a valid php type ('false', 'true',"
                 " 'array'. 'object', 'long', 'double', 'null', 'resource', "
-                "'reference', 'undef') on line %zu",
-                keyword, sp_line_no);
-    return -1;
+                "'reference', 'undef') on line %zu", token, kw->lineno);
+    return SP_PARSER_ERROR;
   }
-  pefree(value, 1);
-  return consumed;
+  zend_string_release(value);
+  return SP_PARSER_SUCCESS;
 }
 
-int parse_str(char *restrict line, char *restrict keyword, void *retval) {
+
+SP_PARSEKW_FN(parse_str) {
   CHECK_DUPLICATE_KEYWORD(retval);
-  zend_string *value = NULL;
+  SP_PARSE_ARG(value);
 
-  size_t consumed = 0;
-  value = get_param(&consumed, line, SP_TYPE_STR, keyword);
-  if (value) {
-    *(zend_string **)retval = value;
-    return consumed;
-  }
-  return -1;
+  *(zend_string **)retval = value;
+
+  return SP_PARSER_SUCCESS;
 }
 
-int parse_cidr(char *restrict line, char *restrict keyword, void *retval) {
-  CHECK_DUPLICATE_KEYWORD(retval);
+SP_PARSEKW_FN(parse_int) {
+  int ret = SP_PARSER_SUCCESS;
+  SP_PARSE_ARG(value);
+
+  char *endptr;
+  errno = 0;
+  *(int*)retval = (int)strtoimax(ZSTR_VAL(value), &endptr, 10);
+  if (errno != 0 || !endptr || endptr == ZSTR_VAL(value)) {
+    sp_log_err("config", "Failed to parse arg '%s' of `%s` on line %zu", ZSTR_VAL(value), token, kw->lineno);
+    ret = SP_PARSER_ERROR;
+  }
+  zend_string_release(value);
+  return ret;
+}
 
-  size_t consumed = 0;
-  zend_string *value = get_param(&consumed, line, SP_TYPE_STR, keyword);
+SP_PARSEKW_FN(parse_ulong) {
+  int ret = SP_PARSER_SUCCESS;
+  SP_PARSE_ARG(value);
 
-  if (!value) {
-    sp_log_err("config", "%s doesn't contain a valid cidr on line %zu", line, sp_line_no);
-    return -1;
+  char *endptr;
+  errno = 0;
+  *(u_long*)retval = (u_long)strtoul(ZSTR_VAL(value), &endptr, 10);
+  if (errno != 0 || !endptr || endptr == ZSTR_VAL(value)) {
+    sp_log_err("config", "Failed to parse arg '%s' of `%s` on line %zu", ZSTR_VAL(value), token, kw->lineno);
+    ret = SP_PARSER_ERROR;
   }
+  zend_string_release(value);
+  return ret;
+}
+
+SP_PARSEKW_FN(parse_cidr) {
+  CHECK_DUPLICATE_KEYWORD(retval);
+  SP_PARSE_ARG(value);
 
   sp_cidr *cidr = pecalloc(sizeof(sp_cidr), 1, 1);
 
   if (0 != get_ip_and_cidr(ZSTR_VAL(value), cidr)) {
     pefree(cidr, 1);
-    *(sp_cidr **)retval = NULL;
-    return -1;
+    cidr = NULL;
   }
 
   *(sp_cidr **)retval = cidr;
-  return consumed;
+  return cidr ? SP_PARSER_SUCCESS : SP_PARSER_ERROR;
 }
 
-int parse_regexp(char *restrict line, char *restrict keyword, void *retval) {
+SP_PARSEKW_FN(parse_regexp) {
   /* TODO: Do we want to use pcre_study?
    * (http://www.pcre.org/original/doc/html/pcre_study.html)
    * maybe not: http://sljit.sourceforge.net/pcre.html*/
   CHECK_DUPLICATE_KEYWORD(retval);
+  SP_PARSE_ARG(value);
 
-  size_t consumed = 0;
-  zend_string *value = get_param(&consumed, line, SP_TYPE_STR, keyword);
-
-  if (value) {
-    sp_pcre *compiled_re = sp_pcre_compile(ZSTR_VAL(value));
-    if (NULL != compiled_re) {
-      *(sp_pcre **)retval = compiled_re;
-      return consumed;
-    }
-  }
-  char *closing_paren = strchr(line, ')');
-  if (NULL != closing_paren) {
-    closing_paren[0] = '\0';
+  sp_pcre *compiled_re = sp_pcre_compile(ZSTR_VAL(value));
+  if (!compiled_re) {
+    sp_log_err("config", "Invalid regexp '%s' for '.%s()' on line %zu", ZSTR_VAL(value), token, kw->lineno);
+    zend_string_release_ex(value, 1);
+    return SP_PARSER_ERROR;
   }
-  sp_log_err("config",
-             "'%s)' is expecting a valid regexp, and not '%s' on line %zu",
-             keyword, line, sp_line_no);
-  return -1;
-}
 
-int sp_parse_config(const char *conf_file) {
-  FILE *fd = fopen(conf_file, "r");
-  char *lineptr = NULL;
-  size_t n = 0;
-  sp_line_no = 1;
+  *(sp_pcre **)retval = compiled_re;
 
-  if (fd == NULL) {
-    sp_log_err("config", "Could not open configuration file %s : %s", conf_file,
-               strerror(errno));
-    return FAILURE;
-  }
-
-  while (getline(&lineptr, &n, fd) > 0) {
-    /* We trash the terminal `\n`. This simplify the display of logs. */
-    if (lineptr[strlen(lineptr) - 1] == '\n') {
-      if (strlen(lineptr) >= 2 && lineptr[strlen(lineptr) - 2] == '\r') {
-        lineptr[strlen(lineptr) - 2] = '\0';
-      } else {
-        lineptr[strlen(lineptr) - 1] = '\0';
-      }
-    }
-    if (parse_line(lineptr) == -1) {
-      fclose(fd);
-      free(lineptr);
-      return FAILURE;
-    }
-    free(lineptr);
-    lineptr = NULL;
-    n = 0;
-    sp_line_no++;
-  }
-  fclose(fd);
-  return SUCCESS;
+  return SP_PARSER_SUCCESS;
 }
 
 void sp_free_disabled_function(void *data) {
@@ -292,4 +305,4 @@ void sp_free_ini_entry(void *data) {
   sp_pcre_free(entry->regexp);
   sp_free_zstr(entry->msg);
   sp_free_zstr(entry->set);
-}
\ No newline at end of file
+}