libsqreen 0.3.0.0.3

data/ext/libsqreen/paths.rb

@@ -0,0 +1,53 @@
+# Copyright (c) 2015 Sqreen. All Rights Reserved.
+# Please refer to our terms for more information: https://www.sqreen.com/terms.html
+
+require 'rbconfig'
+require 'shellwords'
+
+module LibSqreen
+  module Paths
+    module_function
+
+    def include_paths
+      [Shellwords.escape(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 header_files
+      ['waf.h']
+    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
+end

data/ext/libsqreen_extension/extconf.rb

@@ -0,0 +1,27 @@
+# Copyright (c) 2015 Sqreen. All Rights Reserved.
+# Please refer to our terms for more information: https://www.sqreen.com/terms.html
+
+require 'mkmf'
+
+$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}'"
+  end
+end
+
+create_makefile('libsqreen_extension')

data/ext/libsqreen_extension/libsqreen_extension.c

@@ -0,0 +1,559 @@
+// Copyright (c) 2015 Sqreen. All Rights Reserved.
+// Please refer to our terms for more information: https://www.sqreen.com/terms.html
+
+#include <ruby.h>
+#include <stdbool.h>
+
+#ifndef LIBSQREEN_STUB
+
+#include <waf.h>
+
+/* boxes */
+
+// PWArgs box
+struct libsqreen_waf_args {
+  void *boxed;
+};
+
+static void
+libsqreen_waf_args_free(void *b) {
+    struct libsqreen_waf_args *box = b;
+
+    if (box == NULL) {
+        return;
+    }
+
+    if (box->boxed == NULL) {
+        return;
+    }
+
+    box->boxed = NULL;
+}
+
+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;
+}
+
+static VALUE
+libsqreen_waf_args_klass() {
+    VALUE mLibSqreen;
+    VALUE mWAF;
+    VALUE cArgs;
+
+    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"));
+
+    return cArgs;
+}
+
+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);
+
+    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);
+
+    return waf_args;
+}
+
+static void
+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;
+}
+
+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;
+}
+
+/* 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"));
+
+    return mWAF;
+}
+
+static VALUE
+libsqreen_version(VALUE self) {
+    PWVersion version;
+    VALUE result;
+
+    version = powerwaf_getVersion();
+    result = rb_ary_new();
+    rb_ary_push(result, INT2NUM(version.major));
+    rb_ary_push(result, INT2NUM(version.minor));
+    rb_ary_push(result, INT2NUM(version.patch));
+
+    return result;
+}
+
+static VALUE
+libsqreen_waf_set(VALUE self, VALUE name, VALUE rules) {
+    char * pw_name;
+    char * pw_rules;
+    bool pw_result;
+    VALUE result;
+
+    Check_Type(name, T_STRING);
+    Check_Type(rules, T_STRING);
+
+    pw_name = StringValueCStr(name);
+    pw_rules = StringValueCStr(rules);
+    pw_result = powerwaf_initializePowerWAF(pw_name, pw_rules);
+
+    result = pw_result ? Qtrue : Qfalse;
+
+    return result;
+}
+
+static VALUE
+libsqreen_waf_delete(VALUE self, VALUE name) {
+    char * pw_name;
+
+    Check_Type(name, T_STRING);
+
+    pw_name = StringValueCStr(name);
+    powerwaf_clearRule(pw_name);
+
+    return Qnil;
+}
+
+static VALUE
+libsqreen_waf_clear(VALUE self) {
+    powerwaf_clearAll();
+
+    return Qnil;
+}
+
+static const PWArgs PWArgsNil;
+
+int on_hash_iteration(VALUE key, VALUE val, VALUE args);
+
+PWArgs value_to_pw_args(VALUE val) {
+    PWArgs pw_val;
+
+    switch (TYPE(val)) {
+    case T_STRING:
+        {
+            char *pw_string;
+            size_t pw_len;
+
+            pw_string = StringValuePtr(val);
+            pw_len = RSTRING_LEN(val);
+            pw_val = powerwaf_createStringWithLength(pw_string, pw_len);
+        }
+        break;
+    case T_FIXNUM:
+        {
+            int64_t pw_int;
+
+            pw_int = FIX2LONG(val);
+            pw_val = powerwaf_createInt(pw_int);
+        }
+        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);
+            rb_hash_foreach(val, on_hash_iteration, waf_args);
+        }
+        break;
+    case T_ARRAY:
+        {
+            pw_val = powerwaf_createArray();
+            for (int i = 0; i < RARRAY_LEN(val); i++) {
+                VALUE e;
+                PWArgs pw_e;
+                bool ok;
+
+                e = rb_ary_entry(val, i);
+
+                if (e == Qnil) {
+                    continue;
+                }
+
+                pw_e = value_to_pw_args(e);
+                ok = powerwaf_addToPWArgsArray(&pw_val, pw_e);
+                if (!ok) {
+                    powerwaf_freeInput(&pw_e, false);
+                }
+            }
+        }
+        break;
+    case T_NIL:
+        pw_val = PWArgsNil;
+        break;
+    default:
+        pw_val = PWArgsNil;
+        break;
+    }
+
+    return pw_val;
+}
+
+int on_hash_iteration(VALUE key, VALUE val, VALUE args) {
+    PWArgs *pw_args;
+    char *pw_key;
+    PWArgs pw_val;
+    bool ok;
+
+    Check_Type(key, T_STRING);
+    // Check_Type(in, libsqreen_waf_args)
+
+    if (val == Qnil) {
+        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);
+    if (!ok) {
+        powerwaf_freeInput(&pw_val, false);
+    }
+
+    return ST_CONTINUE;
+}
+
+static VALUE
+libsqreen_waf_args_initialize(VALUE self, VALUE args) {
+    VALUE hash;
+    long len;
+    PWArgs pw_args;
+
+    len = RARRAY_LEN(args);
+    if (len > 2) {
+        rb_raise(rb_eArgError, "wrong number of arguments");
+    }
+    if (len == 0) {
+        return self;
+    }
+
+    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);
+
+    return self;
+}
+
+
+VALUE ret_code_to_sym(PW_RET_CODE level) {
+    VALUE sym;
+
+    switch (level) {
+    case PW_ERR_INTERNAL:
+        sym = ID2SYM(rb_intern("internal_error"));
+        break;
+    case PW_ERR_TIMEOUT:
+        sym = ID2SYM(rb_intern("timeout"));
+        break;
+    case PW_ERR_INVALID_CALL:
+        sym = ID2SYM(rb_intern("invalid_call"));
+        break;
+    case PW_ERR_INVALID_RULE:
+        sym = ID2SYM(rb_intern("invalid_rule"));
+        break;
+    case PW_ERR_INVALID_FLOW:
+        sym = ID2SYM(rb_intern("invalid_flow"));
+        break;
+    case PW_ERR_NORULE:
+        sym = ID2SYM(rb_intern("no_rule"));
+        break;
+    case PW_GOOD:
+        sym = ID2SYM(rb_intern("good"));
+        break;
+    case PW_MONITOR:
+        sym = ID2SYM(rb_intern("monitor"));
+        break;
+    case PW_BLOCK:
+        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);
+
+    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));
+
+	powerwaf_freeInput(&pw_args, false);
+	powerwaf_freeReturn(pw_ret);
+
+    return result;
+}
+
+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;
+    }
+
+    return sym;
+}
+
+VALUE log_level_to_fixnum(PW_LOG_LEVEL level) {
+    VALUE sym;
+
+    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;
+    }
+
+    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;
+    } else {
+        rb_raise(rb_eArgError, "not valid value");
+        level = _PWL_AFTER_LAST;
+    }
+
+    return level;
+}
+
+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;
+
+    Check_Type(severity, T_SYMBOL);
+
+    level = sym_to_log_level(severity);
+    powerwaf_setupLogging((powerwaf_logging_cb_t)on_log, level);
+
+    return Qnil;
+}
+
+static VALUE
+libsqreen_waf_log_disable(VALUE self) {
+    PW_LOG_LEVEL level = PWL_ERROR;
+
+    powerwaf_setupLogging(NULL, level);
+
+    return Qnil;
+}
+
+static VALUE
+libsqreen_waf_set_logger(VALUE self, VALUE logger) {
+    ID i_logger;
+
+    if (logger == Qnil) {
+        libsqreen_waf_log_disable(self);
+    }
+
+    i_logger = rb_intern("@logger");
+    rb_ivar_set(self, i_logger, logger);
+
+    if (logger != Qnil) {
+        libsqreen_waf_log_enable(self, ID2SYM(rb_intern("error")));
+    }
+
+    return logger;
+}
+
+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);
+
+    return logger;
+}
+
+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;
+    }
+
+    severity = log_level_to_fixnum(level);
+    if (severity == Qnil) {
+        return;
+    }
+
+    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);
+}
+
+#endif
+
+// extension initializer
+void
+Init_libsqreen_extension(void) {
+    VALUE mLibSqreen;
+
+    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);
+            }
+        }
+    }
+
+    #endif
+}