Modernize style of kdb_log.c

ulog_get_entries had an unreachable branch which was removed during
de-indentation.

1 files changed, 292 insertions, 460 deletions

diff --git a/src/lib/kdb/kdb_log.c b/src/lib/kdb/kdb_log.c
index 4ecc34057c..f70d3fed3b 100644
--- a/src/lib/kdb/kdb_log.c
+++ b/src/lib/kdb/kdb_log.c
@@ -4,8 +4,6 @@
  * Use is subject to license terms.
  */
 
-/* #pragma ident        "@(#)kdb_log.c  1.3     04/02/23 SMI" */
-
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <unistd.h>
@@ -23,14 +21,12 @@
 #define MAP_FAILED ((void *)-1)
 #endif
 
-/*
- * This modules includes all the necessary functions that create and
- * modify the Kerberos principal update and header logs.
- */
+/* This module includes all the necessary functions that create and modify the
+ * Kerberos principal update and header logs. */
 
-#define getpagesize()   sysconf(_SC_PAGESIZE)
+#define getpagesize() sysconf(_SC_PAGESIZE)
 
-static int              pagesize = 0;
+static int pagesize = 0;
 
 #define INIT_ULOG(ctx)                          \
     log_ctx = ctx->kdblog_context;              \
@@ -38,11 +34,7 @@ static int              pagesize = 0;
     ulog = log_ctx->ulog;                       \
     assert(ulog != NULL)
 
-/* XXX */
-typedef unsigned long ulong_t;
-typedef unsigned int uint_t;
-
-static int extend_file_to(int fd, uint_t new_size);
+static int extend_file_to(int fd, unsigned int new_size);
 
 krb5_error_code
 ulog_lock(krb5_context ctx, int mode)
@@ -52,43 +44,35 @@ ulog_lock(krb5_context ctx, int mode)
 
     if (ctx == NULL)
         return KRB5_LOG_ERROR;
-    if (ctx->kdblog_context == NULL || ctx->kdblog_context->iproprole == IPROP_NULL)
+    if (ctx->kdblog_context == NULL ||
+        ctx->kdblog_context->iproprole == IPROP_NULL)
         return 0;
     INIT_ULOG(ctx);
     return krb5_lock_file(ctx, log_ctx->ulogfd, mode);
 }
 
-/*
- * Sync update entry to disk.
- */
+/* Sync update entry to disk. */
 static krb5_error_code
 ulog_sync_update(kdb_hlog_t *ulog, kdb_ent_header_t *upd)
 {
-    ulong_t             start, end, size;
-    krb5_error_code     retval;
+    unsigned long start, end, size;
 
     if (ulog == NULL)
-        return (KRB5_LOG_ERROR);
+        return KRB5_LOG_ERROR;
 
     if (!pagesize)
         pagesize = getpagesize();
 
-    start = ((ulong_t)upd) & (~(pagesize-1));
+    start = (unsigned long)upd & ~(pagesize - 1);
 
-    end = (((ulong_t)upd) + ulog->kdb_block +
-           (pagesize-1)) & (~(pagesize-1));
+    end = ((unsigned long)upd + ulog->kdb_block + (pagesize - 1)) &
+        ~(pagesize - 1);
 
     size = end - start;
-    if ((retval = msync((caddr_t)start, size, MS_SYNC))) {
-        return (retval);
-    }
-
-    return (0);
+    return msync((caddr_t)start, size, MS_SYNC);
 }
 
-/*
- * Sync memory to disk for the update log header.
- */
+/* Sync memory to disk for the update log header. */
 void
 ulog_sync_header(kdb_hlog_t *ulog)
 {
@@ -97,129 +81,111 @@ ulog_sync_header(kdb_hlog_t *ulog)
         pagesize = getpagesize();
 
     if (msync((caddr_t)ulog, pagesize, MS_SYNC)) {
-        /*
-         * Couldn't sync to disk, let's panic
-         */
+        /* Couldn't sync to disk, let's panic. */
         syslog(LOG_ERR, _("ulog_sync_header: could not sync to disk"));
         abort();
     }
 }
 
 /*
- * Resizes the array elements.  We reinitialize the update log rather than
+ * Resize the array elements.  We reinitialize the update log rather than
  * unrolling the the log and copying it over to a temporary log for obvious
- * performance reasons.  Slaves will subsequently do a full resync, but
- * the need for resizing should be very small.
+ * performance reasons.  Slaves will subsequently do a full resync, but the
+ * need for resizing should be very small.
  */
 static krb5_error_code
-ulog_resize(kdb_hlog_t *ulog, uint32_t ulogentries, int ulogfd, uint_t recsize)
+ulog_resize(kdb_hlog_t *ulog, uint32_t ulogentries, int ulogfd,
+            unsigned int recsize)
 {
-    uint_t              new_block, new_size;
+    unsigned int new_block, new_size;
 
     if (ulog == NULL)
-        return (KRB5_LOG_ERROR);
-
-    new_size = sizeof (kdb_hlog_t);
+        return KRB5_LOG_ERROR;
 
+    new_size = sizeof(kdb_hlog_t);
     new_block = (recsize / ULOG_BLOCK) + 1;
     new_block *= ULOG_BLOCK;
-
     new_size += ulogentries * new_block;
 
-    if (new_size <= MAXLOGLEN) {
-        /*
-         * Reinit log with new block size
-         */
-        (void) memset(ulog, 0, sizeof (kdb_hlog_t));
-
-        ulog->kdb_hmagic = KDB_ULOG_HDR_MAGIC;
-        ulog->db_version_num = KDB_VERSION;
-        ulog->kdb_state = KDB_STABLE;
-        ulog->kdb_block = new_block;
+    if (new_size > MAXLOGLEN)
+        return KRB5_LOG_ERROR;
 
-        ulog_sync_header(ulog);
+    /* Reinit log with new block size. */
+    memset(ulog, 0, sizeof(*ulog));
+    ulog->kdb_hmagic = KDB_ULOG_HDR_MAGIC;
+    ulog->db_version_num = KDB_VERSION;
+    ulog->kdb_state = KDB_STABLE;
+    ulog->kdb_block = new_block;
+    ulog_sync_header(ulog);
 
-        /*
-         * Time to expand log considering new block size
-         */
-        if (extend_file_to(ulogfd, new_size) < 0)
-            return errno;
-    } else {
-        /*
-         * Can't map into file larger than MAXLOGLEN
-         */
-        return (KRB5_LOG_ERROR);
-    }
+    /* Expand log considering new block size. */
+    if (extend_file_to(ulogfd, new_size) < 0)
+        return errno;
 
-    return (0);
+    return 0;
 }
 
 /*
- * Adds an entry to the update log.
- * The layout of the update log looks like:
+ * Add an entry to the update log.  The layout of the update log looks like:
  *
  * header log -> [ update header -> xdr(kdb_incr_update_t) ], ...
  */
 krb5_error_code
 ulog_add_update(krb5_context context, kdb_incr_update_t *upd)
 {
-    XDR         xdrs;
+    XDR xdrs;
     kdbe_time_t ktime;
-    struct timeval      timestamp;
+    struct timeval timestamp;
     kdb_ent_header_t *indx_log;
-    uint_t              i, recsize;
-    ulong_t             upd_size;
-    krb5_error_code     retval;
-    kdb_sno_t   cur_sno;
-    kdb_log_context     *log_ctx;
-    kdb_hlog_t  *ulog = NULL;
-    uint32_t    ulogentries;
-    int         ulogfd;
+    unsigned int i, recsize;
+    unsigned long upd_size;
+    krb5_error_code retval;
+    kdb_sno_t cur_sno;
+    kdb_log_context *log_ctx;
+    kdb_hlog_t *ulog = NULL;
+    uint32_t ulogentries;
+    int ulogfd;
 
     INIT_ULOG(context);
     ulogentries = log_ctx->ulogentries;
     ulogfd = log_ctx->ulogfd;
 
     if (upd == NULL)
-        return (KRB5_LOG_ERROR);
+        return KRB5_LOG_ERROR;
 
-    (void) gettimeofday(&timestamp, NULL);
+    (void)gettimeofday(&timestamp, NULL);
     ktime.seconds = timestamp.tv_sec;
     ktime.useconds = timestamp.tv_usec;
 
     upd_size = xdr_sizeof((xdrproc_t)xdr_kdb_incr_update_t, upd);
 
-    recsize = sizeof (kdb_ent_header_t) + upd_size;
+    recsize = sizeof(kdb_ent_header_t) + upd_size;
 
     if (recsize > ulog->kdb_block) {
-        if ((retval = ulog_resize(ulog, ulogentries, ulogfd, recsize))) {
-            /* Resize element array failed */
-            return (retval);
-        }
+        retval = ulog_resize(ulog, ulogentries, ulogfd, recsize);
+        if (retval)
+            return retval;
     }
 
     cur_sno = ulog->kdb_last_sno;
 
     /*
-     * We need to overflow our sno, replicas will do full
-     * resyncs once they see their sno > than the masters.
+     * If we need to, wrap our sno around to 1.  A slaves will do a full resync
+     * since its sno will be out of range of the ulog (or in extreme cases,
+     * its timestamp won't match).
      */
     if (cur_sno == (kdb_sno_t)-1)
         cur_sno = 1;
     else
         cur_sno++;
 
-    /*
-     * We squirrel this away for finish_update() to index
-     */
+    /* Squirrel this away for finish_update() to index. */
     upd->kdb_entry_sno = cur_sno;
 
     i = (cur_sno - 1) % ulogentries;
-
     indx_log = (kdb_ent_header_t *)INDEX(ulog, i);
 
-    (void) memset(indx_log, 0, ulog->kdb_block);
-
+    memset(indx_log, 0, ulog->kdb_block);
     indx_log->kdb_umagic = KDB_ULOG_MAGIC;
     indx_log->kdb_entry_size = upd_size;
     indx_log->kdb_entry_sno = cur_sno;
@@ -231,10 +197,11 @@ ulog_add_update(krb5_context context, kdb_incr_update_t *upd)
     xdrmem_create(&xdrs, (char *)indx_log->entry_data,
                   indx_log->kdb_entry_size, XDR_ENCODE);
     if (!xdr_kdb_incr_update_t(&xdrs, upd))
-        return (KRB5_LOG_CONV);
+        return KRB5_LOG_CONV;
 
-    if ((retval = ulog_sync_update(ulog, indx_log)))
-        return (retval);
+    retval = ulog_sync_update(ulog, indx_log);
+    if (retval)
+        return retval;
 
     if (ulog->kdb_num < ulogentries)
         ulog->kdb_num++;
@@ -242,38 +209,32 @@ ulog_add_update(krb5_context context, kdb_incr_update_t *upd)
     ulog->kdb_last_sno = cur_sno;
     ulog->kdb_last_time = ktime;
 
-    /*
-     * Since this is a circular array, once we circled, kdb_first_sno is
-     * always kdb_entry_sno + 1.
-     */
     if (cur_sno > ulogentries) {
+        /* Once we've circled, kdb_first_sno is the sno of the next entry. */
         i = upd->kdb_entry_sno % ulogentries;
         indx_log = (kdb_ent_header_t *)INDEX(ulog, i);
         ulog->kdb_first_sno = indx_log->kdb_entry_sno;
         ulog->kdb_first_time = indx_log->kdb_time;
     } else if (cur_sno == 1) {
+        /* This is the first update, or we wrapped. */
         ulog->kdb_first_sno = 1;
         ulog->kdb_first_time = indx_log->kdb_time;
     }
 
     ulog_sync_header(ulog);
-
-    return (0);
+    return 0;
 }
 
-/*
- * Mark the log entry as committed and sync the memory mapped log
- * to file.
- */
+/* Mark the log entry as committed and sync the memory mapped log to file. */
 krb5_error_code
 ulog_finish_update(krb5_context context, kdb_incr_update_t *upd)
 {
-    krb5_error_code     retval;
-    kdb_ent_header_t    *indx_log;
-    uint_t              i;
-    kdb_log_context     *log_ctx;
-    kdb_hlog_t          *ulog = NULL;
-    uint32_t            ulogentries;
+    krb5_error_code retval;
+    kdb_ent_header_t *indx_log;
+    unsigned int i;
+    kdb_log_context *log_ctx;
+    kdb_hlog_t *ulog = NULL;
+    uint32_t ulogentries;
 
     INIT_ULOG(context);
     ulogentries = log_ctx->ulogentries;
@@ -281,42 +242,33 @@ ulog_finish_update(krb5_context context, kdb_incr_update_t *upd)
     i = (upd->kdb_entry_sno - 1) % ulogentries;
 
     indx_log = (kdb_ent_header_t *)INDEX(ulog, i);
-
     indx_log->kdb_commit = TRUE;
 
     ulog->kdb_state = KDB_STABLE;
 
-    if ((retval = ulog_sync_update(ulog, indx_log)))
-        return (retval);
+    retval = ulog_sync_update(ulog, indx_log);
+    if (retval)
+        return retval;
 
     ulog_sync_header(ulog);
-
-    return (0);
+    return 0;
 }
 
-/*
- * Set the header log details on the slave and sync it to file.
- */
+/* Set the header log details on the slave and sync it to file. */
 static void
 ulog_finish_update_slave(kdb_hlog_t *ulog, kdb_last_t lastentry)
 {
-
     ulog->kdb_last_sno = lastentry.last_sno;
     ulog->kdb_last_time = lastentry.last_time;
-
     ulog_sync_header(ulog);
 }
 
-/*
- * Delete an entry to the update log.
- */
+/* Delete an entry to the update log. */
 krb5_error_code
 ulog_delete_update(krb5_context context, kdb_incr_update_t *upd)
 {
-
     upd->kdb_deleted = TRUE;
-
-    return (ulog_add_update(context, upd));
+    return ulog_add_update(context, upd);
 }
 
 /*
@@ -328,15 +280,15 @@ ulog_delete_update(krb5_context context, kdb_incr_update_t *upd)
 krb5_error_code
 ulog_replay(krb5_context context, kdb_incr_result_t *incr_ret, char **db_args)
 {
-    krb5_db_entry       *entry = NULL;
-    kdb_incr_update_t   *upd = NULL, *fupd;
-    int                 i, no_of_updates;
-    krb5_error_code     retval;
-    krb5_principal      dbprinc = NULL;
-    kdb_last_t          errlast;
-    char                *dbprincstr = NULL;
-    kdb_log_context     *log_ctx;
-    kdb_hlog_t          *ulog = NULL;
+    krb5_db_entry *entry = NULL;
+    kdb_incr_update_t *upd = NULL, *fupd;
+    int i, no_of_updates;
+    krb5_error_code retval;
+    krb5_principal dbprinc;
+    kdb_last_t errlast;
+    char *dbprincstr;
+    kdb_log_context *log_ctx;
+    kdb_hlog_t *ulog = NULL;
 
     INIT_ULOG(context);
 
@@ -344,16 +296,15 @@ ulog_replay(krb5_context context, kdb_incr_result_t *incr_ret, char **db_args)
     upd = incr_ret->updates.kdb_ulog_t_val;
     fupd = upd;
 
-    /*
-     * We reset last_sno and last_time to 0, if krb5_db2_db_put_principal
-     * or krb5_db2_db_delete_principal fail.
-     */
+    /* We reset last_sno and last_time to 0, if krb5_db2_db_put_principal or
+     * krb5_db2_db_delete_principal fail. */
     errlast.last_sno = (unsigned int)0;
     errlast.last_time.seconds = (unsigned int)0;
     errlast.last_time.useconds = (unsigned int)0;
 
-    if ((retval = krb5_db_open(context, db_args,
-                               KRB5_KDB_OPEN_RW|KRB5_KDB_SRV_TYPE_ADMIN)))
+    retval = krb5_db_open(context, db_args,
+                          KRB5_KDB_OPEN_RW | KRB5_KDB_SRV_TYPE_ADMIN);
+    if (retval)
         goto cleanup;
 
     for (i = 0; i < no_of_updates; i++) {
@@ -361,54 +312,34 @@ ulog_replay(krb5_context context, kdb_incr_result_t *incr_ret, char **db_args)
             continue;
 
         if (upd->kdb_deleted) {
-            dbprincstr = malloc((upd->kdb_princ_name.utf8str_t_len
-                                 + 1) * sizeof (char));
-
-            if (dbprincstr == NULL) {
-                retval = ENOMEM;
+            dbprincstr = k5alloc(upd->kdb_princ_name.utf8str_t_len + 1,
+                                 &retval);
+            if (dbprincstr == NULL)
                 goto cleanup;
-            }
-
-            (void) strncpy(dbprincstr,
-                           (char *)upd->kdb_princ_name.utf8str_t_val,
-                           (upd->kdb_princ_name.utf8str_t_len + 1));
-            dbprincstr[upd->kdb_princ_name.utf8str_t_len] = 0;
-
-            if ((retval = krb5_parse_name(context, dbprincstr,
-                                          &dbprinc))) {
-                goto cleanup;
-            }
+            memcpy(dbprincstr, (char *)upd->kdb_princ_name.utf8str_t_val,
+                   upd->kdb_princ_name.utf8str_t_len);
+            dbprincstr[upd->kdb_princ_name.utf8str_t_len] = '\0';
 
+            retval = krb5_parse_name(context, dbprincstr, &dbprinc);
             free(dbprincstr);
+            if (retval)
+                goto cleanup;
 
             retval = krb5int_delete_principal_no_log(context, dbprinc);
-
-            if (dbprinc) {
-                krb5_free_principal(context, dbprinc);
-                dbprinc = NULL;
-            }
-
+            krb5_free_principal(context, dbprinc);
             if (retval)
                 goto cleanup;
         } else {
-            entry = (krb5_db_entry *)malloc(sizeof (krb5_db_entry));
-
-            if (!entry) {
-                retval = errno;
+            entry = k5alloc(sizeof(krb5_db_entry), &retval);
+            if (entry == NULL)
                 goto cleanup;
-            }
 
-            (void) memset(entry, 0, sizeof (krb5_db_entry));
-
-            if ((retval = ulog_conv_2dbentry(context, &entry, upd)))
+            retval = ulog_conv_2dbentry(context, &entry, upd);
+            if (retval)
                 goto cleanup;
 
             retval = krb5int_put_principal_no_log(context, entry);
-
-            if (entry) {
-                krb5_db_free_principal(context, entry);
-                entry = NULL;
-            }
+            krb5_db_free_principal(context, entry);
             if (retval)
                 goto cleanup;
         }
@@ -420,31 +351,31 @@ cleanup:
     if (fupd)
         ulog_free_entries(fupd, no_of_updates);
 
-    if (log_ctx && (log_ctx->iproprole == IPROP_SLAVE)) {
+    if (log_ctx && log_ctx->iproprole == IPROP_SLAVE) {
         if (retval)
             ulog_finish_update_slave(ulog, errlast);
         else
             ulog_finish_update_slave(ulog, incr_ret->lastentry);
     }
 
-    return (retval);
+    return retval;
 }
 
 /*
- * Validate the log file and resync any uncommitted update entries
- * to the principal database.
+ * Validate the log file and resync any uncommitted update entries to the
+ * principal database.
  *
  * Must be called with lock held.
  */
 static krb5_error_code
 ulog_check(krb5_context context, kdb_hlog_t *ulog, char **db_args)
 {
-    XDR                 xdrs;
-    krb5_error_code     retval = 0;
-    unsigned int        i;
-    kdb_ent_header_t    *indx_log;
-    kdb_incr_update_t   *upd = NULL;
-    kdb_incr_result_t   *incr_ret = NULL;
+    XDR xdrs;
+    krb5_error_code retval = 0;
+    unsigned int i;
+    kdb_ent_header_t *indx_log;
+    kdb_incr_update_t *upd = NULL;
+    kdb_incr_result_t *incr_ret = NULL;
 
     ulog->kdb_state = KDB_STABLE;
 
@@ -452,94 +383,71 @@ ulog_check(krb5_context context, kdb_hlog_t *ulog, char **db_args)
         indx_log = (kdb_ent_header_t *)INDEX(ulog, i);
 
         if (indx_log->kdb_umagic != KDB_ULOG_MAGIC) {
-            /*
-             * Update entry corrupted we should scream and die
-             */
+            /* The update entry is corrupted; we should scream and die. */
             ulog->kdb_state = KDB_CORRUPT;
             retval = KRB5_LOG_CORRUPT;
             break;
         }
 
-        if (indx_log->kdb_commit == FALSE) {
-            ulog->kdb_state = KDB_UNSTABLE;
+        if (indx_log->kdb_commit)
+            continue;
 
-            incr_ret = (kdb_incr_result_t *)
-                malloc(sizeof (kdb_incr_result_t));
-            if (incr_ret == NULL) {
-                retval = errno;
-                goto error;
-            }
+        ulog->kdb_state = KDB_UNSTABLE;
 
-            upd = (kdb_incr_update_t *)
-                malloc(sizeof (kdb_incr_update_t));
-            if (upd == NULL) {
-                retval = errno;
-                goto error;
-            }
+        incr_ret = k5alloc(sizeof(kdb_incr_result_t), &retval);
+        if (incr_ret == NULL)
+            goto error;
+        upd = k5alloc(sizeof(kdb_incr_update_t), &retval);
+        if (upd == NULL)
+            goto error;
 
-            (void) memset(upd, 0, sizeof (kdb_incr_update_t));
-            xdrmem_create(&xdrs, (char *)indx_log->entry_data,
-                          indx_log->kdb_entry_size, XDR_DECODE);
-            if (!xdr_kdb_incr_update_t(&xdrs, upd)) {
-                retval = KRB5_LOG_CONV;
-                goto error;
-            }
+        xdrmem_create(&xdrs, (char *)indx_log->entry_data,
+                      indx_log->kdb_entry_size, XDR_DECODE);
+        if (!xdr_kdb_incr_update_t(&xdrs, upd)) {
+            retval = KRB5_LOG_CONV;
+            goto error;
+        }
 
-            incr_ret->updates.kdb_ulog_t_len = 1;
-            incr_ret->updates.kdb_ulog_t_val = upd;
-
-            upd->kdb_commit = TRUE;
-
-            /*
-             * We don't want to readd this update and just use the
-             * existing update to be propagated later on
-             */
-            ulog_set_role(context, IPROP_NULL);
-            retval = ulog_replay(context, incr_ret, db_args);
-
-            /*
-             * upd was freed by ulog_replay, we NULL
-             * the pointer in case we subsequently break from loop.
-             */
-            upd = NULL;
-            if (incr_ret) {
-                free(incr_ret);
-                incr_ret = NULL;
-            }
-            ulog_set_role(context, IPROP_MASTER);
+        incr_ret->updates.kdb_ulog_t_len = 1;
+        incr_ret->updates.kdb_ulog_t_val = upd;
 
-            if (retval)
-                goto error;
-
-            /*
-             * We flag this as committed since this was
-             * the last entry before kadmind crashed, ergo
-             * the slaves have not seen this update before
-             */
-            indx_log->kdb_commit = TRUE;
-            retval = ulog_sync_update(ulog, indx_log);
-            if (retval)
-                goto error;
+        upd->kdb_commit = TRUE;
 
-            ulog->kdb_state = KDB_STABLE;
-        }
+        /* We don't want to re-add this update; just use the existing update to
+         * be propagated later on.  ulog_replay frees upd. */
+        ulog_set_role(context, IPROP_NULL);
+        retval = ulog_replay(context, incr_ret, db_args);
+        free(incr_ret);
+        incr_ret = NULL;
+        upd = NULL;
+        ulog_set_role(context, IPROP_MASTER);
+        if (retval)
+            goto error;
+
+        /*
+         * We flag this as committed since this was the last entry before
+         * kadmind crashed, ergo the slaves have not seen this update before.
+         */
+        indx_log->kdb_commit = TRUE;
+        retval = ulog_sync_update(ulog, indx_log);
+        if (retval)
+            goto error;
+
+        ulog->kdb_state = KDB_STABLE;
     }
 
 error:
     if (upd)
         ulog_free_entries(upd, 1);
-
     free(incr_ret);
-
     ulog_sync_header(ulog);
-
-    return (retval);
+    return retval;
 }
 
 static void
 ulog_reset(kdb_hlog_t *ulog)
 {
-    (void) memset(ulog, 0, sizeof (*ulog));
+    memset(ulog, 0, sizeof(*ulog));
     ulog->kdb_hmagic = KDB_ULOG_HDR_MAGIC;
     ulog->db_version_num = KDB_VERSION;
     ulog->kdb_state = KDB_STABLE;
@@ -587,44 +495,34 @@ ulog_map(krb5_context context, const char *logname, uint32_t ulogentries,
          int caller, char **db_args)
 {
     struct stat st;
-    krb5_error_code     retval;
-    uint32_t    ulog_filesize;
-    kdb_log_context     *log_ctx;
-    kdb_hlog_t  *ulog = NULL;
-    int         ulogfd = -1;
+    krb5_error_code retval;
+    uint32_t ulog_filesize;
+    kdb_log_context *log_ctx;
+    kdb_hlog_t *ulog = NULL;
+    int ulogfd = -1;
 
-    ulog_filesize = sizeof (kdb_hlog_t);
+    ulog_filesize = sizeof(kdb_hlog_t);
 
     if (stat(logname, &st) == -1) {
-
-        if (caller == FKPROPLOG) {
-            /*
-             * File doesn't exist so we exit with kproplog
-             */
-            return (errno);
-        }
+        /* File doesn't exist so we exit with kproplog. */
+        if (caller == FKPROPLOG)
+            return errno;
 
         ulogfd = open(logname, O_RDWR | O_CREAT, 0600);
-        if (ulogfd == -1) {
-            return (errno);
-        }
+        if (ulogfd == -1)
+            return errno;
 
-        if (lseek(ulogfd, 0L, SEEK_CUR) == -1) {
-            return (errno);
-        }
+        if (lseek(ulogfd, 0L, SEEK_CUR) == -1)
+            return errno;
 
-        if ((caller == FKADMIND) || (caller == FKCOMMAND))
+        if (caller == FKADMIND || caller == FKCOMMAND)
             ulog_filesize += ulogentries * ULOG_BLOCK;
 
         if (extend_file_to(ulogfd, ulog_filesize) < 0)
             return errno;
     } else {
-
         ulogfd = open(logname, O_RDWR, 0600);
         if (ulogfd == -1)
-            /*
-             * Can't open existing log file
-             */
             return errno;
     }
 
@@ -635,31 +533,29 @@ ulog_map(krb5_context context, const char *logname, uint32_t ulogentries,
         }
         ulog_filesize = st.st_size;
 
-        ulog = (kdb_hlog_t *)mmap(0, ulog_filesize,
-                                  PROT_READ+PROT_WRITE, MAP_PRIVATE, ulogfd, 0);
+        ulog = mmap(0, ulog_filesize, PROT_READ | PROT_WRITE, MAP_PRIVATE,
+                    ulogfd, 0);
     } else {
-        /*
-         * else kadmind, kpropd, & kcommands should udpate stores
-         */
-        ulog = (kdb_hlog_t *)mmap(0, MAXLOGLEN,
-                                  PROT_READ+PROT_WRITE, MAP_SHARED, ulogfd, 0);
+        /* kadmind, kpropd, & kcommands should udpate stores. */
+        ulog = mmap(0, MAXLOGLEN, PROT_READ | PROT_WRITE, MAP_SHARED,
+                    ulogfd, 0);
     }
 
     if (ulog == MAP_FAILED) {
-        /*
-         * Can't map update log file to memory
-         */
+        /* Can't map update log file to memory. */
         close(ulogfd);
-        return (errno);
+        return errno;
     }
 
     if (!context->kdblog_context) {
-        if (!(log_ctx = malloc(sizeof (kdb_log_context))))
-            return (errno);
+        log_ctx = k5alloc(sizeof(kdb_log_context), &retval);
+        if (log_ctx == NULL)
+            return retval;
         memset(log_ctx, 0, sizeof(*log_ctx));
         context->kdblog_context = log_ctx;
-    } else
+    } else {
         log_ctx = context->kdblog_context;
+    }
     log_ctx->ulog = ulog;
     log_ctx->ulogentries = ulogentries;
     log_ctx->ulogfd = ulogfd;
@@ -670,7 +566,7 @@ ulog_map(krb5_context context, const char *logname, uint32_t ulogentries,
 
     if (ulog->kdb_hmagic != KDB_ULOG_HDR_MAGIC && ulog->kdb_hmagic != 0) {
         ulog_lock(context, KRB5_LOCKMODE_UNLOCK);
-        return (KRB5_LOG_CORRUPT);
+        return KRB5_LOG_CORRUPT;
     }
 
     if (ulog->kdb_hmagic != KDB_ULOG_HDR_MAGIC || caller == FKLOAD) {
@@ -678,56 +574,47 @@ ulog_map(krb5_context context, const char *logname, uint32_t ulogentries,
         if (caller != FKPROPLOG)
             ulog_sync_header(ulog);
         ulog_lock(context, KRB5_LOCKMODE_UNLOCK);
-        return (0);
+        return 0;
     }
 
-    if ((caller == FKPROPLOG) || (caller == FKPROPD)) {
+    if (caller == FKPROPLOG || caller == FKPROPD) {
         /* kproplog and kpropd don't need to do anything else. */
         ulog_lock(context, KRB5_LOCKMODE_UNLOCK);
-        return (0);
+        return 0;
     }
 
     if (caller == FKADMIND) {
         switch (ulog->kdb_state) {
         case KDB_STABLE:
         case KDB_UNSTABLE:
-            /*
-             * Log is currently un/stable, check anyway
-             */
+            /* Log is currently un/stable, check anyway. */
             retval = ulog_check(context, ulog, db_args);
             ulog_lock(context, KRB5_LOCKMODE_UNLOCK);
             if (retval)
-                return (retval);
+                return retval;
             break;
         case KDB_CORRUPT:
             ulog_lock(context, KRB5_LOCKMODE_UNLOCK);
-            return (KRB5_LOG_CORRUPT);
+            return KRB5_LOG_CORRUPT;
         default:
-            /*
-             * Invalid db state
-             */
+            /* Invalid db state. */
             ulog_lock(context, KRB5_LOCKMODE_UNLOCK);
-            return (KRB5_LOG_ERROR);
+            return KRB5_LOG_ERROR;
         }
     }
     assert(caller == FKADMIND || caller == FKCOMMAND);
 
-    /*
-     * Reinit ulog if the log is being truncated or expanded after
-     * we have circled.
-     */
+    /* Reinit ulog if the log is being truncated or expanded after we have
+     * circled. */
     if (ulog->kdb_num != ulogentries) {
-        if ((ulog->kdb_num != 0) &&
-            ((ulog->kdb_last_sno > ulog->kdb_num) ||
-             (ulog->kdb_num > ulogentries))) {
-
+        if (ulog->kdb_num != 0 &&
+            (ulog->kdb_last_sno > ulog->kdb_num ||
+             ulog->kdb_num > ulogentries)) {
             ulog_reset(ulog);
             ulog_sync_header(ulog);
         }
 
-        /*
-         * Expand ulog if we have specified a greater size
-         */
+        /* Expand ulog if we have specified a greater size. */
         if (ulog->kdb_num < ulogentries) {
             ulog_filesize += ulogentries * ulog->kdb_block;
 
@@ -739,26 +626,23 @@ ulog_map(krb5_context context, const char *logname, uint32_t ulogentries,
     }
     ulog_lock(context, KRB5_LOCKMODE_UNLOCK);
 
-    return (0);
+    return 0;
 }
 
-/*
- * Get the last set of updates seen, (last+1) to n is returned.
- */
+/* Get the last set of updates seen, (last+1) to n is returned. */
 krb5_error_code
-ulog_get_entries(krb5_context context,          /* input - krb5 lib config */
-                 kdb_last_t last,               /* input - slave's last sno */
-                 kdb_incr_result_t *ulog_handle) /* output - incr result for slave */
+ulog_get_entries(krb5_context context, kdb_last_t last,
+                 kdb_incr_result_t *ulog_handle)
 {
-    XDR                 xdrs;
-    kdb_ent_header_t    *indx_log;
-    kdb_incr_update_t   *upd;
-    uint_t              indx, count;
-    uint32_t            sno;
-    krb5_error_code     retval;
-    kdb_log_context     *log_ctx;
-    kdb_hlog_t          *ulog = NULL;
-    uint32_t            ulogentries;
+    XDR xdrs;
+    kdb_ent_header_t *indx_log;
+    kdb_incr_update_t *upd;
+    unsigned int indx, count;
+    uint32_t sno;
+    krb5_error_code retval;
+    kdb_log_context *log_ctx;
+    kdb_hlog_t *ulog = NULL;
+    uint32_t ulogentries;
 
     INIT_ULOG(context);
     ulogentries = log_ctx->ulogentries;
@@ -767,163 +651,112 @@ ulog_get_entries(krb5_context context,          /* input - krb5 lib config */
     if (retval)
         return retval;
 
-    /*
-     * Check to make sure we don't have a corrupt ulog first.
-     */
+    /* Check to make sure we don't have a corrupt ulog first. */
     if (ulog->kdb_state == KDB_CORRUPT) {
         ulog_handle->ret = UPDATE_ERROR;
-        (void) ulog_lock(context, KRB5_LOCKMODE_UNLOCK);
-        return (KRB5_LOG_CORRUPT);
+        (void)ulog_lock(context, KRB5_LOCKMODE_UNLOCK);
+        return KRB5_LOG_CORRUPT;
     }
 
     /*
-     * We need to lock out other processes here, such as kadmin.local,
-     * since we are looking at the last_sno and looking up updates.  So
-     * we can share with other readers.
+     * We need to lock out other processes here, such as kadmin.local, since we
+     * are looking at the last_sno and looking up updates.  So we can share
+     * with other readers.
      */
     retval = krb5_db_lock(context, KRB5_LOCKMODE_SHARED);
     if (retval) {
-        (void) ulog_lock(context, KRB5_LOCKMODE_UNLOCK);
-        return (retval);
+        (void)ulog_lock(context, KRB5_LOCKMODE_UNLOCK);
+        return retval;
     }
 
-    /*
-     * We may have overflowed the update log or we shrunk the log, or
-     * the client's ulog has just been created.
-     */
-    if ((last.last_sno > ulog->kdb_last_sno) ||
-        (last.last_sno < ulog->kdb_first_sno) ||
-        (last.last_sno == 0)) {
+    /* We may have overflowed the update log or shrunk the log, or the client
+     * may have created its ulog. */
+    if (last.last_sno > ulog->kdb_last_sno ||
+        last.last_sno < ulog->kdb_first_sno || last.last_sno == 0) {
         ulog_handle->lastentry.last_sno = ulog->kdb_last_sno;
-        (void) ulog_lock(context, KRB5_LOCKMODE_UNLOCK);
-        (void) krb5_db_unlock(context);
         ulog_handle->ret = UPDATE_FULL_RESYNC_NEEDED;
-        return (0);
-    } else if (last.last_sno <= ulog->kdb_last_sno) {
-        sno = last.last_sno;
-
-        indx = (sno - 1) % ulogentries;
-
-        indx_log = (kdb_ent_header_t *)INDEX(ulog, indx);
+        goto cleanup;
+    }
 
-        /*
-         * Validate the time stamp just to make sure it was the same sno
-         */
-        if ((indx_log->kdb_time.seconds == last.last_time.seconds) &&
-            (indx_log->kdb_time.useconds == last.last_time.useconds)) {
-
-            /*
-             * If we have the same sno we return success
-             */
-            if (last.last_sno == ulog->kdb_last_sno) {
-                (void) ulog_lock(context, KRB5_LOCKMODE_UNLOCK);
-                (void) krb5_db_unlock(context);
-                ulog_handle->ret = UPDATE_NIL;
-                return (0);
-            }
+    sno = last.last_sno;
+    indx = (sno - 1) % ulogentries;
+    indx_log = (kdb_ent_header_t *)INDEX(ulog, indx);
 
-            count = ulog->kdb_last_sno - sno;
+    if (indx_log->kdb_time.seconds != last.last_time.seconds ||
+        indx_log->kdb_time.useconds != last.last_time.useconds) {
+        /* We have time stamp mismatch or we no longer have the slave's last
+         * sno, so we brute force it. */
+        ulog_handle->ret = UPDATE_FULL_RESYNC_NEEDED;
+        goto cleanup;
+    }
 
-            ulog_handle->updates.kdb_ulog_t_val =
-                (kdb_incr_update_t *)malloc(
-                    sizeof (kdb_incr_update_t) * count);
+    /* If we have the same sno we return success. */
+    if (last.last_sno == ulog->kdb_last_sno) {
+        ulog_handle->ret = UPDATE_NIL;
+        goto cleanup;
+    }
 
-            upd = ulog_handle->updates.kdb_ulog_t_val;
+    count = ulog->kdb_last_sno - sno;
+    upd = calloc(count, sizeof(kdb_incr_update_t));
+    if (upd == NULL) {
+        ulog_handle->ret = UPDATE_ERROR;
+        retval = ENOMEM;
+        goto cleanup;
+    }
+    ulog_handle->updates.kdb_ulog_t_val = upd;
 
-            if (upd == NULL) {
-                (void) ulog_lock(context, KRB5_LOCKMODE_UNLOCK);
-                (void) krb5_db_unlock(context);
-                ulog_handle->ret = UPDATE_ERROR;
-                return (errno);
-            }
+    for (; sno < ulog->kdb_last_sno; sno++) {
+        indx = sno % ulogentries;
+        indx_log = (kdb_ent_header_t *)INDEX(ulog, indx);
 
-            while (sno < ulog->kdb_last_sno) {
-                indx = sno % ulogentries;
-
-                indx_log = (kdb_ent_header_t *)
-                    INDEX(ulog, indx);
-
-                (void) memset(upd, 0,
-                              sizeof (kdb_incr_update_t));
-                xdrmem_create(&xdrs,
-                              (char *)indx_log->entry_data,
-                              indx_log->kdb_entry_size, XDR_DECODE);
-                if (!xdr_kdb_incr_update_t(&xdrs, upd)) {
-                    (void) ulog_lock(context, KRB5_LOCKMODE_UNLOCK);
-                    (void) krb5_db_unlock(context);
-                    ulog_handle->ret = UPDATE_ERROR;
-                    return (KRB5_LOG_CONV);
-                }
-                /*
-                 * Mark commitment since we didn't
-                 * want to decode and encode the
-                 * incr update record the first time.
-                 */
-                upd->kdb_commit = indx_log->kdb_commit;
-
-                upd++;
-                sno++;
-            } /* while */
-
-            ulog_handle->updates.kdb_ulog_t_len = count;
-
-            ulog_handle->lastentry.last_sno = ulog->kdb_last_sno;
-            ulog_handle->lastentry.last_time.seconds =
-                ulog->kdb_last_time.seconds;
-            ulog_handle->lastentry.last_time.useconds =
-                ulog->kdb_last_time.useconds;
-            ulog_handle->ret = UPDATE_OK;
-
-            (void) ulog_lock(context, KRB5_LOCKMODE_UNLOCK);
-            (void) krb5_db_unlock(context);
-
-            return (0);
-        } else {
-            /*
-             * We have time stamp mismatch or we no longer have
-             * the slave's last sno, so we brute force it
-             */
-            (void) ulog_lock(context, KRB5_LOCKMODE_UNLOCK);
-            (void) krb5_db_unlock(context);
-            ulog_handle->ret = UPDATE_FULL_RESYNC_NEEDED;
-
-            return (0);
+        memset(upd, 0, sizeof(kdb_incr_update_t));
+        xdrmem_create(&xdrs, (char *)indx_log->entry_data,
+                      indx_log->kdb_entry_size, XDR_DECODE);
+        if (!xdr_kdb_incr_update_t(&xdrs, upd)) {
+            ulog_handle->ret = UPDATE_ERROR;
+            retval = KRB5_LOG_CONV;
+            goto cleanup;
         }
+
+        /* Mark commitment since we didn't want to decode and encode the incr
+         * update record the first time. */
+        upd->kdb_commit = indx_log->kdb_commit;
+        upd++;
     }
 
-    /*
-     * Should never get here, return error
-     */
-    (void) ulog_lock(context, KRB5_LOCKMODE_UNLOCK);
-    ulog_handle->ret = UPDATE_ERROR;
-    return (KRB5_LOG_ERROR);
+    ulog_handle->updates.kdb_ulog_t_len = count;
+
+    ulog_handle->lastentry.last_sno = ulog->kdb_last_sno;
+    ulog_handle->lastentry.last_time.seconds = ulog->kdb_last_time.seconds;
+    ulog_handle->lastentry.last_time.useconds = ulog->kdb_last_time.useconds;
+    ulog_handle->ret = UPDATE_OK;
+
+cleanup:
+    (void)ulog_lock(context, KRB5_LOCKMODE_UNLOCK);
+    (void)krb5_db_unlock(context);
+    return retval;
 }
 
 krb5_error_code
 ulog_set_role(krb5_context ctx, iprop_role role)
 {
-    kdb_log_context     *log_ctx;
-
-    if (!ctx->kdblog_context) {
-        if (!(log_ctx = malloc(sizeof (kdb_log_context))))
-            return (errno);
-        memset(log_ctx, 0, sizeof(*log_ctx));
-        ctx->kdblog_context = log_ctx;
-    } else
-        log_ctx = ctx->kdblog_context;
-
-    log_ctx->iproprole = role;
-
-    return (0);
+    if (ctx->kdblog_context == NULL) {
+        ctx->kdblog_context = calloc(1, sizeof(*ctx->kdblog_context));
+        if (ctx->kdblog_context == NULL)
+            return ENOMEM;
+    }
+    ctx->kdblog_context->iproprole = role;
+    return 0;
 }
 
-/*
- * Extend update log file.
- */
-static int extend_file_to(int fd, uint_t new_size)
+/* Extend update log file. */
+static int
+extend_file_to(int fd, unsigned int new_size)
 {
     off_t current_offset;
-    static const char zero[512] = { 0, };
+    static const char zero[512];
+    ssize_t wrote_size;
+    size_t write_size;
 
     current_offset = lseek(fd, 0, SEEK_END);
     if (current_offset < 0)
@@ -933,7 +766,6 @@ static int extend_file_to(int fd, uint_t new_size)
         return -1;
     }
     while (current_offset < (off_t)new_size) {
-        int write_size, wrote_size;
         write_size = new_size - current_offset;
         if (write_size > 512)
             write_size = 512;
@@ -941,7 +773,7 @@ static int extend_file_to(int fd, uint_t new_size)
         if (wrote_size < 0)
             return -1;
         if (wrote_size == 0) {
-            errno = EINVAL;     /* XXX ?? */
+            errno = EINVAL;
             return -1;
         }
         current_offset += wrote_size;