libsqreen 0.6.1.0.1 → 1.0.4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4ed91a585c820add7e0c12a77e14ffe98af314ba6ff63933cb44249d114bdc43
-  data.tar.gz: 38b7a36192217771d45f9af2cfd05776c654c1174fe1877d1c17f3d528faeefe
+  metadata.gz: c2ae03953a7873a5385ccb306ba5ed318a3a26b4cea7e2bd2e07c7896a00e5f6
+  data.tar.gz: 7c041b5f6cb494c4a90146c547c922348714b8e41acfe9398f87d57ace23452f
 SHA512:
-  metadata.gz: 7c7475304370b268725cc9de6b1b7de2281457c196bc302e7a5f7f5426ae69482b36eaf7068ec0e4f539e94f27067ddd57526199de1bf1bd54dfc676e121be47
-  data.tar.gz: a3ef8f4146dd1f5f674d2b4f9df3ba3cdbb52ba8c9279886e789a6753bfaa708f5f9887fc0214965738a5f0eddf256ffacc24dcde82bc63480d9bc0599c3f1ba
+  metadata.gz: 76c210772b5a88b86a7e8d1e06e2bb0d50040d030fe612fa9bfca5de7b62feebec5d2d5d15c4f575761620a739024d0ed758fbfd95773802cc36ec1e1162ccbf
+  data.tar.gz: ee82a4de97c206df867fe626331376dfa9a982e49be60e310d93f94eff0c7c9c35482af5c9f7fdb1c1654c0db46622cb4f85ebddf528c37edf6c49d79a9c5641

data/ext/libsqreen_extension/libsqreen_extension.c

@@ -26,8 +26,8 @@ static VALUE waf_args_cls;
 static const PWArgs pw_args_invalid = { .type = PWI_INVALID };
 
 static const PWConfig pw_config = {
-    .maxArrayLength = UINT64_MAX,
-    .maxMapDepth = UINT64_MAX,
+    .maxArrayLength = 256,
+    .maxMapDepth = 64,
 };
 
 static VALUE cvt_ruby_str_to_utf8(VALUE value);
@@ -47,7 +47,7 @@ libsqreen_waf_args_free(void *b) {
         return;
     }
 
-    powerwaf_freeInput(&box->pw_args, false);
+    pw_freeArg(&box->pw_args);
     box->pw_args = pw_args_invalid;
 }
 
@@ -121,7 +121,7 @@ libsqreen_version(VALUE self) {
     PWVersion version;
     VALUE result;
 
-    version = powerwaf_getVersion();
+    version = pw_getVersion();
     result = rb_ary_new();
     rb_ary_push(result, INT2NUM(version.major));
     rb_ary_push(result, INT2NUM(version.minor));
@@ -143,7 +143,7 @@ libsqreen_waf_set(VALUE self, VALUE name, VALUE rules) {
 
     pw_name = StringValueCStr(name);
     pw_rules = StringValueCStr(rules);
-    pw_result = powerwaf_init(pw_name, pw_rules, &pw_config);
+    pw_result = pw_init(pw_name, pw_rules, &pw_config, NULL);
 
     result = pw_result ? Qtrue : Qfalse;
 
@@ -159,7 +159,7 @@ libsqreen_waf_delete(VALUE self, VALUE name) {
     Check_Type(name, T_STRING);
 
     pw_name = StringValueCStr(name);
-    powerwaf_clearRule(pw_name);
+    pw_clearRule(pw_name);
 
     return Qnil;
 }
@@ -168,7 +168,7 @@ static VALUE
 libsqreen_waf_clear(VALUE self) {
     (void)self;
 
-    powerwaf_clearAll();
+    pw_clearAll();
 
     return Qnil;
 }
@@ -188,7 +188,7 @@ value_to_pw_args(VALUE val) {
 
             pw_string = StringValuePtr(utf8_val);
             pw_len = (size_t)RSTRING_LEN(utf8_val);
-            pw_val = powerwaf_createStringWithLength(pw_string, pw_len);
+            pw_val = pw_createStringWithLength(pw_string, pw_len);
         }
         break;
     case T_FIXNUM:
@@ -196,13 +196,13 @@ value_to_pw_args(VALUE val) {
             int64_t pw_int;
 
             pw_int = FIX2LONG(val);
-            pw_val = powerwaf_createInt(pw_int);
+            pw_val = pw_createInt(pw_int);
         }
         break;
     case T_HASH:
         {
             VALUE waf_args = libsqreen_waf_args_new();
-            libsqreen_waf_args_set_boxed(waf_args, powerwaf_createMap());
+            libsqreen_waf_args_set_boxed(waf_args, pw_createMap());
             // can in principle raise exception, but the WAF allocated
             // memory (included the partial list of allocated values
             // inserted in the map by on_hash_iteration) is already
@@ -216,7 +216,7 @@ value_to_pw_args(VALUE val) {
     case T_ARRAY:
         {
             VALUE waf_args = libsqreen_waf_args_new();
-            libsqreen_waf_args_set_boxed(waf_args, powerwaf_createArray());
+            libsqreen_waf_args_set_boxed(waf_args, pw_createArray());
             PWArgs *array_p = libsqreen_waf_args_get_boxed(waf_args);
 
             for (int i = 0; i < RARRAY_LEN(val); i++) {
@@ -232,9 +232,9 @@ value_to_pw_args(VALUE val) {
 
                 // can in principle raise
                 pw_e = value_to_pw_args(e);
-                ok = powerwaf_addToPWArgsArray(array_p, pw_e);
+                ok = pw_addArray(array_p, pw_e);
                 if (!ok) {
-                    powerwaf_freeInput(&pw_e, false);
+                    pw_freeArg(&pw_e);
                 }
             }
 
@@ -249,7 +249,7 @@ value_to_pw_args(VALUE val) {
          * in the log if the values in the top map are missing. Replace all
          * invalid values with an empty map (this uses more maps than needed,
            but also doesn't hurt) */
-        pw_val = powerwaf_createMap();
+        pw_val = pw_createMap();
         break;
     }
 
@@ -279,9 +279,9 @@ on_hash_iteration(volatile VALUE key, VALUE val, VALUE waf_value) {
     PWArgs value_to_add = value_to_pw_args(val);
     // key is volatile because between its last usage
     // and the usage of its component pw_key, GC may run
-    ok = powerwaf_addToPWArgsMap(parent, pw_key, pw_len, value_to_add);
+    ok = pw_addMap(parent, pw_key, pw_len, value_to_add);
     if (!ok) {
-        powerwaf_freeInput(&value_to_add, false);
+        pw_freeArg(&value_to_add);
     }
 
     return ST_CONTINUE;
@@ -433,7 +433,7 @@ libsqreen_waf_run(int argc, const VALUE *argv, VALUE self) {
 
     rb_scan_args(argc, argv, "31", &name, &args, &budget, &max_run_budget);
 
-    PWRet *pw_ret;
+    PWRet pw_ret;
     VALUE result = rb_ary_new();
 
     Check_Type(name, T_STRING);
@@ -447,7 +447,7 @@ libsqreen_waf_run(int argc, const VALUE *argv, VALUE self) {
     struct timespec start = get_time_mono();
 
     VALUE waf_args = libsqreen_waf_args_new_from_hash(args);
-    PWArgs *pw_args = libsqreen_waf_args_get_boxed(waf_args);
+    PWArgs pw_args = *libsqreen_waf_args_get_boxed(waf_args);
     const char *pw_name = StringValueCStr(name);
     size_t run_budget = calc_run_budget(start, gen_budget, max_run_budget);
     if (run_budget == 0) {
@@ -456,13 +456,13 @@ libsqreen_waf_run(int argc, const VALUE *argv, VALUE self) {
         return result;
     }
 
-    pw_ret = powerwaf_run(pw_name, pw_args, run_budget);
+    pw_ret = pw_run(pw_name, pw_args, run_budget);
 
-    rb_ary_push(result, ret_code_to_sym(pw_ret->action));
-    rb_ary_push(result, pw_ret->data == NULL ? Qnil : rb_str_new2(pw_ret->data));
+    rb_ary_push(result, ret_code_to_sym(pw_ret.action));
+    rb_ary_push(result, pw_ret.data == NULL ? Qnil : rb_str_new2(pw_ret.data));
 
     libsqreen_waf_args_invalidate(waf_args);
-    powerwaf_freeReturn(pw_ret);
+    pw_freeReturn(pw_ret);
 
     return result;
 }

data/ext/libsqreen_extension/logging.c

@@ -38,7 +38,7 @@ log_init() {
 
 static  void
 on_log(PW_LOG_LEVEL level, const char *function, const char *file,
-       int line, const char *message, size_t message_len);
+       int line, const char *message, unsigned long long message_len);
 
 
 static VALUE log_level_to_fixnum(PW_LOG_LEVEL level) {
@@ -108,7 +108,7 @@ libsqreen_waf_log_enable(VALUE self, VALUE severity) {
     Check_Type(severity, T_SYMBOL);
 
     level = sym_to_log_level(severity);
-    powerwaf_setupLogging(on_log, level);
+    pw_setupLogging(on_log, level);
     log_threshold = level;
 
     return Qnil;
@@ -119,7 +119,7 @@ libsqreen_waf_log_disable(VALUE self) {
     (void)self;
     PW_LOG_LEVEL level = PWL_ERROR;
 
-    powerwaf_setupLogging(NULL, level);
+    pw_setupLogging(NULL, level);
     log_threshold = _PWL_AFTER_LAST;
 
     return Qnil;
@@ -159,7 +159,7 @@ on_log(PW_LOG_LEVEL level,
        const char *function,
        const char *file,
        int line,
-       const char *message, size_t message_len) {
+       const char *message, unsigned long long message_len) {
     VALUE severity;
     VALUE logger;
     VALUE log_msg;

data/lib/libsqreen/version.rb

@@ -2,5 +2,5 @@
 # Please refer to our terms for more information: https://www.sqreen.com/terms.html
 
 module LibSqreen
-  VERSION = "0.6.1.0.1"
+  VERSION = "1.0.4.0.0"
 end

data/vendor/libsqreen/include/waf.h

@@ -1,235 +1,335 @@
 //
 //  PowerWAF
-//  Copyright © 2019 Sqreen. All rights reserved.
+//  Copyright © 2020 Sqreen. All rights reserved.
 //
 
-#ifndef PowerWAF_h
-#define PowerWAF_h
+#ifndef pw_h
+#define pw_h
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
-#include <stdint.h>
 #include <stdbool.h>
-#include <stdlib.h>
+#include <stdint.h>
 
 #define PW_MAX_STRING_LENGTH 4096
 #define PW_MAX_MAP_DEPTH 20
 #define PW_MAX_ARRAY_LENGTH 256
 #define PW_RUN_TIMEOUT 5000
 
-typedef enum
-{
-	PWI_INVALID          = 0,
-	PWI_SIGNED_NUMBER    = 1 << 0,	// `value` shall be decoded as a int64_t (or int32_t on 32bits platforms)
-	PWI_UNSIGNED_NUMBER  = 1 << 1,	// `value` shall be decoded as a uint64_t (or uint32_t on 32bits platforms)
-	PWI_STRING           = 1 << 2,	// `value` shall be decoded as a UTF-8 string of length `nbEntries`
-	PWI_ARRAY            = 1 << 3,	// `value` shall be decoded as an array of PWArgs of length `nbEntries`, each item having no `parameterName`
-	PWI_MAP              = 1 << 4,	// `value` shall be decoded as an array of PWArgs of length `nbEntries`, each item having a `parameterName`
-} PW_INPUT_TYPE;
-
-typedef struct _PWArgs PWArgs;
-
-struct _PWArgs
-{
-	const char * parameterName;
-	uint64_t parameterNameLength;
-	union {
-		const char * stringValue;
-		uint64_t uintValue;
-		int64_t intValue;
-		const PWArgs * array;
-		const void * rawHandle;
+	typedef enum
+	{
+		PWI_INVALID         = 0,
+		PWI_SIGNED_NUMBER   = 1 << 0, // `value` shall be decoded as a int64_t (or int32_t on 32bits platforms)
+		PWI_UNSIGNED_NUMBER = 1 << 1, // `value` shall be decoded as a uint64_t (or uint32_t on 32bits platforms)
+		PWI_STRING          = 1 << 2, // `value` shall be decoded as a UTF-8 string of length `nbEntries`
+		PWI_ARRAY           = 1 << 3, // `value` shall be decoded as an array of PWArgs of length `nbEntries`, each item having no `parameterName`
+		PWI_MAP             = 1 << 4, // `value` shall be decoded as an array of PWArgs of length `nbEntries`, each item having a `parameterName`
+	} PW_INPUT_TYPE;
+
+	typedef void* PWHandle;
+	typedef void* PWAddContext;
+	typedef struct _PWArgs PWArgs;
+
+	struct _PWArgs
+	{
+		const char* parameterName;
+		uint64_t parameterNameLength;
+		union
+		{
+			const char* stringValue;
+			uint64_t uintValue;
+			int64_t intValue;
+			const PWArgs* array;
+			const void* rawHandle;
+		};
+		uint64_t nbEntries;
+		PW_INPUT_TYPE type;
 	};
-	uint64_t nbEntries;
-	PW_INPUT_TYPE type;
-};
-
-typedef struct
-{
-	uint64_t maxArrayLength;
-	uint64_t maxMapDepth;
-} PWConfig;
 
-/// InitializePowerWAF
-///
-/// Initialize a rule in the PowerWAF
-/// Must be called before calling RunPowerWAF on this rule name
-/// Will clear any existing rule with the same name
-///
-/// @param ruleName Name the atom that provided the patterns we're about to initialize with
-/// @param wafRule JSON blob containing the patterns to work with
-/// @param config Customized limits for the PWArgs validation
-/// @return The success (true) or faillure (false) of the init
-
-extern bool powerwaf_init(const char * ruleName, const char * wafRule, const PWConfig * config);
-
-
-typedef enum
-{
-	PWD_PARSING_JSON = 0,
-	PWD_PARSING_RULE,
-	PWD_PARSING_RULE_FILTER,
-	PWD_OPERATOR_VALUE,
-	PWD_DUPLICATE_RULE,
-	PWD_PARSING_FLOW,
-	PWD_PARSING_FLOW_STEP,
-	PWD_MEANINGLESS_STEP,
-	PWD_DUPLICATE_FLOW,
-	PWD_DUPLICATE_FLOW_STEP,
-} PW_DIAG_CODE;
-
-/// powerwaf_initWithDiag
-///
-/// Initialize a rule in the PowerWAF
-/// Must be called before calling RunPowerWAF on this rule name
-/// Will clear any existing rule with the same name
-/// If any error is encountered and an errors pointer is provided, it'll be populated with a report in JSON
-///
-/// @param ruleName Name the atom that provided the patterns we're about to initialize with
-/// @param wafRule JSON blob containing the patterns to work with
-/// @param config Customized limits for the PWArgs validation. NULL or a value of 0 mean using the default value described above
-/// @param errors Pointer to the pointer to be populated with a potential error report. Set to NULL not to generate such a report
-/// @return The success (true) or faillure (false) of the init
-
-
-extern bool powerwaf_initWithDiag(const char * ruleName, const char * wafRule, const PWConfig * config, char ** errors);
-
-/// powerwaf_freeDiagnotics
-///
-/// Free the error report generated by powerwaf_initWithDiag
-///
-/// @param errors Pointer to a populated error report. NULL will be safely ignored
-
-
-extern void powerwaf_freeDiagnotics(char * errors);
-
-/// ClearRule
-///
-///	Flush all context related to a rule
-///
-/// @param ruleName Name of the rule to unload
-
-extern void powerwaf_clearRule(const char * ruleName);
-
-/// ClearAll
-///
-///	Flush all context
-
-extern void powerwaf_clearAll(void);
-
-
-typedef enum
-{
-	PW_ERR_INTERNAL     = -6,
-	PW_ERR_TIMEOUT      = -5,
-	PW_ERR_INVALID_CALL = -4,
-	PW_ERR_INVALID_RULE = -3,
-	PW_ERR_INVALID_FLOW = -2,
-	PW_ERR_NORULE       = -1,
-	PW_GOOD             =  0,
-	PW_MONITOR          =  1,
-	PW_BLOCK            =  2
-} PW_RET_CODE;
-
-typedef struct
-{
-	PW_RET_CODE action;
-	const char * data;
-} PWRet;
-
-/// RunPowerWAF
-///
-/// Run the patterns from a rule on a set of parameters
-///
-/// Threading guarantees: When calling this API, a lock will be taken for a very short window as this call will take ownership of a shared smart pointer.
-/// 	This pointer implement reference counting and can be owned by as many thread as you want.
-/// 	If you call powerwaf_init while evaluation of powerwaf_run is ongoing, the calls having already taken ownership will safely finish processing.
-/// 	The shared pointer will be destroyed, without locking powerwaf_init, when the last powerwaf_run finish processing.
-///
-/// Maximum budget: The budget is internally stored in nanoseconds in an int64_t variable. This is then added to the current time, also coded in nano seconds.
-/// 	Due to those convertions, the maximum safe value for the next 15 years is 2^52. After that, 2^51.
-///
-/// @param ruleName Name of the rule you want to run
-/// @param parameters The request's parameters
-/// @param timeLeftInUs The maximum time in microsecond PowerWAF is allowed to take
-/// @return Whether the pattern matched or whether we encountered an error
-
-extern PWRet * powerwaf_run(const char * ruleName, const PWArgs * parameters, size_t timeLeftInUs);
-
-
-typedef struct {
-	uint16_t major;
-	uint16_t minor;
-	uint16_t patch;
-} PWVersion;
-
-/// GetVersion
-///
-/// Return the API version of PowerWAF
-///
-/// @return The API version in SemVer form
-
-extern PWVersion powerwaf_getVersion(void);
-
-
-typedef enum
-{
-	PWL_TRACE,
-	PWL_DEBUG,
-	PWL_INFO,
-	PWL_WARN,
-	PWL_ERROR,
-	
-	_PWL_AFTER_LAST,
-} PW_LOG_LEVEL;
-
-///
-/// Callback that powerwaf will call to relay messages to the binding.
-///
-/// @param level The logging level
-/// @param function The native function that emitted the message. Never NULL
-/// @param file The file of the native function that emmitted the message. Never null
-/// @param line The line where the message was emmitted. Non-negative
-/// @param message The size of the logging message. NUL-terminated
-/// @param message_len The length of the logging message (excluding NUL terminator)
-///
-
-typedef void (*powerwaf_logging_cb_t)(
-		PW_LOG_LEVEL level, const char *function, const char *file, int line,
-		const char *message, size_t message_len);
-
-///
-/// Sets up PowerWAF to rely logging messages to the binding
-///
-/// @param cb The callback to call, or NULL to stop relaying messages
-/// @param min_level The minimum logging level for which to relay messages (ignored if cb is NULL)
-/// @return whether the logging sink was successfully replaced
-///
-bool powerwaf_setupLogging(powerwaf_logging_cb_t cb, PW_LOG_LEVEL min_level);
-
-/// PWArgs utils
-
-extern PWArgs powerwaf_getInvalidPWArgs(void);
-extern PWArgs powerwaf_createStringWithLength(const char * string, size_t length);
-extern PWArgs powerwaf_createString(const char * string);
-extern PWArgs powerwaf_createInt(int64_t value);
-extern PWArgs powerwaf_createUint(uint64_t value);
-extern PWArgs powerwaf_createArray(void);
-extern PWArgs powerwaf_createMap(void);
-extern bool powerwaf_addToPWArgsArray(PWArgs * array, PWArgs entry);
-// Setting entryNameLength to 0 will result in the entryName length being re-computed with strlen
-extern bool powerwaf_addToPWArgsMap(PWArgs * map, const char * entryName, size_t entryNameLength, PWArgs entry);
-extern void powerwaf_freeInput(PWArgs *input, bool freeSelf);
-extern void powerwaf_freeReturn(PWRet *output);
+	typedef enum
+	{
+		PWD_PARSING_JSON = 0,
+		PWD_PARSING_RULE,
+		PWD_PARSING_RULE_FILTER,
+		PWD_OPERATOR_VALUE,
+		PWD_DUPLICATE_RULE,
+		PWD_PARSING_FLOW,
+		PWD_PARSING_FLOW_STEP,
+		PWD_MEANINGLESS_STEP,
+		PWD_DUPLICATE_FLOW,
+		PWD_DUPLICATE_FLOW_STEP,
+		PWD_STEP_HAS_INVALID_RULE
+	} PW_DIAG_CODE;
+
+	typedef enum
+	{
+		PW_ERR_INTERNAL     = -6,
+		PW_ERR_TIMEOUT      = -5,
+		PW_ERR_INVALID_CALL = -4,
+		PW_ERR_INVALID_RULE = -3,
+		PW_ERR_INVALID_FLOW = -2,
+		PW_ERR_NORULE       = -1,
+		PW_GOOD             = 0,
+		PW_MONITOR          = 1,
+		PW_BLOCK            = 2
+	} PW_RET_CODE;
+
+	typedef enum
+	{
+		PWL_TRACE,
+		PWL_DEBUG,
+		PWL_INFO,
+		PWL_WARN,
+		PWL_ERROR,
+
+		_PWL_AFTER_LAST,
+	} PW_LOG_LEVEL;
+
+	/// pw_init
+	///
+	/// Initialize a rule in the PowerWAF
+	/// Must be called before calling RunPowerWAF on this rule name
+	/// Will clear any existing rule with the same name
+	///
+
+	typedef struct
+	{
+		uint64_t maxArrayLength;
+		uint64_t maxMapDepth;
+	} PWConfig;
+
+	///
+	/// @param ruleName Name the atom that provided the patterns we're about to initialize with
+	/// @param wafRule JSON blob containing the patterns to work with
+	/// @param config Customized limits for the PWArgs validation
+	/// @param errors Pointer to the pointer to be populated with a potential error report. Set to NULL not to generate such a report
+	/// @return The success (true) or faillure (false) of the init
+
+	extern bool pw_init(const char* ruleName, const char* wafRule, const PWConfig* config, char** errors);
+
+	/// RunPowerWAF
+	///
+	/// Run the patterns from a rule on a set of parameters
+	///
+
+	typedef struct
+	{
+		PW_RET_CODE action;
+		const char* data;
+		const char* perfData;
+
+		uint32_t perfTotalRuntime;
+		uint32_t perfCacheHitRate;
+	} PWRet;
+
+	///
+	/// Threading guarantees: When calling this API, a lock will be taken for a very short window as this call will take ownership of a shared smart pointer.
+	/// 	This pointer implement reference counting and can be owned by as many thread as you want.
+	/// 	If you call pw_init while evaluation of pw_run is ongoing, the calls having already taken ownership will safely finish processing.
+	/// 	The shared pointer will be destroyed, without locking pw_init, when the last pw_run finish processing.
+	///
+	/// Maximum budget: The budget is internally stored in nanoseconds in an int64_t variable. This is then added to the current time, also coded in nano seconds.
+	/// 	Due to those convertions, the maximum safe value for the next 15 years is 2^52. After that, 2^51.
+	///
+	/// @param ruleName Name of the rule you want to run
+	/// @param parameters The request's parameters
+	/// @param timeLeftInUs The maximum time in microsecond PowerWAF is allowed to take
+	/// @return Whether the pattern matched or whether we encountered an error
+
+	extern PWRet pw_run(const char* ruleName, const PWArgs parameters, uint64_t timeLeftInUs);
+
+	/// pw_clearRule
+	///
+	///	Flush all context related to a rule
+	///
+	/// @param ruleName Name of the rule to unload
+
+	extern void pw_clearRule(const char* ruleName);
+
+	/// ClearAll
+	///
+	///	Flush all context
+
+	extern void pw_clearAll(void);
+
+	///
+	/// The following APIs (handle API) give the caller the full responsibility of the lifecycle of the wafHandle
+	/// Freeing this handle while another run is in progress will cause crashes or worst.
+	/// Don't use this API unless you understand the consequence and can provide 100% guarantee around it.
+	/// In exchange for this risk, your handle isn't added to the registry and access won't involve our internal mutex
+	///
+
+	/// pw_initH
+	///
+	/// Initialize a rule in the PowerWAF, and return a handle
+	///
+	/// @param wafRule JSON blob containing the patterns to work with
+	/// @param config Customized limits for the PWArgs validation
+	/// @param errors Pointer to the pointer to be populated with a potential error report. Set to NULL not to generate such a report
+	/// @return The handle of the initialized rule on success, NULL overwise
+
+	extern PWHandle pw_initH(const char* wafRule, const PWConfig* config, char** errors);
+
+	/// pw_runH
+	///
+	/// Run the patterns from a handle on a set of parameters
+	///
+	/// Threading guarantees: When calling this API, you're on your own.
+	/// 	Calling clearRuleH while a pw_runH is running will likely cause a use after free and a crash
+	/// 	Unless you _know_ what you're doing, use the safe API
+	///
+	/// Maximum budget: The budget is internally stored in nanoseconds in an int64_t variable. This is then added to the current time, also coded in nano seconds.
+	/// 	Due to those convertions, the maximum safe value for the next 15 years is 2^52. After that, 2^51.
+	///
+	/// @param wafHandle The rule handle
+	/// @param parameters The request's parameters
+	/// @param timeLeftInUs The maximum time in microsecond PowerWAF is allowed to take
+	/// @return Whether the pattern matched or whether we encountered an error
+
+	extern PWRet pw_runH(const PWHandle wafHandle, const PWArgs parameters, uint64_t timeLeftInUs);
+
+	/// pw_clearRuleH
+	///
+	///	Destroy a WAF handle
+	///
+	/// @param wafHandle handle to destroy
+
+	extern void pw_clearRuleH(PWHandle wafHandle);
+
+	///
+	/// Additive API
+	///
+	/// pw_initAdditive
+	///
+	/// Create a additive context you can use with pw_runAdd
+	/// Similarly to the handle API, you must call pw_clearAdditive at the end of the request to free caches
+	/// You must make sure that the context isn't in use in pw_runAdditive when or after calling pw_clearAdditive
+	///
+	/// @param ruleName Name of the rule you want to run (managed API)
+	/// @return A pointer to an additive context, or NULL if something went wrong
+
+	PWAddContext pw_initAdditive(const char* ruleName);
+
+	/// pw_initAdditiveH
+	///
+	/// Similar to pw_initAdditive but for the handle API
+	///
+	/// @param powerwafHandle The rule handle
+	/// @return A pointer to an additive context, or NULL if something went wrong
+
+	PWAddContext pw_initAdditiveH(const PWHandle powerwafHandle);
+
+	/// pw_runAdditive
+	///
+	/// Run the rules affiliated with an additive context on some new parameters
+	///
+	/// Important considerations:
+	///		You can call this API multiple time with the same context, and it will run on all new and past parameters
+	///		When sending PWArgs to this API, the additive context take ownership of the PWArgs and will take care of freeing it
+	///		When passing a parameter you already passed, further runs will ignore the past values
+	///
+	/// @param context The additive context for this request
+	/// @param newArgs The newly available parameters
+	/// @param timeLeftInUs The maximum time in microsecond PowerWAF is allowed to take
+	/// @return Whether the pattern matched or whether we encountered an error
+
+	PWRet pw_runAdditive(PWAddContext context, PWArgs newArgs, uint64_t timeLeftInUs);
+
+	/// pw_clearAdditive
+	///
+	/// Destroy the additive API context
+	/// Also take care of freeing any parameter sent to the context
+	///
+	/// @param context The additive context to free
+
+	void pw_clearAdditive(PWAddContext context);
+
+	/// pw_freeDiagnotics
+	///
+	/// Free the error report generated by pw_init
+	///
+	/// @param errors Pointer to a populated error report. NULL will be safely ignored
+
+	extern void pw_freeDiagnotics(char* errors);
+
+	/// pw_freeReturn
+	///
+	/// Free the buffers in the PWRet structure returned by pw_run
+	///
+	/// @param output Structure provided by pw_run
+
+	extern void pw_freeReturn(PWRet output);
+
+	/// GetVersion
+	///
+	/// Return the API version of PowerWAF
+	///
+
+	typedef struct
+	{
+		uint16_t major;
+		uint16_t minor;
+		uint16_t patch;
+	} PWVersion;
+
+	///
+	/// @return The API version in SemVer form
+
+	extern PWVersion pw_getVersion(void);
+
+	///
+	/// Callback that powerwaf will call to relay messages to the binding.
+	///
+	/// @param level The logging level
+	/// @param function The native function that emitted the message. Never NULL
+	/// @param file The file of the native function that emmitted the message. Never null
+	/// @param line The line where the message was emmitted. Non-negative
+	/// @param message The size of the logging message. NUL-terminated
+	/// @param message_len The length of the logging message (excluding NUL terminator)
+	///
+
+	typedef void (*pw_logging_cb_t)(
+		PW_LOG_LEVEL level, const char* function, const char* file, int line,
+		const char* message, uint64_t message_len);
+
+	///
+	/// Sets up PowerWAF to rely logging messages to the binding
+	///
+	/// @param cb The callback to call, or NULL to stop relaying messages
+	/// @param min_level The minimum logging level for which to relay messages (ignored if cb is NULL)
+	/// @return whether the logging sink was successfully replaced
+	///
+	bool pw_setupLogging(pw_logging_cb_t cb, PW_LOG_LEVEL min_level);
+
+	/// PWArgs utils
+
+	extern PWArgs pw_getInvalid(void);
+	extern PWArgs pw_createStringWithLength(const char* string, uint64_t length);
+	extern PWArgs pw_createString(const char* string);
+	extern PWArgs pw_createInt(int64_t value);
+	extern PWArgs pw_createUint(uint64_t value);
+	extern PWArgs pw_createArray(void);
+	extern PWArgs pw_createMap(void);
+	extern bool pw_addArray(PWArgs* array, PWArgs entry);
+	// Setting entryNameLength to 0 will result in the entryName length being re-computed with strlen
+	extern bool pw_addMap(PWArgs* map, const char* entryName, uint64_t entryNameLength, PWArgs entry);
+	extern void pw_freeArg(PWArgs* input);
+
+	/// Allocation utils to access PowerWAF's heap
+	/// If you're using the following two PWArgs util, make sure the memory is owned by libSqreen!
+	extern void* pw_memAlloc(uint64_t size);
+	extern void* pw_memRealloc(void* ptr, uint64_t size);
+	extern void pw_memFree(void* ptr);
+
+	/// Those APIs take ownership of your pointers: those may be free-ed at any time by libSqreen. Only use them with pointer allocated with pw_mem*
+	extern PWArgs pw_initString(const char* string, uint64_t length);
+	extern bool pw_addMapNoCopy(PWArgs* map, const char* entryName, uint64_t entryNameLength, PWArgs entry);
 
 #ifdef __cplusplus
 }
-#ifdef TESTING
-extern std::unordered_map<std::string, std::shared_ptr<PowerWAF>> & exportInternalRuleCollection();
-#endif
-
 #endif /* __cplusplus */
 
-#endif /* PowerWAF_h */
+#endif /* pw_h */

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: libsqreen
 version: !ruby/object:Gem::Version
-  version: 0.6.1.0.1
+  version: 1.0.4.0.0
 platform: ruby
 authors:
 - Sqreen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-06-26 00:00:00.000000000 Z
+date: 2020-10-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -116,8 +116,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.7
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: Make the Sqreen agent faster