radcli 0.1.0

data/ext/radcli/adenroll.h

@@ -0,0 +1,143 @@
+/*
+ * adcli
+ *
+ * Copyright (C) 2012 Red Hat Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301 USA
+ *
+ * Author: Stef Walter <stefw@gnome.org>
+ */
+
+#ifndef ADENROLL_H_
+#define ADENROLL_H_
+
+#include "adconn.h"
+
+typedef enum {
+	ADCLI_ENROLL_NO_KEYTAB = 1 << 1,
+	ADCLI_ENROLL_ALLOW_OVERWRITE = 1 << 2,
+	ADCLI_ENROLL_PASSWORD_VALID = 1 << 3,
+} adcli_enroll_flags;
+
+typedef struct _adcli_enroll adcli_enroll;
+
+adcli_result       adcli_enroll_prepare                 (adcli_enroll *enroll,
+                                                         adcli_enroll_flags flags);
+
+adcli_result       adcli_enroll_load                    (adcli_enroll *enroll);
+
+adcli_result       adcli_enroll_join                    (adcli_enroll *enroll,
+                                                         adcli_enroll_flags join_flags);
+
+adcli_result       adcli_enroll_update                  (adcli_enroll *enroll,
+		                                         adcli_enroll_flags flags);
+
+adcli_result       adcli_enroll_delete                  (adcli_enroll *enroll,
+                                                         adcli_enroll_flags delete_flags);
+
+adcli_result       adcli_enroll_password                (adcli_enroll *enroll,
+                                                         adcli_enroll_flags password_flags);
+
+adcli_enroll *     adcli_enroll_new                     (adcli_conn *conn);
+
+adcli_enroll *     adcli_enroll_ref                     (adcli_enroll *enroll);
+
+void               adcli_enroll_unref                   (adcli_enroll *enroll);
+
+const char *       adcli_enroll_get_host_fqdn           (adcli_enroll *enroll);
+
+void               adcli_enroll_set_host_fqdn           (adcli_enroll *enroll,
+                                                         const char *value);
+
+const char *       adcli_enroll_get_computer_name       (adcli_enroll *enroll);
+
+void               adcli_enroll_set_computer_name       (adcli_enroll *enroll,
+                                                         const char *value);
+
+const char *       adcli_enroll_get_computer_password   (adcli_enroll *enroll);
+
+void               adcli_enroll_set_computer_password   (adcli_enroll *enroll,
+                                                         const char *host_password);
+
+void               adcli_enroll_reset_computer_password (adcli_enroll *enroll);
+
+const char *       adcli_enroll_get_domain_ou           (adcli_enroll *enroll);
+
+void               adcli_enroll_set_domain_ou           (adcli_enroll *enroll,
+                                                         const char *value);
+
+const char *       adcli_enroll_get_computer_dn         (adcli_enroll *enroll);
+
+void               adcli_enroll_set_computer_dn         (adcli_enroll *enroll,
+                                                         const char *value);
+
+const char **      adcli_enroll_get_service_names       (adcli_enroll *enroll);
+
+void               adcli_enroll_set_service_names       (adcli_enroll *enroll,
+                                                         const char **value);
+
+void               adcli_enroll_add_service_name        (adcli_enroll *enroll,
+                                                         const char *value);
+
+const char **      adcli_enroll_get_service_principals  (adcli_enroll *enroll);
+
+void               adcli_enroll_set_service_principals  (adcli_enroll *enroll,
+                                                         const char **value);
+
+const char *       adcli_enroll_get_user_principal      (adcli_enroll *enroll);
+
+void               adcli_enroll_set_user_principal      (adcli_enroll *enroll,
+                                                         const char *value);
+
+void               adcli_enroll_auto_user_principal     (adcli_enroll *enroll);
+
+unsigned int       adcli_enroll_get_computer_password_lifetime (adcli_enroll *enroll);
+void               adcli_enroll_set_computer_password_lifetime (adcli_enroll *enroll,
+                                                         unsigned int lifetime);
+
+krb5_kvno          adcli_enroll_get_kvno                (adcli_enroll *enroll);
+
+void               adcli_enroll_set_kvno                (adcli_enroll *enroll,
+                                                         krb5_kvno value);
+
+krb5_keytab        adcli_enroll_get_keytab              (adcli_enroll *enroll);
+
+const char *       adcli_enroll_get_keytab_name         (adcli_enroll *enroll);
+
+void               adcli_enroll_set_keytab_name         (adcli_enroll *enroll,
+                                                         const char *value);
+
+krb5_enctype *     adcli_enroll_get_keytab_enctypes     (adcli_enroll *enroll);
+
+void               adcli_enroll_set_keytab_enctypes     (adcli_enroll *enroll,
+                                                         krb5_enctype *enctypes);
+
+const char *       adcli_enroll_get_os_name             (adcli_enroll *enroll);
+
+void               adcli_enroll_set_os_name             (adcli_enroll *enroll,
+                                                         const char *value);
+
+const char *       adcli_enroll_get_os_version          (adcli_enroll *enroll);
+
+void               adcli_enroll_set_os_version          (adcli_enroll *enroll,
+                                                         const char *value);
+
+const char *       adcli_enroll_get_os_service_pack     (adcli_enroll *enroll);
+
+void               adcli_enroll_set_os_service_pack     (adcli_enroll *enroll,
+                                                         const char *value);
+
+#endif /* ADENROLL_H_ */

data/ext/radcli/adutil.h

@@ -0,0 +1,94 @@
+/*
+ * adcli
+ *
+ * Copyright (C) 2012 Red Hat Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301 USA
+ *
+ * Author: Stef Walter <stefw@gnome.org>
+ */
+
+#ifndef ADUTIL_H_
+#define ADUTIL_H_
+
+#include <stdlib.h>
+#include <stdbool.h>
+
+typedef enum {
+	/* Successful completion */
+	ADCLI_SUCCESS = 0,
+
+	/*
+	 * Invalid input or unexpected system behavior.
+	 *
+	 * This is almost always caused by a bug, or completely broken
+	 * system configuration or state. This is returned when memory
+	 * allocation fails, but the process will almost certainly have
+	 * been killed first.
+	 *
+	 * This is returned for invalid inputs (such an unexpected
+	 * NULL) to adcli.
+	 */
+	ADCLI_ERR_UNEXPECTED = -2,
+
+	/*
+	 * A general failure, that doesn't fit into the other categories.
+	 * Not much the caller can do.
+	 */
+	ADCLI_ERR_FAIL = -3,
+
+	/*
+	 * A problem with the active directory or connecting to it.
+	 */
+	ADCLI_ERR_DIRECTORY = -4,
+
+	/*
+	 * A logic problem with the configuration of the local system, or
+	 * the settings passed into adcli.
+	 */
+	ADCLI_ERR_CONFIG = -5,
+
+	/*
+	 * Invalid credentials.
+	 *
+	 * The credentials are invalid, or don't have the necessary
+	 * access rights.
+	 */
+	ADCLI_ERR_CREDENTIALS = -6,
+} adcli_result;
+
+typedef enum {
+	ADCLI_MESSAGE_INFO,
+	ADCLI_MESSAGE_WARNING,
+	ADCLI_MESSAGE_ERROR
+} adcli_message_type;
+
+const char *      adcli_result_to_string        (adcli_result res);
+
+int               adcli_mem_clear               (void *data,
+                                                 size_t length);
+
+
+typedef void      (* adcli_message_func)        (adcli_message_type type,
+                                                 const char *message);
+
+void              adcli_set_message_func        (adcli_message_func message_func);
+
+void              adcli_clear_last_error        (void);
+
+const char *      adcli_get_last_error          (void);
+
+#endif /* ADUTIL_H_ */

data/ext/radcli/extconf.rb

@@ -0,0 +1,16 @@
+require "mkmf"
+
+LIBDIR     = RbConfig::CONFIG['libdir']
+INCLUDEDIR = RbConfig::CONFIG['includedir']
+HEADER_DIRS = [INCLUDEDIR, File.expand_path(File.join(File.dirname(__FILE__), "ext/radcli"))]
+LIB_DIRS = [LIBDIR, File.expand_path(File.join(File.dirname(__FILE__), "../lib"))]
+libs = ['-ladcli', '-lldap', '-lkrb5', '-lsasl2', '-lgssapi_krb5']
+
+dir_config('radcli', HEADER_DIRS, LIB_DIRS)
+
+libs.each do |lib|
+  $LOCAL_LIBS << "#{lib} "
+end
+
+create_makefile('radcli')
+

data/ext/radcli/radcli.c

@@ -0,0 +1,13 @@
+#include <ruby.h>
+#include <radcli.h>
+
+VALUE m_adcli;
+VALUE c_adconn_exception;
+VALUE c_adenroll_exception;
+
+void Init_radcli() {
+    m_adcli = rb_define_module("Adcli");
+
+    Init_AdConn();
+    Init_AdEnroll();
+}

data/ext/radcli/radcli.h

@@ -0,0 +1,31 @@
+#ifndef ADCLI_H_INCLUDED
+#define ADCLI_H_INCLUDED
+
+#include <ruby.h>
+#include <adconn.h>
+#include <adenroll.h>
+#include <stdio.h>
+#include <errno.h>
+
+// Function prototypes
+void Init_AdConn();
+void Init_AdEnroll();
+
+// Variable declarations
+extern VALUE m_adcli;
+extern VALUE c_adconn;
+extern VALUE c_adenroll;
+extern VALUE c_adconn_exception;
+extern VALUE c_adenroll_exception;
+
+// Adcli::AdConn
+typedef struct {
+    adcli_conn *conn;
+} RUBY_ADCONN;
+
+// Adcli::AdEnroll
+typedef struct {
+    adcli_enroll *enroll;
+} RUBY_ADENROLL;
+
+#endif

data/ext/radcli/radconn.c

@@ -0,0 +1,291 @@
+#include <radcli.h>
+ 
+VALUE c_adconn;
+
+// Free function for the Adcli::Adconn class.
+static void radcli_free (RUBY_ADCONN* ptr) {
+    if(!ptr)
+        return;
+
+    adcli_conn_unref (ptr->conn);
+
+    free (ptr);
+}
+
+// Allocation function for the Adcli:Adconn class.
+static VALUE radconn_allocate (VALUE klass) {
+    RUBY_ADCONN* ptr = malloc (sizeof(RUBY_ADCONN));
+
+    memset (ptr, 0, sizeof(RUBY_ADCONN));
+
+    return Data_Wrap_Struct (klass, 0, radcli_free, ptr);
+}
+
+/*
+ * call-seq:
+ *  Adcli::Adconn.new("domain.com")
+ * 
+ *  Creates and returns a new Adcli::Adconn object. 
+ * 
+ */
+static VALUE radconn_initialize (VALUE self, VALUE domain) {
+    RUBY_ADCONN* ptr;
+
+    Check_Type(domain, T_STRING);
+    
+    const char *domain_name = StringValuePtr(domain);
+
+    Data_Get_Struct (self, RUBY_ADCONN, ptr);
+    
+    ptr->conn = adcli_conn_new (domain_name);
+
+    return self;
+}
+
+/* 
+ * call-seq:
+ *   Adcli::Adconn.set_login_ccache_name("")
+ *
+ *  Set the login kerberos cache name
+ * 
+ */
+static VALUE radconn_set_login_ccache_name (VALUE self, VALUE ccname) {
+    RUBY_ADCONN* ptr;
+
+    Check_Type(ccname, T_STRING);
+
+    const char *c_ccname = StringValuePtr(ccname);
+
+    Data_Get_Struct (self, RUBY_ADCONN, ptr);
+
+    adcli_conn_set_login_ccache_name (ptr->conn, c_ccname);
+
+    return self;
+}
+
+/*
+ * call-seq:
+ *   Adcli::Adconn.get_login_ccache_name()
+ *
+ *  Get the login kerberos cache name
+ *
+ */
+static VALUE radconn_get_login_ccache_name (VALUE self) {
+    RUBY_ADCONN* ptr;
+    const char *login_ccache = NULL;
+
+    Data_Get_Struct (self, RUBY_ADCONN, ptr);
+
+    login_ccache = adcli_conn_get_login_ccache_name (ptr->conn); 
+
+    return rb_str_new_cstr (login_ccache);
+}
+
+/*
+ * call-seq:
+ *  Adcli::Adconn.set_login_user("user")
+ *
+ * Sets the login user that we should authenticate as.
+ * 
+ */
+static VALUE radconn_set_login_user (VALUE self, VALUE user) {
+    RUBY_ADCONN* ptr;
+
+    Check_Type(user, T_STRING);
+
+    const char *c_user = StringValuePtr(user);
+
+    Data_Get_Struct (self, RUBY_ADCONN, ptr);
+
+    adcli_conn_set_login_user (ptr->conn, c_user);
+
+    return self;
+}
+ 
+/*
+ * call-seq:
+ *  Adcli::Adconn.get_login_user # => 'user'
+ *
+ * Get the login user for authentication.
+ * 
+ */
+ static VALUE radconn_get_login_user (VALUE self) {
+    RUBY_ADCONN* ptr;
+    const char *login_user = NULL;
+
+    Data_Get_Struct (self, RUBY_ADCONN, ptr);
+
+    login_user = adcli_conn_get_login_user (ptr->conn);
+    
+    return rb_str_new_cstr (login_user);
+}
+
+/*
+ * call-seq:
+ *  Adcli::Adconn.set_user_password
+ *
+ * Sets the login user password for authentication.
+ * 
+ */
+static VALUE radconn_set_user_password (VALUE self, VALUE password) {
+    RUBY_ADCONN* ptr;
+
+    Check_Type(password, T_STRING);
+
+    const char *c_password = StringValuePtr(password);
+
+    Data_Get_Struct (self, RUBY_ADCONN, ptr);
+
+    adcli_conn_set_user_password (ptr->conn, c_password);
+
+    return self;
+}
+ 
+/*
+ * call-seq:
+ *  Adcli::Adconn.get_user_password
+ *
+ * Gets the login user password for authentication.
+ * 
+ */
+static VALUE radconn_get_user_password (VALUE self) {
+    RUBY_ADCONN* ptr;
+    const char *login_password = NULL;
+
+    Data_Get_Struct (self, RUBY_ADCONN, ptr);
+
+    login_password = adcli_conn_get_user_password(ptr->conn);
+
+    return rb_str_new_cstr(login_password);
+}
+
+/*
+ * call-seq:
+ *  Adcli::Adconn.get_domain_realm # => 'YOUR.REALM.COM'
+ *
+ * Gets the domain realm.
+ * 
+ */
+static VALUE radconn_get_domain_realm (VALUE self) {
+    RUBY_ADCONN* ptr;
+    const char *domain_realm = NULL;
+
+    Data_Get_Struct (self ,RUBY_ADCONN, ptr);
+
+    domain_realm  = adcli_conn_get_domain_realm(ptr->conn);
+
+    return rb_str_new_cstr (domain_realm);
+} 
+
+/*
+ * call-seq:
+ *  Adcli::Adconn.set_domain_realm('YOUR.REALM.COM')
+ *
+ * Set the domain realm.
+ * 
+ */
+static VALUE radconn_set_domain_realm (VALUE self, VALUE domain_realm) {
+    RUBY_ADCONN* ptr;
+
+    Check_Type(domain_realm, T_STRING);
+
+    char *c_domain_realm = StringValuePtr(domain_realm);
+
+    Data_Get_Struct (self, RUBY_ADCONN, ptr);
+
+    adcli_conn_set_domain_realm (ptr->conn, c_domain_realm);
+
+    return self;
+}
+
+
+/*
+ * call-seq:
+ *  Adcli::Adconn.get_domain_controller #=> 'YOUR.DC.REALM.COM'
+ *
+ * Get the domain controller to use.
+ * 
+ */
+static VALUE radconn_get_domain_controller (VALUE self) {
+    RUBY_ADCONN* ptr;
+    const char *domain_controller = NULL;
+
+    Data_Get_Struct (self ,RUBY_ADCONN, ptr);
+
+    domain_controller = adcli_conn_get_domain_controller (ptr->conn);
+
+    return rb_str_new_cstr (domain_controller);
+} 
+
+/*
+ * call-seq:
+ *  Adcli::Adconn.set_domain_controller('YOUR.DC.REALM.COM')
+ *
+ * Get the domain controller to use.
+ * 
+ */
+static VALUE radconn_set_domain_controller (VALUE self, VALUE domain_controller) {
+    RUBY_ADCONN* ptr;
+    
+    Check_Type(domain_controller, T_STRING);
+
+    char *c_domain_controller = StringValuePtr (domain_controller);
+
+    Data_Get_Struct (self, RUBY_ADCONN, ptr);
+
+    adcli_conn_set_domain_controller (ptr->conn, c_domain_controller);
+
+    return self;
+}
+
+/*
+ * call-seq:
+ *  Adcli::Adconn.connect
+ *
+ * Connect to Active Directory and authenticate using the login username and password.
+ * 
+ */
+static VALUE radconn_connect (VALUE self) {
+    RUBY_ADCONN* ptr;
+    adcli_result result;
+
+    Data_Get_Struct (self ,RUBY_ADCONN, ptr);
+
+    result = adcli_conn_connect (ptr->conn);
+
+    if (result != ADCLI_SUCCESS) {
+        rb_raise(c_adconn_exception, "%s", adcli_get_last_error());
+    }
+
+    return self;
+}
+
+void Init_AdConn()
+{
+    c_adconn = rb_define_class_under (m_adcli, "AdConn", rb_cObject);
+    c_adconn_exception = rb_define_class_under (m_adcli, "Exception", rb_eStandardError);
+
+    // Allocate functions
+    rb_define_alloc_func (c_adconn, radconn_allocate);
+
+    // Initializers
+    rb_define_method (c_adconn, "initialize", radconn_initialize, 1);
+
+    // AdConn Methods
+    rb_define_method (c_adconn, "get_login_ccache_name", radconn_get_login_ccache_name, 0);
+    rb_define_method (c_adconn, "set_login_ccache_name", radconn_set_login_ccache_name, 1);
+
+    rb_define_method (c_adconn, "get_login_user", radconn_get_login_user, 0);
+    rb_define_method (c_adconn, "set_login_user", radconn_set_login_user, 1);
+
+    rb_define_method (c_adconn, "get_user_password", radconn_get_user_password, 0);
+    rb_define_method (c_adconn, "set_user_password", radconn_set_user_password, 1);
+
+    rb_define_method (c_adconn, "get_domain_realm", radconn_get_domain_realm, 0);
+    rb_define_method (c_adconn, "set_domain_realm", radconn_set_domain_realm, 1);
+
+    rb_define_method(c_adconn, "get_domain_controller", radconn_get_domain_controller, 0);
+    rb_define_method(c_adconn, "set_domain_controller", radconn_set_domain_controller, 1);
+
+    rb_define_method(c_adconn, "connect", radconn_connect, 0);
+}