krb5 commit: Modernize style of kdb_log.c
Greg Hudson
ghudson at MIT.EDU
Tue Jan 22 17:51:26 EST 2013
https://github.com/krb5/krb5/commit/4b3937182b75e08eaf8f259828b018a2b6d2c111
commit 4b3937182b75e08eaf8f259828b018a2b6d2c111
Author: Greg Hudson <ghudson at mit.edu>
Date: Tue Jan 22 01:42:31 2013 -0500
Modernize style of kdb_log.c
ulog_get_entries had an unreachable branch which was removed during
de-indentation.
src/lib/kdb/kdb_log.c | 752 +++++++++++++++++++------------------------------
1 files changed, 292 insertions(+), 460 deletions(-)
diff --git a/src/lib/kdb/kdb_log.c b/src/lib/kdb/kdb_log.c
index 4ecc340..f70d3fe 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(×tamp, NULL);
+ (void)gettimeofday(×tamp, 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;
More information about the cvs-krb5
mailing list