rkerberos 0.2.3 → 0.3.1

data/ext/rkerberos/principal.c

@@ -4,13 +4,22 @@ VALUE cKrb5Principal;
 
 
 // TypedData functions for RUBY_KRB5_PRINC
+static void rkrb5_princ_typed_mark(void *ptr) {
+  if (!ptr) return;
+  RUBY_KRB5_PRINC *p = (RUBY_KRB5_PRINC *)ptr;
+  if (p->rb_context != Qnil)
+    rb_gc_mark(p->rb_context);
+}
+
 static void rkrb5_princ_typed_free(void *ptr) {
   if (!ptr) return;
   RUBY_KRB5_PRINC *p = (RUBY_KRB5_PRINC *)ptr;
   if (p->principal)
     krb5_free_principal(p->ctx, p->principal);
-  if (p->ctx)
+  if (p->ctx && p->rb_context == Qnil)
     krb5_free_context(p->ctx);
+  else if (p->rb_context != Qnil)
+    rkrb5_context_release(p->rb_context);
   free(p);
 }
 
@@ -20,7 +29,7 @@ static size_t rkrb5_princ_typed_size(const void *ptr) {
 
 static const rb_data_type_t rkrb5_princ_data_type = {
   "RUBY_KRB5_PRINC",
-  {NULL, rkrb5_princ_typed_free, rkrb5_princ_typed_size,},
+  {rkrb5_princ_typed_mark, rkrb5_princ_typed_free, rkrb5_princ_typed_size,},
   NULL, NULL, RUBY_TYPED_FREE_IMMEDIATELY
 };
 
@@ -28,34 +37,68 @@ static const rb_data_type_t rkrb5_princ_data_type = {
 static VALUE rkrb5_princ_allocate(VALUE klass){
   RUBY_KRB5_PRINC* ptr = ALLOC(RUBY_KRB5_PRINC);
   memset(ptr, 0, sizeof(RUBY_KRB5_PRINC));
+  ptr->rb_context = Qnil;
   return TypedData_Wrap_Struct(klass, &rkrb5_princ_data_type, ptr);
 }
 
 /*
  * call-seq:
- *   Kerberos::Krb5::Principal.new(name)
+ *   Kerberos::Krb5::Principal.new(name: nil, context: nil)
  *
  * Creates and returns a new Krb5::Principal object. If a block is provided
  * then it yields itself.
  *
+ * A principal +name+ may be provided as a keyword argument. If not provided
+ * or nil, the principal attribute will be nil.
+ *
+ * An optional +context+ keyword argument may be provided. If given, it must
+ * be a Kerberos::Krb5::Context object and will be used instead of creating
+ * a new context via krb5_init_context.
+ *
  * Example:
  *
- *   principal1 = Kerberos::Krb5::Principal.new('Jon')
+ *   principal1 = Kerberos::Krb5::Principal.new(name: 'Jon')
  *
- *   principal2 = Kerberos::Krb5::Principal.new('Jon') do |pr|
+ *   principal2 = Kerberos::Krb5::Principal.new(name: 'Jon') do |pr|
  *     pr.expire_time = Time.now + 20000
  *   end
+ *
+ *   ctx = Kerberos::Krb5::Context.new
+ *   principal3 = Kerberos::Krb5::Principal.new(name: 'Jon', context: ctx)
  */
-static VALUE rkrb5_princ_initialize(VALUE self, VALUE v_name){
+static VALUE rkrb5_princ_initialize(int argc, VALUE* argv, VALUE self){
   RUBY_KRB5_PRINC* ptr;
   krb5_error_code kerror;
+  VALUE v_opts = Qnil;
+  VALUE v_name = Qnil;
+  VALUE v_context = Qnil;
+  ID kw_table[2] = { rb_intern("name"), rb_intern("context") };
+  VALUE kw_vals[2];
 
   TypedData_Get_Struct(self, RUBY_KRB5_PRINC, &rkrb5_princ_data_type, ptr);
 
-  kerror = krb5_init_context(&ptr->ctx);
+  rb_scan_args(argc, argv, "0:", &v_opts);
+
+  if(NIL_P(v_opts))
+    v_opts = rb_hash_new();
 
-  if(kerror)
-    rb_raise(cKrb5Exception, "krb5_init_context failed: %s", error_message(kerror));
+  rb_get_kwargs(v_opts, kw_table, 0, 2, kw_vals);
+  v_name = kw_vals[0] == Qundef ? Qnil : kw_vals[0];
+  v_context = kw_vals[1] == Qundef ? Qnil : kw_vals[1];
+
+  // Initialize or borrow the context
+  if(!NIL_P(v_context)){
+    ptr->ctx = rkrb5_context_borrow(v_context);
+    ptr->rb_context = v_context;
+  }
+  else{
+    kerror = krb5_init_context(&ptr->ctx);
+
+    if(kerror)
+      rb_raise(cKrb5Exception, "krb5_init_context failed: %s", error_message(kerror));
+
+    ptr->rb_context = Qnil;
+  }
 
   if(NIL_P(v_name)){
     rb_iv_set(self, "@principal", Qnil);
@@ -94,6 +137,36 @@ static VALUE rkrb5_princ_initialize(VALUE self, VALUE v_name){
   return self;
 }
 
+/*
+ * call-seq:
+ *   principal.close
+ *
+ * Releases the principal and its Kerberos context lease. Once closed, the
+ * principal cannot be reused.
+ */
+static VALUE rkrb5_princ_close(VALUE self){
+  RUBY_KRB5_PRINC* ptr;
+
+  TypedData_Get_Struct(self, RUBY_KRB5_PRINC, &rkrb5_princ_data_type, ptr);
+
+  if(!ptr->ctx)
+    return self;
+
+  if(ptr->principal)
+    krb5_free_principal(ptr->ctx, ptr->principal);
+
+  if(ptr->rb_context == Qnil)
+    krb5_free_context(ptr->ctx);
+  else
+    rkrb5_context_release(ptr->rb_context);
+
+  ptr->ctx = NULL;
+  ptr->principal = NULL;
+  ptr->rb_context = Qnil;
+
+  return self;
+}
+
 /*
  * call-seq:
  *   principal.realm
@@ -102,13 +175,16 @@ static VALUE rkrb5_princ_initialize(VALUE self, VALUE v_name){
  */
 static VALUE rkrb5_princ_get_realm(VALUE self){
   RUBY_KRB5_PRINC* ptr;
+  krb5_data* realm;
 
   TypedData_Get_Struct(self, RUBY_KRB5_PRINC, &rkrb5_princ_data_type, ptr);
 
   if(!ptr->principal)
     rb_raise(cKrb5Exception, "no principal has been established");
 
-  return rb_str_new2(krb5_princ_realm(ptr->ctx, ptr->principal)->data);
+  realm = krb5_princ_realm(ptr->ctx, ptr->principal);
+
+  return rb_str_new(realm->data, realm->length);
 }
 
 /*
@@ -144,6 +220,10 @@ static VALUE rkrb5_princ_equal(VALUE self, VALUE v_other){
   VALUE v_bool = Qfalse;
 
   TypedData_Get_Struct(self, RUBY_KRB5_PRINC, &rkrb5_princ_data_type, ptr1);
+
+  if(!rb_obj_is_kind_of(v_other, cKrb5Principal))
+    return Qfalse;
+
   TypedData_Get_Struct(v_other, RUBY_KRB5_PRINC, &rkrb5_princ_data_type, ptr2);
 
   if(!ptr1->principal || !ptr2->principal)
@@ -233,6 +313,51 @@ static VALUE rkrb5_princ_inspect(VALUE self){
   return v_str;
 }
 
+/*
+ * call-seq:
+ *   principal.principal_type -> Integer
+ *
+ * Returns the type of the principal as an integer, e.g.
+ * KRB5_NT_PRINCIPAL (1), KRB5_NT_SRV_HST (2), etc.
+ */
+static VALUE rkrb5_princ_get_type(VALUE self){
+  RUBY_KRB5_PRINC* ptr;
+
+  TypedData_Get_Struct(self, RUBY_KRB5_PRINC, &rkrb5_princ_data_type, ptr);
+
+  if(!ptr->principal)
+    rb_raise(cKrb5Exception, "no principal has been established");
+
+  return INT2FIX(krb5_princ_type(ptr->ctx, ptr->principal));
+}
+
+/*
+ * call-seq:
+ *   principal.components -> Array
+ *
+ * Returns an array of the component strings that make up this principal
+ * name (excluding the realm). For example, "admin/instance@REALM" would
+ * return ["admin", "instance"].
+ */
+static VALUE rkrb5_princ_components(VALUE self){
+  RUBY_KRB5_PRINC* ptr;
+
+  TypedData_Get_Struct(self, RUBY_KRB5_PRINC, &rkrb5_princ_data_type, ptr);
+
+  if(!ptr->principal)
+    rb_raise(cKrb5Exception, "no principal has been established");
+
+  int n = krb5_princ_size(ptr->ctx, ptr->principal);
+  VALUE v_array = rb_ary_new_capa(n);
+
+  for(int i = 0; i < n; i++){
+    krb5_data* component = krb5_princ_component(ptr->ctx, ptr->principal, i);
+    rb_ary_push(v_array, rb_str_new(component->data, component->length));
+  }
+
+  return v_array;
+}
+
 void Init_principal(void){
   /* The Kerberos::Krb5::Principal class encapsulates a Kerberos principal. */
   cKrb5Principal = rb_define_class_under(cKrb5, "Principal", rb_cObject);
@@ -243,7 +368,7 @@ void Init_principal(void){
 
   // Constructor
 
-  rb_define_method(cKrb5Principal, "initialize", rkrb5_princ_initialize, 1);
+  rb_define_method(cKrb5Principal, "initialize", rkrb5_princ_initialize, -1);
 
   // Instance Methods
 
@@ -251,6 +376,9 @@ void Init_principal(void){
   rb_define_method(cKrb5Principal, "realm", rkrb5_princ_get_realm, 0);
   rb_define_method(cKrb5Principal, "realm=", rkrb5_princ_set_realm, 1);
   rb_define_method(cKrb5Principal, "==", rkrb5_princ_equal, 1);
+  rb_define_method(cKrb5Principal, "principal_type", rkrb5_princ_get_type, 0);
+  rb_define_method(cKrb5Principal, "components", rkrb5_princ_components, 0);
+  rb_define_method(cKrb5Principal, "close", rkrb5_princ_close, 0);
 
   // Attributes