Assume mutex locking cannot fail

Locking and unlocking a non-recursive mutex is a simple memory
operation and should not fail on any reasonable platform with correct
usage.  A pthread mutex can return EDEADLK on lock or EPERM on unlock,
or EINVAL if the mutex is uninitialized, but all of these conditions
would reflect serious bugs in the calling code.

Change the k5_mutex_lock and k5_mutex_unlock wrappers to return void
and adjust all call sites.  Propagate this change through
k5_cc_mutex_lock and k5_cc_mutex_unlock as well.

5 files changed, 95 insertions, 277 deletions

diff --git a/src/lib/krb5/ccache/cc-int.h b/src/lib/krb5/ccache/cc-int.h
index c29fbec2e..272425e39 100644
--- a/src/lib/krb5/ccache/cc-int.h
+++ b/src/lib/krb5/ccache/cc-int.h
@@ -98,10 +98,10 @@ k5_cc_mutex_assert_locked(krb5_context context, k5_cc_mutex *m);
 void
 k5_cc_mutex_assert_unlocked(krb5_context context, k5_cc_mutex *m);
 
-krb5_error_code
+void
 k5_cc_mutex_lock(krb5_context context, k5_cc_mutex *m);
 
-krb5_error_code
+void
 k5_cc_mutex_unlock(krb5_context context, k5_cc_mutex *m);
 
 extern k5_cc_mutex krb5int_mcc_mutex;
@@ -116,10 +116,10 @@ extern krb5_error_code KRB5_CALLCONV krb5_stdccv3_context_unlock
 (krb5_context context);
 #endif
 
-krb5_error_code
+void
 k5_cc_mutex_force_unlock(k5_cc_mutex *m);
 
-krb5_error_code
+void
 k5_cccol_force_unlock(void);
 
 krb5_error_code
diff --git a/src/lib/krb5/ccache/cc_file.c b/src/lib/krb5/ccache/cc_file.c
index 24b36b835..3ba13188c 100644
--- a/src/lib/krb5/ccache/cc_file.c
+++ b/src/lib/krb5/ccache/cc_file.c
@@ -1440,9 +1440,7 @@ krb5_fcc_initialize(krb5_context context, krb5_ccache id, krb5_principal princ)
     krb5_error_code kret = 0;
     int reti = 0;
 
-    kret = k5_cc_mutex_lock(context, &((krb5_fcc_data *) id->data)->lock);
-    if (kret)
-        return kret;
+    k5_cc_mutex_lock(context, &((krb5_fcc_data *) id->data)->lock);
 
     MAYBE_OPEN(context, id, FCC_OPEN_AND_ERASE);
 
@@ -1475,12 +1473,9 @@ krb5_fcc_initialize(krb5_context context, krb5_ccache id, krb5_principal princ)
  */
 static krb5_error_code dereference(krb5_context context, krb5_fcc_data *data)
 {
-    krb5_error_code kerr;
     struct fcc_set **fccsp;
 
-    kerr = k5_cc_mutex_lock(context, &krb5int_cc_file_mutex);
-    if (kerr)
-        return kerr;
+    k5_cc_mutex_lock(context, &krb5int_cc_file_mutex);
     for (fccsp = &fccs; *fccsp != NULL; fccsp = &(*fccsp)->next)
         if ((*fccsp)->data == data)
             break;
@@ -1498,9 +1493,7 @@ static krb5_error_code dereference(krb5_context context, krb5_fcc_data *data)
         free(data->filename);
         zap(data->buf, sizeof(data->buf));
         if (data->file >= 0) {
-            kerr = k5_cc_mutex_lock(context, &data->lock);
-            if (kerr)
-                return kerr;
+            k5_cc_mutex_lock(context, &data->lock);
             krb5_fcc_close_file(context, data);
             k5_cc_mutex_unlock(context, &data->lock);
         }
@@ -1546,9 +1539,7 @@ krb5_fcc_destroy(krb5_context context, krb5_ccache id)
     unsigned int wlen;
     char zeros[BUFSIZ];
 
-    kret = k5_cc_mutex_lock(context, &data->lock);
-    if (kret)
-        return kret;
+    k5_cc_mutex_lock(context, &data->lock);
 
     if (OPENCLOSE(id)) {
         invalidate_cache(data);
@@ -1693,9 +1684,7 @@ krb5_fcc_resolve (krb5_context context, krb5_ccache *id, const char *residual)
     krb5_fcc_data *data;
     struct fcc_set *setptr;
 
-    kret = k5_cc_mutex_lock(context, &krb5int_cc_file_mutex);
-    if (kret)
-        return kret;
+    k5_cc_mutex_lock(context, &krb5int_cc_file_mutex);
     for (setptr = fccs; setptr; setptr = setptr->next) {
         if (!strcmp(setptr->data->filename, residual))
             break;
@@ -1705,11 +1694,7 @@ krb5_fcc_resolve (krb5_context context, krb5_ccache *id, const char *residual)
         assert(setptr->refcount != 0);
         setptr->refcount++;
         assert(setptr->refcount != 0);
-        kret = k5_cc_mutex_lock(context, &data->lock);
-        if (kret) {
-            k5_cc_mutex_unlock(context, &krb5int_cc_file_mutex);
-            return kret;
-        }
+        k5_cc_mutex_lock(context, &data->lock);
         k5_cc_mutex_unlock(context, &krb5int_cc_file_mutex);
     } else {
         data = malloc(sizeof(krb5_fcc_data));
@@ -1730,14 +1715,7 @@ krb5_fcc_resolve (krb5_context context, krb5_ccache *id, const char *residual)
             free(data);
             return kret;
         }
-        kret = k5_cc_mutex_lock(context, &data->lock);
-        if (kret) {
-            k5_cc_mutex_unlock(context, &krb5int_cc_file_mutex);
-            k5_cc_mutex_destroy(&data->lock);
-            free(data->filename);
-            free(data);
-            return kret;
-        }
+        k5_cc_mutex_lock(context, &data->lock);
         /* data->version,mode filled in for real later */
         data->version = data->mode = 0;
         data->flags = KRB5_TC_OPENCLOSE;
@@ -1798,9 +1776,7 @@ krb5_fcc_start_seq_get(krb5_context context, krb5_ccache id,
     krb5_error_code kret = KRB5_OK;
     krb5_fcc_data *data = (krb5_fcc_data *)id->data;
 
-    kret = k5_cc_mutex_lock(context, &data->lock);
-    if (kret)
-        return kret;
+    k5_cc_mutex_lock(context, &data->lock);
 
     fcursor = (krb5_fcc_cursor *) malloc(sizeof(krb5_fcc_cursor));
     if (fcursor == NULL) {
@@ -1869,9 +1845,7 @@ krb5_fcc_next_cred(krb5_context context, krb5_ccache id, krb5_cc_cursor *cursor,
     krb5_octet octet;
     krb5_fcc_data *d = (krb5_fcc_data *) id->data;
 
-    kret = k5_cc_mutex_lock(context, &d->lock);
-    if (kret)
-        return kret;
+    k5_cc_mutex_lock(context, &d->lock);
 
     memset(creds, 0, sizeof(*creds));
     MAYBE_OPEN(context, id, FCC_OPEN_RDONLY);
@@ -1960,9 +1934,7 @@ krb5int_fcc_new_unique(krb5_context context, char *template, krb5_ccache *id)
     struct fcc_set *setptr;
 
     /* Set master lock */
-    kret = k5_cc_mutex_lock(context, &krb5int_cc_file_mutex);
-    if (kret)
-        return kret;
+    k5_cc_mutex_lock(context, &krb5int_cc_file_mutex);
 
     ret = mkstemp(template);
     if (ret == -1) {
@@ -1998,16 +1970,7 @@ krb5int_fcc_new_unique(krb5_context context, char *template, krb5_ccache *id)
         unlink(template);
         return kret;
     }
-    kret = k5_cc_mutex_lock(context, &data->lock);
-    if (kret) {
-        k5_cc_mutex_unlock(context, &krb5int_cc_file_mutex);
-        k5_cc_mutex_destroy(&data->lock);
-        free(data->filename);
-        free(data);
-        close(ret);
-        unlink(template);
-        return kret;
-    }
+    k5_cc_mutex_lock(context, &data->lock);
 
     /*
      * The file is initially closed at the end of this call...
@@ -2156,9 +2119,7 @@ krb5_fcc_get_principal(krb5_context context, krb5_ccache id, krb5_principal *pri
 {
     krb5_error_code kret = KRB5_OK;
 
-    kret = k5_cc_mutex_lock(context, &((krb5_fcc_data *) id->data)->lock);
-    if (kret)
-        return kret;
+    k5_cc_mutex_lock(context, &((krb5_fcc_data *) id->data)->lock);
 
     MAYBE_OPEN(context, id, FCC_OPEN_RDONLY);
 
@@ -2199,9 +2160,7 @@ krb5_fcc_store(krb5_context context, krb5_ccache id, krb5_creds *creds)
 #define TCHECK(ret) if (ret != KRB5_OK) goto lose;
     krb5_error_code ret;
 
-    ret = k5_cc_mutex_lock(context, &((krb5_fcc_data *) id->data)->lock);
-    if (ret)
-        return ret;
+    k5_cc_mutex_lock(context, &((krb5_fcc_data *) id->data)->lock);
 
     /* Make sure we are writing to the end of the file */
     MAYBE_OPEN(context, id, FCC_OPEN_RDWR);
@@ -2272,9 +2231,7 @@ krb5_fcc_set_flags(krb5_context context, krb5_ccache id, krb5_flags flags)
 {
     krb5_error_code ret = KRB5_OK;
 
-    ret = k5_cc_mutex_lock(context, &((krb5_fcc_data *) id->data)->lock);
-    if (ret)
-        return ret;
+    k5_cc_mutex_lock(context, &((krb5_fcc_data *) id->data)->lock);
 
     /* XXX This should check for illegal combinations, if any.. */
     if (flags & KRB5_TC_OPENCLOSE) {
@@ -2308,14 +2265,10 @@ krb5_fcc_set_flags(krb5_context context, krb5_ccache id, krb5_flags flags)
 static krb5_error_code KRB5_CALLCONV
 krb5_fcc_get_flags(krb5_context context, krb5_ccache id, krb5_flags *flags)
 {
-    krb5_error_code ret = KRB5_OK;
-
-    ret = k5_cc_mutex_lock(context, &((krb5_fcc_data *) id->data)->lock);
-    if (ret)
-        return ret;
+    k5_cc_mutex_lock(context, &((krb5_fcc_data *) id->data)->lock);
     *flags = ((krb5_fcc_data *) id->data)->flags;
     k5_cc_mutex_unlock(context, &((krb5_fcc_data *) id->data)->lock);
-    return ret;
+    return 0;
 }
 
 static krb5_error_code KRB5_CALLCONV
@@ -2415,19 +2368,17 @@ krb5_fcc_last_change_time(krb5_context context, krb5_ccache id,
 static krb5_error_code KRB5_CALLCONV
 krb5_fcc_lock(krb5_context context, krb5_ccache id)
 {
-    krb5_error_code ret = 0;
     krb5_fcc_data *data = (krb5_fcc_data *) id->data;
-    ret = k5_cc_mutex_lock(context, &data->lock);
-    return ret;
+    k5_cc_mutex_lock(context, &data->lock);
+    return 0;
 }
 
 static krb5_error_code KRB5_CALLCONV
 krb5_fcc_unlock(krb5_context context, krb5_ccache id)
 {
-    krb5_error_code ret = 0;
     krb5_fcc_data *data = (krb5_fcc_data *) id->data;
-    ret = k5_cc_mutex_unlock(context, &data->lock);
-    return ret;
+    k5_cc_mutex_unlock(context, &data->lock);
+    return 0;
 }
 
 static krb5_error_code
@@ -2441,10 +2392,7 @@ krb5_fcc_data_last_change_time(krb5_context context, krb5_fcc_data *data,
 
     *change_time = 0;
 
-    kret = k5_cc_mutex_lock(context, &data->lock);
-    if (kret) {
-        return kret;
-    }
+    k5_cc_mutex_lock(context, &data->lock);
 
     ret = stat(data->filename, &buf);
     if (ret == -1) {
diff --git a/src/lib/krb5/ccache/cc_keyring.c b/src/lib/krb5/ccache/cc_keyring.c
index 20b275c41..bbe2a2e6d 100644
--- a/src/lib/krb5/ccache/cc_keyring.c
+++ b/src/lib/krb5/ccache/cc_keyring.c
@@ -392,9 +392,7 @@ krb5_krcc_initialize(krb5_context context, krb5_ccache id,
 
     DEBUG_PRINT(("krb5_krcc_initialize: entered\n"));
 
-    kret = k5_cc_mutex_lock(context, &((krb5_krcc_data *) id->data)->lock);
-    if (kret)
-        return kret;
+    k5_cc_mutex_lock(context, &((krb5_krcc_data *) id->data)->lock);
 
     kret = krb5_krcc_clearcache(context, id);
     if (kret != KRB5_OK)
@@ -484,7 +482,7 @@ krb5_krcc_clearcache(krb5_context context, krb5_ccache id)
 static krb5_error_code KRB5_CALLCONV
 krb5_krcc_destroy(krb5_context context, krb5_ccache id)
 {
-    krb5_error_code kret;
+    krb5_error_code kret = 0;
     krb5_krcc_data *d;
     int     res;
 
@@ -492,9 +490,7 @@ krb5_krcc_destroy(krb5_context context, krb5_ccache id)
 
     d = (krb5_krcc_data *) id->data;
 
-    kret = k5_cc_mutex_lock(context, &d->lock);
-    if (kret)
-        return kret;
+    k5_cc_mutex_lock(context, &d->lock);
 
     krb5_krcc_clearcache(context, id);
     free(d->name);
@@ -513,7 +509,7 @@ cleanup:
 
     krb5_change_cache();
 
-    return KRB5_OK;
+    return kret;
 }
 
 
@@ -653,7 +649,6 @@ krb5_krcc_start_seq_get(krb5_context context, krb5_ccache id,
                         krb5_cc_cursor * cursor)
 {
     krb5_krcc_cursor krcursor;
-    krb5_error_code kret;
     krb5_krcc_data *d;
     unsigned int size;
     int     res;
@@ -661,9 +656,7 @@ krb5_krcc_start_seq_get(krb5_context context, krb5_ccache id,
     DEBUG_PRINT(("krb5_krcc_start_seq_get: entered\n"));
 
     d = id->data;
-    kret = k5_cc_mutex_lock(context, &d->lock);
-    if (kret)
-        return kret;
+    k5_cc_mutex_lock(context, &d->lock);
 
     /*
      * Determine how many keys currently exist and update numkeys.
@@ -862,11 +855,7 @@ krb5_krcc_generate_new(krb5_context context, krb5_ccache * id)
 
     lid->ops = &krb5_krcc_ops;
 
-    kret = k5_cc_mutex_lock(context, &krb5int_krcc_mutex);
-    if (kret) {
-        free(lid);
-        return kret;
-    }
+    k5_cc_mutex_lock(context, &krb5int_krcc_mutex);
 
 /* XXX These values are platform-specific and should not be here! */
 /* XXX There is a bug in FC5 where these are not included in errno.h  */
@@ -1028,9 +1017,7 @@ krb5_krcc_store(krb5_context context, krb5_ccache id, krb5_creds * creds)
 
     DEBUG_PRINT(("krb5_krcc_store: entered\n"));
 
-    kret = k5_cc_mutex_lock(context, &d->lock);
-    if (kret)
-        return kret;
+    k5_cc_mutex_lock(context, &d->lock);
 
     /* Get the service principal name and use it as the key name */
     kret = krb5_unparse_name(context, creds->server, &keyname);
@@ -1073,36 +1060,30 @@ static krb5_error_code KRB5_CALLCONV
 krb5_krcc_last_change_time(krb5_context context, krb5_ccache id,
                            krb5_timestamp *change_time)
 {
-    krb5_error_code ret = 0;
     krb5_krcc_data *data = (krb5_krcc_data *) id->data;
 
-    *change_time = 0;
-
-    ret = k5_cc_mutex_lock(context, &data->lock);
-    if (!ret) {
-        *change_time = data->changetime;
-        k5_cc_mutex_unlock(context, &data->lock);
-    }
-
-    return ret;
+    k5_cc_mutex_lock(context, &data->lock);
+    *change_time = data->changetime;
+    k5_cc_mutex_unlock(context, &data->lock);
+    return 0;
 }
 
 static krb5_error_code KRB5_CALLCONV
 krb5_krcc_lock(krb5_context context, krb5_ccache id)
 {
-    krb5_error_code ret = 0;
     krb5_krcc_data *data = (krb5_krcc_data *) id->data;
-    ret = k5_cc_mutex_lock(context, &data->lock);
-    return ret;
+
+    k5_cc_mutex_lock(context, &data->lock);
+    return 0;
 }
 
 static krb5_error_code KRB5_CALLCONV
 krb5_krcc_unlock(krb5_context context, krb5_ccache id)
 {
-    krb5_error_code ret = 0;
     krb5_krcc_data *data = (krb5_krcc_data *) id->data;
-    ret = k5_cc_mutex_unlock(context, &data->lock);
-    return ret;
+
+    k5_cc_mutex_unlock(context, &data->lock);
+    return 0;
 }
 
 
@@ -1172,9 +1153,7 @@ krb5_krcc_retrieve_principal(krb5_context context, krb5_ccache id,
     int     psize;
     krb5_krcc_bc bc;
 
-    kret = k5_cc_mutex_lock(context, &d->lock);
-    if (kret)
-        return kret;
+    k5_cc_mutex_lock(context, &d->lock);
 
     if (!d->princ_id) {
         princ = 0L;
diff --git a/src/lib/krb5/ccache/cc_memory.c b/src/lib/krb5/ccache/cc_memory.c
index b774251a1..e1cc638f8 100644
--- a/src/lib/krb5/ccache/cc_memory.c
+++ b/src/lib/krb5/ccache/cc_memory.c
@@ -153,9 +153,7 @@ krb5_mcc_initialize(krb5_context context, krb5_ccache id, krb5_principal princ)
     krb5_mcc_data *d;
 
     d = (krb5_mcc_data *)id->data;
-    ret = k5_cc_mutex_lock(context, &d->lock);
-    if (ret)
-        return ret;
+    k5_cc_mutex_lock(context, &d->lock);
 
     krb5_mcc_free(context, id);
 
@@ -220,11 +218,8 @@ krb5_mcc_destroy(krb5_context context, krb5_ccache id)
 {
     krb5_mcc_list_node **curr, *node;
     krb5_mcc_data *d;
-    krb5_error_code err;
 
-    err = k5_cc_mutex_lock(context, &krb5int_mcc_mutex);
-    if (err)
-        return err;
+    k5_cc_mutex_lock(context, &krb5int_mcc_mutex);
 
     d = (krb5_mcc_data *)id->data;
     for (curr = &mcc_head; *curr; curr = &(*curr)->next) {
@@ -237,9 +232,7 @@ krb5_mcc_destroy(krb5_context context, krb5_ccache id)
     }
     k5_cc_mutex_unlock(context, &krb5int_mcc_mutex);
 
-    err = k5_cc_mutex_lock(context, &d->lock);
-    if (err)
-        return err;
+    k5_cc_mutex_lock(context, &d->lock);
 
     krb5_mcc_free(context, id);
     free(d->name);
@@ -282,9 +275,7 @@ krb5_mcc_resolve (krb5_context context, krb5_ccache *id, const char *residual)
     krb5_error_code err;
     krb5_mcc_data *d;
 
-    err = k5_cc_mutex_lock(context, &krb5int_mcc_mutex);
-    if (err)
-        return err;
+    k5_cc_mutex_lock(context, &krb5int_mcc_mutex);
     for (ptr = mcc_head; ptr; ptr=ptr->next)
         if (!strcmp(ptr->cache->name, residual))
             break;
@@ -336,13 +327,10 @@ krb5_mcc_start_seq_get(krb5_context context, krb5_ccache id,
                        krb5_cc_cursor *cursor)
 {
     krb5_mcc_cursor mcursor;
-    krb5_error_code err;
     krb5_mcc_data *d;
 
     d = id->data;
-    err = k5_cc_mutex_lock(context, &d->lock);
-    if (err)
-        return err;
+    k5_cc_mutex_lock(context, &d->lock);
     mcursor = d->link;
     k5_cc_mutex_unlock(context, &d->lock);
     *cursor = (krb5_cc_cursor) mcursor;
@@ -491,11 +479,7 @@ krb5_mcc_generate_new (krb5_context context, krb5_ccache *id)
 
     lid->ops = &krb5_mcc_ops;
 
-    err = k5_cc_mutex_lock(context, &krb5int_mcc_mutex);
-    if (err) {
-        free(lid);
-        return err;
-    }
+    k5_cc_mutex_lock(context, &krb5int_mcc_mutex);
 
     /* Check for uniqueness with mutex locked to avoid race conditions */
     while (1) {
@@ -674,9 +658,7 @@ krb5_mcc_store(krb5_context ctx, krb5_ccache id, krb5_creds *creds)
     err = krb5_copy_creds(ctx, creds, &new_node->creds);
     if (err)
         goto cleanup;
-    err = k5_cc_mutex_lock(ctx, &mptr->lock);
-    if (err)
-        goto cleanup;
+    k5_cc_mutex_lock(ctx, &mptr->lock);
     new_node->next = mptr->link;
     mptr->link = new_node;
     update_mcc_change_time(mptr);
@@ -692,7 +674,6 @@ krb5_mcc_ptcursor_new(
     krb5_context context,
     krb5_cc_ptcursor *cursor)
 {
-    krb5_error_code ret = 0;
     krb5_cc_ptcursor n = NULL;
     struct krb5_mcc_ptcursor_data *cdata = NULL;
 
@@ -704,24 +685,15 @@ krb5_mcc_ptcursor_new(
     n->ops = &krb5_mcc_ops;
     cdata = malloc(sizeof(struct krb5_mcc_ptcursor_data));
     if (cdata == NULL) {
-        ret = ENOMEM;
-        goto errout;
+        free(n);
+        return ENOMEM;
     }
     n->data = cdata;
-    ret = k5_cc_mutex_lock(context, &krb5int_mcc_mutex);
-    if (ret)
-        goto errout;
+    k5_cc_mutex_lock(context, &krb5int_mcc_mutex);
     cdata->cur = mcc_head;
-    ret = k5_cc_mutex_unlock(context, &krb5int_mcc_mutex);
-    if (ret)
-        goto errout;
-
-errout:
-    if (ret) {
-        krb5_mcc_ptcursor_free(context, &n);
-    }
+    k5_cc_mutex_unlock(context, &krb5int_mcc_mutex);
     *cursor = n;
-    return ret;
+    return 0;
 }
 
 static krb5_error_code KRB5_CALLCONV
@@ -730,7 +702,6 @@ krb5_mcc_ptcursor_next(
     krb5_cc_ptcursor cursor,
     krb5_ccache *ccache)
 {
-    krb5_error_code ret = 0;
     struct krb5_mcc_ptcursor_data *cdata = NULL;
 
     *ccache = NULL;
@@ -744,19 +715,10 @@ krb5_mcc_ptcursor_next(
 
     (*ccache)->ops = &krb5_mcc_ops;
     (*ccache)->data = cdata->cur->cache;
-    ret = k5_cc_mutex_lock(context, &krb5int_mcc_mutex);
-    if (ret)
-        goto errout;
+    k5_cc_mutex_lock(context, &krb5int_mcc_mutex);
     cdata->cur = cdata->cur->next;
-    ret = k5_cc_mutex_unlock(context, &krb5int_mcc_mutex);
-    if (ret)
-        goto errout;
-errout:
-    if (ret && *ccache != NULL) {
-        free(*ccache);
-        *ccache = NULL;
-    }
-    return ret;
+    k5_cc_mutex_unlock(context, &krb5int_mcc_mutex);
+    return 0;
 }
 
 static krb5_error_code KRB5_CALLCONV
@@ -779,18 +741,12 @@ krb5_mcc_last_change_time(
     krb5_ccache id,
     krb5_timestamp *change_time)
 {
-    krb5_error_code ret = 0;
     krb5_mcc_data *data = (krb5_mcc_data *) id->data;
 
-    *change_time = 0;
-
-    ret = k5_cc_mutex_lock(context, &data->lock);
-    if (!ret) {
-        *change_time = data->changetime;
-        k5_cc_mutex_unlock(context, &data->lock);
-    }
-
-    return ret;
+    k5_cc_mutex_lock(context, &data->lock);
+    *change_time = data->changetime;
+    k5_cc_mutex_unlock(context, &data->lock);
+    return 0;
 }
 
 /*
@@ -809,19 +765,19 @@ update_mcc_change_time(krb5_mcc_data *d)
 static krb5_error_code KRB5_CALLCONV
 krb5_mcc_lock(krb5_context context, krb5_ccache id)
 {
-    krb5_error_code ret = 0;
     krb5_mcc_data *data = (krb5_mcc_data *) id->data;
-    ret = k5_cc_mutex_lock(context, &data->lock);
-    return ret;
+
+    k5_cc_mutex_lock(context, &data->lock);
+    return 0;
 }
 
 static krb5_error_code KRB5_CALLCONV
 krb5_mcc_unlock(krb5_context context, krb5_ccache id)
 {
-    krb5_error_code ret = 0;
     krb5_mcc_data *data = (krb5_mcc_data *) id->data;
-    ret = k5_cc_mutex_unlock(context, &data->lock);
-    return ret;
+
+    k5_cc_mutex_unlock(context, &data->lock);
+    return 0;
 }
 
 const krb5_cc_ops krb5_mcc_ops = {
diff --git a/src/lib/krb5/ccache/ccbase.c b/src/lib/krb5/ccache/ccbase.c
index 370c9439b..191a97a0d 100644
--- a/src/lib/krb5/ccache/ccbase.c
+++ b/src/lib/krb5/ccache/ccbase.c
@@ -151,11 +151,8 @@ krb5_cc_register(krb5_context context, const krb5_cc_ops *ops,
                  krb5_boolean override)
 {
     struct krb5_cc_typelist *t;
-    krb5_error_code err;
 
-    err = k5_mutex_lock(&cc_typelist_lock);
-    if (err)
-        return err;
+    k5_mutex_lock(&cc_typelist_lock);
     for (t = cc_typehead;t && strcmp(t->ops->prefix,ops->prefix);t = t->next)
         ;
     if (t) {
@@ -254,13 +251,9 @@ krb5int_cc_getops(krb5_context context,
                   const char *pfx,
                   const krb5_cc_ops **ops)
 {
-    krb5_error_code err;
     struct krb5_cc_typelist *tlist;
 
-    err = k5_mutex_lock(&cc_typelist_lock);
-    if (err)
-        return err;
-
+    k5_mutex_lock(&cc_typelist_lock);
     for (tlist = cc_typehead; tlist; tlist = tlist->next) {
         if (strcmp (tlist->ops->prefix, pfx) == 0) {
             *ops = tlist->ops;
@@ -312,7 +305,6 @@ krb5_cc_new_unique(
 krb5_error_code
 krb5int_cc_typecursor_new(krb5_context context, krb5_cc_typecursor *t)
 {
-    krb5_error_code err = 0;
     krb5_cc_typecursor n = NULL;
 
     *t = NULL;
@@ -320,19 +312,11 @@ krb5int_cc_typecursor_new(krb5_context context, krb5_cc_typecursor *t)
     if (n == NULL)
         return ENOMEM;
 
-    err = k5_mutex_lock(&cc_typelist_lock);
-    if (err)
-        goto errout;
+    k5_mutex_lock(&cc_typelist_lock);
     n->tptr = cc_typehead;
-    err = k5_mutex_unlock(&cc_typelist_lock);
-    if (err)
-        goto errout;
-
+    k5_mutex_unlock(&cc_typelist_lock);
     *t = n;
-errout:
-    if (err)
-        free(n);
-    return err;
+    return 0;
 }
 
 krb5_error_code
@@ -340,23 +324,15 @@ krb5int_cc_typecursor_next(krb5_context context,
                            krb5_cc_typecursor t,
                            const krb5_cc_ops **ops)
 {
-    krb5_error_code err = 0;
-
     *ops = NULL;
     if (t->tptr == NULL)
         return 0;
 
-    err = k5_mutex_lock(&cc_typelist_lock);
-    if (err)
-        goto errout;
+    k5_mutex_lock(&cc_typelist_lock);
     *ops = t->tptr->ops;
     t->tptr = t->tptr->next;
-    err = k5_mutex_unlock(&cc_typelist_lock);
-    if (err)
-        goto errout;
-
-errout:
-    return err;
+    k5_mutex_unlock(&cc_typelist_lock);
+    return 0;
 }
 
 krb5_error_code
@@ -470,15 +446,13 @@ k5_cc_mutex_assert_unlocked(krb5_context context, k5_cc_mutex *m)
     k5_assert_unlocked(&m->lock);
 }
 
-krb5_error_code
+void
 k5_cc_mutex_lock(krb5_context context, k5_cc_mutex *m)
 {
-    krb5_error_code ret = 0;
-
     /* not locked or already locked by another context */
     if (m->owner != context) {
         /* acquire lock, blocking until available */
-        ret = k5_mutex_lock(&m->lock);
+        k5_mutex_lock(&m->lock);
         m->owner = context;
         m->refcount = 1;
     }
@@ -486,17 +460,14 @@ k5_cc_mutex_lock(krb5_context context, k5_cc_mutex *m)
     else {
         m->refcount++;
     }
-    return ret;
 }
 
-krb5_error_code
+void
 k5_cc_mutex_unlock(krb5_context context, k5_cc_mutex *m)
 {
-    krb5_error_code ret = 0;
-
     /* verify owner and sanity check refcount */
     if ((m->owner != context) || (m->refcount < 1)) {
-        return ret;
+        return;
     }
     /* decrement & unlock when count reaches zero */
     m->refcount--;
@@ -504,21 +475,17 @@ k5_cc_mutex_unlock(krb5_context context, k5_cc_mutex *m)
         m->owner = NULL;
         k5_mutex_unlock(&m->lock);
     }
-    return ret;
 }
 
 /* necessary to make reentrant locks play nice with krb5int_cc_finalize */
-krb5_error_code
+void
 k5_cc_mutex_force_unlock(k5_cc_mutex *m)
 {
-    krb5_error_code ret = 0;
-
     m->refcount = 0;
     m->owner = NULL;
     if (m->refcount > 0) {
         k5_mutex_unlock(&m->lock);
     }
-    return ret;
 }
 
 /*
@@ -530,34 +497,16 @@ krb5_cccol_lock(krb5_context context)
 {
     krb5_error_code ret = 0;
 
-    ret = k5_cc_mutex_lock(context, &cccol_lock);
-    if (ret) {
-        return ret;
-    }
-    ret = k5_mutex_lock(&cc_typelist_lock);
-    if (ret) {
-        k5_cc_mutex_unlock(context, &cccol_lock);
-        return ret;
-    }
-    ret = k5_cc_mutex_lock(context, &krb5int_cc_file_mutex);
-    if (ret) {
-        k5_mutex_unlock(&cc_typelist_lock);
-        k5_cc_mutex_unlock(context, &cccol_lock);
-        return ret;
-    }
-    ret = k5_cc_mutex_lock(context, &krb5int_mcc_mutex);
-    if (ret) {
-        k5_cc_mutex_unlock(context, &krb5int_cc_file_mutex);
-        k5_mutex_unlock(&cc_typelist_lock);
-        k5_cc_mutex_unlock(context, &cccol_lock);
-        return ret;
-    }
+    k5_cc_mutex_lock(context, &cccol_lock);
+    k5_mutex_lock(&cc_typelist_lock);
+    k5_cc_mutex_lock(context, &krb5int_cc_file_mutex);
+    k5_cc_mutex_lock(context, &krb5int_mcc_mutex);
+#ifdef USE_KEYRING_CCACHE
+    k5_cc_mutex_lock(context, &krb5int_krcc_mutex);
+#endif
 #ifdef USE_CCAPI_V3
     ret = krb5_stdccv3_context_lock(context);
 #endif
-#ifdef USE_KEYRING_CCACHE
-    ret = k5_cc_mutex_lock(context, &krb5int_krcc_mutex);
-#endif
     if (ret) {
         k5_cc_mutex_unlock(context, &krb5int_mcc_mutex);
         k5_cc_mutex_unlock(context, &krb5int_cc_file_mutex);
@@ -577,20 +526,16 @@ krb5_cccol_unlock(krb5_context context)
     /* sanity check */
     k5_cc_mutex_assert_locked(context, &cccol_lock);
 
-    ret = k5_mutex_lock(&cc_typelist_lock);
-    if (ret) {
-        k5_cc_mutex_unlock(context, &cccol_lock);
-        return ret;
-    }
+    k5_mutex_lock(&cc_typelist_lock);
 
     /* unlock each type in the opposite order */
+#ifdef USE_CCAPI_V3
+    krb5_stdccv3_context_unlock(context);
+#endif
 #ifdef USE_KEYRING_CCACHE
     k5_cc_mutex_assert_locked(context, &krb5int_krcc_mutex);
     k5_cc_mutex_unlock(context, &krb5int_krcc_mutex);
 #endif
-#ifdef USE_CCAPI_V3
-    krb5_stdccv3_context_unlock(context);
-#endif
     k5_cc_mutex_assert_locked(context, &krb5int_mcc_mutex);
     k5_cc_mutex_unlock(context, &krb5int_mcc_mutex);
     k5_cc_mutex_assert_locked(context, &krb5int_cc_file_mutex);
@@ -604,23 +549,15 @@ krb5_cccol_unlock(krb5_context context)
 }
 
 /* necessary to make reentrant locks play nice with krb5int_cc_finalize */
-krb5_error_code
+void
 k5_cccol_force_unlock()
 {
-    krb5_error_code ret = 0;
-
     /* sanity check */
     if ((&cccol_lock)->refcount == 0) {
-        return 0;
+        return;
     }
 
-    ret = k5_mutex_lock(&cc_typelist_lock);
-    if (ret) {
-        (&cccol_lock)->refcount = 0;
-        (&cccol_lock)->owner = NULL;
-        k5_mutex_unlock(&(&cccol_lock)->lock);
-        return ret;
-    }
+    k5_mutex_lock(&cc_typelist_lock);
 
     /* unlock each type in the opposite order */
 #ifdef USE_KEYRING_CCACHE
@@ -634,6 +571,4 @@ k5_cccol_force_unlock()
 
     k5_mutex_unlock(&cc_typelist_lock);
     k5_cc_mutex_force_unlock(&cccol_lock);
-
-    return ret;
 }