oysteikt/heimdal
0
0
Fork 0
Code Issues 5 Pull Requests Releases Activity

Use krb5_enomem() more consistently in lib/krb5.

Browse Source
This commit is contained in:
Roland C. Dowdeswell
2013-02-13 16:15:00 +08:00
parent edae63418e
commit f0f07ff408
62 changed files with 393 additions and 837 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
lib/krb5/Makefile.am
View File

@@ -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 \

15
lib/krb5/acache.c
View File

@@ -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;
}

4
lib/krb5/acl.c
View File

@@ -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;

31
lib/krb5/addr_families.c
View File

@@ -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;

4
lib/krb5/asn1_glue.c
View File

@@ -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;

30
lib/krb5/auth_context.c
View File

@@ -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);

13
lib/krb5/build_auth.c
View File

@@ -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);

36
lib/krb5/cache.c
View File

@@ -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;
}

13
lib/krb5/config_file.c
View File

@@ -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
}

6
lib/krb5/config_reg.c
View File

@@ -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)

38
lib/krb5/context.c
View File

@@ -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);
}

11
lib/krb5/copy_host_realm.c
View File

@@ -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;

10
lib/krb5/creds.c
View File

@@ -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);
}

6
lib/krb5/crypto-arcfour.c
View File

@@ -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),

12
lib/krb5/crypto-des-common.c
View File

@@ -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);

6
lib/krb5/crypto-evp.c
View File

@@ -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);

18
lib/krb5/crypto-pk.c
View File

@@ -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;

94
lib/krb5/crypto.c
View File

@@ -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

6
lib/krb5/data.c
View File

@@ -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);

19
lib/krb5/deprecated.c
View File

@@ -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);

180
lib/krb5/digest.c
View File

@@ -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;

16
lib/krb5/expand_hostname.c
View File

@@ -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);

17
lib/krb5/fcache.c
View File

@@ -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;

6
lib/krb5/generate_subkey.c
View File

@@ -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 */

9
lib/krb5/get_addrs.c
View File

@@ -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. */

7
lib/krb5/get_default_realm.c
View File

@@ -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;
}

19
lib/krb5/get_for_creds.c
View File

@@ -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;
}

9
lib/krb5/get_host_realm.c
View File

@@ -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;

27
lib/krb5/get_in_tkt.c
View File

@@ -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;

17
lib/krb5/init_creds.c
View File

@@ -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;
}

56
lib/krb5/init_creds_pw.c
View File

@@ -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;
}

16
lib/krb5/kcm.c
View File

@@ -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;

6
lib/krb5/keyblock.c
View File

@@ -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) {

11
lib/krb5/keytab_any.c
View File

@@ -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);

39
lib/krb5/keytab_file.c
View File

@@ -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);

30
lib/krb5/keytab_keyfile.c
View File

@@ -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;

15
lib/krb5/keytab_memory.c
View File

@@ -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++]);

19
lib/krb5/krbhst.c
View File

@@ -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;

39
lib/krb5/log.c
View File

@@ -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);

7
lib/krb5/mcache.c
View File

@@ -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;
}

34
lib/krb5/misc.c
View File

@@ -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

4
lib/krb5/mit_glue.c
View File

@@ -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);
}

4
lib/krb5/mk_priv.c
View File

@@ -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)

7
lib/krb5/mk_rep.c
View File

@@ -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

7
lib/krb5/padata.c
View File

@@ -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;

69
lib/krb5/pkinit.c
View File

@@ -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;

8
lib/krb5/rd_cred.c
View File

@@ -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;
}

3
lib/krb5/rd_rep.c
View File

@@ -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);

17
lib/krb5/rd_req.c
View File

@@ -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);

3
lib/krb5/rd_safe.c
View File

@@ -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;
}

4
lib/krb5/recvauth.c
View File

@@ -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)) {

14
lib/krb5/replay.c
View File

@@ -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);

6
lib/krb5/salt-aes.c
View File

@@ -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) {

9
lib/krb5/salt-arcfour.c
View File

@@ -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);

6
lib/krb5/salt-des.c
View File

@@ -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);

12
lib/krb5/salt-des3.c
View File

@@ -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,

19
lib/krb5/salt.c
View File

@@ -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;

59
lib/krb5/scache.c
View File

@@ -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;
}

2
lib/krb5/send_to_kdc.c
View File

@@ -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;

11
lib/krb5/set_default_realm.c
View File

@@ -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;

7
lib/krb5/ticket.c
View File

@@ -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;

7
lib/krb5/verify_user.c
View File

@@ -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;
}