1 files changed, 247 insertions, 193 deletions

diff --git a/src/sp_config.c b/src/sp_config.c
index c12b435..7294b0e 100644
--- a/src/sp_config.c
+++ b/src/sp_config.c
@@ -4,248 +4,302 @@
 
 #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},
-    {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, &(SPCFG(unserialize))},
+    {parse_enable,              SP_TOKEN_HARDEN_RANDOM, &(SPCFG(random).enable)},
+    {parse_log_media,           SP_TOKEN_LOG_MEDIA, &(SPCFG(log_media))},
+    {parse_disabled_functions,  SP_TOKEN_DISABLE_FUNC, NULL},
+    {parse_readonly_exec,       SP_TOKEN_READONLY_EXEC, &(SPCFG(readonly_exec))},
+    {parse_enable,              SP_TOKEN_GLOBAL_STRICT, &(SPCFG(global_strict).enable)},
+    {parse_upload_validation,   SP_TOKEN_UPLOAD_VALIDATION, &(SPCFG(upload_validation))},
+    {parse_cookie,              SP_TOKEN_COOKIE_ENCRYPTION, NULL},
+    {parse_global,              SP_TOKEN_GLOBAL, NULL},
+    {parse_enable,              SP_TOKEN_AUTO_COOKIE_SECURE, &(SPCFG(auto_cookie_secure).enable)},
+    {parse_enable,              SP_TOKEN_XXE_PROTECTION, &(SPCFG(xxe_protection).enable)},
+    {parse_eval_filter_conf,    SP_TOKEN_EVAL_BLACKLIST, &(SPCFG(eval).blacklist)},
+    {parse_eval_filter_conf,    SP_TOKEN_EVAL_WHITELIST, &(SPCFG(eval).whitelist)},
+    {parse_session,             SP_TOKEN_SESSION_ENCRYPTION, &(SPCFG(session))},
+    {parse_enable,              SP_TOKEN_SLOPPY_COMPARISON, &(SPCFG(sloppy).enable)},
+    {parse_wrapper_whitelist,   SP_TOKEN_ALLOW_WRAPPERS, &(SPCFG(wrapper))},
+    {parse_ini_protection,      SP_TOKEN_INI_PROTECTION, &(SPCFG(ini))},
+    {parse_ini_entry,           SP_TOKEN_INI, NULL},
+    {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;
 
-  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);
+  int ret = sp_config_scan(ZSTR_VAL(data), sp_process_config_root);
 
-  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_string_release_ex(data, 0);
+
+  return ret;
+}
+
+
+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 */
-int parse_empty(char *restrict line, char *restrict keyword, void *retval) {
+#define CHECK_DUPLICATE_KEYWORD(retval) \
+  if (*(void**)(retval)) { \
+    sp_log_err("config", "duplicate keyword '%s' on line %zu", token, kw->lineno); \
+    return SP_PARSER_ERROR; }
+
+
+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) {
-  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) {
-    if (zend_string_equals_literal_ci(value, "undef")) {
-      *(sp_php_type *)retval = SP_PHP_TYPE_UNDEF;
-    } else if (zend_string_equals_literal_ci(value, "null")) {
-      *(sp_php_type *)retval = SP_PHP_TYPE_NULL;
-    } else if (zend_string_equals_literal_ci(value, "true")) {
-      *(sp_php_type *)retval = SP_PHP_TYPE_TRUE;
-    } else if (zend_string_equals_literal_ci(value, "false")) {
-      *(sp_php_type *)retval = SP_PHP_TYPE_FALSE;
-    } else if (zend_string_equals_literal_ci(value, "long")) {
-      *(sp_php_type *)retval = SP_PHP_TYPE_LONG;
-    } else if (zend_string_equals_literal_ci(value, "double")) {
-      *(sp_php_type *)retval = SP_PHP_TYPE_DOUBLE;
-    } else if (zend_string_equals_literal_ci(value, "string")) {
-      *(sp_php_type *)retval = SP_PHP_TYPE_STRING;
-    } else if (zend_string_equals_literal_ci(value, "array")) {
-      *(sp_php_type *)retval = SP_PHP_TYPE_ARRAY;
-    } else if (zend_string_equals_literal_ci(value, "object")) {
-      *(sp_php_type *)retval = SP_PHP_TYPE_OBJECT;
-    } else if (zend_string_equals_literal_ci(value, "resource")) {
-      *(sp_php_type *)retval = SP_PHP_TYPE_RESOURCE;
-    } 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',"
-                 " 'array'. 'object', 'long', 'double', 'null', 'resource', "
-                 "'reference', 'undef') on line %zu",
-                 keyword, sp_line_no);
-      return -1;
-    }
-    pefree(value, 1);
-    return consumed;
+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;
+  } else if (zend_string_equals_literal_ci(value, "null")) {
+    *(sp_php_type *)retval = SP_PHP_TYPE_NULL;
+  } else if (zend_string_equals_literal_ci(value, "true")) {
+    *(sp_php_type *)retval = SP_PHP_TYPE_TRUE;
+  } else if (zend_string_equals_literal_ci(value, "false")) {
+    *(sp_php_type *)retval = SP_PHP_TYPE_FALSE;
+  } else if (zend_string_equals_literal_ci(value, "long")) {
+    *(sp_php_type *)retval = SP_PHP_TYPE_LONG;
+  } else if (zend_string_equals_literal_ci(value, "double")) {
+    *(sp_php_type *)retval = SP_PHP_TYPE_DOUBLE;
+  } else if (zend_string_equals_literal_ci(value, "string")) {
+    *(sp_php_type *)retval = SP_PHP_TYPE_STRING;
+  } else if (zend_string_equals_literal_ci(value, "array")) {
+    *(sp_php_type *)retval = SP_PHP_TYPE_ARRAY;
+  } else if (zend_string_equals_literal_ci(value, "object")) {
+    *(sp_php_type *)retval = SP_PHP_TYPE_OBJECT;
+  } else if (zend_string_equals_literal_ci(value, "resource")) {
+    *(sp_php_type *)retval = SP_PHP_TYPE_RESOURCE;
+  } else if (zend_string_equals_literal_ci(value, "reference")) {
+    *(sp_php_type *)retval = SP_PHP_TYPE_REFERENCE;
   } else {
-    return -1;
+    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", token, kw->lineno);
+    return SP_PARSER_ERROR;
   }
+  zend_string_release(value);
+  return SP_PARSER_SUCCESS;
 }
 
-int parse_str(char *restrict line, char *restrict keyword, void *retval) {
-  zend_string *value = NULL;
 
-  size_t consumed = 0;
-  value = get_param(&consumed, line, SP_TYPE_STR, keyword);
-  if (value) {
-    *(zend_string **)retval = value;
-    return consumed;
-  }
-  return -1;
+SP_PARSEKW_FN(parse_str) {
+  CHECK_DUPLICATE_KEYWORD(retval);
+  SP_PARSE_ARG(value);
+
+  *(zend_string **)retval = value;
+
+  return SP_PARSER_SUCCESS;
 }
 
-int parse_cidr(char *restrict line, char *restrict keyword, void *retval) {
-  size_t consumed = 0;
-  zend_string *value = get_param(&consumed, line, SP_TYPE_STR, keyword);
-  sp_cidr *cidr = pecalloc(sizeof(sp_cidr), 1, 1);
+SP_PARSEKW_FN(parse_int) {
+  int ret = SP_PARSER_SUCCESS;
+  SP_PARSE_ARG(value);
 
-  if (value) {
-    if (-1 == get_ip_and_cidr(ZSTR_VAL(value), cidr)) {
-      return -1;
-    }
-    *(sp_cidr **)retval = cidr;
-    return consumed;
-  } else {
-    sp_log_err("config", "%s doesn't contain a valid cidr on line %zu", line,
-               sp_line_no);
-    return -1;
+  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;
 }
 
-int parse_regexp(char *restrict line, char *restrict keyword, void *retval) {
-  /* 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*/
-  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_pcre *compiled_re = sp_pcre_compile(ZSTR_VAL(value));
-    if (NULL != compiled_re) {
-      *(sp_pcre **)retval = compiled_re;
-      return consumed;
-    }
+  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;
   }
-  char *closing_paren = strchr(line, ')');
-  if (NULL != closing_paren) {
-    closing_paren[0] = '\0';
-  }
-  sp_log_err("config",
-             "'%s)' is expecting a valid regexp, and not '%s' on line %zu",
-             keyword, line, sp_line_no);
-  return -1;
+  zend_string_release(value);
+  return ret;
 }
 
-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_PARSEKW_FN(parse_cidr) {
+  CHECK_DUPLICATE_KEYWORD(retval);
+  SP_PARSE_ARG(value);
 
-  if (fd == NULL) {
-    sp_log_err("config", "Could not open configuration file %s : %s", conf_file,
-               strerror(errno));
-    return FAILURE;
+  sp_cidr *cidr = pecalloc(sizeof(sp_cidr), 1, 1);
+
+  if (0 != get_ip_and_cidr(ZSTR_VAL(value), cidr)) {
+    pefree(cidr, 1);
+    cidr = NULL;
   }
 
-  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++;
+  *(sp_cidr **)retval = cidr;
+  return cidr ? SP_PARSER_SUCCESS : SP_PARSER_ERROR;
+}
+
+SP_PARSEKW_FN(parse_regexp) {
+  CHECK_DUPLICATE_KEYWORD(retval);
+  SP_PARSE_ARG(value);
+
+  sp_regexp *compiled_re = sp_regexp_compile(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;
   }
-  fclose(fd);
-  return SUCCESS;
+
+  *(sp_regexp **)retval = compiled_re;
+
+  return SP_PARSER_SUCCESS;
 }
 
-void sp_disabled_function_list_free(sp_list_node *list) {
-  sp_list_node *cursor = list;
-  while (cursor) {
-    sp_disabled_function *df = cursor->data;
-    if (df) {
-      sp_list_free(df->functions_list);
-      sp_list_free(df->param_array_keys);
-      sp_list_free(df->var_array_keys);
+void sp_free_disabled_function(void *data) {
+  sp_disabled_function *df = data;
 
-      sp_pcre_free(df->r_filename);
-      sp_pcre_free(df->r_function);
-      sp_pcre_free(df->r_param);
-      sp_pcre_free(df->r_ret);
-      sp_pcre_free(df->r_value);
-      sp_pcre_free(df->r_key);
+  sp_free_zstr(df->textual_representation);
 
-      sp_tree_free(df->param);
-      sp_tree_free(df->var);
-    }
-    cursor = cursor->next;
-  }
+  sp_free_zstr(df->filename);
+  sp_regexp_free(df->r_filename);
+
+  sp_free_zstr(df->function);
+  sp_regexp_free(df->r_function);
+  sp_list_free(df->functions_list, free);
+
+  sp_free_zstr(df->hash);
+
+  sp_tree_free(df->param);
+  sp_regexp_free(df->r_param);
+
+  sp_regexp_free(df->r_ret);
+  sp_free_zstr(df->ret);
+
+  sp_regexp_free(df->r_value);
+  sp_free_zstr(df->value);
+
+  sp_regexp_free(df->r_key);
+  sp_free_zstr(df->key);
+
+  sp_free_zstr(df->dump);
+  sp_free_zstr(df->alias);
+
+  // sp_list_free(df->param_array_keys);
+  // sp_list_free(df->var_array_keys);
+
+  sp_tree_free(df->var);
+
+  pefree(df->cidr, 1);
 }
 
-void sp_cookie_list_free(sp_list_node *list) {
-  sp_list_node *cursor = list;
-  while (cursor) {
-    sp_cookie *c = cursor->data;
-    if (c) {
-      sp_pcre_free(c->name_r);
-    }
-    cursor = cursor->next;
+void sp_free_cookie(void *data) {
+  sp_cookie *c = data;
+  if (c->name)
+    zend_string_release_ex(c->name, 1);
+  sp_regexp_free(c->name_r);
+}
+
+void sp_free_zstr(void *data) {
+  if (data) {
+    zend_string_release_ex((zend_string*)data, 1);
   }
 }
+
+void sp_free_ini_entry(void *data) {
+  sp_ini_entry *entry = data;
+
+  sp_free_zstr(entry->key);
+  sp_free_zstr(entry->min);
+  sp_free_zstr(entry->max);
+  sp_regexp_free(entry->regexp);
+  sp_free_zstr(entry->msg);
+  sp_free_zstr(entry->set);
+}