Cleanup

PyKAdminCommon.c

@@ -25,18 +25,21 @@ krb5_error_code pykadmin_unpack_xdr_osa_princ_ent_rec(PyKAdminObject *kadmin, kr
         adb->admin_history_kvno = 0;
     }
 
-    xdrmem_create(&xdrs, (caddr_t)tl_data.tl_data_contents, tl_data.tl_data_length, XDR_DECODE);
+    if (tl_data.tl_data_length) {
+        xdrmem_create(&xdrs, (caddr_t)tl_data.tl_data_contents, tl_data.tl_data_length, XDR_DECODE);
+
+        if (!pykadmin_xdr_osa_princ_ent_rec(&xdrs, adb)) {
+            xdr_destroy(&xdrs);
+            retval = KADM5_XDR_FAILURE;
+            goto done;
+        }
 
-    if (!pykadmin_xdr_osa_princ_ent_rec(&xdrs, adb)) {
         xdr_destroy(&xdrs);
-        retval = KADM5_XDR_FAILURE;
-        goto done;
     }
 
-    xdr_destroy(&xdrs);
-
-    retval = KADM5_OK;
+    //retval = KADM5_OK;
 done: 
+
     return retval;
 }
 
@@ -152,7 +155,7 @@ krb5_error_code pykadmin_kadm_from_kdb(PyKAdminObject *kadmin, krb5_db_entry *kd
     }
 
     if ((mask & KADM5_MOD_NAME) || (mask & KADM5_MOD_TIME)) {
-        if ((retval = krb5_dbe_lookup_mod_princ_data(kadmin->context, kdb, &(entry->mod_date), &(entry->mod_name))));
+        if ((retval = krb5_dbe_lookup_mod_princ_data(kadmin->context, kdb, &(entry->mod_date), &(entry->mod_name))))
             goto done;
 
         if (! (mask & KADM5_MOD_TIME))
@@ -162,21 +165,22 @@ krb5_error_code pykadmin_kadm_from_kdb(PyKAdminObject *kadmin, krb5_db_entry *kd
             krb5_free_principal(kadmin->context, entry->mod_name);
             entry->mod_name = NULL;
         }
-    }
+    }  
+
 
     if (mask & KADM5_KVNO) {
-        for (entry->kvno = 0, i=0; i<kdb->n_key_data; i++)
+        entry->kvno = 0;
+        for (i = 0; i < kdb->n_key_data; i++) {
             if ((krb5_kvno) kdb->key_data[i].key_data_kvno > entry->kvno)
-                entry->kvno = kdb->key_data[i].key_data_kvno;
+                entry->kvno = (krb5_kvno) kdb->key_data[i].key_data_kvno;
+        }
     }
 
-    /* api vs github src differ come back to  
-    TODO
     if (mask & KADM5_MKVNO) {
-        if ((retval = krb5_dbe_get_mkvno(kadmin->context, kdb, &entry->mkvno)))
+        if ((retval = krb5_dbe_lookup_mkvno(kadmin->context, kdb, &entry->mkvno)))
             goto done;
     }
-    */
+
 
 
     /* key data */
@@ -231,8 +235,9 @@ krb5_error_code pykadmin_kadm_from_kdb(PyKAdminObject *kadmin, krb5_db_entry *kd
 
     */
 
-    if ((retval = pykadmin_unpack_xdr_osa_princ_ent_rec(kadmin, kdb, adb)))
+    if ((retval = pykadmin_unpack_xdr_osa_princ_ent_rec(kadmin, kdb, adb))) {
         goto done;
+    }
 
     /* load data stored into the entry rec */
 
@@ -260,6 +265,96 @@ krb5_error_code pykadmin_kadm_from_kdb(PyKAdminObject *kadmin, krb5_db_entry *kd
 }
 
 
+int pykadmin_compare_tl_data(krb5_context ctx, krb5_tl_data *a, krb5_tl_data *b) {
+
+    int result = 1; 
+
+    if (a && b) {
+
+        result &= (a->tl_data_type == b->tl_data_type);
+        result &= (a->tl_data_length == b->tl_data_length);
+
+        if (result)
+            result &= (memcmp(a->tl_data_contents, b->tl_data_contents, a->tl_data_length) == 0);
+    } else {
+
+        result &= (a == b);
+    } 
+
+    // tl_data_next 
+
+    return result;
+}
+
+
+
+int pykadmin_compare_key_data(krb5_context ctx, krb5_key_data *a, krb5_key_data *b) {
+
+    int result = 1; 
+    int i, idx; 
+
+    if (a && b) {
+        result &= (a->key_data_ver == b->key_data_ver);
+        result &= (a->key_data_kvno == b->key_data_kvno);
+
+        if (result) {
+
+            idx = (a->key_data_ver == 1 ? 1 : 2);
+            for (i = 0; i < idx; i++) {
+
+                result &= (a->key_data_type[i] == b->key_data_type[i]);
+                result &= (a->key_data_length[i] == b->key_data_length[i]);
+
+                if (result)
+                    result &= (memcmp(a->key_data_contents[i], b->key_data_contents[i], a->key_data_length[i]) == 0);
+            }
+        }
+    } else {
+
+        result &= (a == b);
+    }
+
+
+    return result;
+}
+
+int pykadmin_principal_ent_rec_compare(krb5_context ctx, kadm5_principal_ent_rec *a, kadm5_principal_ent_rec *b) {
+
+    int result = 1; 
+
+    result &= krb5_principal_compare(ctx, a->principal, b->principal);
+
+    result &= (a->princ_expire_time == b->princ_expire_time);
+    result &= (a->last_pwd_change == b->last_pwd_change);
+    result &= (a->pw_expiration == b->pw_expiration);
+    result &= (a->max_life == b->max_life);
+
+    result &= krb5_principal_compare(ctx, a->mod_name, b->mod_name);
+
+    result &= (a->mod_date == b->mod_date);
+    result &= (a->attributes == b->attributes);
+
+    result &= (a->kvno == b->kvno);
+    result &= (a->mkvno == b->mkvno);
+
+    if (a->policy && b->policy)
+        result &= (strcmp(a->policy, b->policy) == 0);
+
+    result &= (a->max_renewable_life == b->max_renewable_life);
+    result &= (a->last_success == b->last_success);
+    result &= (a->last_failed == b->last_failed);
+    result &= (a->fail_auth_count == b->fail_auth_count);
+    result &= (a->n_key_data == b->n_key_data);
+    result &= (a->n_tl_data == b->n_tl_data);
+
+    result &= pykadmin_compare_tl_data(ctx, a->tl_data, b->tl_data);
+
+    result &= pykadmin_compare_key_data(ctx, a->key_data, b->key_data);
+
+    return result; 
+}
+
+
 /*
 krb5_error_code pykadmin_copy_kadm_ent_rec(PyKAdminObject *kadmin, kadm5_principal_ent_rec *src, kadm5_principal_ent_rec *dst) {
 

PyKAdminCommon.h

@@ -6,12 +6,16 @@
 #include <kdb.h>
 #include <kadm5/admin.h>
 #include <krb5/krb5.h>
+#include <string.h>
 
 #include "PyKadminXDR.h"
 #include "PyKAdminObject.h"
 
 krb5_error_code pykadmin_kadm_from_kdb(PyKAdminObject *kadmin, krb5_db_entry *kdb, kadm5_principal_ent_rec *entry, long mask); 
 
+int pykadmin_principal_ent_rec_compare(krb5_context ctx, kadm5_principal_ent_rec *a, kadm5_principal_ent_rec *b);
+
+
 // TODO
 //krb5_error_code pykadmin_copy_kadm_ent_rec(PyKAdminObject *kadmin, kadm5_principal_ent_rec *src, kadm5_principal_ent_rec *dst);
 

PyKAdminErrors.c

@@ -1,8 +1,6 @@
 
 #include "PyKAdminErrors.h"
 
-#define IS_NULL(ptr) (ptr == NULL)
-
 void PyKAdminError_insert(PyObject *module, kadm5_ret_t retval, char *error_name, char *error_string) {
 
     PyObject *error_number        = PyLong_FromUnsignedLong(retval);
@@ -112,17 +110,17 @@ PyObject *PyKAdmin_RaiseKAdminError(kadm5_ret_t retval, char *caller) {
 
     PyDict_SetItemString(error_dict, kERROR_NUMBER, error_number);
 
-    if (!IS_NULL(KAdminErrorsDict)) {
+    if (KAdminErrorsDict) {
 
         error_tuple = PyDict_GetItem(KAdminErrorsDict, error_number);
 
-        if (!IS_NULL(error_tuple) && (PyTuple_GET_SIZE(error_tuple) >= 2)) {
+        if (error_tuple && (PyTuple_GET_SIZE(error_tuple) >= 2)) {
             error_object = PyTuple_GetItem(error_tuple, 0x0); 
             error_string = PyTuple_GetItem(error_tuple, 0x1);
         }
     }
 
-    if (!IS_NULL(error_string)) {
+    if (error_string) {
         PyDict_SetItemString(error_dict, kERROR_STRING, error_string);
     } else {
         error_string = PyString_FromString(caller);
@@ -131,7 +129,7 @@ PyObject *PyKAdmin_RaiseKAdminError(kadm5_ret_t retval, char *caller) {
     }
 
 
-    if (!IS_NULL(error_object)) {
+    if (error_object) {
         PyErr_SetObject(error_object, error_dict);
     } else {
         PyErr_SetObject(KAdminError, error_dict);

PyKAdminObject.c

@@ -8,31 +8,32 @@
 #include "PyKAdminCommon.h"
 
 
-#define IS_NULL(ptr) (ptr == NULL)
-
 static void PyKAdminObject_dealloc(PyKAdminObject *self) {
 
     kadm5_ret_t retval;
 
-    krb5_db_unlock(self->context);
-
-    if (!IS_NULL(self->server_handle)) {
-        retval = kadm5_destroy(self->server_handle);
-        if (retval) {}
-    }
-
-    if (!IS_NULL(self->context)) {
-        krb5_free_context(self->context);
-    }
+    if (self) {
+        krb5_db_unlock(self->context);
 
-    if (!IS_NULL(self->realm)) {
-        free(self->realm);
-    }
+        if (self->server_handle) {
+            retval = kadm5_destroy(self->server_handle);
+            if (retval) {}
+            self->server_handle = NULL;
+        }
+
+        if (self->context) {
+            krb5_free_context(self->context);
+            self->context = NULL;
+        }
 
+        if (self->realm) {
+            free(self->realm);
+        }
 
-    self->ob_type->tp_free((PyObject*)self);
+        self->ob_type->tp_free((PyObject*)self);
+    }
 }
-
+    
 static PyObject *PyKAdminObject_new(PyTypeObject *type, PyObject *args, PyObject *kwds) {
 
     PyKAdminObject *self; 
@@ -79,7 +80,7 @@ static PyObject *PyKAdminObject_delete_principal(PyKAdminObject *self, PyObject
     if (!PyArg_ParseTuple(args, "s", &client_name))
         return NULL;
 
-    if (!IS_NULL(self->server_handle)) {
+    if (self->server_handle) {
 
         retval = krb5_parse_name(self->context, client_name, &princ);
         if (retval != 0x0) { PyKAdmin_RaiseKAdminError(retval, "krb5_parse_name"); return NULL; }
@@ -138,13 +139,13 @@ static PyObject *PyKAdminObject_create_principal(PyKAdminObject *self, PyObject
 static PyKAdminPrincipalObject *PyKAdminObject_get_principal(PyKAdminObject *self, PyObject *args, PyObject *kwds) {
 
     PyKAdminPrincipalObject *principal = NULL;
-    char *client_name; 
+    char *client_name = NULL;
 
     if (!PyArg_ParseTuple(args, "s", &client_name)) {
         return NULL;
     }
 
-    if (!IS_NULL(self->server_handle)) {
+    if (self->server_handle) {
         principal = PyKAdminPrincipalObject_principal_with_name(self, client_name);
 
     } 
@@ -194,14 +195,13 @@ static int kdb_iter_princs(void *data, krb5_db_entry *kdb) {
 
         if (self->each_principal.callback) {
 
-            result = PyObject_CallFunctionObjArgs(self->each_principal.callback, principal, self->each_principal.arg, NULL);
+            result = PyObject_CallFunctionObjArgs(self->each_principal.callback, principal, self->each_principal.data, NULL);
 
             if (!result) {
                 // use self to hold exception 
             }
 
         }
-        Py_XDECREF(args);
         KAdminPrincipal_destroy(principal);
     }
 
@@ -218,16 +218,16 @@ static PyObject *PyKAdminObject_each_principal(PyKAdminObject *self, PyObject *a
     kadm5_ret_t lock = 0; 
 
 
-    static char *kwlist[] = {"", "arg", "match", NULL};
+    static char *kwlist[] = {"", "data", "match", NULL};
 
-    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!|Oz", kwlist, &PyFunction_Type, &self->each_principal.callback, &self->each_principal.arg, &match))
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!|Oz", kwlist, &PyFunction_Type, &self->each_principal.callback, &self->each_principal.data, &match))
         return NULL;
 
-    if (!self->each_principal.arg)
-        self->each_principal.arg = Py_None;
+    if (!self->each_principal.data)
+        self->each_principal.data = Py_None;
 
     Py_XINCREF(self->each_principal.callback);
-    Py_XINCREF(self->each_principal.arg);
+    Py_XINCREF(self->each_principal.data);
 
     lock = kadm5_lock(self->server_handle);
 
@@ -243,7 +243,7 @@ static PyObject *PyKAdminObject_each_principal(PyKAdminObject *self, PyObject *a
     }
 
     Py_XDECREF(self->each_principal.callback);
-    Py_XDECREF(self->each_principal.arg);
+    Py_XDECREF(self->each_principal.data);
 
     if (retval) {
         // TODO raise proper exception

PyKAdminObject.h

@@ -11,7 +11,7 @@
 
 typedef struct {
 	PyObject *callback;
-	PyObject *arg;
+	PyObject *data;
 } each_iteration_t; 
 
 typedef struct {

PyKAdminPolicyObject.c

@@ -5,8 +5,6 @@
 #include "PyKAdminPrincipalObject.h"
 #include "PyKAdminPolicyObject.h"
 
-#define IS_NULL(ptr) (ptr == NULL)
-
 static void PyKAdminPolicyObject_dealloc(PyKAdminPolicyObject *self) {
 
     self->ob_type->tp_free((PyObject*)self);
@@ -85,7 +83,7 @@ PyKAdminPolicyObject *PyKAdminPolicyObject_create(PyKAdminObject *kadmin, char *
 
     policy = (PyKAdminPolicyObject *)PyKAdminPolicyObject_new(&PyKAdminPolicyObject_Type, NULL, NULL);
 
-    if (!IS_NULL(policy)) {
+    if (policy) {
         Py_XINCREF(kadmin);
         policy->kadmin = kadmin;
     }