libsqreen 0.3.0.0.3 → 0.6.1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cbb56500787a0d15c668257164ca25170ba8121cfca9245b5c4416534245cf8a
-  data.tar.gz: d238a6f72450a914cf6fe6b2a62aa8fc322972083ab5d6a2e6c9765b461c26f4
+  metadata.gz: b2850167f572c0e567ef756d51190d20b5405f891d59de71748b485931793ba4
+  data.tar.gz: 47bb4f25a4a71e66bff95c1883eb02109b0e0e56b5d928ff7a7bf3b583d4cb92
 SHA512:
-  metadata.gz: c765d809b966a065a1b89df955ece005c668d259a46594f234fa77d25d97e0bf2c6e6178bbbf546424fed649c5b13c864546ddc7267373d7d1eaf923ed2a454c
-  data.tar.gz: c7a42810d5012ed06f6cbd5bd7ce17a5dd908f2395cca19d43b784847325a10a65f3f23a56cf59a765d3614e6c7422eeabf4386899584bed20319649fff1484d
+  metadata.gz: 5191657554a0705f61ad7b78644f51630ebdb337d8e40e24ab1058ce2803cc9e2250e620af55f7417479ef8ec94b906dfd4a1879712bd5332c8cb8d72939b680
+  data.tar.gz: 5e7fed1e0ea2f85d4f6e39215bd092a5c4230674901efed98ce648d4be5d294e5bf01668f4cc64a91333ca0bc2a5f5058241da7ce8b83e15afbd5a6cba945922

data/ext/env_overrides.rb

@@ -0,0 +1,5 @@
+c = RbConfig::MAKEFILE_CONFIG
+
+c['CC'] = ENV['LIBSQREEN_CC'] if ENV['LIBSQREEN_CC']
+c['CFLAGS'] += ' ' + ENV['LIBSQREEN_CFLAGS'] if ENV['LIBSQREEN_CFLAGS']
+c['LDFLAGS'] += ' ' + ENV['LIBSQREEN_LDFLAGS'] if ENV['LIBSQREEN_LDFLAGS']

data/ext/libsqreen_extension/extconf.rb

@@ -1,27 +1,75 @@
 # Copyright (c) 2015 Sqreen. All Rights Reserved.
 # Please refer to our terms for more information: https://www.sqreen.com/terms.html
 
+require_relative '../env_overrides.rb'
 require 'mkmf'
+require 'shellwords'
 
-$LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), '../../ext'))
-require 'libsqreen/location'
-location = LibSqreen::Location.load!
-begin
-  location.verify!
-rescue LibSqreen::Location::Vendor::HeaderNotFound
-  puts 'could not find header. fallback to stubbing.'
-  $defs.push('-DLIBSQREEN_STUB')
-rescue LibSqreen::Location::Vendor::ArchiveNotFound
-  puts "could not find binary archive:  native features for platform #{RUBY_PLATFORM} not supported. fallback to stubbing."
-  $defs.push('-DLIBSQREEN_STUB')
-else
-  location.configure
-
-  $CFLAGS += ' -std=c99'
-  if RUBY_PLATFORM =~ /linux/
-    version_script_path = File.expand_path(File.join(File.dirname(__FILE__), '../../ext/libsqreen_extension/libsqreen_extension.version'))
-    $LDFLAGS += " -lpthread -Wl,--version-script='#{version_script_path}'"
+module Paths
+  module_function
+
+  def include_paths
+    [File.join(vendored_source_path, 'libsqreen', 'include')]
   end
+
+  def object_paths
+    objects = [
+      File.join(vendored_source_path, 'libsqreen', cpu, platform, libname),
+    ]
+
+    return objects if platform == 'darwin'
+
+    objects << File.join(vendored_source_path, 'libc++', cpu, platform, 'libc++.a')
+    objects << File.join(vendored_source_path, 'libc++', cpu, platform, 'libc++abi.a')
+    objects << File.join(vendored_source_path, 'libc++', cpu, platform, 'libunwind.a')
+
+    objects
+  end
+
+  def has_object_files?
+    object_paths.all? { |p| File.file?(p) }
+  end
+
+  def config
+    RbConfig::MAKEFILE_CONFIG
+  end
+
+  def platform
+    RUBY_PLATFORM =~ /(solaris|darwin|linux(?=-.*$)|linux$)/ && $1
+  end
+
+  def cpu
+    RUBY_PLATFORM =~ /^(universal\.|)(.*?)-/ && $2
+  end
+
+  def libname
+    "libsqreen.#{config['LIBEXT']}"
+  end
+
+  def vendored_source_path
+    File.expand_path('../../../vendor', __FILE__)
+  end
+end
+
+$INCFLAGS << ' ' + Paths.include_paths.map { |x| '-I' + Shellwords.escape(x) }.join(' ')
+$LDFLAGS << ' ' + Paths.object_paths.map { |x| Shellwords.escape(x) }.join(' ')
+
+WARNINGS = %w(no-declaration-after-statement
+              unused-parameter missing-prototypes unused-function
+              sign-conversion)
+
+$CFLAGS += " -std=c99 #{WARNINGS.map { |x| "-W#{x}" }.join(' ')}"
+
+src_prefix = nil
+unless Paths.has_object_files?
+  puts "WARNING: Could not find binary objects. " \
+    "Native features for platform #{RUBY_PLATFORM} not supported. Fallback to stubbing."
+  src_prefix = File.join($srcdir, 'stub')
+end
+
+if RUBY_PLATFORM =~ /linux/
+  version_script_path = File.expand_path(File.join(File.dirname(__FILE__), '../../ext/libsqreen_extension/libsqreen_extension.version'))
+  $LDFLAGS += " -lpthread -Wl,--version-script='#{version_script_path}'"
 end
 
-create_makefile('libsqreen_extension')
+create_makefile('libsqreen_extension', src_prefix)

data/ext/libsqreen_extension/libsqreen_extension.c

@@ -3,16 +3,40 @@
 
 #include <ruby.h>
 #include <stdbool.h>
+#include <stdint.h>
+#include <time.h>
 
-#ifndef LIBSQREEN_STUB
+void Init_libsqreen_extension(void);
 
 #include <waf.h>
+#include "logging.h"
+#include <ruby/encoding.h>
+
+static const rb_encoding *utf8_enc;
+static const rb_encoding *latin1_enc;
+static const rb_encoding *ascii8bit_enc;
+static const rb_encoding *usascii_enc;
+static VALUE utf8_str;
+static VALUE iso8859_1_str;
+
+extern VALUE waf_mod;
+VALUE waf_mod;
+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,
+};
+
+static VALUE cvt_ruby_str_to_utf8(VALUE value);
 
-/* boxes */
 
 // PWArgs box
 struct libsqreen_waf_args {
-  void *boxed;
+    // owned; value should not be shared
+    PWArgs pw_args;
 };
 
 static void
@@ -23,96 +47,77 @@ libsqreen_waf_args_free(void *b) {
         return;
     }
 
-    if (box->boxed == NULL) {
-        return;
-    }
-
-    box->boxed = NULL;
+    powerwaf_freeInput(&box->pw_args, false);
+    box->pw_args = pw_args_invalid;
 }
 
 static VALUE
 libsqreen_waf_args_alloc(VALUE klass) {
-  VALUE obj;
-  struct libsqreen_waf_args *box;
-
-  obj = Data_Make_Struct(klass, struct libsqreen_waf_args, NULL, libsqreen_waf_args_free, box);
-
-  box->boxed = NULL;
-
-  return obj;
-}
+    VALUE obj;
+    struct libsqreen_waf_args *box;
 
-static VALUE
-libsqreen_waf_args_klass() {
-    VALUE mLibSqreen;
-    VALUE mWAF;
-    VALUE cArgs;
+    obj = Data_Make_Struct(klass, struct libsqreen_waf_args,
+                           NULL /* gc_mark */, libsqreen_waf_args_free, box);
 
-    mLibSqreen = rb_const_get(rb_cObject, rb_intern("LibSqreen"));
-    mWAF = rb_const_get(mLibSqreen, rb_intern("WAF"));
-    cArgs = rb_const_get(mWAF, rb_intern("Args"));
+    box->pw_args = pw_args_invalid;
 
-    return cArgs;
+    return obj;
 }
 
 static VALUE
 libsqreen_waf_args_new() {
-    VALUE cArgs;
-    ID new;
-    VALUE waf_args;
-
-    cArgs = libsqreen_waf_args_klass();
-    new = rb_intern("new");
-    waf_args = rb_funcall(cArgs, new, 0);
+    ID new = rb_intern("new");
+    VALUE waf_args = rb_funcall(waf_args_cls, new, 0);
 
     return waf_args;
 }
 
 static VALUE
 libsqreen_waf_args_new_from_hash(VALUE hash) {
-    VALUE cArgs;
-    ID new;
-    VALUE waf_args;
-
-    cArgs = libsqreen_waf_args_klass();
-    new = rb_intern("new");
-    waf_args = rb_funcall(cArgs, new, 1, hash);
+    ID new = rb_intern("new");
+    VALUE waf_args = rb_funcall(waf_args_cls, new, 1, hash);
 
     return waf_args;
 }
 
+// transfers onwership
 static void
-libsqreen_waf_args_set_boxed(VALUE self, PWArgs *args) {
+libsqreen_waf_args_set_boxed(VALUE self, PWArgs args) {
     struct libsqreen_waf_args *box;
     Data_Get_Struct(self, struct libsqreen_waf_args, box);
-    box->boxed = (void *)args;
+    box->pw_args = args;
 }
 
 static PWArgs *
 libsqreen_waf_args_get_boxed(VALUE self) {
-    PWArgs *args;
-
     struct libsqreen_waf_args *box;
     Data_Get_Struct(self, struct libsqreen_waf_args, box);
-    args = (PWArgs *)box->boxed;
-    return args;
+    return &box->pw_args;
 }
 
-/* wrappers */
-
-static VALUE
-libsqreen_waf_module() {
-    VALUE mLibSqreen;
-    VALUE mWAF;
-
-    mLibSqreen = rb_const_get(rb_cObject, rb_intern("LibSqreen"));
-    mWAF = rb_const_get(mLibSqreen, rb_intern("WAF"));
+// drops the reference, returns it, but doesn't invalidate it
+static PWArgs
+libsqreen_waf_args_relinquish(VALUE self) {
+    struct libsqreen_waf_args *box;
+    Data_Get_Struct(self, struct libsqreen_waf_args, box);
+    PWArgs ret = box->pw_args;
+    box->pw_args = pw_args_invalid;
+    return ret;
+}
 
-    return mWAF;
+static void
+libsqreen_waf_args_invalidate(VALUE self) {
+    struct libsqreen_waf_args *box;
+    Data_Get_Struct(self, struct libsqreen_waf_args, box);
+    libsqreen_waf_args_free(box);
 }
 
+/* wrappers */
+
 static VALUE
 libsqreen_version(VALUE self) {
+    (void) self;
+
     PWVersion version;
     VALUE result;
 
@@ -127,6 +132,7 @@ libsqreen_version(VALUE self) {
 
 static VALUE
 libsqreen_waf_set(VALUE self, VALUE name, VALUE rules) {
+    (void)self;
     char * pw_name;
     char * pw_rules;
     bool pw_result;
@@ -137,7 +143,7 @@ libsqreen_waf_set(VALUE self, VALUE name, VALUE rules) {
 
     pw_name = StringValueCStr(name);
     pw_rules = StringValueCStr(rules);
-    pw_result = powerwaf_initializePowerWAF(pw_name, pw_rules);
+    pw_result = powerwaf_init(pw_name, pw_rules, &pw_config);
 
     result = pw_result ? Qtrue : Qfalse;
 
@@ -146,6 +152,8 @@ libsqreen_waf_set(VALUE self, VALUE name, VALUE rules) {
 
 static VALUE
 libsqreen_waf_delete(VALUE self, VALUE name) {
+    (void)self;
+
     char * pw_name;
 
     Check_Type(name, T_STRING);
@@ -158,16 +166,17 @@ libsqreen_waf_delete(VALUE self, VALUE name) {
 
 static VALUE
 libsqreen_waf_clear(VALUE self) {
+    (void)self;
+
     powerwaf_clearAll();
 
     return Qnil;
 }
 
-static const PWArgs PWArgsNil;
-
-int on_hash_iteration(VALUE key, VALUE val, VALUE args);
+static int on_hash_iteration(VALUE key, VALUE val, VALUE args);
 
-PWArgs value_to_pw_args(VALUE val) {
+static PWArgs
+value_to_pw_args(VALUE val) {
     PWArgs pw_val;
 
     switch (TYPE(val)) {
@@ -175,9 +184,10 @@ PWArgs value_to_pw_args(VALUE val) {
         {
             char *pw_string;
             size_t pw_len;
+            VALUE utf8_val = cvt_ruby_str_to_utf8(val);
 
-            pw_string = StringValuePtr(val);
-            pw_len = RSTRING_LEN(val);
+            pw_string = StringValuePtr(utf8_val);
+            pw_len = (size_t)RSTRING_LEN(utf8_val);
             pw_val = powerwaf_createStringWithLength(pw_string, pw_len);
         }
         break;
@@ -191,17 +201,24 @@ PWArgs value_to_pw_args(VALUE val) {
         break;
     case T_HASH:
         {
-            VALUE waf_args;
-
-            pw_val = powerwaf_createMap();
-            waf_args = libsqreen_waf_args_new();
-            libsqreen_waf_args_set_boxed(waf_args, &pw_val);
+            VALUE waf_args = libsqreen_waf_args_new();
+            libsqreen_waf_args_set_boxed(waf_args, powerwaf_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
+            // wrapped so is reachable by the GC
             rb_hash_foreach(val, on_hash_iteration, waf_args);
+
+            // relinquish ownership to the caller to avoid double frees
+            pw_val = libsqreen_waf_args_relinquish(waf_args);
         }
         break;
     case T_ARRAY:
         {
-            pw_val = powerwaf_createArray();
+            VALUE waf_args = libsqreen_waf_args_new();
+            libsqreen_waf_args_set_boxed(waf_args, powerwaf_createArray());
+            PWArgs *array_p = libsqreen_waf_args_get_boxed(waf_args);
+
             for (int i = 0; i < RARRAY_LEN(val); i++) {
                 VALUE e;
                 PWArgs pw_e;
@@ -213,44 +230,58 @@ PWArgs value_to_pw_args(VALUE val) {
                     continue;
                 }
 
+                // can in principle raise
                 pw_e = value_to_pw_args(e);
-                ok = powerwaf_addToPWArgsArray(&pw_val, pw_e);
+                ok = powerwaf_addToPWArgsArray(array_p, pw_e);
                 if (!ok) {
                     powerwaf_freeInput(&pw_e, false);
                 }
             }
+
+            pw_val = libsqreen_waf_args_relinquish(waf_args);
         }
         break;
     case T_NIL:
-        pw_val = PWArgsNil;
-        break;
+        /* break intentionally missing */
     default:
-        pw_val = PWArgsNil;
+        RUBY_LOG(PWL_INFO, "Found argument of unaccepted type: %d", TYPE(val));
+        /* 0.6.1 doesn't cancel the whole rule, but it still complains
+         * 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();
         break;
     }
 
     return pw_val;
 }
 
-int on_hash_iteration(VALUE key, VALUE val, VALUE args) {
-    PWArgs *pw_args;
+static int
+on_hash_iteration(volatile VALUE key, VALUE val, VALUE waf_value) {
     char *pw_key;
-    PWArgs pw_val;
+    size_t pw_len;
     bool ok;
 
-    Check_Type(key, T_STRING);
-    // Check_Type(in, libsqreen_waf_args)
+    if (RB_TYPE_P(key, T_SYMBOL)) {
+        key = rb_sym_to_s(key); // can't fail
+        // will go to next if
+    }
 
-    if (val == Qnil) {
+    if (RB_TYPE_P(key, T_STRING)) {
+        pw_key = StringValuePtr(key);
+        pw_len = (size_t)RSTRING_LEN(key);
+    } else {
         return ST_CONTINUE;
     }
 
-    pw_args = (PWArgs *)libsqreen_waf_args_get_boxed(args);
-    pw_key = StringValueCStr(key);
-    pw_val = value_to_pw_args(val);
-    ok = powerwaf_addToPWArgsMap(pw_args, pw_key, strlen(pw_key), pw_val);
+    PWArgs *parent = libsqreen_waf_args_get_boxed(waf_value);
+    // can throw, but nothing allocated by powerwaf yet
+    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);
     if (!ok) {
-        powerwaf_freeInput(&pw_val, false);
+        powerwaf_freeInput(&value_to_add, false);
     }
 
     return ST_CONTINUE;
@@ -258,11 +289,7 @@ int on_hash_iteration(VALUE key, VALUE val, VALUE args) {
 
 static VALUE
 libsqreen_waf_args_initialize(VALUE self, VALUE args) {
-    VALUE hash;
-    long len;
-    PWArgs pw_args;
-
-    len = RARRAY_LEN(args);
+    long len = RARRAY_LEN(args);
     if (len > 2) {
         rb_raise(rb_eArgError, "wrong number of arguments");
     }
@@ -270,17 +297,18 @@ libsqreen_waf_args_initialize(VALUE self, VALUE args) {
         return self;
     }
 
-    hash = rb_ary_entry(args, 0);
+    VALUE hash = rb_ary_entry(args, 0);
     Check_Type(hash, T_HASH);
 
-    pw_args = value_to_pw_args(hash);
-    libsqreen_waf_args_set_boxed(self, &pw_args);
+    PWArgs pw_args = value_to_pw_args(hash);
+    libsqreen_waf_args_set_boxed(self, pw_args);
 
     return self;
 }
 
 
-VALUE ret_code_to_sym(PW_RET_CODE level) {
+static VALUE
+ret_code_to_sym(PW_RET_CODE level) {
     VALUE sym;
 
     switch (level) {
@@ -312,199 +340,187 @@ VALUE ret_code_to_sym(PW_RET_CODE level) {
         sym = ID2SYM(rb_intern("block"));
         break;
     default:
-        sym = Qnil;
         rb_raise(rb_eArgError, "not valid value");
-        break;
     }
 
     return sym;
 }
 
-static VALUE
-libsqreen_waf_run(VALUE self, VALUE name, VALUE args, VALUE budget) {
-    VALUE waf_args;
-    char *pw_name;
-    PWArgs pw_args;
-    size_t pw_budget;
-    PWRet *pw_ret;
-    VALUE result;
 
-    Check_Type(name, T_STRING);
-    Check_Type(args, T_HASH);
-    Check_Type(budget, T_FIXNUM);
-
-    waf_args = libsqreen_waf_args_new_from_hash(args);
-    pw_args = *(PWArgs *)libsqreen_waf_args_get_boxed(waf_args);
-    pw_budget = FIX2LONG(budget);
-    pw_name = StringValueCStr(name);
-	pw_ret = powerwaf_runPowerWAF(pw_name, &pw_args, pw_budget);
+static int64_t
+get_max_run_budget(VALUE arg_max_run_budg) {
+    if (NIL_P(arg_max_run_budg)) {
+        // use default value provided by waf headers
+        RUBY_LOG(PWL_DEBUG, "Using %d us as run timeout (default)",
+                 PW_RUN_TIMEOUT);
+        return PW_RUN_TIMEOUT; // 5000 us as of this time
+    }
 
-    result = rb_ary_new();
-    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));
+    if (!FIXNUM_P(arg_max_run_budg)) {
+        RUBY_LOG(PWL_ERROR, "Max run budget is not a fixnum; "
+                            "using default %d us", PW_RUN_TIMEOUT);
+        return PW_RUN_TIMEOUT; // 5000 us as of this time
+    }
 
-	powerwaf_freeInput(&pw_args, false);
-	powerwaf_freeReturn(pw_ret);
+    long res = FIX2LONG(arg_max_run_budg);
+    if (res <= 0) {
+        RUBY_LOG(PWL_DEBUG, "Max run budget is not positive; "
+                            "using default %d us", PW_RUN_TIMEOUT);
+        return PW_RUN_TIMEOUT;
+    }
 
-    return result;
+    RUBY_LOG(PWL_DEBUG, "Using %ld us as max run timeout override", res);
+    return (int64_t)res;
 }
 
-VALUE log_level_to_sym(PW_LOG_LEVEL level) {
-    VALUE sym;
-
-    switch (level) {
-    case PWL_TRACE:
-        sym = ID2SYM(rb_intern("trace"));
-        break;
-    case PWL_DEBUG:
-        sym = ID2SYM(rb_intern("debug"));
-        break;
-    case PWL_INFO:
-        sym = ID2SYM(rb_intern("info"));
-        break;
-    case PWL_WARN:
-        sym = ID2SYM(rb_intern("warn"));
-        break;
-    case PWL_ERROR:
-        sym = ID2SYM(rb_intern("error"));
-        break;
-    default:
-        sym = Qnil;
-        rb_raise(rb_eArgError, "not valid value");
-        break;
+static inline struct timespec
+get_time_mono() {
+    struct timespec out;
+    int res = clock_gettime(CLOCK_MONOTONIC, &out);
+    if (res) {
+        // this should never fail, but...
+        RUBY_LOG(PWL_INFO, "clock_gettime failed");
+        return (struct timespec) {0};
     }
-
-    return sym;
+    return out;
 }
 
-VALUE log_level_to_fixnum(PW_LOG_LEVEL level) {
-    VALUE sym;
+static inline int64_t
+timespec_diff_us(struct timespec a, struct timespec b)
+{
+    return (((int64_t)a.tv_sec - (int64_t)b.tv_sec) * 1000000000L +
+            ((int64_t)a.tv_nsec - (int64_t)b.tv_nsec)) / 1000;
+}
 
-    switch (level) {
-    case PWL_TRACE:
-        sym = INT2FIX(0); // Logger::DEBUG
-        break;
-    case PWL_DEBUG:
-        sym = INT2FIX(0); // Logger::DEBUG
-        break;
-    case PWL_INFO:
-        sym = INT2FIX(1); // Logger::INFO
-        break;
-    case PWL_WARN:
-        sym = INT2FIX(2); // Logger::WARN
-        break;
-    case PWL_ERROR:
-        sym = INT2FIX(3); // Logger::ERROR
-        break;
-    default:
-        sym = Qnil;
-        rb_raise(rb_eArgError, "not valid value");
-        break;
+static inline size_t
+calc_run_budget(struct timespec start,
+                int64_t gen_budget,
+                VALUE arg_max_run_budg) {
+    struct timespec after_conv = get_time_mono();
+    int64_t spent_conv = timespec_diff_us(after_conv, start);
+    int64_t rem_gen_budget = gen_budget - spent_conv;
+    if (rem_gen_budget < 0) {
+        rem_gen_budget = 0;
+    }
+    RUBY_LOG(PWL_DEBUG, "Conversion of WAF arguments took %" PRId64
+                        " us; remaining general budget is %" PRId64 " us",
+             spent_conv, rem_gen_budget);
+    if (rem_gen_budget == 0) {
+        RUBY_LOG(PWL_INFO, "General budget of %" PRId64 " us exhausted after "
+                           "native conversion (spent %" PRId64 " us)",
+                 gen_budget, spent_conv);
+        return 0;
     }
 
-    return sym;
-}
-
-PW_LOG_LEVEL sym_to_log_level(VALUE sym) {
-    PW_LOG_LEVEL level;
-
-    Check_Type(sym, T_SYMBOL);
-
-    if (SYM2ID(sym) == rb_intern("trace")) {
-        level = PWL_TRACE;
-    } else if (SYM2ID(sym) == rb_intern("debug")) {
-        level = PWL_DEBUG;
-    } else if (SYM2ID(sym) == rb_intern("info")) {
-        level = PWL_INFO;
-    } else if (SYM2ID(sym) == rb_intern("warn")) {
-        level = PWL_WARN;
-    } else if (SYM2ID(sym) == rb_intern("error")) {
-        level = PWL_ERROR;
+    size_t run_budget;
+    int64_t max_run_budget = get_max_run_budget(arg_max_run_budg);
+    if (rem_gen_budget > max_run_budget) {
+        run_budget = (size_t)max_run_budget;
+        RUBY_LOG(PWL_DEBUG, "Using run budget of % " PRId64 " us instead of "
+                            "remaining general budget of %" PRId64 " us",
+                 run_budget, rem_gen_budget);
     } else {
-        rb_raise(rb_eArgError, "not valid value");
-        level = _PWL_AFTER_LAST;
+        run_budget = (size_t)rem_gen_budget;
     }
-
-    return level;
+    return run_budget;
 }
 
-void on_log(PW_LOG_LEVEL level, const char *function, const char *file, int line, const char *message, size_t message_len);
-
 static VALUE
-libsqreen_waf_log_enable(VALUE self, VALUE severity) {
-    PW_LOG_LEVEL level;
+libsqreen_waf_run(int argc, const VALUE *argv, VALUE self) {
+    (void)self;
 
-    Check_Type(severity, T_SYMBOL);
+    VALUE name, args, budget, max_run_budget;
 
-    level = sym_to_log_level(severity);
-    powerwaf_setupLogging((powerwaf_logging_cb_t)on_log, level);
+    rb_scan_args(argc, argv, "31", &name, &args, &budget, &max_run_budget);
 
-    return Qnil;
-}
-
-static VALUE
-libsqreen_waf_log_disable(VALUE self) {
-    PW_LOG_LEVEL level = PWL_ERROR;
-
-    powerwaf_setupLogging(NULL, level);
-
-    return Qnil;
-}
+    PWRet *pw_ret;
+    VALUE result = rb_ary_new();
 
-static VALUE
-libsqreen_waf_set_logger(VALUE self, VALUE logger) {
-    ID i_logger;
+    Check_Type(name, T_STRING);
+    Check_Type(args, T_HASH);
+    Check_Type(budget, T_FIXNUM);
+    if (!NIL_P(max_run_budget)) {
+        Check_Type(max_run_budget, T_FIXNUM);
+    }
 
-    if (logger == Qnil) {
-        libsqreen_waf_log_disable(self);
+    int64_t gen_budget = (int64_t)FIX2LONG(budget); // in us
+    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);
+    const char *pw_name = StringValueCStr(name);
+    size_t run_budget = calc_run_budget(start, gen_budget, max_run_budget);
+    if (run_budget == 0) {
+        rb_ary_push(result,  ID2SYM(rb_intern("timeout")));
+        rb_ary_push(result, Qnil);
+        return result;
     }
 
-    i_logger = rb_intern("@logger");
-    rb_ivar_set(self, i_logger, logger);
+    pw_ret = powerwaf_run(pw_name, pw_args, run_budget);
 
-    if (logger != Qnil) {
-        libsqreen_waf_log_enable(self, ID2SYM(rb_intern("error")));
-    }
+    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);
 
-    return logger;
+    return result;
 }
 
 static VALUE
-libsqreen_waf_get_logger(VALUE self) {
-    VALUE logger;
-    ID i_logger;
-
-    i_logger = rb_intern("@logger");
-    logger = rb_ivar_get(self, i_logger);
+encode_as_utf8(VALUE string) {
+    return rb_funcall(string, rb_intern("encode"), 1, utf8_str);
+}
 
-    return logger;
+static VALUE
+fall_back_encode_as_utf8(VALUE string) {
+    VALUE dup = rb_funcall(string, rb_intern("dup"), 0);
+    VALUE latin1_str = rb_funcall(
+                dup, rb_intern("force_encoding"), 1, iso8859_1_str);
+    return encode_as_utf8(latin1_str);
 }
 
-void
-on_log(PW_LOG_LEVEL level, const char *function, const char *file, int line, const char *message, size_t message_len) {
-    VALUE severity;
-    VALUE logger;
-    VALUE log_msg;
-    VALUE mWAF;
-
-    mWAF = libsqreen_waf_module();
-    logger = libsqreen_waf_get_logger(mWAF);
-    if (logger == Qnil) {
-        return;
+static VALUE
+cvt_ruby_str_to_utf8(VALUE value) {
+    rb_encoding *const enc = rb_enc_get(value);
+
+    bool is_utf8 = enc == utf8_enc || enc == usascii_enc;
+    if (!is_utf8 && (enc == ascii8bit_enc || enc == latin1_enc)) {
+        char *str = RSTRING_PTR(value);
+        long len = RSTRING_LEN(value);
+        // still some hope left
+        is_utf8 = true;
+        for (long i = 0; i < len; i++) {
+            if ((unsigned char) str[i] >= 0x80) {
+                is_utf8 = false;
+                break;
+            }
+        }
     }
 
-    severity = log_level_to_fixnum(level);
-    if (severity == Qnil) {
-        return;
+    if (is_utf8) {
+        // may not be valid_encoding?, but the WAF tolerates this
+        return value;
     }
 
-    log_msg = rb_sprintf("from %s:%d:in `%s': %s",  file, line, function, message);
-    //rb_funcall(logger, SYM2ID(sym_level), 1, log_msg);
-    rb_funcall(logger, rb_intern("add"), 2, severity, log_msg);
+    // attempt conversion
+    int excepted;
+    VALUE result = rb_protect(encode_as_utf8, value, &excepted);
+    if (excepted) {
+        RUBY_LOG(PWL_DEBUG, "Error converting string to UTF-8. Encoding: %s",
+                 ONIGENC_NAME(enc));
+        // conversion failed, try fallback
+        result = rb_protect(fall_back_encode_as_utf8, value, &excepted);
+        if (excepted) {
+            RUBY_LOG(PWL_INFO, "Fallback conversion -> latin1 -> utf8 also "
+                               "failed!");
+            // fallback also failed; stop attempting conversion
+            return value;
+        }
+    }
+    return result;
 }
 
-#endif
-
 // extension initializer
 void
 Init_libsqreen_extension(void) {
@@ -512,48 +528,37 @@ Init_libsqreen_extension(void) {
 
     mLibSqreen = rb_define_module("LibSqreen");
 
-    // record load order
-    {
-        ID i_load_order;
-        VALUE load_order;
-
-        i_load_order = rb_intern("@load_order");
-        load_order = rb_ivar_get(mLibSqreen, i_load_order);
-        if (load_order == Qnil) {
-            load_order = rb_ary_new();
-            rb_ivar_set(mLibSqreen, i_load_order, load_order);
-        }
-
-        rb_ary_push(load_order, ID2SYM(rb_intern("libsqreen_extension.c")));
-    }
-
-    #ifndef LIBSQREEN_STUB
-
     // define C API bindings
     {
         rb_define_module_function(mLibSqreen, "version", libsqreen_version, 0);
 
-        {
-            VALUE mWAF;
-            mWAF = rb_define_module_under(mLibSqreen, "WAF");
-            rb_define_module_function(mWAF, "[]=", libsqreen_waf_set, 2);
-            rb_define_module_function(mWAF, "delete", libsqreen_waf_delete, 1);
-            rb_define_module_function(mWAF, "clear", libsqreen_waf_clear, 0);
-            rb_define_module_function(mWAF, "run", libsqreen_waf_run, 3);
-            rb_define_module_function(mWAF, "logger", libsqreen_waf_get_logger, 0);
-            rb_define_module_function(mWAF, "logger=", libsqreen_waf_set_logger, 1);
-            rb_define_module_function(mWAF, "log_level=", libsqreen_waf_log_enable, 1);
-            rb_define_module_function(mWAF, "log_disable", libsqreen_waf_log_disable, 0);
-            rb_define_const(mWAF, "BUDGET_MAX", ULL2NUM((size_t)-1));
-
-            {
-                VALUE cArgs;
-                cArgs = rb_define_class_under(mWAF, "Args", rb_cData);
-                rb_define_alloc_func(cArgs, libsqreen_waf_args_alloc);
-                rb_define_method(cArgs, "initialize", libsqreen_waf_args_initialize, -2);
-            }
-        }
+        waf_mod = rb_define_module_under(mLibSqreen, "WAF");
+        rb_gc_register_mark_object(waf_mod);
+        rb_define_module_function(waf_mod, "[]=", libsqreen_waf_set, 2);
+        rb_define_module_function(waf_mod, "set", libsqreen_waf_set, 2);
+        rb_define_module_function(waf_mod, "delete", libsqreen_waf_delete, 1);
+        rb_define_module_function(waf_mod, "clear", libsqreen_waf_clear, 0);
+        rb_define_module_function(waf_mod, "run", libsqreen_waf_run, -1);
+        rb_define_module_function(waf_mod, "logger", libsqreen_waf_get_logger, 0);
+        rb_define_module_function(waf_mod, "logger=", libsqreen_waf_set_logger, 1);
+        rb_define_module_function(waf_mod, "log_level=", libsqreen_waf_log_enable, 1);
+        rb_define_module_function(waf_mod, "log_disable", libsqreen_waf_log_disable, 0);
+
+        waf_args_cls = rb_define_class_under(waf_mod, "Args", rb_cData);
+        rb_define_alloc_func(waf_args_cls, libsqreen_waf_args_alloc);
+        rb_define_method(waf_args_cls, "initialize", libsqreen_waf_args_initialize, -2);
+        rb_gc_register_mark_object(waf_args_cls);
     }
 
-    #endif
+    utf8_enc = rb_enc_find("utf-8");
+    latin1_enc = rb_enc_find("iso-8859-1");
+    ascii8bit_enc = rb_ascii8bit_encoding();
+    usascii_enc = rb_usascii_encoding();
+
+    utf8_str = rb_str_new2("utf-8");
+    rb_gc_register_mark_object(utf8_str);
+    iso8859_1_str = rb_str_new2("iso-8859-1");
+    rb_gc_register_mark_object(iso8859_1_str);
+
+    log_init();
 }