1 files changed, 141 insertions, 193 deletions

diff --git a/src/sp_disabled_functions.c b/src/sp_disabled_functions.c
index c47b5cb..95e19ad 100644
--- a/src/sp_disabled_functions.c
+++ b/src/sp_disabled_functions.c
@@ -13,26 +13,26 @@ static void should_drop_on_ret(const zval* return_value,
                                zend_execute_data* execute_data);
 
 char* get_complete_function_path(zend_execute_data const* const execute_data) {
-  if (zend_is_executing() && !EG(current_execute_data)->func) {
+  if (!execute_data) {
     return NULL;  // LCOV_EXCL_LINE
   }
-  if (!(execute_data->func->common.function_name)) {
+  zend_function *func = execute_data->func;
+  if (!(func->common.function_name)) {
     return NULL;
   }
 
-  char const* class_name;
-  char const* const function_name =
-      ZSTR_VAL(execute_data->func->common.function_name);
+  char const* const function_name = ZSTR_VAL(func->common.function_name);
   char* complete_path_function = NULL;
 
-  class_name = get_active_class_name(NULL);
-  if (*class_name) {
+  if ((func->type == ZEND_USER_FUNCTION || func->type == ZEND_INTERNAL_FUNCTION) && func->common.scope) {
+    char const* class_name = ZSTR_VAL(func->common.scope->name);
     const size_t len = strlen(class_name) + 2 + strlen(function_name) + 1;
     complete_path_function = emalloc(len);
     snprintf(complete_path_function, len, "%s::%s", class_name, function_name);
   } else {
     complete_path_function = estrdup(function_name);
   }
+
   return complete_path_function;
 }
 
@@ -67,28 +67,22 @@ static bool is_functions_list_matching(zend_execute_data* execute_data,
   return false;
 }
 
-static bool is_local_var_matching(
-    zend_execute_data* execute_data,
-    const sp_disabled_function* const config_node) {
+static bool is_local_var_matching(zend_execute_data* execute_data, const sp_disabled_function* const config_node) {
   zval* var_value = {0};
 
   var_value = sp_get_var_value(execute_data, config_node->var, false);
   if (var_value) {
     if (Z_TYPE_P(var_value) == IS_ARRAY) {
       if (config_node->key || config_node->r_key) {
-        if (sp_match_array_key(var_value, config_node->key,
-                               config_node->r_key)) {
+        if (sp_match_array_key(var_value, config_node->key, config_node->r_key)) {
           return true;
         }
-      } else if (sp_match_array_value(var_value, config_node->value,
-                                      config_node->r_value)) {
+      } else if (sp_match_array_value(var_value, config_node->value, config_node->r_value)) {
         return true;
       }
     } else {
-      zend_string const* const var_value_str =
-          sp_zval_to_zend_string(var_value);
-      bool match = sp_match_value(var_value_str, config_node->value,
-                                  config_node->r_value);
+      zend_string const* const var_value_str = sp_zval_to_zend_string(var_value);
+      bool match = sp_match_value(var_value_str, config_node->value, config_node->r_value);
 
       if (true == match) {
         return true;
@@ -98,107 +92,105 @@ static bool is_local_var_matching(
   return false;
 }
 
+static inline const char* get_fn_arg_name(zend_function *fn, uint32_t i) {
+  if (fn->type == ZEND_USER_FUNCTION || (fn->common.fn_flags & ZEND_ACC_USER_ARG_INFO)) {
+    return ZSTR_VAL(fn->op_array.arg_info[i].name);
+  } else {
+    return fn->internal_function.arg_info[i].name;
+  }
+}
+
 static bool is_param_matching(zend_execute_data* execute_data,
                               sp_disabled_function const* const config_node,
                               const zend_string* builtin_param,
                               const char* builtin_param_name,
                               const char** arg_name,
                               const zend_string** arg_value_str) {
-  int nb_param = ZEND_CALL_NUM_ARGS(execute_data);
-  int i = 0;
-  zval* arg_value;
-
-  if (config_node->pos != -1) {
-    if (config_node->pos > nb_param - 1) {
-      char* complete_function_path = get_complete_function_path(execute_data);
-      sp_log_warn("config",
-                  "It seems that you wrote a rule filtering on the "
-                  "%d%s argument of the function '%s', but it takes only %d "
-                  "arguments. "
-                  "Matching on _all_ arguments instead.",
-                  config_node->pos, GET_SUFFIX(config_node->pos),
-                  complete_function_path, nb_param);
-      efree(complete_function_path);
-    } else {
-      i = config_node->pos;
-      nb_param = (config_node->pos) + 1;
-    }
-  }
-
+  // builtin functions
   if (builtin_param) {
     /* We're matching on a language construct (here named "builtin"),
-     * and they can only take a single argument, but PHP considers them
-     * differently than functions arguments. */
+    * and they can only take a single argument, but PHP considers them
+    * differently than functions arguments. */
     *arg_name = builtin_param_name;
     *arg_value_str = builtin_param;
     return sp_match_value(builtin_param, config_node->value,
                           config_node->r_value);
-  } else if (config_node->r_param || config_node->pos != -1) {
-    // We're matching on a function (and not a language construct)
-    for (; i < nb_param; i++) {
-      if (ZEND_USER_CODE(execute_data->func->type)) {  // yay consistency
-        *arg_name = ZSTR_VAL(execute_data->func->common.arg_info[i].name);
-      } else {
-        *arg_name = execute_data->func->internal_function.arg_info[i].name;
-      }
-      const bool pcre_matching =
-          config_node->r_param &&
-          (true == sp_is_regexp_matching(config_node->r_param, *arg_name));
+  }
 
-      /* This is the parameter name we're looking for. */
-      if (true == pcre_matching || config_node->pos != -1) {
-        arg_value = ZEND_CALL_ARG(execute_data, i + 1);
+  // safeguards
+  if (!execute_data || !execute_data->func) {
+    sp_log_debug("no execute data -> silently ignore parameter matching");
+    return false;
+  }
 
-        if (config_node->param_type) {  // Are we matching on the `type`?
-          if (config_node->param_type == Z_TYPE_P(arg_value)) {
-            return true;
-          }
-        } else if (Z_TYPE_P(arg_value) == IS_ARRAY) {
-          *arg_value_str = sp_zval_to_zend_string(arg_value);
-          if (config_node->key || config_node->r_key) {
-            if (sp_match_array_key(arg_value, config_node->key,
-                                   config_node->r_key)) {
-              return true;
-            }
-          } else if (sp_match_array_value(arg_value, config_node->value,
-                                          config_node->r_value)) {
-            return true;
-          }
-        } else {
-          *arg_value_str = sp_zval_to_zend_string(arg_value);
-          if (sp_match_value(*arg_value_str, config_node->value,
-                             config_node->r_value)) {
-            return true;
-          }
-        }
-      }
+  *arg_name = NULL;
+  int call_num_args = EX_NUM_ARGS();
+  zend_function *fn = execute_data->func;
+  int fn_num_args = fn->common.num_args;
+
+  if (!call_num_args) {
+    sp_log_debug("no call arguments -> return");
+    return false; // no arguments to check
+  }
+
+  if (config_node->pos > call_num_args - 1 || config_node->pos > fn_num_args) {
+    // trying to match argument beyond last given argument OR beyond last declared argument.
+    // this is perfectly normal for functions with
+    //   (a) optional arguments
+    //   (b) excess arguments
+    //   (c) variadic arguments which are not supported
+    return false;
+  }
+
+  zval* arg_value = NULL;
+
+  if (config_node->pos > -1) {
+    if (config_node->pos < fn_num_args) {
+      *arg_name = get_fn_arg_name(fn, config_node->pos);
     }
+    arg_value = ZEND_CALL_ARG(execute_data, config_node->pos + 1);
   } else if (config_node->param) {
     *arg_name = config_node->param->value;
     arg_value = sp_get_var_value(execute_data, config_node->param, true);
+  } else if (config_node->r_param) {
+    for (int i = 0; i < call_num_args; i++) {
+      *arg_name = get_fn_arg_name(fn, i);
+      if (true == sp_is_regexp_matching(config_node->r_param, *arg_name)) {
+        arg_value = ZEND_CALL_ARG(execute_data, i + 1);
+      }
+    }
+  }
+  
+  if (!arg_value) {
+    sp_log_debug("no argument match -> return");
+    return false;
+  }
 
-    if (arg_value) {
-      *arg_value_str = sp_zval_to_zend_string(arg_value);
-      if (config_node->param_type) {  // Are we matching on the `type`?
-        if (config_node->param_type == Z_TYPE_P(arg_value)) {
-          return true;
-        }
-      } else if (Z_TYPE_P(arg_value) == IS_ARRAY) {
-        if (config_node->key || config_node->r_key) {
-          if (sp_match_array_key(arg_value, config_node->key,
-                                 config_node->r_key)) {
-            return true;
-          }
-        } else if (sp_match_array_value(arg_value, config_node->value,
-                                        config_node->r_value)) {
-          return true;
-        }
-      } else if (sp_match_value(*arg_value_str, config_node->value,
-                                config_node->r_value)) {
+  if (config_node->param_type) {
+    if (config_node->param_type == Z_TYPE_P(arg_value)) {
+      if (!(config_node->key || config_node->r_key || config_node->value || config_node->r_value)) { // Are we matching on the `type` only?
+        sp_log_debug("arg type match only.");
         return true;
       }
+    } else {
+      sp_log_debug("arg type mismatch -> return");
+      return false;
     }
   }
+
+  *arg_value_str = sp_zval_to_zend_string(arg_value);
+  if (Z_TYPE_P(arg_value) == IS_ARRAY) {
+    if (config_node->key || config_node->r_key) {
+      if (sp_match_array_key(arg_value, config_node->key, config_node->r_key)) {
+        return true;
+      }
+    } else if (sp_match_array_value(arg_value, config_node->value, config_node->r_value)) {
+        return true;
+    }
+  } else if (sp_match_value(*arg_value_str, config_node->value, config_node->r_value)) {
+    return true;
+  }
+
   return false;
 }
 
@@ -218,17 +210,15 @@ static zend_execute_data* is_file_matching(
       return ex;  // LCOV_EXCL_LINE
     }
     ITERATE(ex);
-    if (zend_string_equals(ex->func->op_array.filename,
-                           config_node->filename)) {
+    if (zend_string_equals(ex->func->op_array.filename, config_node->filename)) {
       return ex;  // LCOV_EXCL_LINE
     }
   } else if (config_node->r_filename) {
-    if (sp_is_regexp_matching_zend(config_node->r_filename, current_filename)) {
+    if (sp_is_regexp_matching_zstr(config_node->r_filename, current_filename)) {
       return ex;
     }
     ITERATE(ex);
-    if (sp_is_regexp_matching_zend(config_node->r_filename,
-                                   ex->func->op_array.filename)) {
+    if (sp_is_regexp_matching_zstr(config_node->r_filename, ex->func->op_array.filename)) {
       return ex;
     }
   }
@@ -267,7 +257,7 @@ void should_disable_ht(zend_execute_data* execute_data,
     current_filename = zend_string_init(tmp, strlen(tmp), 0);
   }
 
-  ht_entry = zend_hash_str_find_ptr(ht, function_name, strlen(function_name));
+  ht_entry = zend_hash_str_find_ptr(ht, VAR_AND_LEN(function_name));
 
   if (ht_entry) {
     should_disable(execute_data, function_name, builtin_param,
@@ -289,26 +279,22 @@ static void should_disable(zend_execute_data* execute_data,
   char current_file_hash[SHA256_SIZE * 2 + 1] = {0};
 
   while (config) {
-    sp_disabled_function const* const config_node =
-        (sp_disabled_function*)(config->data);
+    sp_disabled_function const* const config_node = (sp_disabled_function*)(config->data);
     const char* arg_name = NULL;
     const zend_string* arg_value_str = NULL;
 
     /* The order matters, since when we have `config_node->functions_list`,
     we also do have `config_node->function` */
     if (config_node->functions_list) {
-      if (false == is_functions_list_matching(execute_data,
-                                              config_node->functions_list)) {
+      if (false == is_functions_list_matching(execute_data, config_node->functions_list)) {
         goto next;
       }
     } else if (config_node->function) {
-      if (0 !=
-          strcmp(ZSTR_VAL(config_node->function), complete_function_path)) {
+      if (0 != strcmp(ZSTR_VAL(config_node->function), complete_function_path)) {
         goto next;  // LCOV_EXCL_LINE
       }
     } else if (config_node->r_function) {
-      if (false == sp_is_regexp_matching(config_node->r_function,
-                                         complete_function_path)) {
+      if (false == sp_is_regexp_matching(config_node->r_function, complete_function_path)) {
         goto next;
       }
     }
@@ -320,8 +306,7 @@ static void should_disable(zend_execute_data* execute_data,
     }
 
     if (config_node->filename || config_node->r_filename) {
-      zend_execute_data* ex =
-          is_file_matching(execute_data, config_node, current_filename);
+      zend_execute_data* ex = is_file_matching(execute_data, config_node, current_filename);
       if (!ex) {
         goto next;
       }
@@ -344,8 +329,7 @@ static void should_disable(zend_execute_data* execute_data,
       if ('\0' == current_file_hash[0]) {
         compute_hash(ZSTR_VAL(current_filename), current_file_hash);
       }
-      if (0 != strncmp(current_file_hash, ZSTR_VAL(config_node->hash),
-                       SHA256_SIZE)) {
+      if (0 != strncmp(current_file_hash, ZSTR_VAL(config_node->hash), SHA256_SIZE)) {
         goto next;
       }
     }
@@ -366,9 +350,7 @@ static void should_disable(zend_execute_data* execute_data,
             "Snuffleupagus doesn't support variadic functions yet, sorry. "
             "Check https://github.com/jvoisin/snuffleupagus/issues/164 for "
             "details.");
-      } else if (false == is_param_matching(
-                              execute_data, config_node, builtin_param, builtin_param_name,
-                              &arg_name, &arg_value_str)) {
+      } else if (false == is_param_matching(execute_data, config_node, builtin_param, builtin_param_name, &arg_name, &arg_value_str)) {
         goto next;
       }
     }
@@ -379,11 +361,9 @@ static void should_disable(zend_execute_data* execute_data,
     }
 
     if (config_node->functions_list) {
-      sp_log_disable(ZSTR_VAL(config_node->function), arg_name, arg_value_str,
-                     config_node);
+      sp_log_disable(ZSTR_VAL(config_node->function), arg_name, arg_value_str, config_node);
     } else {
-      sp_log_disable(complete_function_path, arg_name, arg_value_str,
-                     config_node);
+      sp_log_disable(complete_function_path, arg_name, arg_value_str, config_node);
     }
 
   next:
@@ -418,7 +398,6 @@ static void should_drop_on_ret(const zval* return_value,
   bool match_type = false, match_value = false;
 
   while (config) {
-    const zend_string* ret_value_str = NULL;
     sp_disabled_function const* const config_node =
         (sp_disabled_function*)(config->data);
 
@@ -462,13 +441,18 @@ static void should_drop_on_ret(const zval* return_value,
       }
     }
 
-    ret_value_str = sp_zval_to_zend_string(return_value);
+    const zend_string* ret_value_str = NULL;
+    sp_php_type ret_type = SP_PHP_TYPE_NULL;
+
+    if (return_value) {
+      ret_value_str = sp_zval_to_zend_string(return_value);
+      ret_type = Z_TYPE_P(return_value);
+    }
 
     match_type = (config_node->ret_type) &&
-                 (config_node->ret_type == Z_TYPE_P(return_value));
-    match_value = (config_node->ret || config_node->r_ret) &&
-                  (true == sp_match_value(ret_value_str, config_node->ret,
-                                          config_node->r_ret));
+                 (config_node->ret_type == ret_type);
+    match_value = return_value && (config_node->ret || config_node->r_ret) &&
+                  (true == sp_match_value(ret_value_str, config_node->ret, config_node->r_ret));
 
     if (true == match_type || true == match_value) {
       if (true == config_node->allow) {
@@ -483,40 +467,28 @@ static void should_drop_on_ret(const zval* return_value,
 
 ZEND_FUNCTION(check_disabled_function) {
   zif_handler orig_handler;
-  const char* current_function_name = get_active_function_name(TSRMLS_C);
+  const char* current_function_name = get_active_function_name();
 
-  should_disable_ht(
-      execute_data, current_function_name, NULL, NULL,
-      SNUFFLEUPAGUS_G(config).config_disabled_functions_reg->disabled_functions,
-      SNUFFLEUPAGUS_G(config).config_disabled_functions_hooked);
+  should_disable_ht(execute_data, current_function_name, NULL, NULL, SPCFG(disabled_functions_reg).disabled_functions, SPCFG(disabled_functions_hooked));
 
-  orig_handler = zend_hash_str_find_ptr(
-      SNUFFLEUPAGUS_G(disabled_functions_hook), current_function_name,
-      strlen(current_function_name));
+  orig_handler = zend_hash_str_find_ptr(SPG(disabled_functions_hook), VAR_AND_LEN(current_function_name));
   orig_handler(INTERNAL_FUNCTION_PARAM_PASSTHRU);
-  should_drop_on_ret_ht(
-      return_value, current_function_name,
-      SNUFFLEUPAGUS_G(config)
-          .config_disabled_functions_reg_ret->disabled_functions,
-      SNUFFLEUPAGUS_G(config).config_disabled_functions_ret_hooked,
-      execute_data);
+
+  should_drop_on_ret_ht(return_value, current_function_name, SPCFG(disabled_functions_reg_ret).disabled_functions, SPCFG(disabled_functions_ret_hooked), execute_data);
 }
 
 static int hook_functions_regexp(const sp_list_node* config) {
   while (config && config->data) {
-    const zend_string* function_name =
-        ((sp_disabled_function*)config->data)->function;
-    const sp_pcre* function_name_regexp =
-        ((sp_disabled_function*)config->data)->r_function;
+    const zend_string* function_name = ((sp_disabled_function*)config->data)->function;
+    sp_regexp *function_name_sp_regexp = ((sp_disabled_function*)config->data)->r_function;
+    const sp_pcre* function_name_regexp = function_name_sp_regexp ? function_name_sp_regexp->re : NULL;
 
     assert(function_name || function_name_regexp);
 
     if (function_name) {
-      HOOK_FUNCTION(ZSTR_VAL(function_name), disabled_functions_hook,
-                    PHP_FN(check_disabled_function));
+      HOOK_FUNCTION(ZSTR_VAL(function_name), disabled_functions_hook, PHP_FN(check_disabled_function));
     } else {
-      HOOK_FUNCTION_BY_REGEXP(function_name_regexp, disabled_functions_hook,
-                              PHP_FN(check_disabled_function));
+      HOOK_FUNCTION_BY_REGEXP(function_name_regexp, disabled_functions_hook, PHP_FN(check_disabled_function));
     }
 
     config = config->next;
@@ -529,10 +501,8 @@ static void hook_functions(HashTable* to_hook_ht, HashTable* hooked_ht) {
   zval* value;
 
   ZEND_HASH_FOREACH_STR_KEY_VAL(to_hook_ht, key, value) {
-    bool hooked = HOOK_FUNCTION(ZSTR_VAL(key), disabled_functions_hook,
-                                PHP_FN(check_disabled_function));
-    bool is_builtin =
-        check_is_builtin_name(((sp_list_node*)Z_PTR_P(value))->data);
+    bool hooked = HOOK_FUNCTION(ZSTR_VAL(key), disabled_functions_hook, PHP_FN(check_disabled_function));
+    bool is_builtin = check_is_builtin_name(((sp_list_node*)Z_PTR_P(value))->data);
     if (hooked || is_builtin) {
       zend_symtable_add_new(hooked_ht, key, value);
       zend_hash_del(to_hook_ht, key);
@@ -543,41 +513,29 @@ static void hook_functions(HashTable* to_hook_ht, HashTable* hooked_ht) {
 
 ZEND_FUNCTION(eval_blacklist_callback) {
   zif_handler orig_handler;
-  const char* current_function_name = get_active_function_name(TSRMLS_C);
-  zend_string* tmp =
-      zend_string_init(current_function_name, strlen(current_function_name), 0);
+  char* current_function_name = get_complete_function_path(EG(current_execute_data));
 
-  if (true == check_is_in_eval_whitelist(tmp)) {
-    zend_string_release(tmp);
+  if (!current_function_name || true == check_is_in_eval_whitelist(current_function_name)) {
     goto whitelisted;
   }
-  zend_string_release(tmp);
 
-  if (SNUFFLEUPAGUS_G(in_eval) > 0) {
-    zend_string* filename = get_eval_filename(zend_get_executed_filename());
-    const int line_number = zend_get_executed_lineno(TSRMLS_C);
-    const sp_config_eval* config_eval = SNUFFLEUPAGUS_G(config).config_eval;
+  if (SPG(in_eval) > 0) {
+    const sp_config_eval* config_eval = &(SPCFG(eval));
 
     if (config_eval->dump) {
-      sp_log_request(config_eval->dump, config_eval->textual_representation,
-                     SP_TOKEN_EVAL_BLACKLIST);
+      sp_log_request(config_eval->dump, config_eval->textual_representation);
     }
     if (config_eval->simulation) {
-      sp_log_simulation("eval",
-                        "A call to %s was tried in eval, in %s:%d, logging it.",
-                        current_function_name, ZSTR_VAL(filename), line_number);
+      sp_log_simulation("eval", "A call to '%s' was tried in eval. logging it.", current_function_name);
     } else {
-      sp_log_drop("eval",
-                  "A call to %s was tried in eval, in %s:%d, dropping it.",
-                  current_function_name, ZSTR_VAL(filename), line_number);
+      sp_log_drop("eval", "A call to '%s' was tried in eval. dropping it.", current_function_name);
     }
-    efree(filename);
   }
 
 whitelisted:
-  orig_handler = zend_hash_str_find_ptr(
-      SNUFFLEUPAGUS_G(sp_eval_blacklist_functions_hook), current_function_name,
-      strlen(current_function_name));
+
+  orig_handler = zend_hash_str_find_ptr(SPG(sp_eval_blacklist_functions_hook), current_function_name, strlen(current_function_name));
+  efree(current_function_name);
   orig_handler(INTERNAL_FUNCTION_PARAM_PASSTHRU);
 }
 
@@ -586,26 +544,19 @@ int hook_disabled_functions(void) {
 
   int ret = SUCCESS;
 
-  hook_functions(SNUFFLEUPAGUS_G(config).config_disabled_functions,
-                 SNUFFLEUPAGUS_G(config).config_disabled_functions_hooked);
-
-  hook_functions(SNUFFLEUPAGUS_G(config).config_disabled_functions_ret,
-                 SNUFFLEUPAGUS_G(config).config_disabled_functions_ret_hooked);
+  hook_functions(SPCFG(disabled_functions), SPCFG(disabled_functions_hooked));
+  hook_functions(SPCFG(disabled_functions_ret), SPCFG(disabled_functions_ret_hooked));
 
-  ret |= hook_functions_regexp(
-      SNUFFLEUPAGUS_G(config)
-          .config_disabled_functions_reg->disabled_functions);
+  ret |= hook_functions_regexp(SPCFG(disabled_functions_reg).disabled_functions);
 
-  ret |= hook_functions_regexp(
-      SNUFFLEUPAGUS_G(config)
-          .config_disabled_functions_reg_ret->disabled_functions);
+  ret |= hook_functions_regexp(SPCFG(disabled_functions_reg_ret).disabled_functions);
 
-  if (NULL != SNUFFLEUPAGUS_G(config).config_eval->blacklist) {
-    sp_list_node* it = SNUFFLEUPAGUS_G(config).config_eval->blacklist;
+  if (NULL != SPCFG(eval).blacklist) {
+    sp_list_node* it = SPCFG(eval).blacklist;
 
     while (it) {
       hook_function(ZSTR_VAL((zend_string*)it->data),
-                    SNUFFLEUPAGUS_G(sp_eval_blacklist_functions_hook),
+                    SPG(sp_eval_blacklist_functions_hook),
                     PHP_FN(eval_blacklist_callback));
       it = it->next;
     }
@@ -622,10 +573,7 @@ int hook_echo(const char* str, size_t str_length) {
 #endif
   zend_string* zs = zend_string_init(str, str_length, 0);
 
-  should_disable_ht(
-      EG(current_execute_data), "echo", zs, NULL,
-      SNUFFLEUPAGUS_G(config).config_disabled_functions_reg->disabled_functions,
-      SNUFFLEUPAGUS_G(config).config_disabled_functions_hooked);
+  should_disable_ht(EG(current_execute_data), "echo", zs, NULL, SPCFG(disabled_functions_reg).disabled_functions, SPCFG(disabled_functions_hooked));
 
   zend_string_release(zs);