journald-native 1.0.3 → 1.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bd487e7cc5f8f4afd839c141cda94ba78a2109cc
-  data.tar.gz: e7b5952a046140f8d0e0141446342b658de604c5
+  metadata.gz: 62f14b24b4e9636244fd45956b5aa2804748099f
+  data.tar.gz: a373cd433f9a905a0c4e1310a42979b50b6f06cb
 SHA512:
-  metadata.gz: 93f5494817ce979b29d2ce630dd4a35675ab685137b61d8556fbb58c816e0d5978c48d4df8c64323baba2fc0feae783af9720790d7565230eea9c58995287f27
-  data.tar.gz: 0a3e5b415e8b0491c7bad759d7d99767022e6c4c212923b3083b08a41e636bc6aa221c552d3334081b8db79a02ae6539e425fef31d9431458eb3ded4e4d6dd9e
+  metadata.gz: 3df15346ea9c39be6bff77310c24e26e03bb23f654d21f15388c8785d09532b88ac47f7cb0ff939dece01535a18d20785790f9faf245044bb9d1258c5509808d
+  data.tar.gz: 34326f6563d13d955da83995d16345a2c385d4f2d87fefee4a248087e703c7c61b8dfb05e4df273db880d4638f6a752abccae058f6b143542efc4cf62588d00c

data/ext/journald_native/CMakeLists.txt

@@ -0,0 +1,7 @@
+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,11 +4,12 @@ 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
 
@@ -33,4 +34,3 @@ 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,149 @@
+#include "journald_native.h"
+#include "sd_journal.h"
+
+#include <memory>
+
+#include "ruby_exception_wrapper.h"
+
+namespace journald_native {
+
+// 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...);
+}
+
+/* initializers */
+inline void init_constants(VALUE module);
+inline void init_methods(VALUE module);
+
+/* methods */
+VALUE native_print(VALUE self, VALUE priority, VALUE message);
+VALUE native_send(int argc, VALUE* argv, VALUE self);
+VALUE native_perror(VALUE self, VALUE message);
+inline VALUE native_print_impl(VALUE v_self, VALUE v_priority, VALUE v_message);
+inline VALUE native_send_impl(int argc, VALUE* argv, VALUE self);
+inline VALUE native_perror_impl(VALUE v_self, VALUE v_message);
+
+/* aux */
+std::string create_safe_string(VALUE string); // throws ruby exceptions
+
+/* initializers */
+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_constants(mJournald); // add constants to Journald
+    init_methods(mNative);     // add methods to Journald::Native
+}
+
+inline void init_constants(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_methods(VALUE module)
+{
+    rb_define_singleton_method(module, "print",  RUBY_METHOD_FUNC(native_print),  2);
+    rb_define_singleton_method(module, "send",   RUBY_METHOD_FUNC(native_send),  -1); /* -1 to pass as C array */
+    rb_define_singleton_method(module, "perror", RUBY_METHOD_FUNC(native_perror), 1);
+}
+
+VALUE native_print(VALUE v_self, VALUE v_priority, VALUE v_message)
+{
+    try {
+        return native_print_impl(v_self, v_priority, v_message);
+    } catch(ruby_exception_wrapper::RbWrappedException &e) {
+        rb_exc_raise(e.getRubyException());
+    }
+}
+
+VALUE native_send(int argc, VALUE* argv, VALUE v_self)
+{
+    try {
+        return native_send_impl(argc, argv, v_self);
+    } catch(ruby_exception_wrapper::RbWrappedException &e) {
+        rb_exc_raise(e.getRubyException());
+    }
+}
+
+VALUE native_perror(VALUE v_self, VALUE v_message)
+{
+    try {
+        return native_perror_impl(v_self, v_message);
+    } catch(ruby_exception_wrapper::RbWrappedException &e) {
+        rb_exc_raise(e.getRubyException());
+    }
+}
+
+/* methods */
+inline VALUE native_print_impl(VALUE v_self, VALUE v_priority, VALUE v_message)
+{
+    int  priority = NUM2INT(v_priority);
+    auto message  = create_safe_string(v_message); // ruby exception here
+
+    int  result   = sd_journal_print(priority, "%s", message.c_str());
+
+    return INT2NUM(result);
+}
+
+inline VALUE native_send_impl(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_impl(VALUE v_self, VALUE v_message)
+{
+    auto message = create_safe_string(v_message); // ruby exception here
+
+    int  result  = sd_journal_perror(message.c_str());
+
+    return INT2NUM(result);
+}
+
+/**
+ * Remove zeros from the string
+ */
+std::string create_safe_string(VALUE v_string)
+{
+    /* convert to string */
+    r(rb_string_value, &v_string);
+
+    char*  str = (char *)RSTRING_PTR(v_string);
+    size_t len = (size_t)RSTRING_LEN(v_string);
+
+    std::string safe_str;
+    safe_str.reserve(len);
+
+    for (size_t i = 0; i < len; i++) {
+        if (str[i]) {
+            safe_str += str[i];
+        }
+    }
+
+    return safe_str;
+}
+
+}

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,91 @@
+#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
+
+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 for func with params
+        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;
+    }
+
+}
+
+#endif

data/ext/journald_native/sd_journal.h

@@ -1,71 +1,41 @@
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 #ifndef JOURNALD_NATIVE_SD_JOURNAL_H
-    #define JOURNALD_NATIVE_SD_JOURNAL_H
-
-    #ifdef __linux__
-
-        /* 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
+#define JOURNALD_NATIVE_SD_JOURNAL_H
 
-        #ifndef HAVE_SD_JOURNAL_PRINT
-            #error Required function sd_journal_print is missing
-        #endif
+#ifdef __linux__
 
-        #ifndef HAVE_SD_JOURNAL_SENDV
-            #error Required function sd_journal_sendv is missing
-        #endif
+    /* do the real stuff */
 
-        #ifndef HAVE_SD_JOURNAL_PERROR
-            #error Required function sd_journal_perror is missing
-        #endif
+    #include "extconf.h"
 
-        /* include systemd-journal headers */
+    /* check for extconf results */
 
-        #include <systemd/sd-journal.h>
-
-    #else
+    #ifndef HAVE_SYSTEMD_SD_JOURNAL_H
+        #error Cannot include <systemd/sd-journal.h>. Please use linux version with systemd-journal installed
+    #endif
 
-        #warning Compiling dummy version of the gem for non-Linux OS
+    #ifndef HAVE_SD_JOURNAL_PRINT
+        #error Required function sd_journal_print is missing
+    #endif
 
-        #include <stdlib.h>
+    #ifndef HAVE_SD_JOURNAL_SENDV
+        #error Required function sd_journal_sendv is missing
+    #endif
 
-        /* use dummy */
-        #define JOURNALD_NATIVE_SYSTEMD_JOURNAL_DUMMY
+    #ifndef HAVE_SD_JOURNAL_PERROR
+        #error Required function sd_journal_perror is missing
+    #endif
 
-        /* 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
+    /* 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>
 
-        /* iovec */
-        struct iovec {
-            void  *iov_base;    /* Starting address */
-            size_t iov_len;     /* Number of bytes to transfer */
-        };
+#else
 
-        int sd_journal_print(int priority, const char *format, ...);
-        int sd_journal_sendv(const struct iovec *iov, int n);
-        int sd_journal_perror(const char *message);
+    #warning Compiling dummy version of the gem for non-Linux OS
 
-    #endif
+    #include "sd_journal_dummy.h"
 
 #endif
 
-#ifdef __cplusplus
-}
-#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.3'
+    VERSION = '1.0.4'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: journald-native
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.0.4
 platform: ruby
 authors:
 - Anton Smirnov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-05 00:00:00.000000000 Z
+date: 2015-03-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -65,10 +65,16 @@ files:
 - 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.c
+- ext/journald_native/sd_journal_dummy.h
 - journald-native.gemspec
 - lib/journald/native.rb
 - lib/journald/native/version.rb
@@ -92,7 +98,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.3
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: systemd-journal logging native lib wrapper

data/ext/journald_native/journald_native.c

@@ -1,143 +0,0 @@
-/* Do not add C line and file to the log messages */
-#define SD_JOURNAL_SUPPRESS_LOCATION
-
-#include <ruby.h>
-#include "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)
-{
-    struct iovec *msgs;
-    int i;
-    int result;
-
-    /* first check everything is a string / convertable to string */
-    for (i = 0; i < argc; i++) {
-        StringValue(argv[i]); /* you may get a ruby exception here */
-    }
-
-    /* allocate memory after all checks to avoid possible memory leak */
-    msgs = calloc(argc, sizeof(struct iovec));
-
-    for (i = 0; i < argc; i++) {
-        VALUE v = argv[i];
-        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 to string */
-    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;
-}

data/ext/journald_native/sd_journal_dummy.c

@@ -1,9 +0,0 @@
-#include "sd_journal.h"
-
-#ifdef JOURNALD_NATIVE_SYSTEMD_JOURNAL_DUMMY
-
-int sd_journal_print(int priority, const char *format, ...) { return 0; }
-int sd_journal_sendv(const struct iovec *iov, int n)        { return 0; }
-int sd_journal_perror(const char *message)                  { return 0; }
-
-#endif