#define k5_mutex_destroy(M) \
(k5_os_mutex_destroy(M))
-#if __GNUC__ >= 4
-static int k5_mutex_lock(k5_mutex_t *)
- __attribute__((warn_unused_result));
-#endif
-static inline int k5_mutex_lock(k5_mutex_t *m)
+static inline void k5_mutex_lock(k5_mutex_t *m)
{
- return k5_os_mutex_lock(m);
+ int r = k5_os_mutex_lock(m);
+ assert(r == 0);
}
-#define k5_mutex_unlock(M) \
- (k5_os_mutex_unlock(M))
+static inline void k5_mutex_unlock(k5_mutex_t *m)
+{
+ int r = k5_os_mutex_unlock(m);
+ assert(r == 0);
+}
#define k5_mutex_assert_locked(M) ((void)(M))
#define k5_mutex_assert_unlocked(M) ((void)(M))
extern int KRB5_CALLCONV krb5int_mutex_alloc (k5_mutex_t **);
extern void KRB5_CALLCONV krb5int_mutex_free (k5_mutex_t *);
-extern int KRB5_CALLCONV krb5int_mutex_lock (k5_mutex_t *)
-#if __GNUC__ >= 4
- __attribute__((warn_unused_result))
-#endif
- ;
-extern int KRB5_CALLCONV krb5int_mutex_unlock (k5_mutex_t *);
+extern void KRB5_CALLCONV krb5int_mutex_lock (k5_mutex_t *);
+extern void KRB5_CALLCONV krb5int_mutex_unlock (k5_mutex_t *);
/* In time, many of the definitions above should move into the support
library, and this file should be greatly simplified. For type
ret = krb5int_crypto_init();
if (ret)
return ret;
- ret = k5_mutex_lock(&fortuna_lock);
- if (ret)
- return ret;
+ k5_mutex_lock(&fortuna_lock);
if (randsource == KRB5_C_RANDSOURCE_OSRAND ||
randsource == KRB5_C_RANDSOURCE_TRUSTEDPARTY) {
/* These sources contain enough entropy that we should use them
krb5_error_code KRB5_CALLCONV
krb5_c_random_make_octets(krb5_context context, krb5_data *outdata)
{
- krb5_error_code ret;
#ifdef _WIN32
DWORD pid = GetCurrentProcessId();
#else
#endif
unsigned char pidbuf[4];
- ret = k5_mutex_lock(&fortuna_lock);
- if (ret)
- return ret;
+ k5_mutex_lock(&fortuna_lock);
if (!have_entropy) {
k5_mutex_unlock(&fortuna_lock);
me.code = minor;
me.mech = *oid;
- err = k5_mutex_lock(&mutex);
- if (err) {
-#ifdef DEBUG
- if (f != stderr) fclose(f);
-#endif
- return 0;
- }
+ k5_mutex_lock(&mutex);
/* Is this status+oid already mapped? */
p = mecherrmap_findright(&m, me);
OM_uint32 *mech_minor)
{
const struct mecherror *p;
- int err;
if (minor == 0) {
return EINVAL;
}
- err = k5_mutex_lock(&mutex);
- if (err)
- return err;
+ k5_mutex_lock(&mutex);
p = mecherrmap_findleft(&m, minor);
k5_mutex_unlock(&mutex);
if (!p) {
return GSS_S_FAILURE;
}
- err = k5_mutex_lock(&gssint_krb5_keytab_lock);
- if (err) {
- free(new);
- return GSS_S_FAILURE;
- }
+ k5_mutex_lock(&gssint_krb5_keytab_lock);
old = krb5_gss_keytab;
krb5_gss_keytab = new;
k5_mutex_unlock(&gssint_krb5_keytab_lock);
if (req_keytab != NULL) {
code = krb5_kt_dup(context, req_keytab, &kt);
} else {
- code = k5_mutex_lock(&gssint_krb5_keytab_lock);
- if (code) {
- *minor_status = code;
- return GSS_S_FAILURE;
- }
+ k5_mutex_lock(&gssint_krb5_keytab_lock);
if (krb5_gss_keytab != NULL) {
code = krb5_kt_resolve(context, krb5_gss_keytab, &kt);
k5_mutex_unlock(&gssint_krb5_keytab_lock);
/* cred handle will have been validated by gssspi_set_cred_option() */
k5creds = (krb5_gss_cred_id_t) *cred_handle;
- code = k5_mutex_lock(&k5creds->lock);
- if (code) {
- *minor_status = code;
- return GSS_S_FAILURE;
- }
+ k5_mutex_lock(&k5creds->lock);
if (k5creds->usage == GSS_C_ACCEPT) {
k5_mutex_unlock(&k5creds->lock);
*minor_status = (OM_uint32) G_BAD_USAGE;
if (err)
return err;
#ifndef _WIN32
- err = k5_mutex_lock(&kg_kdc_flag_mutex);
- if (err)
- return err;
+ k5_mutex_lock(&kg_kdc_flag_mutex);
is_kdc = kdc_flag;
k5_mutex_unlock(&kg_kdc_flag_mutex);
err = gss_krb5int_initialize_library();
if (err)
return err;
- *minor_status = k5_mutex_lock(&kg_kdc_flag_mutex);
- if (*minor_status) {
- return GSS_S_FAILURE;
- }
+ k5_mutex_lock(&kg_kdc_flag_mutex);
kdc_flag = 1;
k5_mutex_unlock(&kg_kdc_flag_mutex);
return GSS_S_COMPLETE;
{
krb5_error_code code;
- code = k5_mutex_lock(&src->lock);
- if (code != 0)
- return code;
-
+ k5_mutex_lock(&src->lock);
code = kg_init_name(context, src->princ, src->service, src->host,
src->ad_context, 0, dst);
-
k5_mutex_unlock(&src->lock);
-
return code;
}
kname = (krb5_gss_name_t)name;
- code = k5_mutex_lock(&kname->lock);
- if (code != 0) {
- *minor_status = code;
- return GSS_S_FAILURE;
- }
+ k5_mutex_lock(&kname->lock);
if (kname->ad_context == NULL) {
code = krb5_authdata_context_init(context, &kname->ad_context);
}
kname = (krb5_gss_name_t)name;
-
- code = k5_mutex_lock(&kname->lock);
- if (code != 0) {
- *minor_status = code;
- krb5_free_context(context);
- return GSS_S_FAILURE;
- }
+ k5_mutex_lock(&kname->lock);
if (kname->ad_context == NULL) {
code = krb5_authdata_context_init(context, &kname->ad_context);
}
kname = (krb5_gss_name_t)name;
-
- code = k5_mutex_lock(&kname->lock);
- if (code != 0) {
- *minor_status = code;
- return GSS_S_FAILURE;
- }
+ k5_mutex_lock(&kname->lock);
if (kname->ad_context == NULL) {
code = krb5_authdata_context_init(context, &kname->ad_context);
}
kname = (krb5_gss_name_t)name;
-
- code = k5_mutex_lock(&kname->lock);
- if (code != 0) {
- *minor_status = code;
- return GSS_S_FAILURE;
- }
+ k5_mutex_lock(&kname->lock);
if (kname->ad_context == NULL) {
code = krb5_authdata_context_init(context, &kname->ad_context);
}
kname = (krb5_gss_name_t)name;
-
- code = k5_mutex_lock(&kname->lock);
- if (code != 0) {
- *minor_status = code;
- return GSS_S_FAILURE;
- }
+ k5_mutex_lock(&kname->lock);
if (kname->ad_context == NULL) {
code = krb5_authdata_context_init(context, &kname->ad_context);
}
kname = (krb5_gss_name_t)name;
-
- code = k5_mutex_lock(&kname->lock);
- if (code != 0) {
- *minor_status = code;
- return GSS_S_FAILURE;
- }
+ k5_mutex_lock(&kname->lock);
if (kname->ad_context == NULL) {
code = krb5_authdata_context_init(context, &kname->ad_context);
}
kname = (krb5_gss_name_t)name;
-
- code = k5_mutex_lock(&kname->lock);
- if (code != 0) {
- *minor_status = code;
- return GSS_S_FAILURE;
- }
+ k5_mutex_lock(&kname->lock);
code = krb5_unparse_name(context, kname->princ, &princstr);
if (code != 0)
if (impersonator_cred->req_enctypes != NULL)
in_creds.keyblock.enctype = impersonator_cred->req_enctypes[0];
- code = k5_mutex_lock(&user->lock);
- if (code != 0) {
- *minor_status = code;
- return GSS_S_FAILURE;
- }
+ k5_mutex_lock(&user->lock);
if (user->ad_context != NULL) {
code = krb5_authdata_export_authdata(context,
}
}
} else {
- kerr = k5_mutex_lock(&cred->lock);
- if (kerr)
- goto error_out;
+ k5_mutex_lock(&cred->lock);
if (cred->req_enctypes)
free(cred->req_enctypes);
cred->req_enctypes = NULL;
kerr = ENOMEM;
goto error_out;
}
- kerr = k5_mutex_lock(&cred->lock);
- if (kerr) {
- free(new_ktypes);
- goto error_out;
- }
+ k5_mutex_lock(&cred->lock);
if (cred->req_enctypes)
free(cred->req_enctypes);
cred->req_enctypes = new_ktypes;
krb5_principal princ;
cred = (krb5_gss_cred_id_t) cred_handle;
-
- code = k5_mutex_lock(&cred->lock);
- if (code) {
- *minor_status = code;
- return GSS_S_FAILURE;
- }
+ k5_mutex_lock(&cred->lock);
if (cred->ccache && cred->expire != 0) {
if ((code = krb5_cc_get_principal(context, cred->ccache, &princ))) {
if (*minor_status != 0)
return (GSS_S_FAILURE);
- *minor_status = k5_mutex_lock(&g_mechListLock);
- if (*minor_status)
- return GSS_S_FAILURE;
+ k5_mutex_lock(&g_mechListLock);
aMech = g_mechList;
while (aMech != NULL) {
* need to lock the g_mechSet in case someone tries to update it while
* I'm copying it.
*/
- *minorStatus = k5_mutex_lock(&g_mechSetLock);
- if (*minorStatus) {
- return GSS_S_FAILURE;
- }
-
+ k5_mutex_lock(&g_mechSetLock);
status = generic_gss_copy_oid_set(minorStatus, &g_mechSet, mechSet_out);
- (void) k5_mutex_unlock(&g_mechSetLock);
+ k5_mutex_unlock(&g_mechSetLock);
return (status);
} /* gss_indicate_mechs */
* since we are accessing parts of the mechList which could be
* modified.
*/
- if (k5_mutex_lock(&g_mechListLock) != 0)
- return GSS_S_FAILURE;
+ k5_mutex_lock(&g_mechListLock);
#if 0
/*
* we need to lock the mech set so that no one else will
* try to read it as we are re-creating it
*/
- if (k5_mutex_lock(&g_mechSetLock) != 0)
- return GSS_S_FAILURE;
+ k5_mutex_lock(&g_mechSetLock);
/* if the oid list already exists we must free it first */
free_mechSet();
g_mechSet.elements =
(gss_OID) calloc(count, sizeof (gss_OID_desc));
if (g_mechSet.elements == NULL) {
- (void) k5_mutex_unlock(&g_mechSetLock);
- (void) k5_mutex_unlock(&g_mechListLock);
+ k5_mutex_unlock(&g_mechSetLock);
+ k5_mutex_unlock(&g_mechListLock);
return (GSS_S_FAILURE);
}
free(g_mechSet.elements);
g_mechSet.count = 0;
g_mechSet.elements = NULL;
- (void) k5_mutex_unlock(&g_mechSetLock);
- (void) k5_mutex_unlock(&g_mechListLock);
+ k5_mutex_unlock(&g_mechSetLock);
+ k5_mutex_unlock(&g_mechListLock);
return (GSS_S_FAILURE);
}
g_OID_copy(curItem, mList->mech_type);
#if 0
g_mechSetTime = fileInfo.st_mtime;
#endif
- (void) k5_mutex_unlock(&g_mechSetLock);
- (void) k5_mutex_unlock(&g_mechListLock);
+ k5_mutex_unlock(&g_mechSetLock);
+ k5_mutex_unlock(&g_mechListLock);
return GSS_S_COMPLETE;
}
return (NULL);
/* make sure we have fresh data */
- if (k5_mutex_lock(&g_mechListLock) != 0)
- return NULL;
+ k5_mutex_lock(&g_mechListLock);
updateMechList();
if ((aMech = searchMechList(oid)) == NULL ||
aMech->optionStr == NULL) {
- (void) k5_mutex_unlock(&g_mechListLock);
+ k5_mutex_unlock(&g_mechListLock);
return (NULL);
}
if (aMech->optionStr)
modOptions = strdup(aMech->optionStr);
- (void) k5_mutex_unlock(&g_mechListLock);
+ k5_mutex_unlock(&g_mechListLock);
return (modOptions);
} /* gssint_get_modOptions */
if (gssint_mechglue_initialize_library() != 0)
return GSS_S_FAILURE;
- if (k5_mutex_lock(&g_mechListLock) != 0)
- return GSS_S_FAILURE;
+ k5_mutex_lock(&g_mechListLock);
/* Read conf file at least once so that interposer plugins have a
* chance of getting initialized. */
status = GSS_S_BAD_MECH;
done:
- (void)k5_mutex_unlock(&g_mechListLock);
+ k5_mutex_unlock(&g_mechListLock);
return status;
}
if (gssint_mechglue_initialize_library() != 0)
return GSS_C_NO_OID;
- if (k5_mutex_lock(&g_mechListLock) != 0)
- return GSS_C_NO_OID;
+ k5_mutex_lock(&g_mechListLock);
for (minfo = g_mechList; minfo != NULL; minfo = minfo->next) {
if (minfo->is_interposer)
}
}
- (void)k5_mutex_unlock(&g_mechListLock);
+ k5_mutex_unlock(&g_mechListLock);
return public_oid;
}
if (gssint_mechglue_initialize_library() != 0)
return (NULL);
- if (k5_mutex_lock(&g_mechListLock) != 0)
- return NULL;
+ k5_mutex_lock(&g_mechListLock);
/* Check if the mechanism is already loaded. */
aMech = g_mechList;
oid = aMech->mech_type;
while (aMech != NULL) {
if (g_OID_equal(aMech->mech_type, oid) && aMech->mech) {
- (void)k5_mutex_unlock(&g_mechListLock);
+ k5_mutex_unlock(&g_mechListLock);
return aMech->mech;
} else if (aMech->int_mech_type != GSS_C_NO_OID &&
g_OID_equal(aMech->int_mech_type, oid)) {
- (void)k5_mutex_unlock(&g_mechListLock);
+ k5_mutex_unlock(&g_mechListLock);
return aMech->int_mech;
}
aMech = aMech->next;
/* is the mechanism present in the list ? */
if (aMech == NULL) {
- (void) k5_mutex_unlock(&g_mechListLock);
+ k5_mutex_unlock(&g_mechListLock);
return ((gss_mechanism)NULL);
}
/* has another thread loaded the mech */
if (aMech->mech) {
- (void) k5_mutex_unlock(&g_mechListLock);
+ k5_mutex_unlock(&g_mechListLock);
return (aMech->mech);
}
(void) syslog(LOG_INFO, "libgss dlopen(%s): %s\n",
aMech->uLibName, dlerror());
#endif
- (void) k5_mutex_unlock(&g_mechListLock);
+ k5_mutex_unlock(&g_mechListLock);
return ((gss_mechanism)NULL);
}
(void) syslog(LOG_INFO, "unable to initialize mechanism"
" library [%s]\n", aMech->uLibName);
#endif
- (void) k5_mutex_unlock(&g_mechListLock);
+ k5_mutex_unlock(&g_mechListLock);
return ((gss_mechanism)NULL);
}
aMech->dl_handle = dl;
- (void) k5_mutex_unlock(&g_mechListLock);
+ k5_mutex_unlock(&g_mechListLock);
return (aMech->mech);
} /* gssint_get_mechanism */
err = CALL_INIT_FUNCTION (kdb_init_lock_list);
if (err)
return err;
- return k5_mutex_lock(&db_lock);
+ k5_mutex_lock(&db_lock);
+ return 0;
}
void
k5_mutex_destroy(&db_lock);
}
-static int
+static void
kdb_unlock_list()
{
- return k5_mutex_unlock(&db_lock);
+ k5_mutex_unlock(&db_lock);
}
/* Return true if the ulog is mapped in the master role. */
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;
(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
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);
*/
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;
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);
}
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);
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;
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));
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;
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) {
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);
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) {
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...
{
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);
#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);
{
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) {
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
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
*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) {
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)
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;
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);
krb5_change_cache();
- return KRB5_OK;
+ return kret;
}
krb5_cc_cursor * cursor)
{
krb5_krcc_cursor krcursor;
- krb5_error_code kret;
krb5_krcc_data *d;
unsigned int size;
int res;
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.
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 */
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);
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;
}
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;
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);
{
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) {
}
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);
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;
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;
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) {
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);
krb5_context context,
krb5_cc_ptcursor *cursor)
{
- krb5_error_code ret = 0;
krb5_cc_ptcursor n = NULL;
struct krb5_mcc_ptcursor_data *cdata = NULL;
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
krb5_cc_ptcursor cursor,
krb5_ccache *ccache)
{
- krb5_error_code ret = 0;
struct krb5_mcc_ptcursor_data *cdata = NULL;
*ccache = NULL;
(*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
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;
}
/*
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 = {
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) {
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;
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;
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
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
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;
}
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--;
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;
}
/*
{
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);
/* 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);
}
/* 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
k5_mutex_unlock(&cc_typelist_lock);
k5_cc_mutex_force_unlock(&cccol_lock);
-
- return ret;
}
int was_open;
char *princname;
- kerror = KTLOCK(id);
- if (kerror)
- return kerror;
+ KTLOCK(id);
if (KTFILEP(id) != NULL) {
was_open = 1;
krb5_error_code retval;
long *fileoff;
- retval = KTLOCK(id);
- if (retval)
- return retval;
+ KTLOCK(id);
if (KTITERS(id) == 0) {
if ((retval = krb5_ktfileint_openr(context, id))) {
krb5_keytab_entry cur_entry;
krb5_error_code kerror;
- kerror = KTLOCK(id);
- if (kerror)
- return kerror;
+ KTLOCK(id);
if (KTFILEP(id) == NULL) {
KTUNLOCK(id);
return KRB5_KT_IOERR;
krb5_error_code kerror;
free(*cursor);
- kerror = KTLOCK(id);
- if (kerror)
- return kerror;
+ KTLOCK(id);
KTITERS(id)--;
if (KTFILEP(id) != NULL && KTITERS(id) == 0)
kerror = krb5_ktfileint_close(context, id);
{
krb5_error_code retval;
- retval = KTLOCK(id);
- if (retval)
- return retval;
+ KTLOCK(id);
if (KTFILEP(id)) {
/* Iterator(s) active -- no changes. */
KTUNLOCK(id);
krb5_error_code kerror;
krb5_int32 delete_point;
- kerror = KTLOCK(id);
- if (kerror)
- return kerror;
+ KTLOCK(id);
if (KTFILEP(id)) {
/* Iterator(s) active -- no changes. */
KTUNLOCK(id);
*id = NULL;
/* First determine if a memory keytab of this name already exists */
- err = KTGLOCK;
- if (err)
- return err;
+ KTGLOCK;
for (list = krb5int_mkt_list; list; list = list->next) {
if (strcmp(name,KTNAME(list->keytab)) == 0)
}
/* Increment the reference count on the keytab we found or created. */
- err = KTLOCK(list->keytab);
- if (err)
- goto done;
+ KTLOCK(list->keytab);
KTREFCNT(list->keytab)++;
KTUNLOCK(list->keytab);
*id = list->keytab;
krb5_error_code err = 0;
/* First determine if a memory keytab of this name already exists */
- err = KTGLOCK;
- if (err)
- return(err);
+ KTGLOCK;
for (listp = &krb5int_mkt_list; *listp; listp = &((*listp)->next))
{
}
/* reduce the refcount and return */
- err = KTLOCK(id);
- if (err)
- goto done;
-
+ KTLOCK(id);
KTREFCNT(id)--;
KTUNLOCK(id);
int found_wrong_kvno = 0;
krb5_boolean similar = 0;
- err = KTLOCK(id);
- if (err)
- return err;
+ KTLOCK(id);
for (cursor = KTLINK(id); cursor && cursor->entry; cursor = cursor->next) {
entry = cursor->entry;
krb5_error_code KRB5_CALLCONV
krb5_mkt_start_seq_get(krb5_context context, krb5_keytab id, krb5_kt_cursor *cursorp)
{
- krb5_error_code err = 0;
-
- err = KTLOCK(id);
- if (err)
- return(err);
-
+ KTLOCK(id);
*cursorp = (krb5_kt_cursor)KTLINK(id);
KTUNLOCK(id);
krb5_mkt_cursor mkt_cursor = (krb5_mkt_cursor)*cursor;
krb5_error_code err = 0;
- err = KTLOCK(id);
- if (err)
- return err;
+ KTLOCK(id);
if (mkt_cursor == NULL) {
KTUNLOCK(id);
krb5_error_code err = 0;
krb5_mkt_cursor cursor;
- err = KTLOCK(id);
- if (err)
- return err;
+ KTLOCK(id);
cursor = (krb5_mkt_cursor)malloc(sizeof(krb5_mkt_link));
if (cursor == NULL) {
krb5_mkt_cursor *pcursor, next;
krb5_error_code err = 0;
- err = KTLOCK(id);
- if (err)
- return err;
+ KTLOCK(id);
if ( KTLINK(id) == NULL ) {
err = KRB5_KT_NOTFOUND;
{
const struct krb5_kt_typelist *t;
struct krb5_kt_typelist *newt;
- krb5_error_code err;
- err = k5_mutex_lock(&kt_typehead_lock);
- if (err)
- return err;
+ k5_mutex_lock(&kt_typehead_lock);
for (t = kt_typehead; t && strcmp(t->ops->prefix,ops->prefix);t = t->next)
;
if (t) {
*ktid = (krb5_keytab) 0;
- err = k5_mutex_lock(&kt_typehead_lock);
- if (err)
- goto cleanup;
+ k5_mutex_lock(&kt_typehead_lock);
tlist = kt_typehead;
/* Don't need to hold the lock, since entries are never modified
or removed once they're in the list. Just need to protect
different threads getting the same value for time, which may be
a technical violation of spec. */
- err = k5_mutex_lock(&krb5int_us_time_mutex);
- if (err)
- return err;
+ k5_mutex_lock(&krb5int_us_time_mutex);
/* Just guessing: If the number of seconds hasn't changed, yet the
microseconds are moving backwards, we probably just got a third
instance of returning the same clock value from the system, so
krb5_rc_register_type(krb5_context context, const krb5_rc_ops *ops)
{
struct krb5_rc_typelist *t;
- krb5_error_code err;
- err = k5_mutex_lock(&rc_typelist_lock);
- if (err)
- return err;
+
+ k5_mutex_lock(&rc_typelist_lock);
for (t = typehead;t && strcmp(t->ops->type,ops->type);t = t->next)
;
if (t) {
*idptr = NULL;
/* Find the named type in the list. */
- err = k5_mutex_lock(&rc_typelist_lock);
- if (err)
- return err;
+ k5_mutex_lock(&rc_typelist_lock);
for (t = typehead; t && strcmp(t->ops->type, type); t = t->next)
;
k5_mutex_unlock(&rc_typelist_lock);
krb5_rc_dfl_get_span(krb5_context context, krb5_rcache id,
krb5_deltat *lifespan)
{
- krb5_error_code err;
struct dfl_data *t;
- err = k5_mutex_lock(&id->lock);
- if (err)
- return err;
+ k5_mutex_lock(&id->lock);
t = (struct dfl_data *) id->data;
*lifespan = t->lifespan;
k5_mutex_unlock(&id->lock);
{
krb5_error_code retval;
- retval = k5_mutex_lock(&id->lock);
- if (retval)
- return retval;
+ k5_mutex_lock(&id->lock);
retval = krb5_rc_dfl_init_locked(context, id, lifespan);
k5_mutex_unlock(&id->lock);
return retval;
krb5_error_code KRB5_CALLCONV
krb5_rc_dfl_close(krb5_context context, krb5_rcache id)
{
- krb5_error_code retval;
- retval = k5_mutex_lock(&id->lock);
- if (retval)
- return retval;
+ k5_mutex_lock(&id->lock);
krb5_rc_dfl_close_no_free(context, id);
k5_mutex_unlock(&id->lock);
k5_mutex_destroy(&id->lock);
krb5_rc_dfl_recover(krb5_context context, krb5_rcache id)
{
krb5_error_code ret;
- ret = k5_mutex_lock(&id->lock);
- if (ret)
- return ret;
+
+ k5_mutex_lock(&id->lock);
ret = krb5_rc_dfl_recover_locked(context, id);
k5_mutex_unlock(&id->lock);
return ret;
{
krb5_error_code retval;
- retval = k5_mutex_lock(&id->lock);
- if (retval)
- return retval;
+ k5_mutex_lock(&id->lock);
retval = krb5_rc_dfl_recover_locked(context, id);
if (retval)
retval = krb5_rc_dfl_init_locked(context, id, lifespan);
if (ret)
return ret;
- ret = k5_mutex_lock(&id->lock);
- if (ret)
- return ret;
+ k5_mutex_lock(&id->lock);
switch(rc_store(context, id, rep, now, FALSE)) {
case CMP_MALLOC:
krb5_rc_dfl_expunge(krb5_context context, krb5_rcache id)
{
krb5_error_code ret;
- ret = k5_mutex_lock(&id->lock);
- if (ret)
- return ret;
+
+ k5_mutex_lock(&id->lock);
ret = krb5_rc_dfl_expunge_locked(context, id);
k5_mutex_unlock(&id->lock);
return ret;
k5_mutex_t *krb5_db2_mutex;
-#define WRAP(NAME,TYPE,ARGLIST,ARGNAMES,ERROR_RESULT) \
+#define WRAP(NAME,TYPE,ARGLIST,ARGNAMES) \
static TYPE wrap_##NAME ARGLIST \
{ \
TYPE result; \
- int code = k5_mutex_lock (krb5_db2_mutex); \
- if (code) { return ERROR_RESULT; } \
+ k5_mutex_lock (krb5_db2_mutex); \
result = NAME ARGNAMES; \
k5_mutex_unlock (krb5_db2_mutex); \
return result; \
#define WRAP_VOID(NAME,ARGLIST,ARGNAMES) \
static void wrap_##NAME ARGLIST \
{ \
- int code = k5_mutex_lock (krb5_db2_mutex); \
- if (code) { return; } \
+ k5_mutex_lock (krb5_db2_mutex); \
NAME ARGNAMES; \
k5_mutex_unlock (krb5_db2_mutex); \
} \
static void wrap_##NAME ()
#define WRAP_K(NAME,ARGLIST,ARGNAMES) \
- WRAP(NAME,krb5_error_code,ARGLIST,ARGNAMES,code)
+ WRAP(NAME,krb5_error_code,ARGLIST,ARGNAMES)
WRAP_K (krb5_db2_open,
( krb5_context kcontext,
DBT key, contents;
krb5_data contdata;
krb5_db_entry *entry;
- krb5_error_code retval, retval2;
+ krb5_error_code retval;
int dbret;
retval = ctx_lock(context, dbc, KRB5_LOCKMODE_SHARED);
retval = krb5_decode_princ_entry(context, &contdata, &entry);
if (retval)
break;
- retval = k5_mutex_unlock(krb5_db2_mutex);
- if (retval)
- break;
+ k5_mutex_unlock(krb5_db2_mutex);
retval = (*func)(func_arg, entry);
krb5_dbe_free(context, entry);
- retval2 = k5_mutex_lock(krb5_db2_mutex);
- /* Note: If re-locking fails, the wrapper in db2_exp.c will
- still try to unlock it again. That would be a bug. Fix
- when integrating the locking better. */
+ k5_mutex_lock(krb5_db2_mutex);
if (retval)
break;
- if (retval2) {
- retval = retval2;
- break;
- }
dbret = dbc->db->seq(dbc->db, &key, &contents, R_NEXT);
}
switch (dbret) {
ldap_set_option(NULL, LDAP_X_OPT_CONNECT_TIMEOUT, &local_timelimit);
#endif
- st = HNDL_LOCK(ldap_context);
- if (st)
- return st;
+ HNDL_LOCK(ldap_context);
while (ldap_context->server_info_list[cnt] != NULL) {
krb5_ldap_server_info *server_info=NULL;
*ldap_server_handle = NULL;
- st = HNDL_LOCK(ldap_context);
- if (st)
- return st;
+ HNDL_LOCK(ldap_context);
if (((*ldap_server_handle)=krb5_get_ldap_handle(ldap_context)) == NULL)
(*ldap_server_handle)=krb5_retry_get_ldap_handle(ldap_context, &st);
HNDL_UNLOCK(ldap_context);
{
krb5_error_code st=0;
- st = HNDL_LOCK(ldap_context);
- if (st)
- return st;
+ HNDL_LOCK(ldap_context);
(*ldap_server_handle)->server_info->server_status = OFF;
time(&(*ldap_server_handle)->server_info->downtime);
krb5_put_ldap_handle(*ldap_server_handle);
krb5_ldap_server_handle *ldap_server_handle)
{
if (ldap_server_handle != NULL) {
- if (HNDL_LOCK(ldap_context) == 0) {
- krb5_put_ldap_handle(ldap_server_handle);
- HNDL_UNLOCK(ldap_context);
- }
+ HNDL_LOCK(ldap_context);
+ krb5_put_ldap_handle(ldap_server_handle);
+ HNDL_UNLOCK(ldap_context);
}
return;
}
err = com_err_finish_init();
if (err)
goto best_try;
- err = k5_mutex_lock(&com_err_hook_lock);
- if (err)
- goto best_try;
+ k5_mutex_lock(&com_err_hook_lock);
p = com_err_hook ? com_err_hook : default_com_err_proc;
(*p)(whoami, code, fmt, ap);
k5_mutex_unlock(&com_err_hook_lock);
/* Make a separate function because the assert invocations below
use the macro expansion on some platforms, which may be insanely
long and incomprehensible. */
-static int com_err_lock_hook_handle(void)
+static void com_err_lock_hook_handle(void)
{
- return k5_mutex_lock(&com_err_hook_lock);
+ k5_mutex_lock(&com_err_hook_lock);
}
et_old_error_hook_func set_com_err_hook (et_old_error_hook_func new_proc)
/* Broken initialization? What can we do? */
if (com_err_finish_init() != 0)
abort();
- if (com_err_lock_hook_handle() != 0)
- abort();
+ com_err_lock_hook_handle();
x = com_err_hook;
com_err_hook = new_proc;
k5_mutex_unlock(&com_err_hook_lock);
/* Broken initialization? What can we do? */
if (com_err_finish_init() != 0)
abort();
- if (com_err_lock_hook_handle() != 0)
- abort();
+ com_err_lock_hook_handle();
x = com_err_hook;
com_err_hook = NULL;
k5_mutex_unlock(&com_err_hook_lock);
#endif
k5_key_delete(K5_KEY_COM_ERR);
k5_mutex_destroy(&com_err_hook_lock);
- if (k5_mutex_lock(&et_list_lock) != 0)
- return;
+ k5_mutex_lock(&et_list_lock);
for (e = et_list; e; e = enext) {
enext = e->next;
free(e);
unsigned int divisor = 100;
char *cp, *cp1;
const struct error_table *table;
- int merr;
l_offset = (unsigned long)code & ((1<<ERRCODE_RANGE)-1);
offset = l_offset;
if (CALL_INIT_FUNCTION(com_err_initialize))
return 0;
- merr = k5_mutex_lock(&et_list_lock);
- if (merr)
- goto oops;
+ k5_mutex_lock(&et_list_lock);
dprintf(("scanning list for %x\n", table_num));
for (e = et_list; e != NULL; e = e->next) {
dprintf(("\t%x = %s\n", e->table->base & ERRCODE_MAX,
add_error_table(const struct error_table *et)
{
struct et_list *e;
- int merr;
if (CALL_INIT_FUNCTION(com_err_initialize))
return 0;
e->table = et;
- merr = k5_mutex_lock(&et_list_lock);
- if (merr) {
- free(e);
- return merr;
- }
+ k5_mutex_lock(&et_list_lock);
e->next = et_list;
et_list = e;
if (et->msgs[et->n_msgs] != NULL && et->msgs[et->n_msgs + 1] != NULL)
bindtextdomain(et->msgs[et->n_msgs], et->msgs[et->n_msgs + 1]);
- return k5_mutex_unlock(&et_list_lock);
+ k5_mutex_unlock(&et_list_lock);
+ return 0;
}
errcode_t KRB5_CALLCONV
remove_error_table(const struct error_table *et)
{
struct et_list **ep, *e;
- int merr;
if (CALL_INIT_FUNCTION(com_err_initialize))
return 0;
- merr = k5_mutex_lock(&et_list_lock);
- if (merr)
- return merr;
+ k5_mutex_lock(&et_list_lock);
/* Remove the entry that matches the error table instance. */
for (ep = &et_list; *ep; ep = &(*ep)->next) {
e = *ep;
*ep = e->next;
free(e);
- return k5_mutex_unlock(&et_list_lock);
+ k5_mutex_unlock(&et_list_lock);
+ return 0;
}
}
k5_mutex_unlock(&et_list_lock);
return ENOMEM;
}
- retval = k5_mutex_lock(&g_shared_trees_mutex);
- if (retval) {
- free(expanded_filename);
- free(prf);
- scan_shared_trees_unlocked();
- return retval;
- }
+ k5_mutex_lock(&g_shared_trees_mutex);
scan_shared_trees_locked();
for (data = g_shared_trees; data; data = data->next) {
if (!strcmp(data->filespec, expanded_filename)
}
if (data) {
data->refcount++;
- (void) k5_mutex_unlock(&g_shared_trees_mutex);
+ k5_mutex_unlock(&g_shared_trees_mutex);
retval = profile_update_file_data(data, NULL);
free(expanded_filename);
if (retval) {
scan_shared_trees_unlocked();
return 0;
}
- (void) k5_mutex_unlock(&g_shared_trees_mutex);
+ k5_mutex_unlock(&g_shared_trees_mutex);
data = profile_make_prf_data(expanded_filename);
if (data == NULL) {
free(prf);
return retval;
}
- retval = k5_mutex_lock(&g_shared_trees_mutex);
- if (retval) {
- profile_close_file(prf);
- scan_shared_trees_unlocked();
- return retval;
- }
+ k5_mutex_lock(&g_shared_trees_mutex);
scan_shared_trees_locked();
data->flags |= PROFILE_FILE_SHARED;
data->next = g_shared_trees;
g_shared_trees = data;
scan_shared_trees_locked();
- (void) k5_mutex_unlock(&g_shared_trees_mutex);
+ k5_mutex_unlock(&g_shared_trees_mutex);
*ret_prof = prf;
return 0;
errcode_t profile_update_file_data(prf_data_t data, char **ret_modspec)
{
- errcode_t retval, retval2;
+ errcode_t retval;
- retval = k5_mutex_lock(&data->lock);
- if (retval)
- return retval;
+ k5_mutex_lock(&data->lock);
retval = profile_update_file_data_locked(data, ret_modspec);
- retval2 = k5_mutex_unlock(&data->lock);
- return retval ? retval : retval2;
+ k5_mutex_unlock(&data->lock);
+ return retval;
}
static int
errcode_t profile_flush_file_data_to_buffer (prf_data_t data, char **bufp)
{
errcode_t retval;
- retval = k5_mutex_lock(&data->lock);
- if (retval)
- return retval;
+
+ k5_mutex_lock(&data->lock);
retval = profile_write_tree_to_buffer(data->root, bufp);
k5_mutex_unlock(&data->lock);
return retval;
if (!data || data->magic != PROF_MAGIC_FILE_DATA)
return PROF_MAGIC_FILE_DATA;
- retval = k5_mutex_lock(&data->lock);
- if (retval)
- return retval;
+ k5_mutex_lock(&data->lock);
if ((data->flags & PROFILE_FILE_DIRTY) == 0) {
k5_mutex_unlock(&data->lock);
if (!data || data->magic != PROF_MAGIC_FILE_DATA)
return PROF_MAGIC_FILE_DATA;
- retval = k5_mutex_lock(&data->lock);
- if (retval)
- return retval;
+ k5_mutex_lock(&data->lock);
retval = write_data_to_file(data, outfile, 1);
k5_mutex_unlock(&data->lock);
return retval;
void profile_dereference_data(prf_data_t data)
{
- int err;
- err = k5_mutex_lock(&g_shared_trees_mutex);
- if (err)
- return;
+ k5_mutex_lock(&g_shared_trees_mutex);
profile_dereference_data_locked(data);
- (void) k5_mutex_unlock(&g_shared_trees_mutex);
+ k5_mutex_unlock(&g_shared_trees_mutex);
}
void profile_dereference_data_locked(prf_data_t data)
{
scan_shared_trees_locked();
}
-int profile_lock_global()
+void profile_lock_global()
{
- return k5_mutex_lock(&g_shared_trees_mutex);
+ k5_mutex_lock(&g_shared_trees_mutex);
}
-int profile_unlock_global()
+void profile_unlock_global()
{
- return k5_mutex_unlock(&g_shared_trees_mutex);
+ k5_mutex_unlock(&g_shared_trees_mutex);
}
void profile_free_file(prf_file_t prf)
/* Increment the refcount on the library handle if there is one. */
if (profile->lib_handle) {
- err = k5_mutex_lock(&profile->lib_handle->lock);
- if (err) {
- /* Don't decrement the refcount we failed to increment. */
- new_profile->lib_handle = NULL;
- profile_abandon(new_profile);
- return err;
- }
+ k5_mutex_lock(&profile->lib_handle->lock);
profile->lib_handle->refcount++;
k5_mutex_unlock(&profile->lib_handle->lock);
}
profile_abandon(profile_t profile)
{
prf_file_t p, next;
- errcode_t err;
if (!profile || profile->magic != PROF_MAGIC_PROFILE)
return;
profile->vt->cleanup(profile->cbdata);
if (profile->lib_handle) {
/* Decrement the refcount on the handle and maybe free it. */
- err = k5_mutex_lock(&profile->lib_handle->lock);
- if (!err && --profile->lib_handle->refcount == 0) {
+ k5_mutex_lock(&profile->lib_handle->lock);
+ if (--profile->lib_handle->refcount == 0) {
krb5int_close_plugin(profile->lib_handle->plugin_handle);
k5_mutex_unlock(&profile->lib_handle->lock);
k5_mutex_destroy(&profile->lib_handle->lock);
free(profile->lib_handle);
- } else if (!err)
+ } else
k5_mutex_unlock(&profile->lib_handle->lock);
}
free(profile->vt);
void profile_dereference_data (prf_data_t);
void profile_dereference_data_locked (prf_data_t);
-int profile_lock_global (void);
-int profile_unlock_global (void);
+void profile_lock_global (void);
+void profile_unlock_global (void);
/* prof_init.c -- included from profile.h */
errcode_t profile_ser_size
file = profile->first_file;
- retval = profile_lock_global();
- if (retval)
- return retval;
+ profile_lock_global();
/* Don't update the file if we've already made modifications */
if (file->data->flags & PROFILE_FILE_DIRTY) {
if (!old_value || !*old_value)
return PROF_EINVAL;
- retval = k5_mutex_lock(&profile->first_file->data->lock);
- if (retval)
- return retval;
+ k5_mutex_lock(&profile->first_file->data->lock);
section = profile->first_file->data->root;
for (cpp = names; cpp[1]; cpp++) {
state = 0;
if (names == 0 || names[0] == 0 || names[1] == 0)
return PROF_BAD_NAMESET;
- retval = k5_mutex_lock(&profile->first_file->data->lock);
- if (retval)
- return retval;
+ k5_mutex_lock(&profile->first_file->data->lock);
section = profile->first_file->data->root;
for (cpp = names; cpp[1]; cpp++) {
state = 0;
if (names == 0 || names[0] == 0 || names[1] == 0)
return PROF_BAD_NAMESET;
- retval = k5_mutex_lock(&profile->first_file->data->lock);
- if (retval)
- return retval;
+ k5_mutex_lock(&profile->first_file->data->lock);
section = profile->first_file->data->root;
for (cpp = names; cpp[1]; cpp++) {
state = 0;
* If the file has changed, then the node pointer is invalid,
* so we'll have search the file again looking for it.
*/
- if (iter->file) {
- retval = k5_mutex_lock(&iter->file->data->lock);
- if (retval)
- return retval;
- }
+ if (iter->file)
+ k5_mutex_lock(&iter->file->data->lock);
if (iter->node && (iter->file->data->upd_serial != iter->file_serial)) {
iter->flags &= ~PROFILE_ITER_FINAL_SEEN;
skip_num = iter->num;
if (retval == ENOENT || retval == EACCES) {
/* XXX memory leak? */
iter->file = iter->file->next;
- if (iter->file) {
- retval = k5_mutex_lock(&iter->file->data->lock);
- if (retval) {
- profile_node_iterator_free(iter_p);
- return retval;
- }
- }
+ if (iter->file)
+ k5_mutex_lock(&iter->file->data->lock);
skip_num = 0;
retval = 0;
goto get_new_file;
if (!section) {
k5_mutex_unlock(&iter->file->data->lock);
iter->file = iter->file->next;
- if (iter->file) {
- retval = k5_mutex_lock(&iter->file->data->lock);
- if (retval) {
- profile_node_iterator_free(iter_p);
- return retval;
- }
- }
+ if (iter->file)
+ k5_mutex_lock(&iter->file->data->lock);
skip_num = 0;
goto get_new_file;
}
if (!p) {
k5_mutex_unlock(&iter->file->data->lock);
iter->file = iter->file->next;
- if (iter->file) {
- retval = k5_mutex_lock(&iter->file->data->lock);
- if (retval) {
- profile_node_iterator_free(iter_p);
- return retval;
- }
- }
+ if (iter->file)
+ k5_mutex_lock(&iter->file->data->lock);
iter->node = 0;
skip_num = 0;
goto get_new_file;
if (code == ep->code && ep->msg != NULL)
return oom_check(strdup(ep->msg));
- if (initialize() || lock())
+ if (initialize())
return oom_check(strdup(_("Kerberos library initialization failure")));
+ lock();
if (fptr == NULL) {
unlock();
#ifdef HAVE_STRERROR_R
k5_set_error_info_callout_fn(const char *(KRB5_CALLCONV *f)(long))
{
initialize();
- if (lock() == 0) {
- fptr = f;
- unlock();
- }
+ lock();
+ fptr = f;
+ unlock();
}
static void thread_termination (void *tptr)
{
- int err = k5_mutex_lock(&key_lock);
- if (err == 0) {
- int i, pass, none_found;
- struct tsd_block *t = tptr;
-
- /* Make multiple passes in case, for example, a libkrb5 cleanup
- function wants to print out an error message, which causes
- com_err to allocate a thread-specific buffer, after we just
- freed up the old one.
-
- Shouldn't actually happen, if we're careful, but check just in
- case. */
-
- pass = 0;
- none_found = 0;
- while (pass < 4 && !none_found) {
- none_found = 1;
- for (i = 0; i < K5_KEY_MAX; i++) {
- if (destructors_set[i] && destructors[i] && t->values[i]) {
- void *v = t->values[i];
- t->values[i] = 0;
- (*destructors[i])(v);
- none_found = 0;
- }
+ int i, pass, none_found;
+ struct tsd_block *t = tptr;
+
+ k5_mutex_lock(&key_lock);
+
+ /*
+ * Make multiple passes in case, for example, a libkrb5 cleanup
+ * function wants to print out an error message, which causes
+ * com_err to allocate a thread-specific buffer, after we just
+ * freed up the old one.
+ *
+ * Shouldn't actually happen, if we're careful, but check just in
+ * case.
+ */
+
+ pass = 0;
+ none_found = 0;
+ while (pass < 4 && !none_found) {
+ none_found = 1;
+ for (i = 0; i < K5_KEY_MAX; i++) {
+ if (destructors_set[i] && destructors[i] && t->values[i]) {
+ void *v = t->values[i];
+ t->values[i] = 0;
+ (*destructors[i])(v);
+ none_found = 0;
}
}
- free (t);
- err = k5_mutex_unlock(&key_lock);
}
+ free (t);
+ k5_mutex_unlock(&key_lock);
/* remove thread from global linked list */
}
assert(destructors_set[keynum] == 0);
destructors[keynum] = destructor;
destructors_set[keynum] = 1;
- err = 0;
#elif defined(_WIN32)
destructors_set[keynum] = 1;
destructors[keynum] = destructor;
LeaveCriticalSection(&key_lock);
- err = 0;
#else /* POSIX */
- err = k5_mutex_lock(&key_lock);
- if (err == 0) {
- assert(destructors_set[keynum] == 0);
- destructors_set[keynum] = 1;
- destructors[keynum] = destructor;
- err = k5_mutex_unlock(&key_lock);
- }
+ k5_mutex_lock(&key_lock);
+ assert(destructors_set[keynum] == 0);
+ destructors_set[keynum] = 1;
+ destructors[keynum] = destructor;
+ k5_mutex_unlock(&key_lock);
#endif
return 0;
#else /* POSIX */
- {
- int err;
-
- /* XXX RESOURCE LEAK:
-
- Need to destroy the allocated objects first! */
-
- err = k5_mutex_lock(&key_lock);
- if (err == 0) {
- assert(destructors_set[keynum] == 1);
- destructors_set[keynum] = 0;
- destructors[keynum] = NULL;
- k5_mutex_unlock(&key_lock);
- }
- }
+ /* XXX RESOURCE LEAK: Need to destroy the allocated objects first! */
+ k5_mutex_lock(&key_lock);
+ assert(destructors_set[keynum] == 1);
+ destructors_set[keynum] = 0;
+ destructors[keynum] = NULL;
+ k5_mutex_unlock(&key_lock);
#endif
}
/* Callable versions of the various macros. */
-int KRB5_CALLCONV
+void KRB5_CALLCONV
krb5int_mutex_lock (k5_mutex_t *m)
{
- return k5_mutex_lock (m);
+ k5_mutex_lock (m);
}
-int KRB5_CALLCONV
+void KRB5_CALLCONV
krb5int_mutex_unlock (k5_mutex_t *m)
{
- return k5_mutex_unlock (m);
+ k5_mutex_unlock (m);
}
projects / thirdparty / krb5.git / commitdiff
