capng_c 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 31b53b59b57445d79f742beb25910e6bb62270673d6c171ffea029938d5f35ee
-  data.tar.gz: 62c157b61e3cc5e1bfd144effb8370a3de756e63a7cfccfb3012d236ceecd2d9
+  metadata.gz: 255863aedacdc832b5ff8da87fb0d97a2916a65b1385c6f8072281967039d632
+  data.tar.gz: e145914ff785ff35cf7df36e86e9fca56a6de5228139b4e9ef586888be20bad3
 SHA512:
-  metadata.gz: a3b0b2deda2fb0c46fcce53f54097659a4d7fddd34e1bc4ce01fd27dea02a220263cf668deb048542009dc92b885753938f753af37e7a87500b806111330e552
-  data.tar.gz: b2968668551f8b397d7f5da73d38004215cef706e2d8e2ecf09453a6ca4ef14ed4b8e550296767a5f38dba9e87edcb669b4edaf2cf8433e3f92c7c9a27591c0a
+  metadata.gz: e401c25553011b8e922b1f7c80574fef9d9890464905b29513485c7a1627091fa26532d6f461d86aeb202e82b64eddca7f31edde1e48f07a00bf8cb3fe67ab01
+  data.tar.gz: 6d6f3fbf99fc67ea2ec32f5803a453782d2f10e6773d7db1905eba33d01c657cb7a3a238d7cc65f910f5ad361398964b44135f4bf79c256d0edb35222f2cdb8d

data/ext/capng/capng.c

@@ -46,27 +46,100 @@ rb_capng_alloc(VALUE klass)
 }
 
 static VALUE
-rb_capng_initialize(VALUE self)
+rb_capng_initialize(int argc, VALUE *argv, VALUE self)
 {
+  VALUE rb_target, rb_pid_or_file;
+  int result = 0;
+  char *target = NULL;
+  int pid = 0, fd = 0;
+  rb_io_t *fptr = NULL;
+
+  rb_scan_args(argc, argv, "02", &rb_target, &rb_pid_or_file);
+
+  if (NIL_P(rb_target)) {
+    return Qnil;
+  }
+
+  if (RB_TYPE_P(rb_target, T_SYMBOL)) {
+    target = RSTRING_PTR(rb_sym2str(rb_target));
+  } else if (RB_TYPE_P(rb_target, T_STRING)) {
+    target = StringValuePtr(rb_target);
+  } else {
+    rb_raise(rb_eArgError, "Expected a String or a Symbol instance for tagret argument");
+  }
+
+  if (strcmp(target, "current_process") == 0) {
+    result = capng_get_caps_process();
+    if (result != 0) {
+      rb_raise(rb_eRuntimeError, "Couldn't get current process' capability");
+    }
+  } else if (strcmp(target, "other_process") == 0) {
+    Check_Type(rb_pid_or_file, T_FIXNUM);
+
+    pid = NUM2INT(rb_pid_or_file);
+    capng_setpid(pid);
+    result = capng_get_caps_process();
+    if (result != 0) {
+      rb_raise(rb_eRuntimeError, "Couldn't get current process' capability");
+    }
+  } else if (strcmp(target, "file") == 0) {
+    Check_Type(rb_pid_or_file, T_FILE);
+
+    fptr = RFILE(rb_pid_or_file)->fptr;
+    fd = fptr->fd;
+    result = capng_get_caps_fd(fd);
+    if (result != 0) {
+      rb_raise(rb_eRuntimeError, "Couldn't get current file capability");
+    }
+  }
+
   return Qnil;
 }
 
 static VALUE
-rb_capng_clear(VALUE self, VALUE rb_action_set)
+rb_capng_clear(VALUE self, VALUE rb_select_name_or_enum)
 {
-  Check_Type(rb_action_set, T_FIXNUM);
+  capng_select_t select = 0;
 
-  capng_clear(NUM2INT(rb_action_set));
+  switch (TYPE(rb_select_name_or_enum)) {
+  case T_SYMBOL:
+    select = select_name_to_select_type(RSTRING_PTR(rb_sym2str(rb_select_name_or_enum)));
+    break;
+  case T_STRING:
+    select = select_name_to_select_type(StringValuePtr(rb_select_name_or_enum));
+    break;
+  case T_FIXNUM:
+    select = NUM2INT(rb_select_name_or_enum);
+    break;
+  default:
+    rb_raise(rb_eArgError, "Expected a String or a Symbol instance, or a capability type constant");
+  }
+
+  capng_clear(select);
 
   return Qnil;
 }
 
 static VALUE
-rb_capng_fill(VALUE self, VALUE rb_action_set)
+rb_capng_fill(VALUE self, VALUE rb_select_name_or_enum)
 {
-  Check_Type(rb_action_set, T_FIXNUM);
+  capng_select_t select = 0;
+
+  switch (TYPE(rb_select_name_or_enum)) {
+  case T_SYMBOL:
+    select = select_name_to_select_type(RSTRING_PTR(rb_sym2str(rb_select_name_or_enum)));
+    break;
+  case T_STRING:
+    select = select_name_to_select_type(StringValuePtr(rb_select_name_or_enum));
+    break;
+  case T_FIXNUM:
+    select = NUM2INT(rb_select_name_or_enum);
+    break;
+  default:
+    rb_raise(rb_eArgError, "Expected a String or a Symbol instance, or a capability type constant");
+  }
 
-  capng_fill(NUM2INT(rb_action_set));
+  capng_fill(select);
 
   return Qnil;
 }
@@ -94,13 +167,41 @@ rb_capng_get_caps_process(VALUE self)
 }
 
 static VALUE
-rb_capng_update(VALUE self, VALUE rb_action_set, VALUE rb_update_type, VALUE rb_capability_or_name)
+rb_capng_update(VALUE self,
+                VALUE rb_action_name_or_action, VALUE rb_capability_name_or_type, VALUE rb_capability_or_name)
 {
   int result = 0;
   unsigned int capability = 0;
+  capng_type_t capability_type = 0;
+  capng_act_t action = 0;
 
-  Check_Type(rb_action_set, T_FIXNUM);
-  Check_Type(rb_update_type, T_FIXNUM);
+  switch (TYPE(rb_action_name_or_action)) {
+  case T_SYMBOL:
+    action = action_name_to_action_type(RSTRING_PTR(rb_sym2str(rb_action_name_or_action)));
+    break;
+  case T_STRING:
+    action = action_name_to_action_type(StringValuePtr(rb_action_name_or_action));
+    break;
+  case T_FIXNUM:
+    action = NUM2INT(rb_action_name_or_action);
+    break;
+  default:
+    rb_raise(rb_eArgError, "Expected a String or a Symbol instance, or a capability type constant");
+  }
+
+  switch (TYPE(rb_capability_name_or_type)) {
+  case T_SYMBOL:
+    capability_type = capability_type_name_to_capability_type(RSTRING_PTR(rb_sym2str(rb_capability_name_or_type)));
+    break;
+  case T_STRING:
+    capability_type = capability_type_name_to_capability_type(StringValuePtr(rb_capability_name_or_type));
+    break;
+  case T_FIXNUM:
+    capability_type = NUM2INT(rb_capability_name_or_type);
+    break;
+  default:
+    rb_raise(rb_eArgError, "Expected a String or a Symbol instance, or a capability type constant");
+  }
 
   switch (TYPE(rb_capability_or_name)) {
   case T_SYMBOL:
@@ -116,7 +217,7 @@ rb_capng_update(VALUE self, VALUE rb_action_set, VALUE rb_update_type, VALUE rb_
     rb_raise(rb_eArgError, "Expected a String or a Symbol instance, or a capability constant");
   }
 
-  result = capng_update(NUM2UINT(rb_action_set), NUM2INT(rb_update_type), capability);
+  result = capng_update(action, capability_type, capability);
 
   if (result == 0)
     return Qtrue;
@@ -166,20 +267,49 @@ rb_capng_change_id(VALUE self, VALUE rb_uid, VALUE rb_gid, VALUE rb_flags)
 }
 
 static VALUE
-rb_capng_have_capabilities_p(VALUE self, VALUE rb_select_enum)
+rb_capng_have_capabilities_p(VALUE self, VALUE rb_select_name_or_enum)
 {
   int result = 0;
+  capng_select_t select = 0;
 
-  result = capng_have_capabilities(NUM2INT(rb_select_enum));
+  switch (TYPE(rb_select_name_or_enum)) {
+  case T_SYMBOL:
+    select = select_name_to_select_type(RSTRING_PTR(rb_sym2str(rb_select_name_or_enum)));
+    break;
+  case T_STRING:
+    select = select_name_to_select_type(StringValuePtr(rb_select_name_or_enum));
+    break;
+  case T_FIXNUM:
+    select = NUM2INT(rb_select_name_or_enum);
+    break;
+  default:
+    rb_raise(rb_eArgError, "Expected a String or a Symbol instance, or a capability type constant");
+  }
+  result = capng_have_capabilities(select);
 
   return INT2NUM(result);
 }
 
 static VALUE
-rb_capng_have_capability_p(VALUE self, VALUE rb_update_type, VALUE rb_capability_or_name)
+rb_capng_have_capability_p(VALUE self, VALUE rb_capability_name_or_type, VALUE rb_capability_or_name)
 {
   int result = 0;
   unsigned int capability = 0;
+  capng_type_t capability_type = 0;
+
+  switch (TYPE(rb_capability_name_or_type)) {
+  case T_SYMBOL:
+    capability_type = capability_type_name_to_capability_type(RSTRING_PTR(rb_sym2str(rb_capability_name_or_type)));
+    break;
+  case T_STRING:
+    capability_type = capability_type_name_to_capability_type(StringValuePtr(rb_capability_name_or_type));
+    break;
+  case T_FIXNUM:
+    capability_type = NUM2INT(rb_capability_name_or_type);
+    break;
+  default:
+    rb_raise(rb_eArgError, "Expected a String or a Symbol instance, or a capability type constant");
+  }
 
   switch (TYPE(rb_capability_or_name)) {
   case T_SYMBOL:
@@ -195,7 +325,7 @@ rb_capng_have_capability_p(VALUE self, VALUE rb_update_type, VALUE rb_capability
     rb_raise(rb_eArgError, "Expected a String or a Symbol instance, or a capability constant");
   }
 
-  result = capng_have_capability(NUM2INT(rb_update_type), capability);
+  result = capng_have_capability(capability_type, capability);
 
   if (result == 1)
     return Qtrue;
@@ -254,7 +384,7 @@ Init_capng(void)
 
   rb_define_alloc_func(rb_cCapNG, rb_capng_alloc);
 
-  rb_define_method(rb_cCapNG, "initialize", rb_capng_initialize, 0);
+  rb_define_method(rb_cCapNG, "initialize", rb_capng_initialize, -1);
   rb_define_method(rb_cCapNG, "clear", rb_capng_clear, 1);
   rb_define_method(rb_cCapNG, "fill", rb_capng_fill, 1);
   rb_define_method(rb_cCapNG, "setpid", rb_capng_setpid, 1);

data/ext/capng/capng.h

@@ -20,6 +20,9 @@
 
 #include <cap-ng.h>
 #include <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
 
 VALUE rb_cCapNG;
 VALUE rb_cCapNGPrint;
@@ -32,6 +35,11 @@ VALUE rb_mResult;
 VALUE rb_mPrint;
 VALUE rb_mFlags;
 
+capng_select_t select_name_to_select_type(char *select_name);
+capng_act_t action_name_to_action_type(char *action_name);
+capng_print_t print_name_to_print_type(char *print_name);
+capng_type_t capability_type_name_to_capability_type(char *capability_name);
+
 void Init_capng_capability(VALUE);
 void Init_capng_enum(VALUE);
 void Init_capng_print(VALUE);

data/ext/capng/print.c

@@ -52,16 +52,46 @@ rb_capng_print_initialize(VALUE self)
 }
 
 static VALUE
-rb_capng_print_caps_text(VALUE self, VALUE rb_where, VALUE rb_select_set)
+rb_capng_print_caps_text(VALUE self, VALUE rb_where_name_or_type, VALUE rb_capability_name_or_type)
 {
   char *result = NULL;
+  capng_type_t capability_type = 0;
+  capng_print_t print_type = 0;
 
-  switch (NUM2LONG(rb_where)) {
+  switch (TYPE(rb_capability_name_or_type)) {
+  case T_SYMBOL:
+    capability_type = capability_type_name_to_capability_type(RSTRING_PTR(rb_sym2str(rb_capability_name_or_type)));
+    break;
+  case T_STRING:
+    capability_type = capability_type_name_to_capability_type(StringValuePtr(rb_capability_name_or_type));
+    break;
+  case T_FIXNUM:
+    capability_type = NUM2INT(rb_capability_name_or_type);
+    break;
+  default:
+    rb_raise(rb_eArgError, "Expected a String or a Symbol instance, or a capability type constant");
+  }
+
+  switch (TYPE(rb_where_name_or_type)) {
+  case T_SYMBOL:
+    print_type = print_name_to_print_type(RSTRING_PTR(rb_sym2str(rb_where_name_or_type)));
+    break;
+  case T_STRING:
+    print_type = print_name_to_print_type(StringValuePtr(rb_where_name_or_type));
+    break;
+  case T_FIXNUM:
+    print_type = NUM2INT(rb_where_name_or_type);
+    break;
+  default:
+    rb_raise(rb_eArgError, "Expected a String or a Symbol instance, or a print type constant");
+  }
+
+  switch (print_type) {
   case CAPNG_PRINT_STDOUT:
-    capng_print_caps_text(CAPNG_PRINT_STDOUT, NUM2LONG(rb_select_set));
+    capng_print_caps_text(CAPNG_PRINT_STDOUT, capability_type);
     break;
   case CAPNG_PRINT_BUFFER:
-    result = capng_print_caps_text(CAPNG_PRINT_BUFFER, NUM2INT(rb_select_set));
+    result = capng_print_caps_text(CAPNG_PRINT_BUFFER, capability_type);
   }
 
   if (result)
@@ -71,16 +101,46 @@ rb_capng_print_caps_text(VALUE self, VALUE rb_where, VALUE rb_select_set)
 }
 
 static VALUE
-rb_capng_print_caps_numeric(VALUE self, VALUE rb_where, VALUE rb_select_set)
+rb_capng_print_caps_numeric(VALUE self, VALUE rb_where_name_or_type, VALUE rb_select_name_or_enum)
 {
   char *result = NULL;
+  capng_select_t select = 0;
+  capng_print_t print_type = 0;
+
+  switch (TYPE(rb_where_name_or_type)) {
+  case T_SYMBOL:
+    print_type = print_name_to_print_type(RSTRING_PTR(rb_sym2str(rb_where_name_or_type)));
+    break;
+  case T_STRING:
+    print_type = print_name_to_print_type(StringValuePtr(rb_where_name_or_type));
+    break;
+  case T_FIXNUM:
+    print_type = NUM2INT(rb_where_name_or_type);
+    break;
+  default:
+    rb_raise(rb_eArgError, "Expected a String or a Symbol instance, or a print type constant");
+  }
+
+  switch (TYPE(rb_select_name_or_enum)) {
+  case T_SYMBOL:
+    select = select_name_to_select_type(RSTRING_PTR(rb_sym2str(rb_select_name_or_enum)));
+    break;
+  case T_STRING:
+    select = select_name_to_select_type(StringValuePtr(rb_select_name_or_enum));
+    break;
+  case T_FIXNUM:
+    select = NUM2INT(rb_select_name_or_enum);
+    break;
+  default:
+    rb_raise(rb_eArgError, "Expected a String or a Symbol instance, or a capability type constant");
+  }
 
-  switch (NUM2LONG(rb_where)) {
+  switch (print_type) {
   case CAPNG_PRINT_STDOUT:
-    capng_print_caps_numeric(CAPNG_PRINT_STDOUT, NUM2INT(rb_select_set));
+    capng_print_caps_numeric(CAPNG_PRINT_STDOUT, select);
     break;
   case CAPNG_PRINT_BUFFER:
-    result = capng_print_caps_numeric(CAPNG_PRINT_BUFFER, NUM2LONG(rb_select_set));
+    result = capng_print_caps_numeric(CAPNG_PRINT_BUFFER, select);
   }
 
   if (result)

data/ext/capng/utils.c

@@ -0,0 +1,80 @@
+/* capng_c */
+/* Copyright 2020- Hiroshi Hatake*/
+/* */
+/* Licensed under the Apache License, Version 2.0 (the "License"); */
+/* you may not use this file except in compliance with the License. */
+/* You may obtain a copy of the License at */
+/*     http://www.apache.org/licenses/LICENSE-2.0 */
+/* Unless required by applicable law or agreed to in writing, software */
+/* distributed under the License is distributed on an "AS IS" BASIS, */
+/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */
+/* See the License for the specific language governing permissions and */
+/* limitations under the License. */
+
+#include <capng.h>
+
+capng_select_t
+select_name_to_select_type(char *select_name)
+{
+  if (strcmp(select_name, "caps") == 0) {
+    return CAPNG_SELECT_CAPS;
+  } else if (strcmp(select_name, "bounds") == 0) {
+    return CAPNG_SELECT_BOUNDS;
+  } else if (strcmp(select_name, "both") == 0) {
+    return CAPNG_SELECT_BOTH;
+#if defined(CAPNG_SELECT_AMBIENT)
+  } else if (strcmp(select_name, "ambient") == 0) {
+    return CAPNG_SELECT_AMBIENT;
+#endif
+#if defined(CAPNG_SELECT_ALL)
+  } else if (strcmp(select_name, "all") == 0) {
+    return CAPNG_SELECT_ALL;
+#endif
+  } else {
+    rb_raise(rb_eArgError, "unknown select name %s", select_name);
+  }
+}
+
+capng_act_t
+action_name_to_action_type(char *action_name)
+{
+  if (strcmp(action_name, "drop") == 0) {
+    return CAPNG_DROP;
+  } else if (strcmp(action_name, "add") == 0) {
+    return CAPNG_ADD;
+  } else {
+    rb_raise(rb_eArgError, "unknown action name %s", action_name);
+  }
+}
+
+capng_print_t
+print_name_to_print_type(char *print_name)
+{
+  if (strcmp(print_name, "stdout") == 0) {
+    return CAPNG_PRINT_STDOUT;
+  } else if (strcmp(print_name, "buffer") == 0) {
+    return CAPNG_PRINT_BUFFER;
+  } else {
+    rb_raise(rb_eArgError, "unknown print name %s", print_name);
+  }
+}
+
+capng_type_t
+capability_type_name_to_capability_type(char *capability_name)
+{
+  if (strcmp(capability_name, "effective") == 0) {
+    return CAPNG_EFFECTIVE;
+  } else if (strcmp(capability_name, "permitted") == 0) {
+    return CAPNG_PERMITTED;
+  } else if (strcmp(capability_name, "inheritable") == 0) {
+    return CAPNG_INHERITABLE;
+  } else if (strcmp(capability_name, "bounding_set") == 0) {
+    return CAPNG_BOUNDING_SET;
+#if defined(CAPNG_AMBIENT)
+  } else if (strcmp(capability_name, "ambient") == 0) {
+    return CAPNG_AMBIENT;
+#endif
+  } else {
+    rb_raise(rb_eArgError, "unknown capability name: %s", capability_name);
+  }
+}

data/lib/capng.rb

@@ -7,6 +7,21 @@ class CapNG
   alias_method :caps_file_raw, :caps_file
   alias_method :apply_caps_file_raw, :apply_caps_file
   alias_method :update_raw, :update
+  alias_method :initialize_raw, :initialize
+
+  def initialize(target = nil, pid_or_path = nil)
+    if target.nil?
+      initialize_raw
+    elsif target && pid_or_path.is_a?(Integer)
+      initialize_raw(target, pid_or_path)
+    elsif target && pid_or_path.is_a?(String) && File.exist?(pid_or_path)
+      File.open(pid_or_path) do
+        initialize_raw(target, pid_or_path);
+      end
+    else
+      initialize_raw
+    end
+  end
 
   def caps_file(file_or_string_path)
     if file_or_string_path.is_a?(String) && File.exist?(file_or_string_path)
@@ -34,9 +49,13 @@ class CapNG
 
   def update(action, type, capability_or_capability_array)
     if capability_or_capability_array.is_a?(Array) && !capability_or_capability_array.empty?
+      results = []
       capability_or_capability_array.each do |capability|
-        update_raw(action, type, capability)
+        result = update_raw(action, type, capability)
+        results << result
+        return results if !result
       end
+      results
     else
       update_raw(action, type, capability_or_capability_array)
     end

data/lib/capng/version.rb

@@ -1,3 +1,3 @@
 class CapNG
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: capng_c
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Hiroshi Hatake
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-10-27 00:00:00.000000000 Z
+date: 2020-10-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -96,6 +96,7 @@ files:
 - ext/capng/extconf.rb
 - ext/capng/print.c
 - ext/capng/state.c
+- ext/capng/utils.c
 - lib/capng.rb
 - lib/capng/version.rb
 homepage: https://github.com/cosmo0920/cap-ng_c
@@ -119,7 +120,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: libcap-ng bindings for Ruby.