From f0f07ff408031a76cf892515f5f72a0d5e30fabf Mon Sep 17 00:00:00 2001 From: "Roland C. Dowdeswell" Date: Wed, 13 Feb 2013 16:15:00 +0800 Subject: [PATCH] Use krb5_enomem() more consistently in lib/krb5. --- lib/krb5/Makefile.am | 1 + lib/krb5/acache.c | 15 +-- lib/krb5/acl.c | 4 +- lib/krb5/addr_families.c | 31 ++---- lib/krb5/asn1_glue.c | 4 +- lib/krb5/auth_context.c | 30 +++--- lib/krb5/build_auth.c | 13 +-- lib/krb5/cache.c | 36 +++---- lib/krb5/config_file.c | 13 +-- lib/krb5/config_reg.c | 6 +- lib/krb5/context.c | 38 +++----- lib/krb5/copy_host_realm.c | 11 +-- lib/krb5/creds.c | 10 +- lib/krb5/crypto-arcfour.c | 6 +- lib/krb5/crypto-des-common.c | 12 +-- lib/krb5/crypto-evp.c | 6 +- lib/krb5/crypto-pk.c | 18 ++-- lib/krb5/crypto.c | 94 +++++++----------- lib/krb5/data.c | 6 +- lib/krb5/deprecated.c | 19 ++-- lib/krb5/digest.c | 180 ++++++++++++----------------------- lib/krb5/expand_hostname.c | 16 +--- lib/krb5/fcache.c | 17 ++-- lib/krb5/generate_subkey.c | 6 +- lib/krb5/get_addrs.c | 9 +- lib/krb5/get_default_realm.c | 7 +- lib/krb5/get_for_creds.c | 19 ++-- lib/krb5/get_host_realm.c | 9 +- lib/krb5/get_in_tkt.c | 27 ++---- lib/krb5/init_creds.c | 17 +--- lib/krb5/init_creds_pw.c | 56 ++++------- lib/krb5/kcm.c | 16 +--- lib/krb5/keyblock.c | 6 +- lib/krb5/keytab_any.c | 11 +-- lib/krb5/keytab_file.c | 39 +++----- lib/krb5/keytab_keyfile.c | 30 ++---- lib/krb5/keytab_memory.c | 15 +-- lib/krb5/krbhst.c | 19 ++-- lib/krb5/log.c | 39 +++----- lib/krb5/mcache.c | 7 +- lib/krb5/misc.c | 34 +++---- lib/krb5/mit_glue.c | 4 +- lib/krb5/mk_priv.c | 4 +- lib/krb5/mk_rep.c | 7 +- lib/krb5/padata.c | 7 +- lib/krb5/pkinit.c | 69 ++++---------- lib/krb5/rd_cred.c | 8 +- lib/krb5/rd_rep.c | 3 +- lib/krb5/rd_req.c | 17 +--- lib/krb5/rd_safe.c | 3 +- lib/krb5/recvauth.c | 4 +- lib/krb5/replay.c | 14 +-- lib/krb5/salt-aes.c | 6 +- lib/krb5/salt-arcfour.c | 9 +- lib/krb5/salt-des.c | 6 +- lib/krb5/salt-des3.c | 12 +-- lib/krb5/salt.c | 19 ++-- lib/krb5/scache.c | 59 ++++-------- lib/krb5/send_to_kdc.c | 2 + lib/krb5/set_default_realm.c | 11 +-- lib/krb5/ticket.c | 7 +- lib/krb5/verify_user.c | 7 +- 62 files changed, 393 insertions(+), 837 deletions(-) diff --git a/lib/krb5/Makefile.am b/lib/krb5/Makefile.am index 9365fd3c6..1d34b35c9 100644 --- a/lib/krb5/Makefile.am +++ b/lib/krb5/Makefile.am @@ -281,6 +281,7 @@ librfc3961_la_SOURCES = \ crypto-rand.c \ crypto-stubs.c \ data.c \ + enomem.c \ error_string.c \ keyblock.c \ n-fold.c \ diff --git a/lib/krb5/acache.c b/lib/krb5/acache.c index 19eeecda4..163de95c0 100644 --- a/lib/krb5/acache.c +++ b/lib/krb5/acache.c @@ -303,8 +303,7 @@ make_cred_from_ccred(krb5_context context, return 0; nomem: - ret = ENOMEM; - krb5_set_error_message(context, ret, N_("malloc: out of memory", "malloc")); + ret = krb5_enomem(context); fail: krb5_free_cred_contents(context, cred); @@ -905,10 +904,8 @@ acc_get_cache_first(krb5_context context, krb5_cc_cursor *cursor) return ret; iter = calloc(1, sizeof(*iter)); - if (iter == NULL) { - krb5_set_error_message(context, ENOMEM, "malloc: out of memory"); - return ENOMEM; - } + if (iter == NULL) + return krb5_enomem(context); error = (*init_func)(&iter->context, ccapi_version_3, NULL, NULL); if (error) { @@ -1036,10 +1033,8 @@ acc_get_default_name(krb5_context context, char **str) (*name->func->release)(name); (*cc->func->release)(cc); - if (error < 0 || *str == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (error < 0 || *str == NULL) + return krb5_enomem(context); return 0; } diff --git a/lib/krb5/acl.c b/lib/krb5/acl.c index c94aae361..90c91e661 100644 --- a/lib/krb5/acl.c +++ b/lib/krb5/acl.c @@ -81,10 +81,8 @@ acl_parse_format(krb5_context context, for(p = format; *p != '\0'; p++) { tmp = malloc(sizeof(*tmp)); if(tmp == NULL) { - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); acl_free_list(acl, 0); - return ENOMEM; + return krb5_enomem(context); } if(*p == 's') { tmp->type = acl_string; diff --git a/lib/krb5/addr_families.c b/lib/krb5/addr_families.c index 8067d2670..10b102440 100644 --- a/lib/krb5/addr_families.c +++ b/lib/krb5/addr_families.c @@ -1172,11 +1172,8 @@ krb5_parse_address(krb5_context context, krb5_address addr; if((*at[i].parse_addr)(context, string, &addr) == 0) { ALLOC_SEQ(addresses, 1); - if (addresses->val == NULL) { - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; - } + if (addresses->val == NULL) + return krb5_enomem(context); addresses->val[0] = addr; return 0; } @@ -1199,10 +1196,8 @@ krb5_parse_address(krb5_context context, ALLOC_SEQ(addresses, n); if (addresses->val == NULL) { - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); freeaddrinfo(ai); - return ENOMEM; + return krb5_enomem(context); } addresses->len = 0; @@ -1412,7 +1407,7 @@ krb5_copy_addresses(krb5_context context, size_t i; ALLOC_SEQ(outaddr, inaddr->len); if(inaddr->len > 0 && outaddr->val == NULL) - return ENOMEM; + return krb5_enomem(context); for(i = 0; i < inaddr->len; i++) krb5_copy_address(context, &inaddr->val[i], &outaddr->val[i]); return 0; @@ -1441,11 +1436,8 @@ krb5_append_addresses(krb5_context context, size_t i; if(source->len > 0) { tmp = realloc(dest->val, (dest->len + source->len) * sizeof(*tmp)); - if(tmp == NULL) { - krb5_set_error_message (context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; - } + if (tmp == NULL) + return krb5_enomem(context); dest->val = tmp; for(i = 0; i < source->len; i++) { /* skip duplicates */ @@ -1484,19 +1476,14 @@ krb5_make_addrport (krb5_context context, u_char *p; *res = malloc (sizeof(**res)); - if (*res == NULL) { - krb5_set_error_message (context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; - } + if (*res == NULL) + return krb5_enomem(context); (*res)->addr_type = KRB5_ADDRESS_ADDRPORT; ret = krb5_data_alloc (&(*res)->address, len); if (ret) { - krb5_set_error_message (context, ret, - N_("malloc: out of memory", "")); free (*res); *res = NULL; - return ret; + return krb5_enomem(context); } p = (*res)->address.data; *p++ = 0; diff --git a/lib/krb5/asn1_glue.c b/lib/krb5/asn1_glue.c index 5b2a2a328..6df8defbc 100644 --- a/lib/krb5/asn1_glue.c +++ b/lib/krb5/asn1_glue.c @@ -55,7 +55,7 @@ _krb5_principalname2krb5_principal (krb5_context context, p = calloc(1, sizeof(*p)); if (p == NULL) - return ENOMEM; + return krb5_enomem(context); ret = copy_PrincipalName(&from, &p->name); if (ret) { free(p); @@ -65,7 +65,7 @@ _krb5_principalname2krb5_principal (krb5_context context, if (p->realm == NULL) { free_PrincipalName(&p->name); free(p); - return ENOMEM; + return krb5_enomem(context); } *principal = p; return 0; diff --git a/lib/krb5/auth_context.c b/lib/krb5/auth_context.c index b1b67906e..142200cf9 100644 --- a/lib/krb5/auth_context.c +++ b/lib/krb5/auth_context.c @@ -50,16 +50,13 @@ krb5_auth_con_init(krb5_context context, krb5_auth_context p; ALLOC(p, 1); - if(!p) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (!p) + return krb5_enomem(context); memset(p, 0, sizeof(*p)); ALLOC(p->authenticator, 1); if (!p->authenticator) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); free(p); - return ENOMEM; + return krb5_enomem(context); } memset (p->authenticator, 0, sizeof(*p->authenticator)); p->flags = KRB5_AUTH_CONTEXT_DO_TIME; @@ -159,7 +156,7 @@ krb5_auth_con_setaddrs(krb5_context context, krb5_free_address (context, auth_context->local_address); else if ((auth_context->local_address = malloc(sizeof(krb5_address))) == NULL) - return ENOMEM; + return krb5_enomem(context); krb5_copy_address(context, local_addr, auth_context->local_address); } if (remote_addr) { @@ -167,7 +164,7 @@ krb5_auth_con_setaddrs(krb5_context context, krb5_free_address (context, auth_context->remote_address); else if ((auth_context->remote_address = malloc(sizeof(krb5_address))) == NULL) - return ENOMEM; + return krb5_enomem(context); krb5_copy_address(context, remote_addr, auth_context->remote_address); } return 0; @@ -264,10 +261,8 @@ krb5_auth_con_getaddrs(krb5_context context, if(*local_addr) krb5_free_address (context, *local_addr); *local_addr = malloc (sizeof(**local_addr)); - if (*local_addr == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (*local_addr == NULL) + return krb5_enomem(context); krb5_copy_address(context, auth_context->local_address, *local_addr); @@ -276,10 +271,9 @@ krb5_auth_con_getaddrs(krb5_context context, krb5_free_address (context, *remote_addr); *remote_addr = malloc (sizeof(**remote_addr)); if (*remote_addr == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); krb5_free_address (context, *local_addr); *local_addr = NULL; - return ENOMEM; + return krb5_enomem(context); } krb5_copy_address(context, auth_context->remote_address, @@ -420,7 +414,7 @@ krb5_auth_con_setenctype(krb5_context context, krb5_free_keyblock(context, auth_context->keyblock); ALLOC(auth_context->keyblock, 1); if(auth_context->keyblock == NULL) - return ENOMEM; + return krb5_enomem(context); auth_context->keyblock->keytype = etype; return 0; } @@ -477,10 +471,8 @@ krb5_auth_con_getauthenticator(krb5_context context, krb5_authenticator *authenticator) { *authenticator = malloc(sizeof(**authenticator)); - if (*authenticator == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (*authenticator == NULL) + return krb5_enomem(context); copy_Authenticator(auth_context->authenticator, *authenticator); diff --git a/lib/krb5/build_auth.c b/lib/krb5/build_auth.c index 01145a28c..003ccae8c 100644 --- a/lib/krb5/build_auth.c +++ b/lib/krb5/build_auth.c @@ -62,8 +62,7 @@ make_etypelist(krb5_context context, ALLOC_SEQ(&ad, 1); if (ad.val == NULL) { free(buf); - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; + return krb5_enomem(context); } ad.val[0].ad_type = KRB5_AUTHDATA_GSS_API_ETYPE_NEGOTIATION; @@ -82,16 +81,14 @@ make_etypelist(krb5_context context, ALLOC(*auth_data, 1); if (*auth_data == NULL) { free(buf); - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; + return krb5_enomem(context); } ALLOC_SEQ(*auth_data, 1); if ((*auth_data)->val == NULL) { free(*auth_data); free(buf); - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; + return krb5_enomem(context); } (*auth_data)->val[0].ad_type = KRB5_AUTHDATA_IF_RELEVANT; @@ -136,7 +133,7 @@ _krb5_build_authenticator (krb5_context context, &auth_context->local_seqnumber); ALLOC(auth.seq_number, 1); if(auth.seq_number == NULL) { - ret = ENOMEM; + ret = krb5_enomem(context); goto fail; } *auth.seq_number = auth_context->local_seqnumber; @@ -147,7 +144,7 @@ _krb5_build_authenticator (krb5_context context, if (cksum) { ALLOC(auth.cksum, 1); if (auth.cksum == NULL) { - ret = ENOMEM; + ret = krb5_enomem(context); goto fail; } ret = copy_Checksum(cksum, auth.cksum); diff --git a/lib/krb5/cache.c b/lib/krb5/cache.c index 88040cbc6..d396c9369 100644 --- a/lib/krb5/cache.c +++ b/lib/krb5/cache.c @@ -383,9 +383,8 @@ krb5_cc_get_full_name(krb5_context context, } if (asprintf(str, "%s:%s", type, name) == -1) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); *str = NULL; - return ENOMEM; + return krb5_enomem(context); } return 0; } @@ -554,10 +553,8 @@ krb5_cc_set_default_name(krb5_context context, const char *name) context->default_cc_name_set = 1; } - if (p == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (p == NULL) + return krb5_enomem(context); ret = _krb5_expand_path_tokens(context, p, &exp_p); free(p); @@ -606,10 +603,8 @@ krb5_cc_default(krb5_context context, { const char *p = krb5_cc_default_name(context); - if (p == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (p == NULL) + return krb5_enomem(context); return krb5_cc_resolve(context, p, id); } @@ -989,7 +984,7 @@ krb5_cc_get_prefix_ops(krb5_context context, const char *prefix) p = strdup(prefix); if (p == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); + krb5_enomem(context); return NULL; } p1 = strchr(p, ':'); @@ -1053,10 +1048,8 @@ krb5_cc_cache_get_first (krb5_context context, } *cursor = calloc(1, sizeof(**cursor)); - if (*cursor == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (*cursor == NULL) + return krb5_enomem(context); (*cursor)->ops = ops; @@ -1388,10 +1381,8 @@ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_cccol_cursor_new(krb5_context context, krb5_cccol_cursor *cursor) { *cursor = calloc(1, sizeof(**cursor)); - if (*cursor == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (*cursor == NULL) + return krb5_enomem(context); (*cursor)->idx = 0; (*cursor)->cursor = NULL; @@ -1577,10 +1568,9 @@ krb5_cc_get_friendly_name(krb5_context context, } else { ret = asprintf(name, "%.*s", (int)data.length, (char *)data.data); krb5_data_free(&data); - if (ret <= 0) { - ret = ENOMEM; - krb5_set_error_message(context, ret, N_("malloc: out of memory", "")); - } else + if (ret <= 0) + ret = krb5_enomem(context); + else ret = 0; } diff --git a/lib/krb5/config_file.c b/lib/krb5/config_file.c index 00b3d6d58..debfd35b2 100644 --- a/lib/krb5/config_file.c +++ b/lib/krb5/config_file.c @@ -447,21 +447,14 @@ krb5_config_parse_file_multi (krb5_context context, int aret; aret = asprintf(&newfname, "%s%s", home, &fname[1]); - if (aret == -1 || newfname == NULL) { - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; - } + if (aret == -1 || newfname == NULL) + return krb5_enomem(context); fname = newfname; } #else /* KRB5_USE_PATH_TOKENS */ if (asprintf(&newfname, "%%{USERCONFIG}%s", &fname[1]) < 0 || newfname == NULL) - { - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; - } + return krb5_enomem(context); fname = newfname; #endif } diff --git a/lib/krb5/config_reg.c b/lib/krb5/config_reg.c index 2611f9f48..04a499d2c 100644 --- a/lib/krb5/config_reg.c +++ b/lib/krb5/config_reg.c @@ -579,10 +579,8 @@ parse_reg_root(krb5_context context, krb5_error_code code = 0; libdefaults = _krb5_config_get_entry(parent, "libdefaults", krb5_config_list); - if (libdefaults == NULL) { - krb5_set_error_message(context, ENOMEM, "Out of memory while parsing configuration"); - return ENOMEM; - } + if (libdefaults == NULL) + return krb5_enomem(context); code = parse_reg_values(context, key, &libdefaults->u.list); if (code) diff --git a/lib/krb5/context.c b/lib/krb5/context.c index 7be765692..d87442964 100644 --- a/lib/krb5/context.c +++ b/lib/krb5/context.c @@ -69,8 +69,7 @@ set_etypes (krb5_context context, etypes = malloc((i+1) * sizeof(*etypes)); if (etypes == NULL) { krb5_config_free_strings (etypes_str); - krb5_set_error_message (context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; + return krb5_enomem(context); } for(j = 0, k = 0; j < i; j++) { krb5_enctype e; @@ -325,11 +324,8 @@ kt_ops_copy(krb5_context context, const krb5_context src_context) return 0; context->kt_types = malloc(sizeof(context->kt_types[0]) * src_context->num_kt_types); - if (context->kt_types == NULL) { - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; - } + if (context->kt_types == NULL) + return krb5_enomem(context); context->num_kt_types = src_context->num_kt_types; memcpy(context->kt_types, src_context->kt_types, @@ -454,11 +450,8 @@ copy_etypes (krb5_context context, i++; *ret_enctypes = malloc(sizeof(ret_enctypes[0]) * i); - if (*ret_enctypes == NULL) { - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; - } + if (*ret_enctypes == NULL) + return krb5_enomem(context); memcpy(*ret_enctypes, enctypes, sizeof(ret_enctypes[0]) * i); return 0; } @@ -485,16 +478,13 @@ krb5_copy_context(krb5_context context, krb5_context *out) *out = NULL; p = calloc(1, sizeof(*p)); - if (p == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (p == NULL) + return krb5_enomem(context); p->mutex = malloc(sizeof(HEIMDAL_MUTEX)); if (p->mutex == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); free(p); - return ENOMEM; + return krb5_enomem(context); } HEIMDAL_MUTEX_init(p->mutex); @@ -1158,10 +1148,8 @@ krb5_set_extra_addresses(krb5_context context, const krb5_addresses *addresses) } if(context->extra_addresses == NULL) { context->extra_addresses = malloc(sizeof(*context->extra_addresses)); - if(context->extra_addresses == NULL) { - krb5_set_error_message (context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (context->extra_addresses == NULL) + return krb5_enomem(context); } return krb5_copy_addresses(context, addresses, context->extra_addresses); } @@ -1240,10 +1228,8 @@ krb5_set_ignore_addresses(krb5_context context, const krb5_addresses *addresses) } if(context->ignore_addresses == NULL) { context->ignore_addresses = malloc(sizeof(*context->ignore_addresses)); - if(context->ignore_addresses == NULL) { - krb5_set_error_message (context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (context->ignore_addresses == NULL) + return krb5_enomem(context); } return krb5_copy_addresses(context, addresses, context->ignore_addresses); } diff --git a/lib/krb5/copy_host_realm.c b/lib/krb5/copy_host_realm.c index 73bc117f1..f68d0d7dc 100644 --- a/lib/krb5/copy_host_realm.c +++ b/lib/krb5/copy_host_realm.c @@ -58,19 +58,14 @@ krb5_copy_host_realm(krb5_context context, ++n; *to = calloc (n, sizeof(**to)); - if (*to == NULL) { - krb5_set_error_message (context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; - } + if (*to == NULL) + return krb5_enomem(context); for (i = 0, p = from; *p != NULL; ++p, ++i) { (*to)[i] = strdup(*p); if ((*to)[i] == NULL) { krb5_free_host_realm (context, *to); - krb5_set_error_message (context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; + return krb5_enomem(context); } } return 0; diff --git a/lib/krb5/creds.c b/lib/krb5/creds.c index 7ef8eb960..78f501b1e 100644 --- a/lib/krb5/creds.c +++ b/lib/krb5/creds.c @@ -138,13 +138,9 @@ krb5_copy_creds (krb5_context context, { krb5_creds *c; - c = malloc (sizeof (*c)); - if (c == NULL) { - krb5_set_error_message (context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; - } - memset (c, 0, sizeof(*c)); + c = calloc(1, sizeof(*c)); + if (c == NULL) + return krb5_enomem(context); *outcred = c; return krb5_copy_creds_contents (context, incred, c); } diff --git a/lib/krb5/crypto-arcfour.c b/lib/krb5/crypto-arcfour.c index ca2d7862c..48da6f0b0 100644 --- a/lib/krb5/crypto-arcfour.c +++ b/lib/krb5/crypto-arcfour.c @@ -75,10 +75,8 @@ _krb5_HMAC_MD5_checksum(krb5_context context, krb5_error_code ret; m = EVP_MD_CTX_create(); - if (m == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (m == NULL) + return krb5_enomem(context); ksign_c.checksum.length = sizeof(ksign_c_data); ksign_c.checksum.data = ksign_c_data; ret = _krb5_internal_hmac(context, c, signature, sizeof(signature), diff --git a/lib/krb5/crypto-des-common.c b/lib/krb5/crypto-des-common.c index f8313952d..962d071f1 100644 --- a/lib/krb5/crypto-des-common.c +++ b/lib/krb5/crypto-des-common.c @@ -70,10 +70,8 @@ _krb5_des_checksum(krb5_context context, krb5_generate_random_block(p, 8); m = EVP_MD_CTX_create(); - if (m == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (m == NULL) + return krb5_enomem(context); EVP_DigestInit_ex(m, evp_md, NULL); EVP_DigestUpdate(m, p, 8); @@ -103,10 +101,8 @@ _krb5_des_verify(krb5_context context, krb5_error_code ret = 0; m = EVP_MD_CTX_create(); - if (m == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (m == NULL) + return krb5_enomem(context); memset(&ivec, 0, sizeof(ivec)); EVP_CipherInit_ex(&ctx->dctx, NULL, NULL, NULL, (void *)&ivec, -1); diff --git a/lib/krb5/crypto-evp.c b/lib/krb5/crypto-evp.c index e8fb1caf6..cab7c2906 100644 --- a/lib/krb5/crypto-evp.c +++ b/lib/krb5/crypto-evp.c @@ -72,10 +72,8 @@ _krb5_evp_encrypt(krb5_context context, /* alloca ? */ size_t len2 = EVP_CIPHER_CTX_iv_length(c); void *loiv = malloc(len2); - if (loiv == NULL) { - krb5_clear_error_message(context); - return ENOMEM; - } + if (loiv == NULL) + return krb5_enomem(context); memset(loiv, 0, len2); EVP_CipherInit_ex(c, NULL, NULL, NULL, loiv, -1); free(loiv); diff --git a/lib/krb5/crypto-pk.c b/lib/krb5/crypto-pk.c index 7fedb65c9..a36cf4dc1 100644 --- a/lib/krb5/crypto-pk.c +++ b/lib/krb5/crypto-pk.c @@ -61,16 +61,13 @@ _krb5_pk_octetstring2key(krb5_context context, keylen = (et->keytype->bits + 7) / 8; keydata = malloc(keylen); - if (keydata == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (keydata == NULL) + return krb5_enomem(context); m = EVP_MD_CTX_create(); if (m == NULL) { free(keydata); - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; + return krb5_enomem(context); } counter = 0; @@ -248,10 +245,8 @@ _krb5_pk_kdf(krb5_context context, keylen = (et->keytype->bits + 7) / 8; keydata = malloc(keylen); - if (keydata == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (keydata == NULL) + return krb5_enomem(context); ret = encode_otherinfo(context, ai, client, server, enctype, as_req, pk_as_rep, ticket, &other); @@ -264,8 +259,7 @@ _krb5_pk_kdf(krb5_context context, if (m == NULL) { free(keydata); free(other.data); - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; + return krb5_enomem(context); } offset = 0; diff --git a/lib/krb5/crypto.c b/lib/krb5/crypto.c index 4377a1a21..8a19b0281 100644 --- a/lib/krb5/crypto.c +++ b/lib/krb5/crypto.c @@ -147,10 +147,8 @@ _key_schedule(krb5_context context, if (key->schedule != NULL) return 0; ALLOC(key->schedule, 1); - if(key->schedule == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (key->schedule == NULL) + return krb5_enomem(context); ret = krb5_data_alloc(key->schedule, kt->schedule_size); if(ret) { free(key->schedule); @@ -325,10 +323,8 @@ get_checksum_key(krb5_context context, size_t i; *key = _new_derived_key(crypto, 0xff/* KRB5_KU_RFC1510_VARIANT */); - if(*key == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (*key == NULL) + return krb5_enomem(context); ret = krb5_copy_keyblock(context, crypto->key.key, &(*key)->key); if(ret) return ret; @@ -666,10 +662,8 @@ krb5_enctype_to_string(krb5_context context, return KRB5_PROG_ETYPE_NOSUPP; } *string = strdup(e->name); - if(*string == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (*string == NULL) + return krb5_enomem(context); return 0; } @@ -836,10 +830,8 @@ encrypt_internal_derived(krb5_context context, block_sz = (sz + et->padsize - 1) &~ (et->padsize - 1); /* pad */ total_sz = block_sz + checksum_sz; p = calloc(1, total_sz); - if(p == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (p == NULL) + return krb5_enomem(context); q = p; krb5_generate_random_block(q, et->confoundersize); /* XXX */ @@ -900,10 +892,8 @@ encrypt_internal(krb5_context context, sz = et->confoundersize + checksum_sz + len; block_sz = (sz + et->padsize - 1) &~ (et->padsize - 1); /* pad */ p = calloc(1, block_sz); - if(p == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (p == NULL) + return krb5_enomem(context); q = p; krb5_generate_random_block(q, et->confoundersize); /* XXX */ @@ -962,10 +952,8 @@ encrypt_internal_special(krb5_context context, krb5_error_code ret; tmp = malloc (sz); - if (tmp == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (tmp == NULL) + return krb5_enomem(context); p = tmp; memset (p, 0, cksum_sz); p += cksum_sz; @@ -1014,10 +1002,8 @@ decrypt_internal_derived(krb5_context context, } p = malloc(len); - if(len != 0 && p == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (len != 0 && p == NULL) + return krb5_enomem(context); memcpy(p, data, len); len -= checksum_sz; @@ -1057,8 +1043,7 @@ decrypt_internal_derived(krb5_context context, result->data = realloc(p, l); if(result->data == NULL && l != 0) { free(p); - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; + return krb5_enomem(context); } result->length = l; return 0; @@ -1091,10 +1076,8 @@ decrypt_internal(krb5_context context, } p = malloc(len); - if(len != 0 && p == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (len != 0 && p == NULL) + return krb5_enomem(context); memcpy(p, data, len); ret = _key_schedule(context, &crypto->key); @@ -1125,8 +1108,7 @@ decrypt_internal(krb5_context context, result->data = realloc(p, l); if(result->data == NULL && l != 0) { free(p); - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; + return krb5_enomem(context); } result->length = l; return 0; @@ -1159,10 +1141,8 @@ decrypt_internal_special(krb5_context context, } p = malloc (len); - if (p == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (p == NULL) + return krb5_enomem(context); memcpy(p, data, len); ret = (*et->encrypt)(context, &crypto->key, p, len, FALSE, usage, ivec); @@ -1175,8 +1155,7 @@ decrypt_internal_special(krb5_context context, result->data = realloc(p, sz); if(result->data == NULL && sz != 0) { free(p); - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; + return krb5_enomem(context); } result->length = sz; return 0; @@ -1864,13 +1843,12 @@ _krb5_derive_key(krb5_context context, nblocks = (kt->bits + et->blocksize * 8 - 1) / (et->blocksize * 8); k = malloc(nblocks * et->blocksize); if(k == NULL) { - ret = ENOMEM; - krb5_set_error_message(context, ret, N_("malloc: out of memory", "")); + ret = krb5_enomem(context); goto out; } ret = _krb5_n_fold(constant, len, k, et->blocksize); if (ret) { - krb5_set_error_message(context, ret, N_("malloc: out of memory", "")); + krb5_enomem(context); goto out; } @@ -1888,8 +1866,7 @@ _krb5_derive_key(krb5_context context, size_t res_len = (kt->bits + 7) / 8; if(len != 0 && c == NULL) { - ret = ENOMEM; - krb5_set_error_message(context, ret, N_("malloc: out of memory", "")); + ret = krb5_enomem(context); goto out; } memcpy(c, constant, len); @@ -1897,14 +1874,13 @@ _krb5_derive_key(krb5_context context, k = malloc(res_len); if(res_len != 0 && k == NULL) { free(c); - ret = ENOMEM; - krb5_set_error_message(context, ret, N_("malloc: out of memory", "")); + ret = krb5_enomem(context); goto out; } ret = _krb5_n_fold(c, len, k, res_len); free(c); if (ret) { - krb5_set_error_message(context, ret, N_("malloc: out of memory", "")); + krb5_enomem(context); goto out; } } @@ -1998,10 +1974,8 @@ _get_derived_key(krb5_context context, return 0; } d = _new_derived_key(crypto, usage); - if(d == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (d == NULL) + return krb5_enomem(context); krb5_copy_keyblock(context, crypto->key.key, &d->key); _krb5_put_int(constant, usage, 5); _krb5_derive_key(context, crypto->et, d, constant, sizeof(constant)); @@ -2035,10 +2009,8 @@ krb5_crypto_init(krb5_context context, { krb5_error_code ret; ALLOC(*crypto, 1); - if(*crypto == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (*crypto == NULL) + return krb5_enomem(context); if(etype == (krb5_enctype)ETYPE_NULL) etype = key->keytype; (*crypto)->et = _krb5_find_enctype(etype); @@ -2641,10 +2613,8 @@ krb5_keytype_to_enctypes (krb5_context context, } ret = malloc(n * sizeof(*ret)); - if (ret == NULL && n != 0) { - krb5_set_error_message(context, ENOMEM, "malloc: out of memory"); - return ENOMEM; - } + if (ret == NULL && n != 0) + return krb5_enomem(context); n = 0; for (i = _krb5_num_etypes - 1; i >= 0; --i) { if (_krb5_etypes[i]->keytype->type == keytype diff --git a/lib/krb5/data.c b/lib/krb5/data.c index f62a5532a..0a6677de9 100644 --- a/lib/krb5/data.c +++ b/lib/krb5/data.c @@ -176,10 +176,8 @@ krb5_copy_data(krb5_context context, { krb5_error_code ret; ALLOC(*outdata, 1); - if(*outdata == NULL) { - krb5_set_error_message(context, ENOMEM, "malloc: out of memory"); - return ENOMEM; - } + if(*outdata == NULL) + return krb5_enomem(context); ret = der_copy_octet_string(indata, *outdata); if(ret) { krb5_clear_error_message (context); diff --git a/lib/krb5/deprecated.c b/lib/krb5/deprecated.c index 03c33531d..dbee7315a 100644 --- a/lib/krb5/deprecated.c +++ b/lib/krb5/deprecated.c @@ -84,10 +84,8 @@ krb5_keytype_to_enctypes_default (krb5_context context, for (n = 0; context->etypes_des[n]; ++n) ; ret = malloc (n * sizeof(*ret)); - if (ret == NULL && n != 0) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (ret == NULL && n != 0) + return krb5_enomem(context); for (i = 0; i < n; ++i) ret[i] = context->etypes_des[i]; *len = n; @@ -140,11 +138,8 @@ krb5_keytype_to_string(krb5_context context, return KRB5_PROG_KEYTYPE_NOSUPP; } *string = strdup(name); - if(*string == NULL) { - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; - } + if (*string == NULL) + return krb5_enomem(context); return 0; } @@ -201,10 +196,8 @@ krb5_password_key_proc (krb5_context context, char buf[BUFSIZ]; *key = malloc (sizeof (**key)); - if (*key == NULL) { - krb5_set_error_message(context, ENOMEM, "malloc: out of memory"); - return ENOMEM; - } + if (*key == NULL) + return krb5_enomem(context); if (password == NULL) { if(UI_UTIL_read_pw_string (buf, sizeof(buf), "Password: ", 0)) { free (*key); diff --git a/lib/krb5/digest.c b/lib/krb5/digest.c index ef3267b3a..4cb3e2504 100644 --- a/lib/krb5/digest.c +++ b/lib/krb5/digest.c @@ -54,8 +54,7 @@ krb5_digest_alloc(krb5_context context, krb5_digest *digest) d = calloc(1, sizeof(*d)); if (d == NULL) { *digest = NULL; - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; + return krb5_enomem(context); } *digest = d; @@ -106,8 +105,7 @@ krb5_digest_set_server_cb(krb5_context context, free(digest->init.channel); digest->init.channel = NULL; } - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; + return krb5_enomem(context); } KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL @@ -120,10 +118,8 @@ krb5_digest_set_type(krb5_context context, return EINVAL; } digest->init.type = strdup(type); - if (digest->init.type == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (digest->init.type == NULL) + return krb5_enomem(context); return 0; } @@ -137,16 +133,13 @@ krb5_digest_set_hostname(krb5_context context, return EINVAL; } digest->init.hostname = malloc(sizeof(*digest->init.hostname)); - if (digest->init.hostname == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (digest->init.hostname == NULL) + return krb5_enomem(context); *digest->init.hostname = strdup(hostname); if (*digest->init.hostname == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); free(digest->init.hostname); digest->init.hostname = NULL; - return ENOMEM; + return krb5_enomem(context); } return 0; } @@ -168,10 +161,8 @@ krb5_digest_set_server_nonce(krb5_context context, return EINVAL; } digest->request.serverNonce = strdup(nonce); - if (digest->request.serverNonce == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (digest->request.serverNonce == NULL) + return krb5_enomem(context); return 0; } @@ -192,10 +183,8 @@ krb5_digest_set_opaque(krb5_context context, return EINVAL; } digest->request.opaque = strdup(opaque); - if (digest->request.opaque == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (digest->request.opaque == NULL) + return krb5_enomem(context); return 0; } @@ -218,16 +207,13 @@ krb5_digest_set_identifier(krb5_context context, return EINVAL; } digest->request.identifier = calloc(1, sizeof(*digest->request.identifier)); - if (digest->request.identifier == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (digest->request.identifier == NULL) + return krb5_enomem(context); *digest->request.identifier = strdup(id); if (*digest->request.identifier == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); free(digest->request.identifier); digest->request.identifier = NULL; - return ENOMEM; + return krb5_enomem(context); } return 0; } @@ -473,16 +459,13 @@ krb5_digest_set_client_nonce(krb5_context context, } digest->request.clientNonce = calloc(1, sizeof(*digest->request.clientNonce)); - if (digest->request.clientNonce == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (digest->request.clientNonce == NULL) + return krb5_enomem(context); *digest->request.clientNonce = strdup(nonce); if (*digest->request.clientNonce == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); free(digest->request.clientNonce); digest->request.clientNonce = NULL; - return ENOMEM; + return krb5_enomem(context); } return 0; } @@ -498,10 +481,8 @@ krb5_digest_set_digest(krb5_context context, return EINVAL; } digest->request.digest = strdup(dgst); - if (digest->request.digest == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (digest->request.digest == NULL) + return krb5_enomem(context); return 0; } @@ -515,10 +496,8 @@ krb5_digest_set_username(krb5_context context, return EINVAL; } digest->request.username = strdup(username); - if (digest->request.username == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (digest->request.username == NULL) + return krb5_enomem(context); return 0; } @@ -532,16 +511,13 @@ krb5_digest_set_authid(krb5_context context, return EINVAL; } digest->request.authid = malloc(sizeof(*digest->request.authid)); - if (digest->request.authid == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (digest->request.authid == NULL) + return krb5_enomem(context); *digest->request.authid = strdup(authid); if (*digest->request.authid == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); free(digest->request.authid); digest->request.authid = NULL; - return ENOMEM; + return krb5_enomem(context); } return 0; } @@ -576,16 +552,13 @@ krb5_digest_set_realm(krb5_context context, return EINVAL; } digest->request.realm = malloc(sizeof(*digest->request.realm)); - if (digest->request.realm == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (digest->request.realm == NULL) + return krb5_enomem(context); *digest->request.realm = strdup(realm); if (*digest->request.realm == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); free(digest->request.realm); digest->request.realm = NULL; - return ENOMEM; + return krb5_enomem(context); } return 0; } @@ -601,16 +574,13 @@ krb5_digest_set_method(krb5_context context, return EINVAL; } digest->request.method = malloc(sizeof(*digest->request.method)); - if (digest->request.method == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (digest->request.method == NULL) + return krb5_enomem(context); *digest->request.method = strdup(method); if (*digest->request.method == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); free(digest->request.method); digest->request.method = NULL; - return ENOMEM; + return krb5_enomem(context); } return 0; } @@ -625,16 +595,13 @@ krb5_digest_set_uri(krb5_context context, return EINVAL; } digest->request.uri = malloc(sizeof(*digest->request.uri)); - if (digest->request.uri == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (digest->request.uri == NULL) + return krb5_enomem(context); *digest->request.uri = strdup(uri); if (*digest->request.uri == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); free(digest->request.uri); digest->request.uri = NULL; - return ENOMEM; + return krb5_enomem(context); } return 0; } @@ -651,16 +618,13 @@ krb5_digest_set_nonceCount(krb5_context context, } digest->request.nonceCount = malloc(sizeof(*digest->request.nonceCount)); - if (digest->request.nonceCount == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (digest->request.nonceCount == NULL) + return krb5_enomem(context); *digest->request.nonceCount = strdup(nonce_count); if (*digest->request.nonceCount == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); free(digest->request.nonceCount); digest->request.nonceCount = NULL; - return ENOMEM; + return krb5_enomem(context); } return 0; } @@ -675,16 +639,13 @@ krb5_digest_set_qop(krb5_context context, return EINVAL; } digest->request.qop = malloc(sizeof(*digest->request.qop)); - if (digest->request.qop == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (digest->request.qop == NULL) + return krb5_enomem(context); *digest->request.qop = strdup(qop); if (*digest->request.qop == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); free(digest->request.qop); digest->request.qop = NULL; - return ENOMEM; + return krb5_enomem(context); } return 0; } @@ -695,10 +656,8 @@ krb5_digest_set_responseData(krb5_context context, const char *response) { digest->request.responseData = strdup(response); - if (digest->request.responseData == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (digest->request.responseData == NULL) + return krb5_enomem(context); return 0; } @@ -803,8 +762,7 @@ krb5_digest_get_client_binding(krb5_context context, if (*type == NULL || *binding == NULL) { free(*type); free(*binding); - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; + return krb5_enomem(context); } } else { *type = NULL; @@ -842,10 +800,8 @@ krb5_ntlm_alloc(krb5_context context, krb5_ntlm *ntlm) { *ntlm = calloc(1, sizeof(**ntlm)); - if (*ntlm == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (*ntlm == NULL) + return krb5_enomem(context); return 0; } @@ -966,10 +922,8 @@ krb5_ntlm_init_get_targetname(krb5_context context, char **name) { *name = strdup(ntlm->initReply.targetname); - if (*name == NULL) { - krb5_clear_error_message(context); - return ENOMEM; - } + if (*name == NULL) + return krb5_enomem(context); return 0; } @@ -1060,10 +1014,8 @@ krb5_ntlm_req_set_username(krb5_context context, const char *username) { ntlm->request.username = strdup(username); - if (ntlm->request.username == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (ntlm->request.username == NULL) + return krb5_enomem(context); return 0; } @@ -1073,10 +1025,8 @@ krb5_ntlm_req_set_targetname(krb5_context context, const char *targetname) { ntlm->request.targetname = strdup(targetname); - if (ntlm->request.targetname == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (ntlm->request.targetname == NULL) + return krb5_enomem(context); return 0; } @@ -1086,10 +1036,8 @@ krb5_ntlm_req_set_lm(krb5_context context, void *hash, size_t len) { ntlm->request.lm.data = malloc(len); - if (ntlm->request.lm.data == NULL && len != 0) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (ntlm->request.lm.data == NULL && len != 0) + return krb5_enomem(context); ntlm->request.lm.length = len; memcpy(ntlm->request.lm.data, hash, len); return 0; @@ -1101,10 +1049,8 @@ krb5_ntlm_req_set_ntlm(krb5_context context, void *hash, size_t len) { ntlm->request.ntlm.data = malloc(len); - if (ntlm->request.ntlm.data == NULL && len != 0) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (ntlm->request.ntlm.data == NULL && len != 0) + return krb5_enomem(context); ntlm->request.ntlm.length = len; memcpy(ntlm->request.ntlm.data, hash, len); return 0; @@ -1116,10 +1062,8 @@ krb5_ntlm_req_set_opaque(krb5_context context, krb5_data *opaque) { ntlm->request.opaque.data = malloc(opaque->length); - if (ntlm->request.opaque.data == NULL && opaque->length != 0) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (ntlm->request.opaque.data == NULL && opaque->length != 0) + return krb5_enomem(context); ntlm->request.opaque.length = opaque->length; memcpy(ntlm->request.opaque.data, opaque->data, opaque->length); return 0; @@ -1131,15 +1075,11 @@ krb5_ntlm_req_set_session(krb5_context context, void *sessionkey, size_t length) { ntlm->request.sessionkey = calloc(1, sizeof(*ntlm->request.sessionkey)); - if (ntlm->request.sessionkey == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (ntlm->request.sessionkey == NULL) + return krb5_enomem(context); ntlm->request.sessionkey->data = malloc(length); - if (ntlm->request.sessionkey->data == NULL && length != 0) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (ntlm->request.sessionkey->data == NULL && length != 0) + return krb5_enomem(context); memcpy(ntlm->request.sessionkey->data, sessionkey, length); ntlm->request.sessionkey->length = length; return 0; diff --git a/lib/krb5/expand_hostname.c b/lib/krb5/expand_hostname.c index 7b638d5f0..5023d1677 100644 --- a/lib/krb5/expand_hostname.c +++ b/lib/krb5/expand_hostname.c @@ -39,11 +39,8 @@ copy_hostname(krb5_context context, char **new_hostname) { *new_hostname = strdup (orig_hostname); - if (*new_hostname == NULL) { - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; - } + if (*new_hostname == NULL) + return krb5_enomem(context); strlwr (*new_hostname); return 0; } @@ -84,13 +81,10 @@ krb5_expand_hostname (krb5_context context, if (a->ai_canonname != NULL) { *new_hostname = strdup (a->ai_canonname); freeaddrinfo (ai); - if (*new_hostname == NULL) { - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; - } else { + if (*new_hostname == NULL) + return krb5_enomem(context); + else return 0; - } } } freeaddrinfo (ai); diff --git a/lib/krb5/fcache.c b/lib/krb5/fcache.c index 731f29341..9beaa1c64 100644 --- a/lib/krb5/fcache.c +++ b/lib/krb5/fcache.c @@ -555,8 +555,7 @@ init_fcc (krb5_context context, sp = krb5_storage_from_fd(fd); if(sp == NULL) { - krb5_clear_error_message(context); - ret = ENOMEM; + ret = krb5_enomem(context); goto out; } krb5_storage_set_eof_code(sp, KRB5_CC_END); @@ -722,10 +721,8 @@ fcc_get_first (krb5_context context, return krb5_einval(context, 2); *cursor = malloc(sizeof(struct fcc_cursor)); - if (*cursor == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (*cursor == NULL) + return krb5_enomem(context); memset(*cursor, 0, sizeof(struct fcc_cursor)); ret = init_fcc (context, id, &FCC_CURSOR(*cursor)->sp, @@ -823,7 +820,7 @@ fcc_remove_cred(krb5_context context, ret = asprintf(&newname, "FILE:%s.XXXXXX", FILENAME(id)); if (ret < 0 || newname == NULL) { krb5_cc_destroy(context, copy); - return ENOMEM; + return krb5_enomem(context); } fd = mkstemp(&newname[5]); @@ -890,10 +887,8 @@ fcc_get_cache_first(krb5_context context, krb5_cc_cursor *cursor) struct fcache_iter *iter; iter = calloc(1, sizeof(*iter)); - if (iter == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (iter == NULL) + return krb5_enomem(context); iter->first = 1; *cursor = iter; return 0; diff --git a/lib/krb5/generate_subkey.c b/lib/krb5/generate_subkey.c index 2344dbc9f..07047461e 100644 --- a/lib/krb5/generate_subkey.c +++ b/lib/krb5/generate_subkey.c @@ -55,10 +55,8 @@ krb5_generate_subkey_extended(krb5_context context, krb5_error_code ret; ALLOC(*subkey, 1); - if (*subkey == NULL) { - krb5_set_error_message(context, ENOMEM,N_("malloc: out of memory", "")); - return ENOMEM; - } + if (*subkey == NULL) + return krb5_enomem(context); if (etype == (krb5_enctype)ETYPE_NULL) etype = key->keytype; /* use session key etype */ diff --git a/lib/krb5/get_addrs.c b/lib/krb5/get_addrs.c index 0e2bfcf66..edb3b044e 100644 --- a/lib/krb5/get_addrs.c +++ b/lib/krb5/get_addrs.c @@ -64,10 +64,8 @@ gethostname_fallback (krb5_context context, krb5_addresses *res) } res->len = 1; res->val = malloc (sizeof(*res->val)); - if (res->val == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (res->val == NULL) + return krb5_enomem(context); res->val[0].addr_type = hostent->h_addrtype; res->val[0].address.data = NULL; res->val[0].address.length = 0; @@ -132,8 +130,7 @@ find_all_addresses (krb5_context context, krb5_addresses *res, int flags) if (res->val == NULL) { krb5_free_addresses(context, &ignore_addresses); freeifaddrs(ifa0); - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; + return krb5_enomem(context); } /* Now traverse the list. */ diff --git a/lib/krb5/get_default_realm.c b/lib/krb5/get_default_realm.c index 2a4933a62..81a55bb15 100644 --- a/lib/krb5/get_default_realm.c +++ b/lib/krb5/get_default_realm.c @@ -73,11 +73,8 @@ krb5_get_default_realm(krb5_context context, } res = strdup (context->default_realms[0]); - if (res == NULL) { - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; - } + if (res == NULL) + return krb5_enomem(context); *realm = res; return 0; } diff --git a/lib/krb5/get_for_creds.c b/lib/krb5/get_for_creds.c index 2ec1c5e41..8a00ccec8 100644 --- a/lib/krb5/get_for_creds.c +++ b/lib/krb5/get_for_creds.c @@ -49,8 +49,7 @@ add_addrs(krb5_context context, tmp = realloc(addr->val, (addr->len + n) * sizeof(*addr->val)); if (tmp == NULL && (addr->len + n) != 0) { - ret = ENOMEM; - krb5_set_error_message(context, ret, N_("malloc: out of memory", "")); + ret = krb5_enomem(context); goto fail; } addr->val = tmp; @@ -266,8 +265,7 @@ krb5_get_forwarded_creds (krb5_context context, cred.msg_type = krb_cred; ALLOC_SEQ(&cred.tickets, 1); if (cred.tickets.val == NULL) { - ret = ENOMEM; - krb5_set_error_message(context, ret, N_("malloc: out of memory", "")); + ret = krb5_enomem(context); goto out2; } ret = decode_Ticket(out_creds->ticket.data, @@ -279,8 +277,7 @@ krb5_get_forwarded_creds (krb5_context context, memset (&enc_krb_cred_part, 0, sizeof(enc_krb_cred_part)); ALLOC_SEQ(&enc_krb_cred_part.ticket_info, 1); if (enc_krb_cred_part.ticket_info.val == NULL) { - ret = ENOMEM; - krb5_set_error_message(context, ret, N_("malloc: out of memory", "")); + ret = krb5_enomem(context); goto out4; } @@ -292,15 +289,13 @@ krb5_get_forwarded_creds (krb5_context context, ALLOC(enc_krb_cred_part.timestamp, 1); if (enc_krb_cred_part.timestamp == NULL) { - ret = ENOMEM; - krb5_set_error_message(context, ret, N_("malloc: out of memory", "")); + ret = krb5_enomem(context); goto out4; } *enc_krb_cred_part.timestamp = sec; ALLOC(enc_krb_cred_part.usec, 1); if (enc_krb_cred_part.usec == NULL) { - ret = ENOMEM; - krb5_set_error_message(context, ret, N_("malloc: out of memory", "")); + ret = krb5_enomem(context); goto out4; } *enc_krb_cred_part.usec = usec; @@ -343,9 +338,7 @@ krb5_get_forwarded_creds (krb5_context context, } else { ALLOC(enc_krb_cred_part.r_address, 1); if (enc_krb_cred_part.r_address == NULL) { - ret = ENOMEM; - krb5_set_error_message(context, ret, - N_("malloc: out of memory", "")); + ret = krb5_enomem(context); goto out4; } diff --git a/lib/krb5/get_host_realm.c b/lib/krb5/get_host_realm.c index ed7f54b3d..35edaecc7 100644 --- a/lib/krb5/get_host_realm.c +++ b/lib/krb5/get_host_realm.c @@ -189,16 +189,13 @@ _krb5_get_host_realm_int (krb5_context context, if(p != NULL) { p++; *realms = malloc(2 * sizeof(krb5_realm)); - if (*realms == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (*realms == NULL) + return krb5_enomem(context); (*realms)[0] = strdup(p); if((*realms)[0] == NULL) { free(*realms); - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; + return krb5_enomem(context); } strupr((*realms)[0]); (*realms)[1] = NULL; diff --git a/lib/krb5/get_in_tkt.c b/lib/krb5/get_in_tkt.c index f97ae7e9a..471b900a0 100644 --- a/lib/krb5/get_in_tkt.c +++ b/lib/krb5/get_in_tkt.c @@ -119,10 +119,8 @@ add_padata(krb5_context context, netypes++; } pa2 = realloc (md->val, (md->len + netypes) * sizeof(*md->val)); - if (pa2 == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (pa2 == NULL) + return krb5_enomem(context); md->val = pa2; for (i = 0; i < netypes; ++i) { @@ -166,14 +164,12 @@ init_as_req (krb5_context context, a->req_body.kdc_options = opts; a->req_body.cname = malloc(sizeof(*a->req_body.cname)); if (a->req_body.cname == NULL) { - ret = ENOMEM; - krb5_set_error_message(context, ret, N_("malloc: out of memory", "")); + ret = krb5_enomem(context); goto fail; } a->req_body.sname = malloc(sizeof(*a->req_body.sname)); if (a->req_body.sname == NULL) { - ret = ENOMEM; - krb5_set_error_message(context, ret, N_("malloc: out of memory", "")); + ret = krb5_enomem(context); goto fail; } ret = _krb5_principal2principalname (a->req_body.cname, creds->client); @@ -189,8 +185,7 @@ init_as_req (krb5_context context, if(creds->times.starttime) { a->req_body.from = malloc(sizeof(*a->req_body.from)); if (a->req_body.from == NULL) { - ret = ENOMEM; - krb5_set_error_message(context, ret, N_("malloc: out of memory", "")); + ret = krb5_enomem(context); goto fail; } *a->req_body.from = creds->times.starttime; @@ -202,8 +197,7 @@ init_as_req (krb5_context context, if(creds->times.renew_till){ a->req_body.rtime = malloc(sizeof(*a->req_body.rtime)); if (a->req_body.rtime == NULL) { - ret = ENOMEM; - krb5_set_error_message(context, ret, N_("malloc: out of memory", "")); + ret = krb5_enomem(context); goto fail; } *a->req_body.rtime = creds->times.renew_till; @@ -226,8 +220,7 @@ init_as_req (krb5_context context, } else { a->req_body.addresses = malloc(sizeof(*a->req_body.addresses)); if (a->req_body.addresses == NULL) { - ret = ENOMEM; - krb5_set_error_message(context, ret, N_("malloc: out of memory", "")); + ret = krb5_enomem(context); goto fail; } @@ -251,8 +244,7 @@ init_as_req (krb5_context context, size_t i; ALLOC(a->padata, 1); if(a->padata == NULL) { - ret = ENOMEM; - krb5_set_error_message(context, ret, N_("malloc: out of memory", "")); + ret = krb5_enomem(context); goto fail; } a->padata->val = NULL; @@ -290,8 +282,7 @@ init_as_req (krb5_context context, else if (*ptypes == KRB5_PADATA_ENC_TIMESTAMP) { ALLOC(a->padata, 1); if (a->padata == NULL) { - ret = ENOMEM; - krb5_set_error_message(context, ret, N_("malloc: out of memory", "")); + ret = krb5_enomem(context); goto fail; } a->padata->len = 0; diff --git a/lib/krb5/init_creds.c b/lib/krb5/init_creds.c index 25bef0f34..a9c151345 100644 --- a/lib/krb5/init_creds.c +++ b/lib/krb5/init_creds.c @@ -60,18 +60,13 @@ krb5_get_init_creds_opt_alloc(krb5_context context, *opt = NULL; o = calloc(1, sizeof(*o)); - if (o == NULL) { - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; - } + if (o == NULL) + return krb5_enomem(context); o->opt_private = calloc(1, sizeof(*o->opt_private)); if (o->opt_private == NULL) { - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); free(o); - return ENOMEM; + return krb5_enomem(context); } o->opt_private->refcount = 1; *opt = o; @@ -423,10 +418,8 @@ krb5_get_init_creds_opt_get_error(krb5_context context, KRB5_DEPRECATED_FUNCTION("Use X instead") { *error = calloc(1, sizeof(**error)); - if (*error == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (*error == NULL) + return krb5_enomem(context); return 0; } diff --git a/lib/krb5/init_creds_pw.c b/lib/krb5/init_creds_pw.c index 859346511..24b0cd6eb 100644 --- a/lib/krb5/init_creds_pw.c +++ b/lib/krb5/init_creds_pw.c @@ -298,11 +298,8 @@ krb5_process_last_request(krb5_context context, krb5_last_req_entry **lre; lre = calloc(lr->len + 1, sizeof(**lre)); - if (lre == NULL) { - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; - } + if (lre == NULL) + return krb5_enomem(context); for (i = 0; i < lr->len; i++) { lre[i] = calloc(1, sizeof(*lre[i])); if (lre[i] == NULL) @@ -464,8 +461,7 @@ get_init_creds_common(krb5_context context, etypes = malloc((options->etype_list_length + 1) * sizeof(krb5_enctype)); if (etypes == NULL) { - ret = ENOMEM; - krb5_set_error_message(context, ret, N_("malloc: out of memory", "")); + ret = krb5_enomem(context); goto out; } memcpy (etypes, options->etype_list, @@ -477,8 +473,7 @@ get_init_creds_common(krb5_context context, pre_auth_types = malloc((options->preauth_list_length + 1) * sizeof(krb5_preauthtype)); if (pre_auth_types == NULL) { - ret = ENOMEM; - krb5_set_error_message(context, ret, N_("malloc: out of memory", "")); + ret = krb5_enomem(context); goto out; } memcpy (pre_auth_types, options->preauth_list, @@ -650,14 +645,12 @@ init_as_req (krb5_context context, a->req_body.kdc_options = opts; a->req_body.cname = malloc(sizeof(*a->req_body.cname)); if (a->req_body.cname == NULL) { - ret = ENOMEM; - krb5_set_error_message(context, ret, N_("malloc: out of memory", "")); + ret = krb5_enomem(context); goto fail; } a->req_body.sname = malloc(sizeof(*a->req_body.sname)); if (a->req_body.sname == NULL) { - ret = ENOMEM; - krb5_set_error_message(context, ret, N_("malloc: out of memory", "")); + ret = krb5_enomem(context); goto fail; } @@ -675,8 +668,7 @@ init_as_req (krb5_context context, if(creds->times.starttime) { a->req_body.from = malloc(sizeof(*a->req_body.from)); if (a->req_body.from == NULL) { - ret = ENOMEM; - krb5_set_error_message(context, ret, N_("malloc: out of memory", "")); + ret = krb5_enomem(context); goto fail; } *a->req_body.from = creds->times.starttime; @@ -688,8 +680,7 @@ init_as_req (krb5_context context, if(creds->times.renew_till){ a->req_body.rtime = malloc(sizeof(*a->req_body.rtime)); if (a->req_body.rtime == NULL) { - ret = ENOMEM; - krb5_set_error_message(context, ret, N_("malloc: out of memory", "")); + ret = krb5_enomem(context); goto fail; } *a->req_body.rtime = creds->times.renew_till; @@ -712,8 +703,7 @@ init_as_req (krb5_context context, } else { a->req_body.addresses = malloc(sizeof(*a->req_body.addresses)); if (a->req_body.addresses == NULL) { - ret = ENOMEM; - krb5_set_error_message(context, ret, N_("malloc: out of memory", "")); + ret = krb5_enomem(context); goto fail; } @@ -1180,10 +1170,9 @@ process_pa_data_to_md(krb5_context context, krb5_error_code ret; ALLOC(*out_md, 1); - if (*out_md == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (*out_md == NULL) + return krb5_enomem(context); + (*out_md)->len = 0; (*out_md)->val = NULL; @@ -1387,10 +1376,8 @@ krb5_init_creds_init(krb5_context context, *rctx = NULL; ctx = calloc(1, sizeof(*ctx)); - if (ctx == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (ctx == NULL) + return krb5_enomem(context); ret = get_init_creds_common(context, client, start_time, options, ctx); if (ret) { @@ -1488,10 +1475,8 @@ krb5_init_creds_set_password(krb5_context context, } if (password) { ctx->password = strdup(password); - if (ctx->password == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (ctx->password == NULL) + return krb5_enomem(context); ctx->keyseed = (void *) ctx->password; } else { ctx->keyseed = NULL; @@ -1559,11 +1544,8 @@ krb5_init_creds_set_keytab(krb5_context context, int kvno = 0, found = 0; a = malloc(sizeof(*a)); - if (a == NULL) { - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; - } + if (a == NULL) + return krb5_enomem(context); a->principal = ctx->cred.client; a->keytab = keytab; @@ -2328,7 +2310,7 @@ krb5_init_creds_get_error(krb5_context context, ret = copy_KRB_ERROR(&ctx->error, error); if (ret) - krb5_set_error_message(context, ret, N_("malloc: out of memory", "")); + krb5_enomem(context); return ret; } diff --git a/lib/krb5/kcm.c b/lib/krb5/kcm.c index 6d783d7d5..557dc5fe4 100644 --- a/lib/krb5/kcm.c +++ b/lib/krb5/kcm.c @@ -553,9 +553,7 @@ kcm_get_first (krb5_context context, c = calloc(1, sizeof(*c)); if (c == NULL) { - ret = ENOMEM; - krb5_set_error_message(context, ret, - N_("malloc: out of memory", "")); + ret = krb5_enomem(context); return ret; } @@ -577,9 +575,7 @@ kcm_get_first (krb5_context context, if (ptr == NULL) { free(c->uuids); free(c); - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; + return krb5_enomem(context); } c->uuids = ptr; @@ -788,9 +784,7 @@ kcm_get_cache_first(krb5_context context, krb5_cc_cursor *cursor) c = calloc(1, sizeof(*c)); if (c == NULL) { - ret = ENOMEM; - krb5_set_error_message(context, ret, - N_("malloc: out of memory", "")); + ret = krb5_enomem(context); goto out; } @@ -819,9 +813,7 @@ kcm_get_cache_first(krb5_context context, krb5_cc_cursor *cursor) ptr = realloc(c->uuids, sizeof(c->uuids[0]) * (c->length + 1)); if (ptr == NULL) { - ret = ENOMEM; - krb5_set_error_message(context, ret, - N_("malloc: out of memory", "")); + ret = krb5_enomem(context); goto out; } c->uuids = ptr; diff --git a/lib/krb5/keyblock.c b/lib/krb5/keyblock.c index 6e781aca7..abca3ee05 100644 --- a/lib/krb5/keyblock.c +++ b/lib/krb5/keyblock.c @@ -135,10 +135,8 @@ krb5_copy_keyblock (krb5_context context, *to = NULL; k = calloc (1, sizeof(*k)); - if (k == NULL) { - krb5_set_error_message(context, ENOMEM, "malloc: out of memory"); - return ENOMEM; - } + if (k == NULL) + return krb5_enomem(context); ret = krb5_copy_keyblock_contents (context, inblock, k); if (ret) { diff --git a/lib/krb5/keytab_any.c b/lib/krb5/keytab_any.c index a808311b8..eea5d64bf 100644 --- a/lib/krb5/keytab_any.c +++ b/lib/krb5/keytab_any.c @@ -63,15 +63,14 @@ any_resolve(krb5_context context, const char *name, krb5_keytab id) while (strsep_copy(&name, ",", buf, sizeof(buf)) != -1) { a = calloc(1, sizeof(*a)); if (a == NULL) { - ret = ENOMEM; + ret = krb5_enomem(context); goto fail; } if (a0 == NULL) { a0 = a; a->name = strdup(buf); if (a->name == NULL) { - ret = ENOMEM; - krb5_set_error_message(context, ret, N_("malloc: out of memory", "")); + ret = krb5_enomem(context); goto fail; } } else @@ -131,10 +130,8 @@ any_start_seq_get(krb5_context context, krb5_error_code ret; c->data = malloc (sizeof(struct any_cursor_extra_data)); - if(c->data == NULL){ - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if(c->data == NULL) + return krb5_enomem(context); ed = (struct any_cursor_extra_data *)c->data; for (ed->a = a; ed->a != NULL; ed->a = ed->a->next) { ret = krb5_kt_start_seq_get(context, ed->a->kt, &ed->cursor); diff --git a/lib/krb5/keytab_file.c b/lib/krb5/keytab_file.c index 51cdd3178..8b596790a 100644 --- a/lib/krb5/keytab_file.c +++ b/lib/krb5/keytab_file.c @@ -59,10 +59,8 @@ krb5_kt_ret_data(krb5_context context, return ret; data->length = size; data->data = malloc(size); - if (data->data == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (data->data == NULL) + return krb5_enomem(context); ret = krb5_storage_read(sp, data->data, size); if(ret != size) return (ret < 0)? errno : KRB5_KT_END; @@ -80,10 +78,8 @@ krb5_kt_ret_string(krb5_context context, if(ret) return ret; *data = malloc(size + 1); - if (*data == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (*data == NULL) + return krb5_enomem(context); ret = krb5_storage_read(sp, *data, size); (*data)[size] = '\0'; if(ret != size) @@ -188,11 +184,8 @@ krb5_kt_ret_principal(krb5_context context, int16_t len; ALLOC(p, 1); - if(p == NULL) { - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; - } + if(p == NULL) + return krb5_enomem(context); ret = krb5_ret_int16(sp, &len); if(ret) { @@ -221,8 +214,7 @@ krb5_kt_ret_principal(krb5_context context, } p->name.name_string.val = calloc(len, sizeof(*p->name.name_string.val)); if(p->name.name_string.val == NULL) { - ret = ENOMEM; - krb5_set_error_message(context, ret, N_("malloc: out of memory", "")); + ret = krb5_enomem(context); goto out; } p->name.name_string.len = len; @@ -292,15 +284,12 @@ fkt_resolve(krb5_context context, const char *name, krb5_keytab id) struct fkt_data *d; d = malloc(sizeof(*d)); - if(d == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if(d == NULL) + return krb5_enomem(context); d->filename = strdup(name); if(d->filename == NULL) { free(d); - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; + return krb5_enomem(context); } d->flags = 0; id->data = d; @@ -397,9 +386,7 @@ fkt_start_seq_get_int(krb5_context context, if (c->sp == NULL) { _krb5_xunlock(context, c->fd); close(c->fd); - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; + return krb5_enomem(context); } krb5_storage_set_eof_code(c->sp, KRB5_KT_END); ret = krb5_ret_int8(c->sp, &pvno); @@ -622,9 +609,7 @@ fkt_add_entry(krb5_context context, krb5_storage *emem; emem = krb5_storage_emem(); if(emem == NULL) { - ret = ENOMEM; - krb5_set_error_message(context, ret, - N_("malloc: out of memory", "")); + ret = krb5_enomem(context); goto out; } ret = krb5_kt_store_principal(context, emem, entry->principal); diff --git a/lib/krb5/keytab_keyfile.c b/lib/krb5/keytab_keyfile.c index 5c1dbff6e..d1af4c19c 100644 --- a/lib/krb5/keytab_keyfile.c +++ b/lib/krb5/keytab_keyfile.c @@ -89,11 +89,8 @@ get_cell_and_realm (krb5_context context, struct akf_data *d) fclose(f); d->cell = strdup (buf); - if (d->cell == NULL) { - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; - } + if (d->cell == NULL) + return krb5_enomem(context); f = fopen (AFS_SERVERMAGICKRBCONF, "r"); if (f != NULL) { @@ -117,9 +114,7 @@ get_cell_and_realm (krb5_context context, struct akf_data *d) if (d->realm == NULL) { free (d->cell); d->cell = NULL; - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; + return krb5_enomem(context); } return 0; } @@ -134,11 +129,8 @@ akf_resolve(krb5_context context, const char *name, krb5_keytab id) int ret; struct akf_data *d = malloc(sizeof (struct akf_data)); - if (d == NULL) { - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; - } + if (d == NULL) + return krb5_enomem(context); d->num_entries = 0; ret = get_cell_and_realm (context, d); @@ -151,9 +143,7 @@ akf_resolve(krb5_context context, const char *name, krb5_keytab id) free (d->cell); free (d->realm); free (d); - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; + return krb5_enomem(context); } id->data = d; @@ -271,9 +261,7 @@ akf_next_entry(krb5_context context, entry->keyblock.keyvalue.data = malloc (8); if (entry->keyblock.keyvalue.data == NULL) { krb5_free_principal (context, entry->principal); - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - ret = ENOMEM; + ret = krb5_enomem(context); goto out; } @@ -348,9 +336,7 @@ akf_add_entry(krb5_context context, sp = krb5_storage_from_fd(fd); if(sp == NULL) { close(fd); - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; + return krb5_enomem(context); } if (created) len = 0; diff --git a/lib/krb5/keytab_memory.c b/lib/krb5/keytab_memory.c index c0deeab92..87953a68e 100644 --- a/lib/krb5/keytab_memory.c +++ b/lib/krb5/keytab_memory.c @@ -73,17 +73,13 @@ mkt_resolve(krb5_context context, const char *name, krb5_keytab id) d = calloc(1, sizeof(*d)); if(d == NULL) { HEIMDAL_MUTEX_unlock(&mkt_mutex); - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; + return krb5_enomem(context); } d->name = strdup(name); if (d->name == NULL) { HEIMDAL_MUTEX_unlock(&mkt_mutex); free(d); - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; + return krb5_enomem(context); } d->entries = NULL; d->num_entries = 0; @@ -175,11 +171,8 @@ mkt_add_entry(krb5_context context, struct mkt_data *d = id->data; krb5_keytab_entry *tmp; tmp = realloc(d->entries, (d->num_entries + 1) * sizeof(*d->entries)); - if(tmp == NULL) { - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; - } + if (tmp == NULL) + return krb5_enomem(context); d->entries = tmp; return krb5_kt_copy_entry_contents(context, entry, &d->entries[d->num_entries++]); diff --git a/lib/krb5/krbhst.c b/lib/krb5/krbhst.c index be9411cf5..f30ec79be 100644 --- a/lib/krb5/krbhst.c +++ b/lib/krb5/krbhst.c @@ -101,9 +101,7 @@ srv_find_realm(krb5_context context, krb5_krbhst_info ***res, int *count, *res = malloc(num_srv * sizeof(**res)); if(*res == NULL) { rk_dns_free_data(r); - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; + return krb5_enomem(context); } rk_dns_srv_order(r); @@ -120,7 +118,7 @@ srv_find_realm(krb5_context context, krb5_krbhst_info ***res, int *count, free((*res)[num_srv]); free(*res); *res = NULL; - return ENOMEM; + return krb5_enomem(context); } (*res)[num_srv++] = hi; @@ -280,11 +278,8 @@ _krb5_krbhost_info_move(krb5_context context, size_t hostnamelen = strlen(from->hostname); /* trailing NUL is included in structure */ *to = calloc(1, sizeof(**to) + hostnamelen); - if(*to == NULL) { - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; - } + if (*to == NULL) + return krb5_enomem(context); (*to)->proto = from->proto; (*to)->port = from->port; @@ -321,7 +316,7 @@ append_host_string(krb5_context context, struct krb5_krbhst_data *kd, hi = parse_hostspec(context, kd, host, def_port, port); if(hi == NULL) - return ENOMEM; + return krb5_enomem(context); append_host_hostinfo(kd, hi); return 0; @@ -1083,7 +1078,7 @@ gethostlist(krb5_context context, const char *realm, *hostlist = calloc(nhost + 1, sizeof(**hostlist)); if(*hostlist == NULL) { krb5_krbhst_free(context, handle); - return ENOMEM; + return krb5_enomem(context); } krb5_krbhst_reset(context, handle); @@ -1093,7 +1088,7 @@ gethostlist(krb5_context context, const char *realm, if(((*hostlist)[nhost++] = strdup(host)) == NULL) { krb5_free_krbhst(context, *hostlist); krb5_krbhst_free(context, handle); - return ENOMEM; + return krb5_enomem(context); } } (*hostlist)[nhost] = NULL; diff --git a/lib/krb5/log.c b/lib/krb5/log.c index 4b289afd8..90d013f99 100644 --- a/lib/krb5/log.c +++ b/lib/krb5/log.c @@ -121,17 +121,12 @@ krb5_initlog(krb5_context context, krb5_log_facility **fac) { krb5_log_facility *f = calloc(1, sizeof(*f)); - if(f == NULL) { - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; - } + if (f == NULL) + return krb5_enomem(context); f->program = strdup(program); if(f->program == NULL){ free(f); - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; + return krb5_enomem(context); } *fac = f; return 0; @@ -147,11 +142,8 @@ krb5_addlog_func(krb5_context context, void *data) { struct facility *fp = log_realloc(fac); - if(fp == NULL) { - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; - } + if (fp == NULL) + return krb5_enomem(context); fp->min = min; fp->max = max; fp->log_func = log_func; @@ -190,11 +182,8 @@ open_syslog(krb5_context context, struct _heimdal_syslog_data *sd = malloc(sizeof(*sd)); int i; - if(sd == NULL) { - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; - } + if (sd == NULL) + return krb5_enomem(context); i = find_value(sev, syslogvals); if(i == -1) i = LOG_ERR; @@ -255,11 +244,8 @@ open_file(krb5_context context, krb5_log_facility *fac, int min, int max, const char *filename, const char *mode, FILE *f, int keep_open) { struct file_data *fd = malloc(sizeof(*fd)); - if(fd == NULL) { - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; - } + if (fd == NULL) + return krb5_enomem(context); fd->filename = filename; fd->mode = mode; fd->fd = f; @@ -307,11 +293,8 @@ krb5_addlog_dest(krb5_context context, krb5_log_facility *f, const char *orig) FILE *file = NULL; int keep_open = 0; fn = strdup(p + 5); - if(fn == NULL) { - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; - } + if (fn == NULL) + return krb5_enomem(context); if(p[4] == '='){ int i = open(fn, O_WRONLY | O_CREAT | O_TRUNC | O_APPEND, 0666); diff --git a/lib/krb5/mcache.c b/lib/krb5/mcache.c index cda6f0ba5..cd4611c6c 100644 --- a/lib/krb5/mcache.c +++ b/lib/krb5/mcache.c @@ -509,11 +509,8 @@ static krb5_error_code KRB5_CALLCONV mcc_default_name(krb5_context context, char **str) { *str = strdup("MEMORY:"); - if (*str == NULL) { - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; - } + if (*str == NULL) + return krb5_enomem(context); return 0; } diff --git a/lib/krb5/misc.c b/lib/krb5/misc.c index 7814761d0..3983e6d27 100644 --- a/lib/krb5/misc.c +++ b/lib/krb5/misc.c @@ -48,42 +48,32 @@ _krb5_s4u2self_to_checksumdata(krb5_context context, size_t i; sp = krb5_storage_emem(); - if (sp == NULL) { - krb5_clear_error_message(context); - return ENOMEM; - } + if (sp == NULL) + return krb5_enomem(context); krb5_storage_set_flags(sp, KRB5_STORAGE_BYTEORDER_LE); ret = krb5_store_int32(sp, self->name.name_type); - if (ret) - goto out; + if (ret) { + krb5_clear_error_message(context); + return ret; + } for (i = 0; i < self->name.name_string.len; i++) { size = strlen(self->name.name_string.val[i]); ssize = krb5_storage_write(sp, self->name.name_string.val[i], size); - if (ssize != (krb5_ssize_t)size) { - ret = ENOMEM; - goto out; - } + if (ssize != (krb5_ssize_t)size) + return krb5_enomem(context); } size = strlen(self->realm); ssize = krb5_storage_write(sp, self->realm, size); - if (ssize != (krb5_ssize_t)size) { - ret = ENOMEM; - goto out; - } + if (ssize != (krb5_ssize_t)size) + return krb5_enomem(context); size = strlen(self->auth); ssize = krb5_storage_write(sp, self->auth, size); - if (ssize != (krb5_ssize_t)size) { - ret = ENOMEM; - goto out; - } + if (ssize != (krb5_ssize_t)size) + return krb5_enomem(context); ret = krb5_storage_to_data(sp, data); krb5_storage_free(sp); return ret; - -out: - krb5_clear_error_message(context); - return ret; } void diff --git a/lib/krb5/mit_glue.c b/lib/krb5/mit_glue.c index 16c230a11..2c011c428 100644 --- a/lib/krb5/mit_glue.c +++ b/lib/krb5/mit_glue.c @@ -96,7 +96,7 @@ krb5_c_get_checksum(krb5_context context, const krb5_checksum *cksum, if (data) { *data = malloc(sizeof(**data)); if (*data == NULL) - return ENOMEM; + return krb5_enomem(context); ret = der_copy_octet_string(&cksum->checksum, *data); if (ret) { @@ -167,7 +167,7 @@ krb5_copy_checksum (krb5_context context, { *new = malloc(sizeof(**new)); if (*new == NULL) - return ENOMEM; + return krb5_enomem(context); return copy_Checksum(old, *new); } diff --git a/lib/krb5/mk_priv.c b/lib/krb5/mk_priv.c index dede6d2fa..e3b2f9128 100644 --- a/lib/krb5/mk_priv.c +++ b/lib/krb5/mk_priv.c @@ -135,10 +135,8 @@ krb5_mk_priv(krb5_context context, ret = krb5_data_copy(outbuf, buf + buf_size - len, len); if (ret) { - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); free(buf); - return ENOMEM; + return krb5_enomem(context); } free (buf); if (auth_context->flags & KRB5_AUTH_CONTEXT_DO_SEQUENCE) diff --git a/lib/krb5/mk_rep.c b/lib/krb5/mk_rep.c index 84c315291..bd24c6ec6 100644 --- a/lib/krb5/mk_rep.c +++ b/lib/krb5/mk_rep.c @@ -67,9 +67,7 @@ krb5_mk_rep(krb5_context context, &body.subkey); if (ret) { free_EncAPRepPart(&body); - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; + return krb5_enomem(context); } } else body.subkey = NULL; @@ -80,9 +78,8 @@ krb5_mk_rep(krb5_context context, &auth_context->local_seqnumber); ALLOC(body.seq_number, 1); if (body.seq_number == NULL) { - krb5_set_error_message(context, ENOMEM, "malloc: out of memory"); free_EncAPRepPart(&body); - return ENOMEM; + return krb5_enomem(context); } *(body.seq_number) = auth_context->local_seqnumber; } else diff --git a/lib/krb5/padata.c b/lib/krb5/padata.c index babe22cb3..71c9a7f14 100644 --- a/lib/krb5/padata.c +++ b/lib/krb5/padata.c @@ -49,11 +49,8 @@ krb5_padata_add(krb5_context context, METHOD_DATA *md, PA_DATA *pa; pa = realloc (md->val, (md->len + 1) * sizeof(*md->val)); - if (pa == NULL) { - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; - } + if (pa == NULL) + return krb5_enomem(context); md->val = pa; pa[md->len].padata_type = type; diff --git a/lib/krb5/pkinit.c b/lib/krb5/pkinit.c index c6106d7d1..901708499 100644 --- a/lib/krb5/pkinit.c +++ b/lib/krb5/pkinit.c @@ -399,9 +399,7 @@ build_auth_pack(krb5_context context, ALLOC(a->pkAuthenticator.paChecksum, 1); if (a->pkAuthenticator.paChecksum == NULL) { - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; + return krb5_enomem(context); } ret = krb5_data_copy(a->pkAuthenticator.paChecksum, @@ -436,11 +434,8 @@ build_auth_pack(krb5_context context, return ret; ctx->u.dh = DH_new(); - if (ctx->u.dh == NULL) { - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; - } + if (ctx->u.dh == NULL) + return krb5_enomem(context); ret = select_dh_group(context, ctx->u.dh, dh_min_bits, ctx->m); if (ret) @@ -763,9 +758,7 @@ pk_mk_padata(krb5_context context, req.trustedCertifiers = calloc(1, sizeof(*req.trustedCertifiers)); if (req.trustedCertifiers == NULL) { - ret = ENOMEM; - krb5_set_error_message(context, ret, - N_("malloc: out of memory", "")); + ret = krb5_enomem(context); free_PA_PK_AS_REQ(&req); goto out; } @@ -980,9 +973,7 @@ get_reply_key_win(krb5_context context, *key = malloc (sizeof (**key)); if (*key == NULL) { free_ReplyKeyPack_Win2k(&key_pack); - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; + return krb5_enomem(context); } ret = copy_EncryptionKey(&key_pack.replyKey, *key); @@ -1045,9 +1036,7 @@ get_reply_key(krb5_context context, *key = malloc (sizeof (**key)); if (*key == NULL) { free_ReplyKeyPack(&key_pack); - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; + return krb5_enomem(context); } ret = copy_EncryptionKey(&key_pack.replyKey, *key); @@ -1430,8 +1419,7 @@ pk_rd_pa_reply_dh(krb5_context context, dh_gen_key = malloc(size); if (dh_gen_key == NULL) { - ret = ENOMEM; - krb5_set_error_message(context, ret, N_("malloc: out of memory", "")); + ret = krb5_enomem(context); goto out; } @@ -1479,9 +1467,7 @@ pk_rd_pa_reply_dh(krb5_context context, dh_gen_key = malloc(size); if (dh_gen_key == NULL) { EC_KEY_free(public); - ret = ENOMEM; - krb5_set_error_message(context, ret, - N_("malloc: out of memory", "")); + ret = krb5_enomem(context); goto out; } dh_gen_keylen = ECDH_compute_key(dh_gen_key, size, @@ -1509,9 +1495,7 @@ pk_rd_pa_reply_dh(krb5_context context, *key = malloc (sizeof (**key)); if (*key == NULL) { - ret = ENOMEM; - krb5_set_error_message(context, ret, - N_("malloc: out of memory", "")); + ret = krb5_enomem(context); goto out; } @@ -1863,11 +1847,8 @@ _krb5_pk_load_id(krb5_context context, /* load cert */ id = calloc(1, sizeof(*id)); - if (id == NULL) { - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; - } + if (id == NULL) + return krb5_enomem(context); if (user_id) { hx509_lock lock; @@ -2050,11 +2031,8 @@ _krb5_parse_moduli_line(krb5_context context, *m = NULL; m1 = calloc(1, sizeof(*m1)); - if (m1 == NULL) { - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; - } + if (m1 == NULL) + return krb5_enomem(context); while (isspace((unsigned char)*p)) p++; @@ -2073,8 +2051,7 @@ _krb5_parse_moduli_line(krb5_context context, } m1->name = strdup(p1); if (m1->name == NULL) { - ret = ENOMEM; - krb5_set_error_message(context, ret, N_("malloc: out of memeory", "")); + ret = krb5_enomem(context); goto out; } @@ -2198,11 +2175,8 @@ _krb5_parse_moduli(krb5_context context, const char *file, *moduli = NULL; m = calloc(1, sizeof(m[0]) * 3); - if (m == NULL) { - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; - } + if (m == NULL) + return krb5_enomem(context); strlcpy(buf, default_moduli_rfc3526_MODP_group14, sizeof(buf)); ret = _krb5_parse_moduli_line(context, "builtin", 1, buf, &m[0]); @@ -2254,9 +2228,7 @@ _krb5_parse_moduli(krb5_context context, const char *file, m2 = realloc(m, (n + 2) * sizeof(m[0])); if (m2 == NULL) { _krb5_free_moduli(m); - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; + return krb5_enomem(context); } m = m2; @@ -2384,11 +2356,8 @@ krb5_get_init_creds_opt_set_pkinit(krb5_context context, opt->opt_private->pk_init_ctx = calloc(1, sizeof(*opt->opt_private->pk_init_ctx)); - if (opt->opt_private->pk_init_ctx == NULL) { - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; - } + if (opt->opt_private->pk_init_ctx == NULL) + return krb5_enomem(context); opt->opt_private->pk_init_ctx->require_binding = 0; opt->opt_private->pk_init_ctx->require_eku = 1; opt->opt_private->pk_init_ctx->require_krbtgt_otherName = 1; diff --git a/lib/krb5/rd_cred.c b/lib/krb5/rd_cred.c index 63a6a4202..e6fe059f4 100644 --- a/lib/krb5/rd_cred.c +++ b/lib/krb5/rd_cred.c @@ -249,9 +249,7 @@ krb5_rd_cred(krb5_context context, sizeof(**ret_creds)); if (*ret_creds == NULL) { - ret = ENOMEM; - krb5_set_error_message(context, ret, - N_("malloc: out of memory", "")); + ret = krb5_enomem(context); goto out; } @@ -261,9 +259,7 @@ krb5_rd_cred(krb5_context context, creds = calloc(1, sizeof(*creds)); if(creds == NULL) { - ret = ENOMEM; - krb5_set_error_message(context, ret, - N_("malloc: out of memory", "")); + ret = krb5_enomem(context); goto out; } diff --git a/lib/krb5/rd_rep.c b/lib/krb5/rd_rep.c index 391d81c19..602535cdb 100644 --- a/lib/krb5/rd_rep.c +++ b/lib/krb5/rd_rep.c @@ -75,8 +75,7 @@ krb5_rd_rep(krb5_context context, *repl = malloc(sizeof(**repl)); if (*repl == NULL) { - ret = ENOMEM; - krb5_set_error_message(context, ret, N_("malloc: out of memory", "")); + ret = krb5_enomem(context); goto out; } ret = decode_EncAPRepPart(data.data, data.length, *repl, &len); diff --git a/lib/krb5/rd_req.c b/lib/krb5/rd_req.c index 78d750fb6..075e2944b 100644 --- a/lib/krb5/rd_req.c +++ b/lib/krb5/rd_req.c @@ -361,8 +361,7 @@ krb5_verify_ap_req2(krb5_context context, t = calloc(1, sizeof(*t)); if (t == NULL) { - ret = ENOMEM; - krb5_clear_error_message (context); + ret = krb5_enomem(context); goto out; } @@ -545,11 +544,8 @@ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_rd_req_in_ctx_alloc(krb5_context context, krb5_rd_req_in_ctx *ctx) { *ctx = calloc(1, sizeof(**ctx)); - if (*ctx == NULL) { - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; - } + if (*ctx == NULL) + return krb5_enomem(context); (*ctx)->check_pac = (context->flags & KRB5_CTX_F_CHECK_PAC) ? 1 : 0; return 0; } @@ -866,11 +862,8 @@ krb5_rd_req_ctx(krb5_context context, *outctx = NULL; o = calloc(1, sizeof(*o)); - if (o == NULL) { - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; - } + if (o == NULL) + return krb5_enomem(context); if (*auth_context == NULL) { ret = krb5_auth_con_init(context, auth_context); diff --git a/lib/krb5/rd_safe.c b/lib/krb5/rd_safe.c index e62906b1f..71c29c276 100644 --- a/lib/krb5/rd_safe.c +++ b/lib/krb5/rd_safe.c @@ -191,8 +191,7 @@ krb5_rd_safe(krb5_context context, outbuf->length = safe.safe_body.user_data.length; outbuf->data = malloc(outbuf->length); if (outbuf->data == NULL && outbuf->length != 0) { - ret = ENOMEM; - krb5_set_error_message(context, ret, N_("malloc: out of memory", "")); + ret = krb5_enomem(context); krb5_data_zero(outbuf); goto failure; } diff --git a/lib/krb5/recvauth.c b/lib/krb5/recvauth.c index a6f1d51c9..3af283d7c 100644 --- a/lib/krb5/recvauth.c +++ b/lib/krb5/recvauth.c @@ -164,9 +164,7 @@ krb5_recvauth_match_version(krb5_context context, if (her_appl_version == NULL) { repl = 2; krb5_net_write (context, p_fd, &repl, 1); - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; + return krb5_enomem(context); } if (krb5_net_read (context, p_fd, her_appl_version, len) != len || !(*match_appl_version)(match_data, her_appl_version)) { diff --git a/lib/krb5/replay.c b/lib/krb5/replay.c index 70480d636..625731167 100644 --- a/lib/krb5/replay.c +++ b/lib/krb5/replay.c @@ -305,11 +305,8 @@ krb5_get_server_rcache(krb5_context context, char *tmp = malloc(4 * piece->length + 1); char *name; - if(tmp == NULL) { - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; - } + if (tmp == NULL) + return krb5_enomem(context); strvisx(tmp, piece->data, piece->length, VIS_WHITE | VIS_OCTAL); #ifdef HAVE_GETEUID ret = asprintf(&name, "FILE:rc_%s_%u", tmp, (unsigned)geteuid()); @@ -317,11 +314,8 @@ krb5_get_server_rcache(krb5_context context, ret = asprintf(&name, "FILE:rc_%s", tmp); #endif free(tmp); - if(ret < 0 || name == NULL) { - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; - } + if (ret < 0 || name == NULL) + return krb5_enomem(context); ret = krb5_rc_resolve_full(context, &rcache, name); free(name); diff --git a/lib/krb5/salt-aes.c b/lib/krb5/salt-aes.c index d2076269d..2444d19b8 100644 --- a/lib/krb5/salt-aes.c +++ b/lib/krb5/salt-aes.c @@ -63,10 +63,8 @@ AES_string_to_key(krb5_context context, kd.schedule = NULL; ALLOC(kd.key, 1); - if(kd.key == NULL) { - krb5_set_error_message (context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (kd.key == NULL) + return krb5_enomem(context); kd.key->keytype = enctype; ret = krb5_data_alloc(&kd.key->keyvalue, et->keytype->size); if (ret) { diff --git a/lib/krb5/salt-arcfour.c b/lib/krb5/salt-arcfour.c index f8a4b391e..374614b91 100644 --- a/lib/krb5/salt-arcfour.c +++ b/lib/krb5/salt-arcfour.c @@ -48,8 +48,7 @@ ARCFOUR_string_to_key(krb5_context context, m = EVP_MD_CTX_create(); if (m == NULL) { - ret = ENOMEM; - krb5_set_error_message(context, ret, N_("malloc: out of memory", "")); + ret = krb5_enomem(context); goto out; } @@ -64,9 +63,7 @@ ARCFOUR_string_to_key(krb5_context context, s = malloc (len * sizeof(s[0])); if (len != 0 && s == NULL) { - krb5_set_error_message (context, ENOMEM, - N_("malloc: out of memory", "")); - ret = ENOMEM; + ret = krb5_enomem(context); goto out; } @@ -89,7 +86,7 @@ ARCFOUR_string_to_key(krb5_context context, key->keytype = enctype; ret = krb5_data_alloc (&key->keyvalue, 16); if (ret) { - krb5_set_error_message (context, ENOMEM, N_("malloc: out of memory", "")); + krb5_enomem(context); goto out; } EVP_DigestFinal_ex (m, key->keyvalue.data, NULL); diff --git a/lib/krb5/salt-des.c b/lib/krb5/salt-des.c index 804b3f254..afcff675b 100644 --- a/lib/krb5/salt-des.c +++ b/lib/krb5/salt-des.c @@ -191,10 +191,8 @@ krb5_DES_string_to_key(krb5_context context, len = password.length + salt.saltvalue.length; s = malloc(len); - if(len > 0 && s == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (len > 0 && s == NULL) + return krb5_enomem(context); memcpy(s, password.data, password.length); memcpy(s + password.length, salt.saltvalue.data, salt.saltvalue.length); DES_string_to_key_int(s, len, &tmp); diff --git a/lib/krb5/salt-des3.c b/lib/krb5/salt-des3.c index f2e40f2d5..c62ba6cac 100644 --- a/lib/krb5/salt-des3.c +++ b/lib/krb5/salt-des3.c @@ -50,10 +50,8 @@ DES3_string_to_key(krb5_context context, len = password.length + salt.saltvalue.length; str = malloc(len); - if(len != 0 && str == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (len != 0 && str == NULL) + return krb5_enomem(context); memcpy(str, password.data, password.length); memcpy(str + password.length, salt.saltvalue.data, salt.saltvalue.length); { @@ -112,10 +110,8 @@ DES3_string_to_key_derived(krb5_context context, char *s; s = malloc(len); - if(len != 0 && s == NULL) { - krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; - } + if (len != 0 && s == NULL) + return krb5_enomem(context); memcpy(s, password.data, password.length); memcpy(s + password.length, salt.saltvalue.data, salt.saltvalue.length); ret = krb5_string_to_key_derived(context, diff --git a/lib/krb5/salt.c b/lib/krb5/salt.c index 5e4c8a1c8..198e1b8a4 100644 --- a/lib/krb5/salt.c +++ b/lib/krb5/salt.c @@ -53,11 +53,8 @@ krb5_salttype_to_string (krb5_context context, for (st = e->keytype->string_to_key; st && st->type; st++) { if (st->type == stype) { *string = strdup (st->name); - if (*string == NULL) { - krb5_set_error_message (context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; - } + if (*string == NULL) + return krb5_enomem(context); return 0; } } @@ -263,11 +260,8 @@ krb5_string_to_key_derived(krb5_context context, keylen = et->keytype->bits / 8; ALLOC(kd.key, 1); - if(kd.key == NULL) { - krb5_set_error_message (context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; - } + if (kd.key == NULL) + return krb5_enomem(context); ret = krb5_data_alloc(&kd.key->keyvalue, et->keytype->size); if(ret) { free(kd.key); @@ -277,13 +271,12 @@ krb5_string_to_key_derived(krb5_context context, tmp = malloc (keylen); if(tmp == NULL) { krb5_free_keyblock(context, kd.key); - krb5_set_error_message (context, ENOMEM, N_("malloc: out of memory", "")); - return ENOMEM; + return krb5_enomem(context); } ret = _krb5_n_fold(str, len, tmp, keylen); if (ret) { free(tmp); - krb5_set_error_message (context, ENOMEM, N_("malloc: out of memory", "")); + krb5_enomem(context); return ret; } kd.schedule = NULL; diff --git a/lib/krb5/scache.c b/lib/krb5/scache.c index 3ea23f705..7b04a5197 100644 --- a/lib/krb5/scache.c +++ b/lib/krb5/scache.c @@ -657,11 +657,8 @@ encode_creds(krb5_context context, krb5_creds *creds, krb5_data *data) krb5_storage *sp; sp = krb5_storage_emem(); - if (sp == NULL) { - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; - } + if (sp == NULL) + return krb5_enomem(context); ret = krb5_store_creds(sp, creds); if (ret) { @@ -687,11 +684,8 @@ decode_creds(krb5_context context, const void *data, size_t length, krb5_storage *sp; sp = krb5_storage_from_readonly_mem(data, length); - if (sp == NULL) { - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; - } + if (sp == NULL) + return krb5_enomem(context); ret = krb5_ret_creds(sp, creds); krb5_storage_free(sp); @@ -881,11 +875,8 @@ scc_get_first (krb5_context context, *cursor = NULL; ctx = calloc(1, sizeof(*ctx)); - if (ctx == NULL) { - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; - } + if (ctx == NULL) + return krb5_enomem(context); ret = make_database(context, s); if (ret) { @@ -904,19 +895,15 @@ scc_get_first (krb5_context context, ret = asprintf(&name, "credIteration%pPid%d", ctx, (int)getpid()); if (ret < 0 || name == NULL) { - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); free(ctx); - return ENOMEM; + return krb5_enomem(context); } ret = asprintf(&ctx->drop, "DROP TABLE %s", name); if (ret < 0 || ctx->drop == NULL) { - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); free(name); free(ctx); - return ENOMEM; + return krb5_enomem(context); } ret = asprintf(&str, "CREATE TEMPORARY TABLE %s " @@ -926,7 +913,7 @@ scc_get_first (krb5_context context, free(ctx->drop); free(name); free(ctx); - return ENOMEM; + return krb5_enomem(context); } ret = exec_stmt(context, s->db, str, KRB5_CC_IO); @@ -1160,11 +1147,8 @@ scc_get_cache_first(krb5_context context, krb5_cc_cursor *cursor) *cursor = NULL; ctx = calloc(1, sizeof(*ctx)); - if (ctx == NULL) { - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; - } + if (ctx == NULL) + return krb5_enomem(context); ret = default_db(context, &ctx->db); if (ctx->db == NULL) { @@ -1175,33 +1159,27 @@ scc_get_cache_first(krb5_context context, krb5_cc_cursor *cursor) ret = asprintf(&name, "cacheIteration%pPid%d", ctx, (int)getpid()); if (ret < 0 || name == NULL) { - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); sqlite3_close(ctx->db); free(ctx); - return ENOMEM; + return krb5_enomem(context); } ret = asprintf(&ctx->drop, "DROP TABLE %s", name); if (ret < 0 || ctx->drop == NULL) { - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); sqlite3_close(ctx->db); free(name); free(ctx); - return ENOMEM; + return krb5_enomem(context); } ret = asprintf(&str, "CREATE TEMPORARY TABLE %s AS SELECT name FROM caches", name); if (ret < 0 || str == NULL) { - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); sqlite3_close(ctx->db); free(name); free(ctx->drop); free(ctx); - return ENOMEM; + return krb5_enomem(context); } ret = exec_stmt(context, ctx->db, str, KRB5_CC_IO); @@ -1223,7 +1201,7 @@ scc_get_cache_first(krb5_context context, krb5_cc_cursor *cursor) free(name); free(ctx->drop); free(ctx); - return ENOMEM; + return krb5_enomem(context); } ret = prepare_stmt(context, ctx->db, &ctx->stmt, str); @@ -1372,11 +1350,8 @@ scc_get_default_name(krb5_context context, char **str) ret = asprintf(str, "SCC:%s", name); free(name); - if (ret < 0 || *str == NULL) { - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; - } + if (ret < 0 || *str == NULL) + return krb5_enomem(context); return 0; } diff --git a/lib/krb5/send_to_kdc.c b/lib/krb5/send_to_kdc.c index 42babc6c1..8e8416b59 100644 --- a/lib/krb5/send_to_kdc.c +++ b/lib/krb5/send_to_kdc.c @@ -182,6 +182,8 @@ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_sendto_ctx_alloc(krb5_context context, krb5_sendto_ctx *ctx) { *ctx = heim_alloc(sizeof(**ctx), "sendto-context", dealloc_sendto_ctx); + if (*ctx == NULL) + return krb5_enomem(context); (*ctx)->hosts = heim_array_create(); return 0; diff --git a/lib/krb5/set_default_realm.c b/lib/krb5/set_default_realm.c index ddce677c1..b3450c40b 100644 --- a/lib/krb5/set_default_realm.c +++ b/lib/krb5/set_default_realm.c @@ -43,17 +43,12 @@ string_to_list (krb5_context context, const char *s, krb5_realm **list) { *list = malloc (2 * sizeof(**list)); - if (*list == NULL) { - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; - } + if (*list == NULL) + return krb5_enomem(context); (*list)[0] = strdup (s); if ((*list)[0] == NULL) { free (*list); - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; + return krb5_enomem(context); } (*list)[1] = NULL; return 0; diff --git a/lib/krb5/ticket.c b/lib/krb5/ticket.c index 979d5ffa6..c1c98edf4 100644 --- a/lib/krb5/ticket.c +++ b/lib/krb5/ticket.c @@ -81,11 +81,8 @@ krb5_copy_ticket(krb5_context context, *to = NULL; tmp = malloc(sizeof(*tmp)); - if(tmp == NULL) { - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; - } + if (tmp == NULL) + return krb5_enomem(context); if((ret = copy_EncTicketPart(&from->ticket, &tmp->ticket))){ free(tmp); return ret; diff --git a/lib/krb5/verify_user.c b/lib/krb5/verify_user.c index 01562ef56..663196b29 100644 --- a/lib/krb5/verify_user.c +++ b/lib/krb5/verify_user.c @@ -100,11 +100,8 @@ KRB5_LIB_FUNCTION int KRB5_LIB_CALL krb5_verify_opt_alloc(krb5_context context, krb5_verify_opt **opt) { *opt = calloc(1, sizeof(**opt)); - if ((*opt) == NULL) { - krb5_set_error_message(context, ENOMEM, - N_("malloc: out of memory", "")); - return ENOMEM; - } + if ((*opt) == NULL) + return krb5_enomem(context); krb5_verify_opt_init(*opt); return 0; }