journald-native 1.0.1 → 1.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 434d6c7409f38d0c734102b165c7422774b4b765
-  data.tar.gz: dbb1a39c162a253430a5ddf497a7b6ecc8c71ee5
+  metadata.gz: 7074ca755c39b71b382f63b7befe21e0dc7e18ec
+  data.tar.gz: 585840efef3b5ee2b50f97e830ecf21df0ec811b
 SHA512:
-  metadata.gz: 53b67e58815b34992d37b8a39339372e2d27393bbefe533d37375aac7fd4ef9386fd35fecece27ee7c9b201f56488d12fed26d22d24a1b17bb00e72fdad67473
-  data.tar.gz: ec9ac27fa92aeb99b0258780342ebdbf34805f90db345990f5e650db5bf9a4ffd8e738f8a64612b7612a03bd4f540ab8091a4a74e8635b234f5caec24d503f68
+  metadata.gz: e19cdf3224ca356c47319c5dd6897cc364a8f4d87a1f9c7d9319a31be19be2b4298cbc1b869024e8f0846f48115947dc296afb9d809de368bc16ae18434cdb2a
+  data.tar.gz: 214828671762b128ae1875fffce35e8a3db25217db47e6bca8d4a127750c3ad1ca55d9c8999c623829dce3a8b998ffe70d2fe62395b3dedf75b3479d3487532a

data/.gitignore

@@ -25,3 +25,5 @@ Makefile
 *.ipr
 *.iws
 .rakeTasks
+.idea
+extconf.h

data/README.md

@@ -1,12 +1,15 @@
 # journald-native
 
+[![Gem Version](https://badge.fury.io/rb/journald-native.svg)](http://badge.fury.io/rb/journald-native)
+[![Reference Status](https://www.versioneye.com/ruby/journald-native/reference_badge.svg)](https://www.versioneye.com/ruby/journald-native/references)
+
 A systemd-journal native logging lib wrapper.
 [See sd-journal help for more info](http://www.freedesktop.org/software/systemd/man/sd_journal_print.html)
 
 ## Usage
 
 ```ruby
-    require 'journald/native'
+require 'journald/native'
 ```
 
 ### Constants
@@ -16,14 +19,14 @@ Constants are used to denote a log level
 Available constants:
 
 ```ruby
-    Journald::LOG_EMERG     # system is unusable
-    Journald::LOG_ALERT     # action must be taken immediately
-    Journald::LOG_CRIT      # critical conditions
-    Journald::LOG_ERR       # error conditions
-    Journald::LOG_WARNING   # warning conditions
-    Journald::LOG_NOTICE    # normal but significant condition
-    Journald::LOG_INFO      # informational
-    Journald::LOG_DEBUG     # debug-level messages
+Journald::LOG_EMERG     # system is unusable
+Journald::LOG_ALERT     # action must be taken immediately
+Journald::LOG_CRIT      # critical conditions
+Journald::LOG_ERR       # error conditions
+Journald::LOG_WARNING   # warning conditions
+Journald::LOG_NOTICE    # normal but significant condition
+Journald::LOG_INFO      # informational
+Journald::LOG_DEBUG     # debug-level messages
 ```
 
 systemd-journal uses syslog constants to denote level therefore they are equal to those of the Syslog module,
@@ -36,14 +39,14 @@ Methods of Journald::Native class wrap systemd-journal calls.
 [See sd-journal help for more info](http://www.freedesktop.org/software/systemd/man/sd_journal_print.html) 
 
 ```ruby
-    Journald::Native.send "MESSAGE=message", "PRIORITY=#{Journald::LOG_WARNING}"
-    Journald::Native.print Journald::LOG_WARNING, "message"
-    Journald::Native.perror "message"
+Journald::Native.send "MESSAGE=message", "PRIORITY=#{Journald::LOG_WARNING}"
+Journald::Native.print Journald::LOG_WARNING, "message"
+Journald::Native.perror "message"
 ```
 
-It is not recommended to use ```print``` and ```perror``` as you may lose ```'\0'``` byte in your string due to
-C zero-terminated string format (all zero bytes in the middle will be removed) On the contrary ```send``` uses
-binary buffers and does not have such shortcoming.
+It is not recommended to use ```print``` and ```perror``` as you may get exception if your string contains
+```'\0'``` byte due to C zero-terminated string format. On the contrary ```send``` uses binary buffers and
+does not have this shortcoming.
 
 ### License
 

data/ext/journald_native/CMakeLists.txt

@@ -0,0 +1,9 @@
+# dummy cmake file for CLion
+
+cmake_minimum_required(VERSION 2.8.4)
+project(journald_native)
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
+
+set(SOURCE_FILES extinit.cpp journald_native.cpp ruby_exception_wrapper.cpp)
+add_executable(journald_native ${SOURCE_FILES})

data/ext/journald_native/cpp14shiv.h

@@ -0,0 +1,78 @@
+/*
+    unique_ptr from http://isocpp.org/files/papers/N3656.txt
+    index sequence from gcc 4.9 sources
+*/
+
+#include <cstddef>
+#include <memory>
+#include <type_traits>
+#include <utility>
+
+namespace std {
+    template<class T> struct _Unique_if {
+        typedef unique_ptr<T> _Single_object;
+    };
+
+    template<class T> struct _Unique_if<T[]> {
+        typedef unique_ptr<T[]> _Unknown_bound;
+    };
+
+    template<class T, size_t N> struct _Unique_if<T[N]> {
+        typedef void _Known_bound;
+    };
+
+    template<class T, class... Args>
+        typename _Unique_if<T>::_Single_object
+        make_unique(Args&&... args) {
+            return unique_ptr<T>(new T(std::forward<Args>(args)...));
+        }
+
+    template<class T>
+        typename _Unique_if<T>::_Unknown_bound
+        make_unique(size_t n) {
+            typedef typename remove_extent<T>::type U;
+            return unique_ptr<T>(new U[n]());
+        }
+
+    template<class T, class... Args>
+        typename _Unique_if<T>::_Known_bound
+        make_unique(Args&&...) = delete;
+
+    /// Class template integer_sequence
+    template<typename _Tp, _Tp... _Idx>
+    struct integer_sequence
+    {
+        typedef _Tp value_type;
+        static constexpr size_t size() { return sizeof...(_Idx); }
+    };
+
+    template<typename _Tp, _Tp _Num,
+            typename _ISeq = typename _Build_index_tuple<_Num>::__type>
+    struct _Make_integer_sequence;
+
+    template<typename _Tp, _Tp _Num,  size_t... _Idx>
+    struct _Make_integer_sequence<_Tp, _Num, _Index_tuple<_Idx...>>
+    {
+        static_assert( _Num >= 0,
+                "Cannot make integer sequence of negative length" );
+
+        typedef integer_sequence<_Tp, static_cast<_Tp>(_Idx)...> __type;
+    };
+
+    /// Alias template make_integer_sequence
+    template<typename _Tp, _Tp _Num>
+    using make_integer_sequence
+    = typename _Make_integer_sequence<_Tp, _Num>::__type;
+
+    /// Alias template index_sequence
+    template<size_t... _Idx>
+    using index_sequence = integer_sequence<size_t, _Idx...>;
+
+    /// Alias template make_index_sequence
+    template<size_t _Num>
+    using make_index_sequence = make_integer_sequence<size_t, _Num>;
+
+    /// Alias template index_sequence_for
+    template<typename... _Types>
+    using index_sequence_for = make_index_sequence<sizeof...(_Types)>;
+}

data/ext/journald_native/extconf.rb

@@ -4,17 +4,33 @@ LIBDIR      = RbConfig::CONFIG['libdir']
 INCLUDEDIR  = RbConfig::CONFIG['includedir']
 
 HEADER_DIRS = [INCLUDEDIR]
-
-LIB_DIRS = [LIBDIR]
+LIB_DIRS    = [LIBDIR]
 
 dir_config('systemd', HEADER_DIRS, LIB_DIRS)
 
+$CPPFLAGS = '-std=c++11'
+
+def have_funcs
+  have_funcs = true
+
+  # check functions. redefine const list in sd_journal.h if changed
+  %w(sd_journal_print sd_journal_sendv sd_journal_perror).each do |func|
+    have_funcs &&= have_func(func)
+  end
+
+  have_funcs
+end
+
 # check headers
-abort 'systemd/sd-journal.h is missing. please install systemd-journal' unless find_header('systemd/sd-journal.h')
+have_header('systemd/sd-journal.h')
+
+# first try to find funcs in systemd
+have_library('systemd')
 
-# check functions
-%w(sd_journal_print sd_journal_sendv sd_journal_perror).each do |func|
-   abort "#{func}() is missing. systemd-journal is not usable" unless find_library('systemd-journal', func)
+unless have_funcs
+  have_library('systemd-journal') # try to fall back to systemd-journal if older systemd
+  have_funcs
 end
 
+create_header
 create_makefile('journald_native')

data/ext/journald_native/extinit.cpp

@@ -0,0 +1,7 @@
+#include "journald_native.h"
+
+/* initialize ruby extension */
+extern "C" void Init_journald_native()
+{
+    journald_native::init_modules();
+}

data/ext/journald_native/journald_native.cpp

@@ -0,0 +1,100 @@
+#include "journald_native.h"
+#include "sd_journal.h"
+
+#include <memory>
+
+#include "ruby_exception_wrapper.h"
+
+namespace journald_native {
+
+namespace {
+
+/* aux */
+// just a short alias for ruby_raisable_call()
+template <typename Func, typename... Args>
+inline auto r(Func f, Args... args) -> decltype(f(args...))
+{
+    return ruby_exception_wrapper::ruby_raisable_call(f, args...);
+}
+
+/* methods */
+inline VALUE native_print(VALUE v_self, VALUE v_priority, VALUE v_message)
+{
+    int         priority = NUM2INT(v_priority);
+    std::string message  = r(rb_string_value_cstr, &v_message);
+
+    int         result   = sd_journal_print(priority, "%s", message.c_str());
+
+    return INT2NUM(result);
+}
+
+inline VALUE native_send(int argc, VALUE* argv, VALUE v_self)
+{
+    auto msgs = std::make_unique<iovec[]>((size_t)argc);
+
+    for (int i = 0; i < argc; i++) {
+        VALUE v = r(rb_string_value, &argv[i]);
+
+        msgs[i].iov_base = (char *)RSTRING_PTR(v);
+        msgs[i].iov_len  = (size_t)RSTRING_LEN(v);
+    }
+
+    int result = sd_journal_sendv(msgs.get(), argc);
+
+    return INT2NUM(result);
+}
+
+inline VALUE native_perror(VALUE v_self, VALUE v_message)
+{
+    std::string message = r(rb_string_value_cstr, &v_message);
+
+    int         result  = sd_journal_perror(message.c_str());
+
+    return INT2NUM(result);
+}
+
+VALUE is_dummy(VALUE v_self = Qnil)
+{
+    constexpr VALUE dummy = JOURNALD_NATIVE_SD_JOURNAL_DUMMY ? Qtrue : Qfalse;
+    return dummy;
+}
+
+/* initializers */
+inline void init_journald(VALUE module)
+{
+    rb_define_const(module, "LOG_EMERG",   INT2NUM(LOG_EMERG));    /* system is unusable */
+    rb_define_const(module, "LOG_ALERT",   INT2NUM(LOG_ALERT));    /* action must be taken immediately */
+    rb_define_const(module, "LOG_CRIT",    INT2NUM(LOG_CRIT));     /* critical conditions */
+    rb_define_const(module, "LOG_ERR",     INT2NUM(LOG_ERR));      /* error conditions */
+    rb_define_const(module, "LOG_WARNING", INT2NUM(LOG_WARNING));  /* warning conditions */
+    rb_define_const(module, "LOG_NOTICE",  INT2NUM(LOG_NOTICE));   /* normal but significant condition */
+    rb_define_const(module, "LOG_INFO",    INT2NUM(LOG_INFO));     /* informational */
+    rb_define_const(module, "LOG_DEBUG",   INT2NUM(LOG_DEBUG));    /* debug-level messages */
+}
+
+inline void init_native(VALUE module)
+{
+    // methods
+    rb_define_singleton_method(module, "print",  RXW_WRAPPED_METHOD_FUNC(native_print, VALUE, VALUE, VALUE),  2);
+    rb_define_singleton_method(module, "send",   RXW_WRAPPED_METHOD_FUNC(native_send, int, VALUE*, VALUE),   -1); /* -1 to pass as C array */
+    rb_define_singleton_method(module, "perror", RXW_WRAPPED_METHOD_FUNC(native_perror, VALUE, VALUE),        1);
+
+    // dummy detection
+    rb_define_const(module, "IS_DUMMY", is_dummy());
+    rb_define_singleton_method(module, "dummy?", RUBY_METHOD_FUNC(is_dummy), 0);
+}
+
+} // private namespace
+
+void init_modules()
+{
+    // no nontrivial destructors during initialization, no need for ruby catch
+
+    VALUE mJournald = rb_define_module("Journald");
+    VALUE mNative   = rb_define_module_under(mJournald, "Native");
+
+    init_journald(mJournald); // add constants to Journald
+    init_native(mNative);     // add methods to Journald::Native
+}
+
+}

data/ext/journald_native/journald_native.h

@@ -0,0 +1,12 @@
+#ifndef JOURNALD_NATIVE_JOURNALD_NATIVE_H
+#define JOURNALD_NATIVE_JOURNALD_NATIVE_H
+
+#include <string>
+#include <ruby.h>
+
+namespace journald_native {
+    /* initializers */
+    void init_modules();
+}
+
+#endif // JOURNALD_NATIVE_JOURNALD_NATIVE_H

data/ext/journald_native/ruby_exception_wrapper.cpp

@@ -0,0 +1,16 @@
+#include "ruby_exception_wrapper.h"
+
+namespace ruby_exception_wrapper {
+
+// callback for rb_rescue2 to catch ruby exception and wrap it by RbWrappedException
+VALUE rethrow_as_cpp(VALUE put_exception_here_ptr, VALUE exception)
+{
+    // cannot actually throw here, just pass the exception
+    VALUE* excptr = reinterpret_cast<VALUE*>(put_exception_here_ptr);
+
+    *excptr = exception;
+
+    return exception;
+}
+
+}

data/ext/journald_native/ruby_exception_wrapper.h

@@ -0,0 +1,105 @@
+#ifndef RUBY_EXCEPTION_WRAPPER_H
+#define RUBY_EXCEPTION_WRAPPER_H
+
+#include <ruby.h>
+
+#include <functional>
+#include <type_traits>
+#include <utility>
+
+#include "cpp14shiv.h" // make this c++14 code c++11 compatible; remove for c++14
+
+// wrap functions, prototype required, i.e. RXW_WRAPPED_METHOD_FUNC(native_send, int, VALUE*, VALUE)
+// functions can be inline
+#define RXW_WRAPPED_METHOD_FUNC(method, ...) ((VALUE (*)(ANYARGS))::ruby_exception_wrapper::method_wrapper_call<decltype(&method), method, __VA_ARGS__>)
+
+namespace ruby_exception_wrapper {
+
+    class RbWrappedException: public std::exception {
+        VALUE ruby_exception;
+    public:
+        RbWrappedException(VALUE e): ruby_exception(e) {};
+        VALUE getRubyException() { return ruby_exception; }
+    };
+
+    // callback for rb_rescue2 to catch ruby exception and wrap it by RbWrappedException
+    VALUE rethrow_as_cpp(VALUE put_exception_here_ptr, VALUE exception);
+
+    namespace {
+        // do real call of function from template
+        template <typename FuncPointer, typename... Args>
+        inline VALUE call_wrapper_tuple_impl(FuncPointer& fp, Args... args)
+        {
+            // only pointers and VALUE permitted
+            // VALUE guaranteed to be able to contain pointer
+            return reinterpret_cast<VALUE>(fp(args...));
+        }
+
+        // unpack params to do real call
+        template <typename CallTuple, std::size_t... Is>
+        inline VALUE call_wrapper_tuple_unpack(CallTuple& call_tuple, std::index_sequence<Is...>)
+        {
+            return call_wrapper_tuple_impl(std::get<Is>(call_tuple)...);
+        }
+
+        // callback for rb_rescue2 for no exceptions
+        template <typename CallTuple>
+        VALUE call_wrapper_tuple(VALUE v_ct) {
+            CallTuple call_tuple = std::move(*reinterpret_cast<CallTuple*>(v_ct));
+
+            return call_wrapper_tuple_unpack(call_tuple, std::make_index_sequence<std::tuple_size<CallTuple>::value> {});
+        };
+
+        // safely call function
+        template <typename Func, typename... Args>
+        inline auto do_raisable_call(Func f, Args... args) -> decltype(f(args...))
+        {
+            typedef std::function<typename std::remove_pointer<Func>::type> FuncPointer;
+            typedef std::tuple<FuncPointer, Args...> CallTuple;
+
+            FuncPointer fp = f;
+
+            CallTuple call_tuple = std::make_tuple(fp, args...);
+
+            VALUE exception = 0; // get raised exception if any
+
+            VALUE result = rb_rescue2(
+                    RUBY_METHOD_FUNC(call_wrapper_tuple<CallTuple>), reinterpret_cast<VALUE>(&call_tuple),
+                    RUBY_METHOD_FUNC(rethrow_as_cpp), reinterpret_cast<VALUE>(&exception),
+                    rb_eException, Qfalse
+            );
+
+            if (exception) { // nonzero here if rescue called unless some pervert throws Qfalse
+                throw RbWrappedException(exception);
+            }
+
+            return reinterpret_cast<decltype(f(args...))>(result);
+        }
+    }
+
+    template <typename Func, typename... Args>
+    inline auto ruby_raisable_call(Func f, Args... args) -> decltype(f(args...))
+    {
+        static_assert(
+                std::is_same<decltype(f(args...)), VALUE>::value || std::is_pointer<decltype(f(args...))>::value,
+                "Only for funcs returning VALUE or pointer"
+        );
+
+        auto result = do_raisable_call(f, args...);
+
+        return result;
+    }
+
+    template <typename Func, Func func, typename... Args>
+    VALUE method_wrapper_call(Args... args)
+    {
+        try {
+            return func(args...);
+        } catch(RbWrappedException &e) {
+            rb_exc_raise(e.getRubyException());
+        }
+    }
+
+}
+
+#endif

data/ext/journald_native/sd_journal.h

@@ -0,0 +1,45 @@
+#ifndef JOURNALD_NATIVE_SD_JOURNAL_H
+#define JOURNALD_NATIVE_SD_JOURNAL_H
+
+#ifdef __linux__
+
+    #define JOURNALD_NATIVE_SD_JOURNAL_DUMMY false
+
+    /* do the real stuff */
+
+    #include "extconf.h"
+
+    /* check for extconf results */
+
+    #ifndef HAVE_SYSTEMD_SD_JOURNAL_H
+        #error Cannot include <systemd/sd-journal.h>. Please use linux version with systemd-journal installed
+    #endif
+
+    #ifndef HAVE_SD_JOURNAL_PRINT
+        #error Required function sd_journal_print is missing
+    #endif
+
+    #ifndef HAVE_SD_JOURNAL_SENDV
+        #error Required function sd_journal_sendv is missing
+    #endif
+
+    #ifndef HAVE_SD_JOURNAL_PERROR
+        #error Required function sd_journal_perror is missing
+    #endif
+
+    /* Do not add C line and file to the log messages */
+    #define SD_JOURNAL_SUPPRESS_LOCATION
+    /* include systemd-journal headers */
+    #include <systemd/sd-journal.h>
+
+#else
+
+    #define JOURNALD_NATIVE_SD_JOURNAL_DUMMY true
+
+    #warning Compiling dummy version of the gem for non-Linux OS
+
+    #include "sd_journal_dummy.h"
+
+#endif
+
+#endif // JOURNALD_NATIVE_SD_JOURNAL_H

data/ext/journald_native/sd_journal_dummy.h

@@ -0,0 +1,23 @@
+/* dummy code to be used in sd_journal.h on non-linux system */
+
+#include <stdlib.h>
+
+/* syslog constants */
+#define LOG_EMERG   0
+#define LOG_ALERT   1
+#define LOG_CRIT    2
+#define LOG_ERR     3
+#define LOG_WARNING 4
+#define LOG_NOTICE  5
+#define LOG_INFO    6
+#define LOG_DEBUG   7
+
+/* iovec */
+struct iovec {
+    void  *iov_base;    /* Starting address */
+    size_t iov_len;     /* Number of bytes to transfer */
+};
+
+inline int sd_journal_print(int priority, const char *format, ...)  { return 0; }
+inline int sd_journal_sendv(const struct iovec *iov, int n)         { return 0; }
+inline int sd_journal_perror(const char *message)                   { return 0; }

data/lib/journald/native/version.rb

@@ -1,5 +1,5 @@
 module Journald
   module Native
-    VERSION = '1.0.1'
+    VERSION = '1.0.6'
   end
 end

metadata

@@ -1,55 +1,55 @@
 --- !ruby/object:Gem::Specification
 name: journald-native
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.6
 platform: ruby
 authors:
 - Anton Smirnov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-30 00:00:00.000000000 Z
+date: 2015-03-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.6'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.6'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rake-compiler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: 
@@ -60,13 +60,21 @@ extensions:
 - ext/journald_native/extconf.rb
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
+- ext/journald_native/CMakeLists.txt
+- ext/journald_native/cpp14shiv.h
 - ext/journald_native/extconf.rb
-- ext/journald_native/journald_native.c
+- ext/journald_native/extinit.cpp
+- ext/journald_native/journald_native.cpp
+- ext/journald_native/journald_native.h
+- ext/journald_native/ruby_exception_wrapper.cpp
+- ext/journald_native/ruby_exception_wrapper.h
+- ext/journald_native/sd_journal.h
+- ext/journald_native/sd_journal_dummy.h
 - journald-native.gemspec
 - lib/journald/native.rb
 - lib/journald/native/version.rb
@@ -80,19 +88,18 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: 1.9.2
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.1.11
+rubygems_version: 2.4.3
 signing_key: 
 specification_version: 4
 summary: systemd-journal logging native lib wrapper
 test_files: []
-has_rdoc: 

data/ext/journald_native/journald_native.c

@@ -1,139 +0,0 @@
-/* Do not add C line and file to the log messages */
-#define SD_JOURNAL_SUPPRESS_LOCATION
-
-#include <ruby.h>
-#include <systemd/sd-journal.h>
-
-void Init_journald_native();
-
-/* initializers */
-static void jdl_init_modules();
-static void jdl_init_constants();
-static void jdl_init_methods();
-
-/* methods */
-static VALUE jdl_native_print(VALUE self, VALUE priority, VALUE message);
-static VALUE jdl_native_send(int argc, VALUE* argv, VALUE self);
-static VALUE jdl_native_perror(VALUE self, VALUE message);
-
-/* aux */
-static char * jdl_alloc_safe_string(VALUE string);
-
-/* globals */
-static VALUE mJournald;
-static VALUE mNative;
-
-void Init_journald_native()
-{
-    jdl_init_modules();
-    jdl_init_constants();
-    jdl_init_methods();
-}
-
-static void jdl_init_modules()
-{
-    mJournald = rb_define_module("Journald");
-    mNative   = rb_define_module_under(mJournald, "Native");
-}
-
-static void jdl_init_constants()
-{
-    rb_define_const(mJournald, "LOG_EMERG",   INT2NUM(LOG_EMERG));    /* system is unusable */
-    rb_define_const(mJournald, "LOG_ALERT",   INT2NUM(LOG_ALERT));    /* action must be taken immediately */
-    rb_define_const(mJournald, "LOG_CRIT",    INT2NUM(LOG_CRIT));     /* critical conditions */
-    rb_define_const(mJournald, "LOG_ERR",     INT2NUM(LOG_ERR));      /* error conditions */
-    rb_define_const(mJournald, "LOG_WARNING", INT2NUM(LOG_WARNING));  /* warning conditions */
-    rb_define_const(mJournald, "LOG_NOTICE",  INT2NUM(LOG_NOTICE));   /* normal but significant condition */
-    rb_define_const(mJournald, "LOG_INFO",    INT2NUM(LOG_INFO));     /* informational */
-    rb_define_const(mJournald, "LOG_DEBUG",   INT2NUM(LOG_DEBUG));    /* debug-level messages */
-}
-
-static void jdl_init_methods()
-{
-    rb_define_singleton_method(mNative, "print",  jdl_native_print,  2);
-    rb_define_singleton_method(mNative, "send",   jdl_native_send,  -1); // -1 to pass as C array
-    rb_define_singleton_method(mNative, "perror", jdl_native_perror, 1);
-}
-
-static VALUE jdl_native_print(VALUE v_self, VALUE v_priority, VALUE v_message)
-{
-    int priority, result;
-    char *message;
-
-    priority = NUM2INT(v_priority);
-    message  = jdl_alloc_safe_string(v_message);
-
-    result = sd_journal_print(priority, "%s", message);
-
-    free(message);
-
-    return INT2NUM(result);
-}
-
-static VALUE jdl_native_send(int argc, VALUE* argv, VALUE self)
-{
-    //const char * fmt = "%s";
-    struct iovec *msgs;
-    size_t i;
-    int result;
-
-    msgs = calloc(argc, sizeof(struct iovec));
-
-    for (i = 0; i < argc; i++) {
-        VALUE v = argv[i];
-        StringValue(v);
-        msgs[i].iov_base = RSTRING_PTR(v);
-        msgs[i].iov_len  = RSTRING_LEN(v);
-    }
-
-    result = sd_journal_sendv(msgs, argc);
-
-    free(msgs);
-
-    return INT2NUM(result);
-}
-
-static VALUE jdl_native_perror(VALUE v_self, VALUE v_message)
-{
-    int result;
-    char *message;
-
-    message = jdl_alloc_safe_string(v_message);
-
-    result = sd_journal_perror(message);
-
-    free(message);
-
-    return INT2NUM(result);
-}
-
-/**
- * Remove zeros from string and ensure it's zero-terminated
- */
-static char * jdl_alloc_safe_string(VALUE v_string)
-{
-    char  *str;
-    size_t len;
-
-    char  *newstr,
-          *ptr;
-    size_t i;
-
-    /* convert tos sring */
-    StringValue(v_string);
-
-    str = RSTRING_PTR(v_string);
-    len = RSTRING_LEN(v_string);
-
-    newstr = calloc(len + 1, sizeof(char));
-
-    for (i = 0, ptr = newstr; i < len; i++) {
-        if (str[i]) {
-            *(ptr++) = str[i];
-        }
-    }
-
-    *ptr = '\0';
-
-    return newstr;
-}