From 4b3937182b75e08eaf8f259828b018a2b6d2c111 Mon Sep 17 00:00:00 2001 From: Greg Hudson Date: Tue, 22 Jan 2013 01:42:31 -0500 Subject: 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 file changed, 292 insertions(+), 460 deletions(-) (limited to 'src/lib') 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 #include #include @@ -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; -- cgit