check return value of alloc functions, from Charles Longeau

git-svn-id: svn://svn.h5l.se/heimdal/trunk/heimdal@21745 ec53bebd-3082-4978-b11e-865c3cabbd6b

ChangeLog

@@ -1,5 +1,7 @@
 2007-07-31  Love H<>rnquist <20>strand  <lha@it.su.se>
 
+	* check return value of alloc functions, from Charles Longeau
+
 	* lib/krb5/principal.c: spelling.
 
 	* kadmin/kadmin.8: spelling

admin/list.c

@@ -114,6 +114,11 @@ do_list(struct list_options *opt, const char *keytab_str)
 	if(opt->keys_flag) {
 	    int i;
 	    s = malloc(2 * entry.keyblock.keyvalue.length + 1);
+	    if (s == NULL) {
+		krb5_warnx(context, "malloc failed");
+		ret = ENOMEM;
+		goto out;
+	    }
 	    for(i = 0; i < entry.keyblock.keyvalue.length; i++)
 		snprintf(s + 2 * i, 3, "%02x", 
 			 ((unsigned char*)entry.keyblock.keyvalue.data)[i]);
@@ -124,6 +129,8 @@ do_list(struct list_options *opt, const char *keytab_str)
     }
     ret = krb5_kt_end_seq_get(context, keytab, &cursor);
     rtbl_format(table, stdout);
+
+out:
     rtbl_destroy(table);
 
     krb5_kt_close(context, keytab);

kadmin/get.c

@@ -87,6 +87,8 @@ static int
 add_column(struct get_entry_data *data, struct field_name *ff, const char *header)
 {
     struct field_info *f = malloc(sizeof(*f));
+    if (f == NULL)
+	return ENOMEM;
     f->ff = ff;
     if(header)
 	f->header = strdup(header);

kadmin/random_password.c

@@ -123,7 +123,11 @@ generate_password(char **pw, int num_classes, ...)
     unsigned char rbuf[8]; /* random buffer */
     int rleft = 0;
 
+    *pw = NULL;
+
     classes = malloc(num_classes * sizeof(*classes));
+    if(classes == NULL)
+	return;
     va_start(ap, num_classes);
     len = 0;
     for(i = 0; i < num_classes; i++){

kadmin/util.c

@@ -648,6 +648,10 @@ parse_des_key (const char *key_string, krb5_key_data *key_data,
 	key_data[i].key_data_type[0]     = ETYPE_DES_CBC_CRC;
 	key_data[i].key_data_length[0]   = 8;
 	key_data[i].key_data_contents[0] = malloc(8);
+	if (key_data[i].key_data_contents[0] == NULL) {
+	    *error = "malloc";
+	    return ENOMEM;
+	}
 	memcpy (key_data[i].key_data_contents[0], bits, 8);
 	/* salt */
 	key_data[i].key_data_type[1]     = KRB5_PW_SALT;

kdc/hprop.c

@@ -157,12 +157,18 @@ v4_prop(void *arg, struct v4_principal *p)
     ent.entry.kvno = p->kvno;
     ent.entry.keys.len = 3;
     ent.entry.keys.val = malloc(ent.entry.keys.len * sizeof(*ent.entry.keys.val));
+    if (ent.entry.keys.val == NULL)
+	krb5_errx(pd->context, ENOMEM, "malloc");
     if(p->mkvno != -1) {
 	ent.entry.keys.val[0].mkvno = malloc (sizeof(*ent.entry.keys.val[0].mkvno));
+	if (ent.entry.keys.val[0].mkvno == NULL)
+	    krb5_errx(pd->context, ENOMEM, "malloc");
 	*(ent.entry.keys.val[0].mkvno) = p->mkvno;
     } else
 	ent.entry.keys.val[0].mkvno = NULL;
     ent.entry.keys.val[0].salt = calloc(1, sizeof(*ent.entry.keys.val[0].salt));
+    if (ent.entry.keys.val[0].salt == NULL)
+	krb5_errx(pd->context, ENOMEM, "calloc");
     ent.entry.keys.val[0].salt->type = KRB5_PADATA_PW_SALT;
     ent.entry.keys.val[0].key.keytype = ETYPE_DES_CBC_MD5;
     krb5_data_alloc(&ent.entry.keys.val[0].key.keyvalue, DES_KEY_SZ);
@@ -292,8 +298,12 @@ ka_convert(struct prop_data *pd, int fd, struct ka_entry *ent)
     hdb.entry.keys.len = 3;
     hdb.entry.keys.val = 
 	malloc(hdb.entry.keys.len * sizeof(*hdb.entry.keys.val));
+    if (hdb.entry.keys.val == NULL)
+	krb5_errx(pd->context, ENOMEM, "malloc");
     hdb.entry.keys.val[0].mkvno = NULL;
     hdb.entry.keys.val[0].salt = calloc(1, sizeof(*hdb.entry.keys.val[0].salt));
+    if (hdb.entry.keys.val[0].salt == NULL)
+	krb5_errx(pd->context, ENOMEM, "calloc");
     if (ka_use_null_salt) {
 	hdb.entry.keys.val[0].salt->type = hdb_pw_salt;
 	hdb.entry.keys.val[0].salt->salt.data = NULL;
@@ -301,6 +311,8 @@ ka_convert(struct prop_data *pd, int fd, struct ka_entry *ent)
     } else {
 	hdb.entry.keys.val[0].salt->type = hdb_afs3_salt;
 	hdb.entry.keys.val[0].salt->salt.data = strdup(afs_cell);
+	if (hdb.entry.keys.val[0].salt->salt.data == NULL)
+	    krb5_errx(pd->context, ENOMEM, "strdup");
 	hdb.entry.keys.val[0].salt->salt.length = strlen(afs_cell);
     }
     

kdc/kerberos5.c

@@ -1554,6 +1554,10 @@ _kdc_as_rep(krb5_context context,
      * otherwise just a dummy lr.
      */
     ek.last_req.val = malloc(2 * sizeof(*ek.last_req.val));
+    if (ek.last_req.val == NULL) {
+	ret = ENOMEM;
+	goto out;
+    }
     ek.last_req.len = 0;
     if (client->entry.pw_end
 	&& (config->kdc_warn_pwexpire == 0

kdc/mit_dump.c

@@ -314,6 +314,8 @@ mit_prop_dump(void *arg, const char *file)
 	    switch(tl_type) {
 	    case mit_KRB5_TL_MOD_PRINC:
 		buf = malloc(tl_length);
+		if (buf == NULL)
+		    errx(ENOMEM, "malloc");
 		getdata(&p, buf, tl_length); /* data itself */
 		val = buf[0] | (buf[1] << 8) | (buf[2] << 16) | (buf[3] << 24);
 		ret = krb5_parse_name(pd->context, (char *)buf + 4, &princ);

lib/hdb/mkey.c

@@ -129,6 +129,11 @@ read_master_keytab(krb5_context context, const char *filename,
     *mkey = NULL;
     while(krb5_kt_next_entry(context, id, &entry, &cursor) == 0) {
 	p = calloc(1, sizeof(*p));
+	if(p == NULL) {
+	    krb5_kt_end_seq_get(context, id, &cursor);
+	    ret = ENOMEM;
+	    goto out;
+	}
 	p->keytab = entry;
 	ret = krb5_crypto_init(context, &p->keytab.keyblock, 0, &p->crypto);
 	p->next = *mkey;

lib/kadm5/get_s.c

@@ -174,6 +174,10 @@ kadm5_s_get_principal(void *server_handle,
 	krb5_data *sp;
 	krb5_get_pw_salt(context->context, ent.entry.principal, &salt);
 	out->key_data = malloc(ent.entry.keys.len * sizeof(*out->key_data));
+	if (out->key_data == NULL) {
+	    ret = ENOMEM;
+	    goto out;
+	}
 	for(i = 0; i < ent.entry.keys.len; i++){
 	    key = &ent.entry.keys.val[i];
 	    kd = &out->key_data[i];

lib/kadm5/log.c

@@ -673,6 +673,8 @@ kadm5_log_replay_modify (kadm5_server_context *context,
 
 	ent.entry.keys.len = num;
 	ent.entry.keys.val = malloc(len * sizeof(*ent.entry.keys.val));
+	if (ent.entry.keys.val == NULL)
+	    return ENOMEM;
 	for (i = 0; i < ent.entry.keys.len; ++i) {
 	    ret = copy_Key(&log_ent.entry.keys.val[i],
 			   &ent.entry.keys.val[i]);

lib/kadm5/marshall.c

@@ -260,6 +260,8 @@ ret_principal_ent(krb5_storage *sp,
 	krb5_ret_int32(sp, &tmp);
 	princ->n_key_data = tmp;
 	princ->key_data = malloc(princ->n_key_data * sizeof(*princ->key_data));
+	if (princ->key_data == NULL)
+	    return ENOMEM;
 	for(i = 0; i < princ->n_key_data; i++)
 	    kadm5_ret_key_data(sp, &princ->key_data[i]);
     }
@@ -269,6 +271,8 @@ ret_principal_ent(krb5_storage *sp,
 	princ->tl_data = NULL;
 	for(i = 0; i < princ->n_tl_data; i++){
 	    krb5_tl_data *tp = malloc(sizeof(*tp));
+	    if (tp == NULL)
+		return ENOMEM;
 	    kadm5_ret_tl_data(sp, tp);
 	    tp->tl_data_next = princ->tl_data;
 	    princ->tl_data = tp;

lib/kadm5/rename_s.c

@@ -72,6 +72,8 @@ kadm5_s_rename_principal(void *server_handle,
 	    if(ent.entry.keys.val[i].salt == NULL){
 		ent.entry.keys.val[i].salt = 
 		    malloc(sizeof(*ent.entry.keys.val[i].salt));
+		if(ent.entry.keys.val[i].salt == NULL)
+		    return ENOMEM;
 		ret = copy_Salt(&salt, ent.entry.keys.val[i].salt);
 		if(ret)
 		    break;

lib/krb5/acache.c

@@ -188,11 +188,10 @@ make_cred_from_ccred(krb5_context context,
 	;
     
     if (i) {
-	cred->authdata.val = malloc(sizeof(cred->authdata.val[0]) * i);
+	cred->authdata.val = calloc(i, sizeof(cred->authdata.val[0]));
 	if (cred->authdata.val == NULL)
 	    goto nomem;
 	cred->authdata.len = i;
-	memset(cred->authdata.val, 0, sizeof(cred->authdata.val[0]) * i);
 	for (i = 0; i < cred->authdata.len; i++) {
 	    cred->authdata.val[i].ad_type = incred->authdata[i]->type;
 	    ret = krb5_data_copy(&cred->authdata.val[i].ad_data,
@@ -207,11 +206,10 @@ make_cred_from_ccred(krb5_context context,
 	;
     
     if (i) {
-	cred->addresses.val = malloc(sizeof(cred->addresses.val[0]) * i);
+	cred->addresses.val = calloc(i, sizeof(cred->addresses.val[0]));
 	if (cred->addresses.val == NULL)
 	    goto nomem;
 	cred->addresses.len = i;
-	memset(cred->addresses.val, 0, sizeof(cred->addresses.val[0]) * i);
 	
 	for (i = 0; i < cred->addresses.len; i++) {
 	    cred->addresses.val[i].addr_type = incred->addresses[i]->type;
@@ -331,6 +329,10 @@ make_ccred_from_cred(krb5_context context,
     for (i = 0; i < incred->addresses.len; i++) {
 	cc_data *addr;
 	addr = malloc(sizeof(*addr));
+	if (addr == NULL) {
+	    ret = ENOMEM;
+	    goto fail;
+	}
 	addr->type = incred->addresses.val[i].addr_type;
 	addr->length = incred->addresses.val[i].address.length;
 	addr->data = malloc(addr->length);

lib/krb5/asn1_glue.c

@@ -53,8 +53,12 @@ _krb5_principalname2krb5_principal (krb5_context context,
 				    const Realm realm)
 {
     krb5_principal p = malloc(sizeof(*p));
+    if (p == NULL)
+	return ENOMEM;
     copy_PrincipalName(&from, &p->name);
     p->realm = strdup(realm);
+    if (p->realm == NULL)
+	return ENOMEM;
     *principal = p;
     return 0;
 }

lib/krb5/auth_context.c

@@ -141,14 +141,16 @@ krb5_auth_con_setaddrs(krb5_context context,
 	if (auth_context->local_address)
 	    krb5_free_address (context, auth_context->local_address);
 	else
-	    auth_context->local_address = malloc(sizeof(krb5_address));
+	    if ((auth_context->local_address = malloc(sizeof(krb5_address))) == NULL)
+		return ENOMEM;
 	krb5_copy_address(context, local_addr, auth_context->local_address);
     }
     if (remote_addr) {
 	if (auth_context->remote_address)
 	    krb5_free_address (context, auth_context->remote_address);
 	else
-	    auth_context->remote_address = malloc(sizeof(krb5_address));
+	    if ((auth_context->remote_address = malloc(sizeof(krb5_address))) == NULL)
+		return ENOMEM;
 	krb5_copy_address(context, remote_addr, auth_context->remote_address);
     }
     return 0;

lib/krb5/n-fold-test.c

@@ -102,7 +102,9 @@ main(int argc, char **argv)
     for (t = tests; t->str; ++t) {
 	int i;
 
-	_krb5_n_fold (t->str, strlen(t->str), data, t->n);
+	ret = _krb5_n_fold (t->str, strlen(t->str), data, t->n);
+	if (ret)
+	    errx(1, "out of memory");
 	if (memcmp (data, t->res, t->n) != 0) {
 	    printf ("n-fold(\"%s\", %d) failed\n", t->str, t->n);
 	    printf ("should be: ");

lib/krb5/store_emem.c

@@ -116,12 +116,23 @@ krb5_storage * KRB5_LIB_FUNCTION
 krb5_storage_emem(void)
 {
     krb5_storage *sp = malloc(sizeof(krb5_storage));
+    if (sp == NULL)
+	return NULL;
     emem_storage *s = malloc(sizeof(*s));
+    if (s == NULL) {
+	free(sp);
+	return NULL;
+    }
     sp->data = s;
     sp->flags = 0;
     sp->eof_code = HEIM_ERR_EOF;
     s->size = 1024;
     s->base = malloc(s->size);
+    if (s->base == NULL) {
+	free(sp);
+	free(s);
+	return NULL;
+    }
     s->len = 0;
     s->ptr = s->base;
     sp->fetch = emem_fetch;

lib/krb5/transited.c

@@ -87,6 +87,10 @@ make_path(krb5_context context, struct tr_realm *r,
 	    if(strcmp(p, to) == 0)
 		break;
 	    tmp = calloc(1, sizeof(*tmp));
+	    if(tmp == NULL){
+		krb5_set_error_string (context, "malloc: out of memory");
+		return ENOMEM;
+	    }
 	    tmp->next = path;
 	    path = tmp;
 	    path->realm = strdup(p);
@@ -107,6 +111,10 @@ make_path(krb5_context context, struct tr_realm *r,
 	    if(strncmp(to, from, p - from) == 0)
 		break;
 	    tmp = calloc(1, sizeof(*tmp));
+	    if(tmp == NULL){
+		krb5_set_error_string (context, "malloc: out of memory");
+		return ENOMEM;
+	    }
 	    tmp->next = path;
 	    path = tmp;
 	    path->realm = malloc(p - from + 1);
@@ -277,6 +285,10 @@ decode_realms(krb5_context context,
 	}
 	if(tr[i] == ','){
 	    tmp = malloc(tr + i - start + 1);
+	    if(tmp == NULL){
+		krb5_set_error_string (context, "malloc: out of memory");
+		return ENOMEM;
+	    }
 	    memcpy(tmp, start, tr + i - start);
 	    tmp[tr + i - start] = '\0';
 	    r = make_realm(tmp);
@@ -290,6 +302,11 @@ decode_realms(krb5_context context,
 	}
     }
     tmp = malloc(tr + i - start + 1);
+    if(tmp == NULL){
+	free(*realms);
+	krb5_set_error_string (context, "malloc: out of memory");
+	return ENOMEM;
+    }
     memcpy(tmp, start, tr + i - start);
     tmp[tr + i - start] = '\0';
     r = make_realm(tmp);

lib/roken/getcap.c

@@ -306,6 +306,8 @@ getent(char **cap, size_t *len, char **db_array, int fd,
 				/* save the data; close frees it */
 		clen = strlen(record);
 		cbuf = malloc(clen + 1);
+		if (cbuf == NULL)
+		    return (-2);
 		memmove(cbuf, record, clen + 1);
 		if (capdbp->close(capdbp) < 0) {
 		    free(cbuf);

lib/roken/getifaddrs.c

@@ -856,14 +856,6 @@ rk_getifaddrs(struct ifaddrs **ifap)
   return 0;
 }
 
-/* ---------------------------------------------------------------------- */
-void ROKEN_LIB_FUNCTION
-rk_freeifaddrs(struct ifaddrs *ifa)
-{
-  free(ifa);
-}
-
-
 #else /* !AF_NETLINK */
 
 /*
@@ -957,8 +949,16 @@ getifaddrs2(struct ifaddrs **ifap,
 
 	(*end)->ifa_next = NULL;
 	(*end)->ifa_name = strdup(ifr->ifr_name);
+	if ((*end)->ifa_name == NULL) {
+	    ret = ENOMEM;
+	    goto error_out;
+	}
 	(*end)->ifa_flags = ifreq.ifr_flags;
 	(*end)->ifa_addr = malloc(salen);
+	if ((*end)->ifa_addr == NULL) {
+	    ret = ENOMEM;
+	    goto error_out;
+	}
 	memcpy((*end)->ifa_addr, sa, salen);
 	(*end)->ifa_netmask = NULL;
 
@@ -966,10 +966,18 @@ getifaddrs2(struct ifaddrs **ifap,
 	/* fix these when we actually need them */
 	if(ifreq.ifr_flags & IFF_BROADCAST) {
 	    (*end)->ifa_broadaddr = malloc(sizeof(ifr->ifr_broadaddr));
+	    if ((*end)->ifa_broadaddr == NULL) {
+		ret = ENOMEM;
+		goto error_out;
+	    }
 	    memcpy((*end)->ifa_broadaddr, &ifr->ifr_broadaddr, 
 		   sizeof(ifr->ifr_broadaddr));
 	} else if(ifreq.ifr_flags & IFF_POINTOPOINT) {
 	    (*end)->ifa_dstaddr = malloc(sizeof(ifr->ifr_dstaddr));
+	    if ((*end)->ifa_dstaddr == NULL) {
+		ret = ENOMEM;
+		goto error_out;
+	    }
 	    memcpy((*end)->ifa_dstaddr, &ifr->ifr_dstaddr, 
 		   sizeof(ifr->ifr_dstaddr));
 	} else
@@ -1080,11 +1088,23 @@ getlifaddrs2(struct ifaddrs **ifap,
 	}
 
 	*end = malloc(sizeof(**end));
+	if (*end == NULL) {
+	    ret = ENOMEM;
+	    goto error_out;
+	}
 
 	(*end)->ifa_next = NULL;
 	(*end)->ifa_name = strdup(ifr->lifr_name);
+	if ((*end)->ifa_name == NULL) {
+	    ret = ENOMEM;
+	    goto error_out;
+	}
 	(*end)->ifa_flags = ifreq.lifr_flags;
 	(*end)->ifa_addr = malloc(salen);
+	if ((*end)->ifa_addr == NULL) {
+	    ret = ENOMEM;
+	    goto error_out;
+	}
 	memcpy((*end)->ifa_addr, sa, salen);
 	(*end)->ifa_netmask = NULL;
 
@@ -1092,10 +1112,18 @@ getlifaddrs2(struct ifaddrs **ifap,
 	/* fix these when we actually need them */
 	if(ifreq.ifr_flags & IFF_BROADCAST) {
 	    (*end)->ifa_broadaddr = malloc(sizeof(ifr->ifr_broadaddr));
+	    if ((*end)->ifa_broadaddr == NULL) {
+		ret = ENOMEM;
+		goto error_out;
+	    }
 	    memcpy((*end)->ifa_broadaddr, &ifr->ifr_broadaddr, 
 		   sizeof(ifr->ifr_broadaddr));
 	} else if(ifreq.ifr_flags & IFF_POINTOPOINT) {
 	    (*end)->ifa_dstaddr = malloc(sizeof(ifr->ifr_dstaddr));
+	    if ((*end)->ifa_dstaddr == NULL) {
+		ret = ENOMEM;
+		goto error_out;
+	    }
 	    memcpy((*end)->ifa_dstaddr, &ifr->ifr_dstaddr, 
 		   sizeof(ifr->ifr_dstaddr));
 	} else
@@ -1150,6 +1178,8 @@ rk_getifaddrs(struct ifaddrs **ifap)
     return ret;
 }
 
+#endif /* !AF_NETLINK */
+
 void ROKEN_LIB_FUNCTION
 rk_freeifaddrs(struct ifaddrs *ifp)
 {
@@ -1171,8 +1201,6 @@ rk_freeifaddrs(struct ifaddrs *ifp)
     }
 }
 
-#endif /* !AF_NETLINK */
-
 #ifdef TEST
 
 void

lib/sl/parse.y

@@ -138,6 +138,8 @@ struct string_list*
 append_string(struct string_list *list, char *str)
 {
     struct string_list *sl = malloc(sizeof(*sl));
+    if (sl == NULL)
+	return sl;
     sl->string = str;
     sl->next = NULL;
     if(list) {