emo/shadow
1
0
Fork 0
Code Issues Pull Requests Packages Releases Activity

Use safer allocation macros

Browse Source 
Use of these macros, apart from the benefits mentioned in the commit
that adds the macros, has some other good side effects:

-  Consistency in getting the size of the object from sizeof(type),
   instead of a mix of sizeof(type) sometimes and sizeof(*p) other
   times.

-  More readable code: no casts, and no sizeof(), so also shorter lines
   that we don't need to cut.

-  Consistency in using array allocation calls for allocations of arrays
   of objects, even when the object size is 1.

Cc: Valentin V. Bartenev <vbartenev@gmail.com>
Signed-off-by: Alejandro Colomar <alx@kernel.org>
This commit is contained in:
Alejandro Colomar 2023-02-04 22:41:18 +01:00 committed by Serge Hallyn
parent 6e58c12752
commit efbbcade43
44 changed files with 196 additions and 118 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
lib/commonio.c
View File

@ -21,6 +21,8 @@
#include <errno.h> #include <errno.h>
#include <stdio.h> #include <stdio.h>
#include <signal.h> #include <signal.h>
#include "alloc.h"
#include "nscd.h" #include "nscd.h"
#include "sssd.h" #include "sssd.h"
#ifdef WITH_TCB #ifdef WITH_TCB
@ -240,11 +242,11 @@ int commonio_lock_nowait (struct commonio_db *db, bool log)
} }
file_len = strlen(db->filename) + 11;/* %lu max size */ file_len = strlen(db->filename) + 11;/* %lu max size */
lock_file_len = strlen(db->filename) + 6; /* sizeof ".lock" */ lock_file_len = strlen(db->filename) + 6; /* sizeof ".lock" */
file = (char*)malloc(file_len); file = MALLOCARRAY(file_len, char);
if (file == NULL) { if (file == NULL) {
goto cleanup_ENOMEM; goto cleanup_ENOMEM;
} }
lock = (char*)malloc(lock_file_len); lock = MALLOCARRAY(lock_file_len, char);
if (lock == NULL) { if (lock == NULL) {
goto cleanup_ENOMEM; goto cleanup_ENOMEM;
} }
@ -513,7 +515,7 @@ int commonio_open (struct commonio_db *db, int mode)
fcntl (fileno (db->fp), F_SETFD, FD_CLOEXEC); fcntl (fileno (db->fp), F_SETFD, FD_CLOEXEC);
buflen = BUFLEN; buflen = BUFLEN;
buf = (char *) malloc (buflen); buf = MALLOCARRAY (buflen, char);
if (NULL == buf) { if (NULL == buf) {
goto cleanup_ENOMEM; goto cleanup_ENOMEM;
} }
@ -524,7 +526,7 @@ int commonio_open (struct commonio_db *db, int mode)
size_t len; size_t len;
buflen += BUFLEN; buflen += BUFLEN;
cp = (char *) realloc (buf, buflen); cp = REALLOCARRAY (buf, buflen, char);
if (NULL == cp) { if (NULL == cp) {
goto cleanup_buf; goto cleanup_buf;
} }
@ -558,7 +560,7 @@ int commonio_open (struct commonio_db *db, int mode)
} }
} }
p = (struct commonio_entry *) malloc (sizeof *p); p = MALLOC (struct commonio_entry);
if (NULL == p) { if (NULL == p) {
goto cleanup_entry; goto cleanup_entry;
} }
@ -635,7 +637,7 @@ commonio_sort (struct commonio_db *db, int (*cmp) (const void *, const void *))
return 0; return 0;
} }
entries = mallocarray (n, sizeof (struct commonio_entry *)); entries = MALLOCARRAY (n, struct commonio_entry *);
if (entries == NULL) { if (entries == NULL) {
return -1; return -1;
} }
@ -954,7 +956,7 @@ int commonio_update (struct commonio_db *db, const void *eptr)
return 1; return 1;
} }
/* not found, new entry */ /* not found, new entry */
p = (struct commonio_entry *) malloc (sizeof *p); p = MALLOC (struct commonio_entry);
if (NULL == p) { if (NULL == p) {
db->ops->free (nentry); db->ops->free (nentry);
errno = ENOMEM; errno = ENOMEM;
@ -991,7 +993,7 @@ int commonio_append (struct commonio_db *db, const void *eptr)
return 0; return 0;
} }
/* new entry */ /* new entry */
p = (struct commonio_entry *) malloc (sizeof *p); p = MALLOC (struct commonio_entry);
if (NULL == p) { if (NULL == p) {
db->ops->free (nentry); db->ops->free (nentry);
errno = ENOMEM; errno = ENOMEM;

7
lib/getdef.c
View File

@ -21,8 +21,11 @@
#ifdef USE_ECONF #ifdef USE_ECONF
#include <libeconf.h> #include <libeconf.h>
#endif #endif
#include "alloc.h"
#include "getdef.h" #include "getdef.h"
#include "shadowlog_internal.h" #include "shadowlog_internal.h"
/* /*
* A configuration item definition. * A configuration item definition.
*/ */
@ -445,14 +448,14 @@ void setdef_config_file (const char* file)
char* cp; char* cp;
len = strlen(file) + strlen(sysconfdir) + 2; len = strlen(file) + strlen(sysconfdir) + 2;
cp = malloc(len); cp = MALLOCARRAY(len, char);
if (cp == NULL) if (cp == NULL)
exit (13); exit (13);
snprintf(cp, len, "%s/%s", file, sysconfdir); snprintf(cp, len, "%s/%s", file, sysconfdir);
sysconfdir = cp; sysconfdir = cp;
#ifdef VENDORDIR #ifdef VENDORDIR
len = strlen(file) + strlen(vendordir) + 2; len = strlen(file) + strlen(vendordir) + 2;
cp = malloc(len); cp = MALLOCARRAY(len, char);
if (cp == NULL) if (cp == NULL)
exit (13); exit (13);
snprintf(cp, len, "%s/%s", file, vendordir); snprintf(cp, len, "%s/%s", file, vendordir);

7
lib/groupio.c
View File

@ -15,6 +15,7 @@
#include <assert.h> #include <assert.h>
#include <stdio.h> #include <stdio.h>
#include "alloc.h"
#include "prototypes.h" #include "prototypes.h"
#include "defines.h" #include "defines.h"
#include "commonio.h" #include "commonio.h"
@ -311,7 +312,7 @@ static /*@null@*/struct commonio_entry *merge_group_entries (
/* Concatenate the 2 lines */ /* Concatenate the 2 lines */
new_line_len = strlen (gr1->line) + strlen (gr2->line) +1; new_line_len = strlen (gr1->line) + strlen (gr2->line) +1;
new_line = (char *)malloc (new_line_len + 1); new_line = MALLOCARRAY (new_line_len + 1, char);
if (NULL == new_line) { if (NULL == new_line) {
return NULL; return NULL;
} }
@ -332,7 +333,7 @@ static /*@null@*/struct commonio_entry *merge_group_entries (
members++; members++;
} }
} }
new_members = (char **)calloc ( (members+1), sizeof(char*) ); new_members = CALLOC (members + 1, char *);
if (NULL == new_members) { if (NULL == new_members) {
free (new_line); free (new_line);
return NULL; return NULL;
@ -393,7 +394,7 @@ static int split_groups (unsigned int max_members)
continue; continue;
} }
new = (struct commonio_entry *) malloc (sizeof *new); new = MALLOC (struct commonio_entry);
if (NULL == new) { if (NULL == new) {
return 0; return 0;
} }

5
lib/groupmem.c
View File

@ -12,6 +12,7 @@
#ident "$Id$" #ident "$Id$"
#include "alloc.h"
#include "prototypes.h" #include "prototypes.h"
#include "defines.h" #include "defines.h"
#include "groupio.h" #include "groupio.h"
@ -21,7 +22,7 @@
struct group *gr; struct group *gr;
int i; int i;
gr = (struct group *) malloc (sizeof *gr); gr = MALLOC (struct group);
if (NULL == gr) { if (NULL == gr) {
return NULL; return NULL;
} }
@ -46,7 +47,7 @@
for (i = 0; grent->gr_mem[i]; i++); for (i = 0; grent->gr_mem[i]; i++);
/*@-mustfreeonly@*/ /*@-mustfreeonly@*/
gr->gr_mem = (char **) mallocarray (i + 1, sizeof (char *)); gr->gr_mem = MALLOCARRAY (i + 1, char *);
/*@=mustfreeonly@*/ /*@=mustfreeonly@*/
if (NULL == gr->gr_mem) { if (NULL == gr->gr_mem) {
gr_free(gr); gr_free(gr);

15
lib/gshadow.c
View File

@ -16,8 +16,11 @@
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#include "alloc.h"
#include "prototypes.h" #include "prototypes.h"
#include "defines.h" #include "defines.h"
static /*@null@*/FILE *shadow; static /*@null@*/FILE *shadow;
static /*@null@*//*@only@*/char **members = NULL; static /*@null@*//*@only@*/char **members = NULL;
static size_t nmembers = 0; static size_t nmembers = 0;
@ -63,7 +66,7 @@ static /*@null@*/char **build_list (char *s, char **list[], size_t * nlist)
while (s != NULL && *s != '\0') { while (s != NULL && *s != '\0') {
size = (nelem + 1) * sizeof (ptr); size = (nelem + 1) * sizeof (ptr);
ptr = realloc (*list, size); ptr = REALLOCARRAY (*list, size, char *);
if (NULL != ptr) { if (NULL != ptr) {
ptr[nelem] = s; ptr[nelem] = s;
nelem++; nelem++;
@ -77,7 +80,7 @@ static /*@null@*/char **build_list (char *s, char **list[], size_t * nlist)
} }
} }
size = (nelem + 1) * sizeof (ptr); size = (nelem + 1) * sizeof (ptr);
ptr = realloc (*list, size); ptr = REALLOCARRAY (*list, size, char *);
if (NULL != ptr) { if (NULL != ptr) {
ptr[nelem] = NULL; ptr[nelem] = NULL;
*list = ptr; *list = ptr;
@ -117,7 +120,7 @@ void endsgent (void)
size_t len = strlen (string) + 1; size_t len = strlen (string) + 1;
if (len > sgrbuflen) { if (len > sgrbuflen) {
char *buf = (char *) reallocarray (sgrbuf, len, sizeof (char)); char *buf = REALLOCARRAY (sgrbuf, len, char);
if (NULL == buf) { if (NULL == buf) {
return NULL; return NULL;
} }
@ -195,7 +198,7 @@ void endsgent (void)
char *cp; char *cp;
if (0 == buflen) { if (0 == buflen) {
buf = (char *) malloc (BUFSIZ); buf = MALLOCARRAY (BUFSIZ, char);
if (NULL == buf) { if (NULL == buf) {
return NULL; return NULL;
} }
@ -216,7 +219,7 @@ void endsgent (void)
&& (feof (fp) == 0)) { && (feof (fp) == 0)) {
size_t len; size_t len;
cp = (char *) realloc (buf, buflen*2); cp = REALLOCARRAY (buf, buflen * 2, char);
if (NULL == cp) { if (NULL == cp) {
return NULL; return NULL;
} }
@ -437,7 +440,7 @@ int putsgent (const struct sgrp *sgrp, FILE * fp)
size += strlen (sgrp->sg_mem[i]) + 1; size += strlen (sgrp->sg_mem[i]) + 1;
} }
buf = malloc (size); buf = MALLOCARRAY (size, char);
if (NULL == buf) { if (NULL == buf) {
return -1; return -1;
} }

4
lib/nss.c
View File

@ -6,6 +6,8 @@
#include <strings.h> #include <strings.h>
#include <ctype.h> #include <ctype.h>
#include <stdatomic.h> #include <stdatomic.h>
#include "alloc.h"
#include "prototypes.h" #include "prototypes.h"
#include "../libsubid/subid.h" #include "../libsubid/subid.h"
#include "shadowlog_internal.h" #include "shadowlog_internal.h"
@ -100,7 +102,7 @@ void nss_init(const char *nsswitch_path) {
subid_nss = NULL; subid_nss = NULL;
goto done; goto done;
} }
subid_nss = malloc(sizeof(*subid_nss)); subid_nss = MALLOC(struct subid_nss_ops);
if (!subid_nss) { if (!subid_nss) {
dlclose(h); dlclose(h);
goto done; goto done;

4
lib/pwmem.c
View File

@ -13,6 +13,8 @@
#ident "$Id$" #ident "$Id$"
#include <stdio.h> #include <stdio.h>
#include "alloc.h"
#include "defines.h" #include "defines.h"
#include "prototypes.h" #include "prototypes.h"
#include "pwio.h" #include "pwio.h"
@ -21,7 +23,7 @@
{ {
struct passwd *pw; struct passwd *pw;
pw = (struct passwd *) calloc (1, sizeof *pw); pw = CALLOC (1, struct passwd);
if (NULL == pw) { if (NULL == pw) {
return NULL; return NULL;
} }

4
lib/run_part.c
View File

@ -8,6 +8,8 @@
#include <sys/wait.h> #include <sys/wait.h>
#include <unistd.h> #include <unistd.h>
#include <lib/prototypes.h> #include <lib/prototypes.h>
#include "alloc.h"
#include "run_part.h" #include "run_part.h"
#include "shadowlog_internal.h" #include "shadowlog_internal.h"
@ -57,7 +59,7 @@ int run_parts (const char *directory, const char *name, const char *action)
struct stat sb; struct stat sb;
path_length=strlen(directory) + strlen(namelist[n]->d_name) + 2; path_length=strlen(directory) + strlen(namelist[n]->d_name) + 2;
char *s = (char*)malloc(path_length); char *s = MALLOCARRAY(path_length, char);
if (!s) { if (!s) {
printf ("could not allocate memory\n"); printf ("could not allocate memory\n");
for (; n<scanlist; n++) { for (; n<scanlist; n++) {

6
lib/sgetgrent.c
View File

@ -14,6 +14,8 @@
#include <stdio.h> #include <stdio.h>
#include <sys/types.h> #include <sys/types.h>
#include <grp.h> #include <grp.h>
#include "alloc.h"
#include "defines.h" #include "defines.h"
#include "prototypes.h" #include "prototypes.h"
@ -44,7 +46,7 @@ static char **list (char *s)
member name, or terminating NULL). */ member name, or terminating NULL). */
if (i >= size) { if (i >= size) {
size = i + 100; /* at least: i + 1 */ size = i + 100; /* at least: i + 1 */
members = reallocarrayf (members, size, sizeof(char *)); members = REALLOCARRAYF(members, size, char *);
if (!members) if (!members)
return NULL; return NULL;
} }
@ -77,7 +79,7 @@ struct group *sgetgrent (const char *buf)
allocate a larger block */ allocate a larger block */
free (grpbuf); free (grpbuf);
size = strlen (buf) + 1000; /* at least: strlen(buf) + 1 */ size = strlen (buf) + 1000; /* at least: strlen(buf) + 1 */
grpbuf = malloc (size); grpbuf = MALLOCARRAY (size, char);
if (grpbuf == NULL) { if (grpbuf == NULL) {
size = 0; size = 0;
return NULL; return NULL;

7
lib/sgroupio.c
View File

@ -14,6 +14,7 @@
#ident "$Id$" #ident "$Id$"
#include "alloc.h"
#include "prototypes.h" #include "prototypes.h"
#include "defines.h" #include "defines.h"
#include "commonio.h" #include "commonio.h"
@ -25,7 +26,7 @@
struct sgrp *sg; struct sgrp *sg;
int i; int i;
sg = (struct sgrp *) calloc (1, sizeof *sg); sg = CALLOC (1, struct sgrp);
if (NULL == sg) { if (NULL == sg) {
return NULL; return NULL;
} }
@ -49,7 +50,7 @@
for (i = 0; NULL != sgent->sg_adm[i]; i++); for (i = 0; NULL != sgent->sg_adm[i]; i++);
/*@-mustfreeonly@*/ /*@-mustfreeonly@*/
sg->sg_adm = (char **) mallocarray (i + 1, sizeof (char *)); sg->sg_adm = MALLOCARRAY (i + 1, char *);
/*@=mustfreeonly@*/ /*@=mustfreeonly@*/
if (NULL == sg->sg_adm) { if (NULL == sg->sg_adm) {
free (sg->sg_passwd); free (sg->sg_passwd);
@ -74,7 +75,7 @@
for (i = 0; NULL != sgent->sg_mem[i]; i++); for (i = 0; NULL != sgent->sg_mem[i]; i++);
/*@-mustfreeonly@*/ /*@-mustfreeonly@*/
sg->sg_mem = (char **) mallocarray (i + 1, sizeof (char *)); sg->sg_mem = MALLOCARRAY (i + 1, char *);
/*@=mustfreeonly@*/ /*@=mustfreeonly@*/
if (NULL == sg->sg_mem) { if (NULL == sg->sg_mem) {
for (i = 0; NULL != sg->sg_adm[i]; i++) { for (i = 0; NULL != sg->sg_adm[i]; i++) {

4
lib/shadowmem.c
View File

@ -16,13 +16,15 @@
#include "defines.h" #include "defines.h"
#include <shadow.h> #include <shadow.h>
#include <stdio.h> #include <stdio.h>
#include "alloc.h"
#include "shadowio.h" #include "shadowio.h"
/*@null@*/ /*@only@*/struct spwd *__spw_dup (const struct spwd *spent) /*@null@*/ /*@only@*/struct spwd *__spw_dup (const struct spwd *spent)
{ {
struct spwd *sp; struct spwd *sp;
sp = (struct spwd *) calloc (1, sizeof *sp); sp = CALLOC (1, struct spwd);
if (NULL == sp) { if (NULL == sp) {
return NULL; return NULL;
} }

4
lib/sssd.c
View File

@ -6,6 +6,8 @@
#include <stdio.h> #include <stdio.h>
#include <sys/wait.h> #include <sys/wait.h>
#include <sys/types.h> #include <sys/types.h>
#include "alloc.h"
#include "exitcodes.h" #include "exitcodes.h"
#include "defines.h" #include "defines.h"
#include "prototypes.h" #include "prototypes.h"
@ -24,7 +26,7 @@ int sssd_flush_cache (int dbflags)
const char *spawnedEnv[] = {NULL}; const char *spawnedEnv[] = {NULL};
int i = 0; int i = 0;
sss_cache_args = malloc(4); sss_cache_args = MALLOCARRAY(4, char);
if (sss_cache_args == NULL) { if (sss_cache_args == NULL) {
return -1; return -1;
} }

10
lib/subordinateio.c
View File

@ -17,6 +17,8 @@
#include <ctype.h> #include <ctype.h>
#include <fcntl.h> #include <fcntl.h>
#include "alloc.h"
#define ID_SIZE 31 #define ID_SIZE 31
/* /*
@ -32,7 +34,7 @@ static /*@null@*/ /*@only@*/void *subordinate_dup (const void *ent)
const struct subordinate_range *rangeent = ent; const struct subordinate_range *rangeent = ent;
struct subordinate_range *range; struct subordinate_range *range;
range = (struct subordinate_range *) malloc (sizeof *range); range = MALLOC (struct subordinate_range);
if (NULL == range) { if (NULL == range) {
return NULL; return NULL;
} }
@ -314,12 +316,12 @@ static bool have_range(struct commonio_db *db,
static bool append_range(struct subid_range **ranges, const struct subordinate_range *new, int n) static bool append_range(struct subid_range **ranges, const struct subordinate_range *new, int n)
{ {
if (!*ranges) { if (!*ranges) {
*ranges = malloc(sizeof(struct subid_range)); *ranges = MALLOC(struct subid_range);
if (!*ranges) if (!*ranges)
return false; return false;
} else { } else {
struct subid_range *alloced; struct subid_range *alloced;
alloced = reallocarray(*ranges, n + 1, sizeof(struct subid_range)); alloced = REALLOCARRAY(*ranges, n + 1, struct subid_range);
if (!alloced) if (!alloced)
return false; return false;
*ranges = alloced; *ranges = alloced;
@ -911,7 +913,7 @@ static int append_uids(uid_t **uids, const char *owner, int n)
return n; return n;
} }
ret = reallocarray(*uids, n + 1, sizeof(uid_t)); ret = REALLOCARRAY(*uids, n + 1, uid_t);
if (!ret) { if (!ret) {
free(*uids); free(*uids);
return -1; return -1;

6
libmisc/addgrps.c
View File

@ -17,6 +17,8 @@
#include <stdio.h> #include <stdio.h>
#include <grp.h> #include <grp.h>
#include <errno.h> #include <errno.h>
#include "alloc.h"
#include "shadowlog.h" #include "shadowlog.h"
#ident "$Id$" #ident "$Id$"
@ -46,7 +48,7 @@ int add_groups (const char *list)
i = 16; i = 16;
for (;;) { for (;;) {
grouplist = (gid_t *) mallocarray (i, sizeof (GETGROUPS_T)); grouplist = MALLOCARRAY (i, GETGROUPS_T);
if (NULL == grouplist) { if (NULL == grouplist) {
return -1; return -1;
} }
@ -88,7 +90,7 @@ int add_groups (const char *list)
fputs (_("Warning: too many groups\n"), shadow_logfd); fputs (_("Warning: too many groups\n"), shadow_logfd);
break; break;
} }
grouplist = (gid_t *) reallocarrayf (grouplist, (size_t)ngroups + 1, sizeof (GETGROUPS_T)); grouplist = REALLOCARRAYF(grouplist, (size_t) ngroups + 1, GETGROUPS_T);
if (grouplist == NULL) { if (grouplist == NULL) {
return -1; return -1;
} }

5
libmisc/agetpass.c
View File

@ -15,6 +15,7 @@
#ident "$Id$" #ident "$Id$"
#include "alloc.h"
#include "prototypes.h" #include "prototypes.h"
@ -46,7 +47,7 @@
* through malloc(3). This makes the function thread-safe, and * through malloc(3). This makes the function thread-safe, and
* also reduces the visibility of the buffer. * also reduces the visibility of the buffer.
* *
* - agetpass() doesn't call realloc(3) internally. Some * - agetpass() doesn't reallocate internally. Some
* implementations of getpass(3), such as glibc, do that, as a * implementations of getpass(3), such as glibc, do that, as a
* consequence of calling getline(3). That's a bug in glibc, * consequence of calling getline(3). That's a bug in glibc,
* which allows leaking prefixes of passwords in freed memory. * which allows leaking prefixes of passwords in freed memory.
@ -101,7 +102,7 @@ agetpass(const char *prompt)
* Let's add one more byte, and if the password uses it, it * Let's add one more byte, and if the password uses it, it
* means the introduced password was longer than PASS_MAX. * means the introduced password was longer than PASS_MAX.
*/ */
pass = malloc(PASS_MAX + 2); pass = MALLOCARRAY(PASS_MAX + 2, char);
if (pass == NULL) if (pass == NULL)
return NULL; return NULL;

12
libmisc/copydir.c
View File

@ -228,7 +228,7 @@ static /*@exposed@*/ /*@null@*/struct link_name *check_link (const char *name, c
return NULL; return NULL;
} }
lp = (struct link_name *) xmalloc (sizeof *lp); lp = XMALLOC (struct link_name);
src_len = strlen (src_orig); src_len = strlen (src_orig);
dst_len = strlen (dst_orig); dst_len = strlen (dst_orig);
name_len = strlen (name); name_len = strlen (name);
@ -236,7 +236,7 @@ static /*@exposed@*/ /*@null@*/struct link_name *check_link (const char *name, c
lp->ln_ino = sb->st_ino; lp->ln_ino = sb->st_ino;
lp->ln_count = sb->st_nlink; lp->ln_count = sb->st_nlink;
len = name_len - src_len + dst_len + 1; len = name_len - src_len + dst_len + 1;
lp->ln_name = (char *) xmalloc (len); lp->ln_name = XMALLOCARRAY (len, char);
(void) snprintf (lp->ln_name, len, "%s%s", dst_orig, name + src_len); (void) snprintf (lp->ln_name, len, "%s%s", dst_orig, name + src_len);
lp->ln_next = links; lp->ln_next = links;
links = lp; links = lp;
@ -326,8 +326,8 @@ static int copy_tree_impl (const struct path_info *src, const struct path_info *
src_len += strlen (src->full_path); src_len += strlen (src->full_path);
dst_len += strlen (dst->full_path); dst_len += strlen (dst->full_path);
src_name = (char *) malloc (src_len); src_name = MALLOCARRAY (src_len, char);
dst_name = (char *) malloc (dst_len); dst_name = MALLOCARRAY (dst_len, char);
if ((NULL == src_name) || (NULL == dst_name)) { if ((NULL == src_name) || (NULL == dst_name)) {
err = -1; err = -1;
@ -561,7 +561,7 @@ static /*@null@*/char *readlink_malloc (const char *filename)
while (true) { while (true) {
ssize_t nchars; ssize_t nchars;
char *buffer = (char *) malloc (size); char *buffer = MALLOCARRAY (size, char);
if (NULL == buffer) { if (NULL == buffer) {
return NULL; return NULL;
} }
@ -626,7 +626,7 @@ static int copy_symlink (const struct path_info *src, const struct path_info *ds
*/ */
if (strncmp (oldlink, src_orig, strlen (src_orig)) == 0) { if (strncmp (oldlink, src_orig, strlen (src_orig)) == 0) {
size_t len = strlen (dst_orig) + strlen (oldlink) - strlen (src_orig) + 1; size_t len = strlen (dst_orig) + strlen (oldlink) - strlen (src_orig) + 1;
char *dummy = (char *) xmalloc (len); char *dummy = XMALLOCARRAY (len, char);
(void) snprintf (dummy, len, "%s%s", (void) snprintf (dummy, len, "%s%s",
dst_orig, dst_orig,
oldlink + strlen (src_orig)); oldlink + strlen (src_orig));

7
libmisc/env.c
View File

@ -60,7 +60,7 @@ static const char *const noslash[] = {
*/ */
void initenv (void) void initenv (void)
{ {
newenvp = (char **) xmallocarray (NEWENVP_STEP, sizeof (char *)); newenvp = XMALLOCARRAY (NEWENVP_STEP, char *);
*newenvp = NULL; *newenvp = NULL;
} }
@ -74,7 +74,7 @@ void addenv (const char *string, /*@null@*/const char *value)
if (NULL != value) { if (NULL != value) {
size_t len = strlen (string) + strlen (value) + 2; size_t len = strlen (string) + strlen (value) + 2;
int wlen; int wlen;
newstring = xmalloc (len); newstring = XMALLOCARRAY (len, char);
wlen = snprintf (newstring, len, "%s=%s", string, value); wlen = snprintf (newstring, len, "%s=%s", string, value);
assert (wlen == (int) len -1); assert (wlen == (int) len -1);
} else { } else {
@ -135,8 +135,7 @@ void addenv (const char *string, /*@null@*/const char *value)
* happily go on, else print a message. * happily go on, else print a message.
*/ */
__newenvp = (char **) reallocarray (newenvp, newenvc + NEWENVP_STEP, __newenvp = REALLOCARRAY(newenvp, newenvc + NEWENVP_STEP, char *);
sizeof (char *));
if (NULL != __newenvp) { if (NULL != __newenvp) {
/* /*

3
libmisc/find_new_gid.c
View File

@ -12,6 +12,7 @@
#include <stdio.h> #include <stdio.h>
#include <errno.h> #include <errno.h>
#include "alloc.h"
#include "prototypes.h" #include "prototypes.h"
#include "groupio.h" #include "groupio.h"
#include "getdef.h" #include "getdef.h"
@ -231,7 +232,7 @@ int find_new_gid (bool sys_group,
*/ */
/* Create an array to hold all of the discovered GIDs */ /* Create an array to hold all of the discovered GIDs */
used_gids = calloc (gid_max + 1, sizeof (bool)); used_gids = CALLOC (gid_max + 1, bool);
if (NULL == used_gids) { if (NULL == used_gids) {
fprintf (log_get_logfd(), fprintf (log_get_logfd(),
_("%s: failed to allocate memory: %s\n"), _("%s: failed to allocate memory: %s\n"),

3
libmisc/find_new_uid.c
View File

@ -12,6 +12,7 @@
#include <stdio.h> #include <stdio.h>
#include <errno.h> #include <errno.h>
#include "alloc.h"
#include "prototypes.h" #include "prototypes.h"
#include "pwio.h" #include "pwio.h"
#include "getdef.h" #include "getdef.h"
@ -231,7 +232,7 @@ int find_new_uid(bool sys_user,
*/ */
/* Create an array to hold all of the discovered UIDs */ /* Create an array to hold all of the discovered UIDs */
used_uids = mallocarray (uid_max + 1, sizeof (bool)); used_uids = MALLOCARRAY (uid_max + 1, bool);
if (NULL == used_uids) { if (NULL == used_uids) {
fprintf (log_get_logfd(), fprintf (log_get_logfd(),
_("%s: failed to allocate memory: %s\n"), _("%s: failed to allocate memory: %s\n"),

6
libmisc/idmapping.c
View File

@ -11,6 +11,8 @@
#include <limits.h> #include <limits.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>
#include "alloc.h"
#include "prototypes.h" #include "prototypes.h"
#include "stpeprintf.h" #include "stpeprintf.h"
#include "idmapping.h" #include "idmapping.h"
@ -44,7 +46,7 @@ struct map_range *get_map_ranges(int ranges, int argc, char **argv)
return NULL; return NULL;
} }
mappings = calloc(ranges, sizeof(*mappings)); mappings = CALLOC(ranges, struct map_range);
if (!mappings) { if (!mappings) {
fprintf(log_get_logfd(), _( "%s: Memory allocation failure\n"), fprintf(log_get_logfd(), _( "%s: Memory allocation failure\n"),
log_get_progname()); log_get_progname());
@ -189,7 +191,7 @@ void write_mapping(int proc_dir_fd, int ranges, const struct map_range *mappings
#endif #endif
bufsize = ranges * ((ULONG_DIGITS + 1) * 3); bufsize = ranges * ((ULONG_DIGITS + 1) * 3);
pos = buf = xmalloc(bufsize); pos = buf = XMALLOCARRAY(bufsize, char);
end = buf + bufsize; end = buf + bufsize;
/* Build the mapping command */ /* Build the mapping command */

10
libmisc/list.c
View File

@ -11,6 +11,8 @@
#ident "$Id$" #ident "$Id$"
#include <assert.h> #include <assert.h>
#include "alloc.h"
#include "prototypes.h" #include "prototypes.h"
#include "defines.h" #include "defines.h"
/* /*
@ -44,7 +46,7 @@
* old entries, and the new entries as well. * old entries, and the new entries as well.
*/ */
tmp = (char **) xmallocarray (i + 2, sizeof member); tmp = XMALLOCARRAY (i + 2, char *);
/* /*
* Copy the original list to the new list, then append the * Copy the original list to the new list, then append the
@ -98,7 +100,7 @@
* old entries. * old entries.
*/ */
tmp = (char **) xmallocarray (j + 1, sizeof member); tmp = XMALLOCARRAY (j + 1, char *);
/* /*
* Copy the original list except the deleted members to the * Copy the original list except the deleted members to the
@ -133,7 +135,7 @@
for (i = 0; NULL != list[i]; i++); for (i = 0; NULL != list[i]; i++);
tmp = (char **) xmallocarray (i + 1, sizeof (char *)); tmp = XMALLOCARRAY (i + 1, char *);
i = 0; i = 0;
while (NULL != *list) { while (NULL != *list) {
@ -210,7 +212,7 @@ bool is_on_list (char *const *list, const char *member)
* Allocate the array we're going to store the pointers into. * Allocate the array we're going to store the pointers into.
*/ */
array = (char **) xmallocarray (i, sizeof (char *)); array = XMALLOCARRAY (i, char *);
/* /*
* Empty list is special - 0 members, not 1 empty member. --marekm * Empty list is special - 0 members, not 1 empty member. --marekm

4
libmisc/loginprompt.c
View File

@ -15,6 +15,8 @@
#include <stdio.h> #include <stdio.h>
#include <signal.h> #include <signal.h>
#include <ctype.h> #include <ctype.h>
#include "alloc.h"
#include "prototypes.h" #include "prototypes.h"
#include "defines.h" #include "defines.h"
#include "getdef.h" #include "getdef.h"
@ -130,7 +132,7 @@ void login_prompt (const char *prompt, char *name, int namesize)
envp[envc] = nvar; envp[envc] = nvar;
} else { } else {
size_t len = strlen (nvar) + 32; size_t len = strlen (nvar) + 32;
envp[envc] = xmalloc (len); envp[envc] = XMALLOCARRAY (len, char);
(void) snprintf (envp[envc], len, (void) snprintf (envp[envc], len,
"L%d=%s", count++, nvar); "L%d=%s", count++, nvar);
} }

3
libmisc/mail.c
View File

@ -15,6 +15,7 @@
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#include "alloc.h"
#include "getdef.h" #include "getdef.h"
#ident "$Id$" #ident "$Id$"
@ -38,7 +39,7 @@ void mailcheck (void)
size_t len = strlen (mailbox) + 5; size_t len = strlen (mailbox) + 5;
int wlen; int wlen;
newmail = xmalloc (len); newmail = XMALLOCARRAY (len, char);
wlen = snprintf (newmail, len, "%s/new", mailbox); wlen = snprintf (newmail, len, "%s/new", mailbox);
assert (wlen == (int) len - 1); assert (wlen == (int) len - 1);

4
libmisc/obscure.c
View File

@ -21,6 +21,8 @@
*/ */
#include <ctype.h> #include <ctype.h>
#include <stdio.h> #include <stdio.h>
#include "alloc.h"
#include "prototypes.h" #include "prototypes.h"
#include "defines.h" #include "defines.h"
#include "getdef.h" #include "getdef.h"
@ -158,7 +160,7 @@ static /*@observer@*//*@null@*/const char *password_check (
newmono = str_lower (xstrdup (new)); newmono = str_lower (xstrdup (new));
oldmono = str_lower (xstrdup (old)); oldmono = str_lower (xstrdup (old));
wrapped = xmalloc (strlen (oldmono) * 2 + 1); wrapped = XMALLOCARRAY (strlen (oldmono) * 2 + 1, char);
strcpy (wrapped, oldmono); strcpy (wrapped, oldmono);
strcat (wrapped, oldmono); strcat (wrapped, oldmono);

4
libmisc/pam_pass_non_interactive.c
View File

@ -14,6 +14,8 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <security/pam_appl.h> #include <security/pam_appl.h>
#include "alloc.h"
#include "prototypes.h" #include "prototypes.h"
#include "shadowlog.h" #include "shadowlog.h"
@ -43,7 +45,7 @@ static int ni_conv (int num_msg,
return PAM_CONV_ERR; return PAM_CONV_ERR;
} }
responses = (struct pam_response *) calloc (num_msg, sizeof (*responses)); responses = CALLOC (num_msg, struct pam_response);
if (NULL == responses) { if (NULL == responses) {
return PAM_CONV_ERR; return PAM_CONV_ERR;
} }

16
libmisc/prefix_flag.c
View File

@ -11,7 +11,9 @@
#include <stdio.h> #include <stdio.h>
#include <assert.h> #include <assert.h>
#include "defines.h" #include "defines.h"
#include "alloc.h"
#include "prototypes.h" #include "prototypes.h"
/*@-exitarg@*/ /*@-exitarg@*/
#include "exitcodes.h" #include "exitcodes.h"
@ -95,18 +97,18 @@ extern const char* process_prefix_flag (const char* short_opt, int argc, char **
} }
size_t len; size_t len;
len = strlen(prefix) + strlen(PASSWD_FILE) + 2; len = strlen(prefix) + strlen(PASSWD_FILE) + 2;
passwd_db_file = xmalloc(len); passwd_db_file = XMALLOCARRAY(len, char);
snprintf(passwd_db_file, len, "%s/%s", prefix, PASSWD_FILE); snprintf(passwd_db_file, len, "%s/%s", prefix, PASSWD_FILE);
pw_setdbname(passwd_db_file); pw_setdbname(passwd_db_file);
len = strlen(prefix) + strlen(GROUP_FILE) + 2; len = strlen(prefix) + strlen(GROUP_FILE) + 2;
group_db_file = xmalloc(len); group_db_file = XMALLOCARRAY(len, char);
snprintf(group_db_file, len, "%s/%s", prefix, GROUP_FILE); snprintf(group_db_file, len, "%s/%s", prefix, GROUP_FILE);
gr_setdbname(group_db_file); gr_setdbname(group_db_file);
#ifdef SHADOWGRP #ifdef SHADOWGRP
len = strlen(prefix) + strlen(SGROUP_FILE) + 2; len = strlen(prefix) + strlen(SGROUP_FILE) + 2;
sgroup_db_file = xmalloc(len); sgroup_db_file = XMALLOCARRAY(len, char);
snprintf(sgroup_db_file, len, "%s/%s", prefix, SGROUP_FILE); snprintf(sgroup_db_file, len, "%s/%s", prefix, SGROUP_FILE);
sgr_setdbname(sgroup_db_file); sgr_setdbname(sgroup_db_file);
#endif #endif
@ -115,18 +117,18 @@ extern const char* process_prefix_flag (const char* short_opt, int argc, char **
#endif #endif
len = strlen(prefix) + strlen(SHADOW_FILE) + 2; len = strlen(prefix) + strlen(SHADOW_FILE) + 2;
spw_db_file = xmalloc(len); spw_db_file = XMALLOCARRAY(len, char);
snprintf(spw_db_file, len, "%s/%s", prefix, SHADOW_FILE); snprintf(spw_db_file, len, "%s/%s", prefix, SHADOW_FILE);
spw_setdbname(spw_db_file); spw_setdbname(spw_db_file);
#ifdef ENABLE_SUBIDS #ifdef ENABLE_SUBIDS
len = strlen(prefix) + strlen("/etc/subuid") + 2; len = strlen(prefix) + strlen("/etc/subuid") + 2;
suid_db_file = xmalloc(len); suid_db_file = XMALLOCARRAY(len, char);
snprintf(suid_db_file, len, "%s/%s", prefix, "/etc/subuid"); snprintf(suid_db_file, len, "%s/%s", prefix, "/etc/subuid");
sub_uid_setdbname(suid_db_file); sub_uid_setdbname(suid_db_file);
len = strlen(prefix) + strlen("/etc/subgid") + 2; len = strlen(prefix) + strlen("/etc/subgid") + 2;
sgid_db_file = xmalloc(len); sgid_db_file = XMALLOCARRAY(len, char);
snprintf(sgid_db_file, len, "%s/%s", prefix, "/etc/subgid"); snprintf(sgid_db_file, len, "%s/%s", prefix, "/etc/subgid");
sub_gid_setdbname(sgid_db_file); sub_gid_setdbname(sgid_db_file);
#endif #endif
@ -135,7 +137,7 @@ extern const char* process_prefix_flag (const char* short_opt, int argc, char **
setdef_config_file(prefix); setdef_config_file(prefix);
#else #else
len = strlen(prefix) + strlen("/etc/login.defs") + 2; len = strlen(prefix) + strlen("/etc/login.defs") + 2;
def_conf_file = xmalloc(len); def_conf_file = XMALLOCARRAY(len, char);
snprintf(def_conf_file, len, "%s/%s", prefix, "/etc/login.defs"); snprintf(def_conf_file, len, "%s/%s", prefix, "/etc/login.defs");
setdef_config_file(def_conf_file); setdef_config_file(def_conf_file);
#endif #endif

4
libmisc/setupenv.c
View File

@ -20,6 +20,8 @@
#include <sys/stat.h> #include <sys/stat.h>
#include <stdio.h> #include <stdio.h>
#include <ctype.h> #include <ctype.h>
#include "alloc.h"
#include "prototypes.h" #include "prototypes.h"
#include "defines.h" #include "defines.h"
#include <pwd.h> #include <pwd.h>
@ -34,7 +36,7 @@ addenv_path (const char *varname, const char *dirname, const char *filename)
size_t len = strlen (dirname) + strlen (filename) + 2; size_t len = strlen (dirname) + strlen (filename) + 2;
int wlen; int wlen;
buf = xmalloc (len); buf = XMALLOCARRAY (len, char);
wlen = snprintf (buf, len, "%s/%s", dirname, filename); wlen = snprintf (buf, len, "%s/%s", dirname, filename);
assert (wlen == (int) len - 1); assert (wlen == (int) len - 1);

10
libmisc/utmp.c
View File

@ -20,6 +20,8 @@
#include <netdb.h> #include <netdb.h>
#include <stdio.h> #include <stdio.h>
#include "alloc.h"
#ident "$Id$" #ident "$Id$"
@ -93,7 +95,7 @@ static bool is_my_tty (const char *tty)
} }
if (NULL != ut) { if (NULL != ut) {
ret = (struct utmp *) xmalloc (sizeof (*ret)); ret = XMALLOC (struct utmp);
memcpy (ret, ut, sizeof (*ret)); memcpy (ret, ut, sizeof (*ret));
} }
@ -158,12 +160,12 @@ static void updwtmp (const char *filename, const struct utmp *ut)
if ( (NULL != host) if ( (NULL != host)
&& ('\0' != host[0])) { && ('\0' != host[0])) {
hostname = (char *) xmalloc (strlen (host) + 1); hostname = XMALLOCARRAY (strlen (host) + 1, char);
strcpy (hostname, host); strcpy (hostname, host);
#ifdef HAVE_STRUCT_UTMP_UT_HOST #ifdef HAVE_STRUCT_UTMP_UT_HOST
} else if ( (NULL != ut) } else if ( (NULL != ut)
&& ('\0' != ut->ut_host[0])) { && ('\0' != ut->ut_host[0])) {
hostname = (char *) xmalloc (sizeof (ut->ut_host) + 1); hostname = XMALLOCARRAY (sizeof (ut->ut_host) + 1, char);
strncpy (hostname, ut->ut_host, sizeof (ut->ut_host)); strncpy (hostname, ut->ut_host, sizeof (ut->ut_host));
hostname[sizeof (ut->ut_host)] = '\0'; hostname[sizeof (ut->ut_host)] = '\0';
#endif /* HAVE_STRUCT_UTMP_UT_HOST */ #endif /* HAVE_STRUCT_UTMP_UT_HOST */
@ -174,7 +176,7 @@ static void updwtmp (const char *filename, const struct utmp *ut)
} }
utent = (struct utmp *) xcalloc (1, sizeof (*utent)); utent = XCALLOC (1, struct utmp);
#ifdef HAVE_STRUCT_UTMP_UT_TYPE #ifdef HAVE_STRUCT_UTMP_UT_TYPE

6
libmisc/xgetXXbyYY.c
View File

@ -30,6 +30,8 @@
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>
#include <errno.h> #include <errno.h>
#include "alloc.h"
#include "prototypes.h" #include "prototypes.h"
#include "shadowlog.h" #include "shadowlog.h"
@ -50,7 +52,7 @@
/* we have to start with something */ /* we have to start with something */
size_t length = 0x100; size_t length = 0x100;
result = malloc(sizeof(LOOKUP_TYPE)); result = MALLOC(LOOKUP_TYPE);
if (NULL == result) { if (NULL == result) {
fprintf (log_get_logfd(), _("%s: out of memory\n"), fprintf (log_get_logfd(), _("%s: out of memory\n"),
"x" STRINGIZE(FUNCTION_NAME)); "x" STRINGIZE(FUNCTION_NAME));
@ -60,7 +62,7 @@
while (true) { while (true) {
int status; int status;
LOOKUP_TYPE *resbuf = NULL; LOOKUP_TYPE *resbuf = NULL;
buffer = (char *)xreallocarray (buffer, length, sizeof(char)); buffer = XREALLOCARRAY (buffer, length, char);
status = REENTRANT_NAME(ARG_NAME, result, buffer, status = REENTRANT_NAME(ARG_NAME, result, buffer,
length, &resbuf); length, &resbuf);
if ((0 == status) && (resbuf == result)) { if ((0 == status) && (resbuf == result)) {

4
src/gpasswd.c
View File

@ -19,6 +19,8 @@
#include <signal.h> #include <signal.h>
#include <stdio.h> #include <stdio.h>
#include <sys/types.h> #include <sys/types.h>
#include "alloc.h"
#include "defines.h" #include "defines.h"
#include "groupio.h" #include "groupio.h"
#include "nscd.h" #include "nscd.h"
@ -834,7 +836,7 @@ static void get_group (struct group *gr)
sg->sg_mem = dup_list (gr->gr_mem); sg->sg_mem = dup_list (gr->gr_mem);
sg->sg_adm = (char **) xmallocarray (2, sizeof (char *)); sg->sg_adm = XMALLOCARRAY (2, char *);
#ifdef FIRST_MEMBER_IS_ADMIN #ifdef FIRST_MEMBER_IS_ADMIN
if (sg->sg_mem[0]) { if (sg->sg_mem[0]) {
sg->sg_adm[0] = xstrdup (sg->sg_mem[0]); sg->sg_adm[0] = xstrdup (sg->sg_mem[0]);

10
src/groupmems.c
View File

@ -18,6 +18,8 @@
#include "pam_defs.h" #include "pam_defs.h"
#endif /* USE_PAM */ #endif /* USE_PAM */
#include <pwd.h> #include <pwd.h>
#include "alloc.h"
#include "defines.h" #include "defines.h"
#include "prototypes.h" #include "prototypes.h"
#include "groupio.h" #include "groupio.h"
@ -125,7 +127,7 @@ static void add_user (const char *user,
static struct sgrp sgrent; static struct sgrp sgrent;
sgrent.sg_name = xstrdup (newgrp->gr_name); sgrent.sg_name = xstrdup (newgrp->gr_name);
sgrent.sg_mem = dup_list (newgrp->gr_mem); sgrent.sg_mem = dup_list (newgrp->gr_mem);
sgrent.sg_adm = (char **) xmalloc (sizeof (char *)); sgrent.sg_adm = XMALLOC (char *);
#ifdef FIRST_MEMBER_IS_ADMIN #ifdef FIRST_MEMBER_IS_ADMIN
if (sgrent.sg_mem[0]) { if (sgrent.sg_mem[0]) {
sgrent.sg_adm[0] = xstrdup (sgrent.sg_mem[0]); sgrent.sg_adm[0] = xstrdup (sgrent.sg_mem[0]);
@ -208,7 +210,7 @@ static void remove_user (const char *user,
static struct sgrp sgrent; static struct sgrp sgrent;
sgrent.sg_name = xstrdup (newgrp->gr_name); sgrent.sg_name = xstrdup (newgrp->gr_name);
sgrent.sg_mem = dup_list (newgrp->gr_mem); sgrent.sg_mem = dup_list (newgrp->gr_mem);
sgrent.sg_adm = (char **) xmalloc (sizeof (char *)); sgrent.sg_adm = XMALLOC (char *);
#ifdef FIRST_MEMBER_IS_ADMIN #ifdef FIRST_MEMBER_IS_ADMIN
if (sgrent.sg_mem[0]) { if (sgrent.sg_mem[0]) {
sgrent.sg_adm[0] = xstrdup (sgrent.sg_mem[0]); sgrent.sg_adm[0] = xstrdup (sgrent.sg_mem[0]);
@ -281,9 +283,9 @@ static void purge_members (const struct group *grp)
/* Create a shadow group based on this group */ /* Create a shadow group based on this group */
static struct sgrp sgrent; static struct sgrp sgrent;
sgrent.sg_name = xstrdup (newgrp->gr_name); sgrent.sg_name = xstrdup (newgrp->gr_name);
sgrent.sg_mem = (char **) xmalloc (sizeof (char *)); sgrent.sg_mem = XMALLOC (char *);
sgrent.sg_mem[0] = NULL; sgrent.sg_mem[0] = NULL;
sgrent.sg_adm = (char **) xmalloc (sizeof (char *)); sgrent.sg_adm = XMALLOC (char *);
sgrent.sg_adm[0] = NULL; sgrent.sg_adm[0] = NULL;
/* Move any password to gshadow */ /* Move any password to gshadow */

10
src/groupmod.c
View File

@ -24,6 +24,8 @@
#include <pwd.h> #include <pwd.h>
#endif /* USE_PAM */ #endif /* USE_PAM */
#endif /* ACCT_TOOLS_SETUID */ #endif /* ACCT_TOOLS_SETUID */
#include "alloc.h"
#include "chkname.h" #include "chkname.h"
#include "defines.h" #include "defines.h"
#include "groupio.h" #include "groupio.h"
@ -249,7 +251,7 @@ static void grp_update (void)
// requested to replace the existing groups // requested to replace the existing groups
if (NULL != grp.gr_mem[0]) if (NULL != grp.gr_mem[0])
gr_free_members(&grp); gr_free_members(&grp);
grp.gr_mem = (char **)xmalloc(sizeof(char *)); grp.gr_mem = XMALLOC(char *);
grp.gr_mem[0] = NULL; grp.gr_mem[0] = NULL;
} else { } else {
// append to existing groups // append to existing groups
@ -557,15 +559,15 @@ static void prepare_failure_reports (void)
#endif #endif
info_passwd.name = group_name; info_passwd.name = group_name;
gr = xmalloc (512); gr = XMALLOCARRAY(512, char);
info_group.audit_msg = gr; info_group.audit_msg = gr;
gr_end = gr + 512; gr_end = gr + 512;
#ifdef SHADOWGRP #ifdef SHADOWGRP
sgr = xmalloc (512); sgr = XMALLOCARRAY(512, char);
info_gshadow.audit_msg = sgr; info_gshadow.audit_msg = sgr;
sgr_end = sgr + 512; sgr_end = sgr + 512;
#endif #endif
pw = xmalloc (512); pw = XMALLOCARRAY(512, char);
info_passwd.audit_msg = pw; info_passwd.audit_msg = pw;
pw_end = pw + 512; pw_end = pw + 512;

5
src/groups.c
View File

@ -14,9 +14,12 @@
#include <grp.h> #include <grp.h>
#include <pwd.h> #include <pwd.h>
#include <stdio.h> #include <stdio.h>
#include "alloc.h"
#include "defines.h" #include "defines.h"
#include "prototypes.h" #include "prototypes.h"
#include "shadowlog.h" #include "shadowlog.h"
/* /*
* Global variables * Global variables
*/ */
@ -88,7 +91,7 @@ int main (int argc, char **argv)
GETGROUPS_T *groups; GETGROUPS_T *groups;
sys_ngroups = sysconf (_SC_NGROUPS_MAX); sys_ngroups = sysconf (_SC_NGROUPS_MAX);
groups = (GETGROUPS_T *) mallocarray (sys_ngroups, sizeof (GETGROUPS_T)); groups = MALLOCARRAY (sys_ngroups, GETGROUPS_T);
(void) setlocale (LC_ALL, ""); (void) setlocale (LC_ALL, "");
(void) bindtextdomain (PACKAGE, LOCALEDIR); (void) bindtextdomain (PACKAGE, LOCALEDIR);

5
src/id.c
View File

@ -23,7 +23,10 @@
#include <pwd.h> #include <pwd.h>
#include <stdio.h> #include <stdio.h>
#include <sys/types.h> #include <sys/types.h>
#include "alloc.h"
#include "defines.h" #include "defines.h"
/* local function prototypes */ /* local function prototypes */
static void usage (void); static void usage (void);
@ -63,7 +66,7 @@ static void usage (void)
* work if the system library is recompiled. * work if the system library is recompiled.
*/ */
sys_ngroups = sysconf (_SC_NGROUPS_MAX); sys_ngroups = sysconf (_SC_NGROUPS_MAX);
groups = (GETGROUPS_T *) mallocarray (sys_ngroups, sizeof (GETGROUPS_T)); groups = MALLOCARRAY (sys_ngroups, GETGROUPS_T);
/* /*
* See if the -a flag has been given to print out the concurrent * See if the -a flag has been given to print out the concurrent

6
src/login.c
View File

@ -22,6 +22,8 @@
#include <sys/stat.h> #include <sys/stat.h>
#include <sys/ioctl.h> #include <sys/ioctl.h>
#include <assert.h> #include <assert.h>
#include "alloc.h"
#include "defines.h" #include "defines.h"
#include "faillog.h" #include "faillog.h"
#include "failure.h" #include "failure.h"
@ -589,7 +591,7 @@ int main (int argc, char **argv)
#ifdef RLOGIN #ifdef RLOGIN
if (rflg) { if (rflg) {
assert (NULL == username); assert (NULL == username);
username = xmalloc (USER_NAME_MAX_LENGTH + 1); username = XMALLOCARRAY (USER_NAME_MAX_LENGTH + 1, char);
username[USER_NAME_MAX_LENGTH] = '\0'; username[USER_NAME_MAX_LENGTH] = '\0';
if (do_rlogin (hostname, username, USER_NAME_MAX_LENGTH, term, sizeof term)) { if (do_rlogin (hostname, username, USER_NAME_MAX_LENGTH, term, sizeof term)) {
preauth_flag = true; preauth_flag = true;
@ -906,7 +908,7 @@ int main (int argc, char **argv)
exit (1); exit (1);
} }
preauth_flag = false; preauth_flag = false;
username = xmalloc (USER_NAME_MAX_LENGTH + 1); username = XMALLOCARRAY (USER_NAME_MAX_LENGTH + 1, char);
username[USER_NAME_MAX_LENGTH] = '\0'; username[USER_NAME_MAX_LENGTH] = '\0';
login_prompt (_("\n%s login: "), username, USER_NAME_MAX_LENGTH); login_prompt (_("\n%s login: "), username, USER_NAME_MAX_LENGTH);

4
src/newgrp.c
View File

@ -16,6 +16,8 @@
#include <pwd.h> #include <pwd.h>
#include <stdio.h> #include <stdio.h>
#include <assert.h> #include <assert.h>
#include "alloc.h"
#include "defines.h" #include "defines.h"
#include "getdef.h" #include "getdef.h"
#include "prototypes.h" #include "prototypes.h"
@ -531,7 +533,7 @@ int main (int argc, char **argv)
/* don't use getgroups(0, 0) - it doesn't work on some systems */ /* don't use getgroups(0, 0) - it doesn't work on some systems */
i = 16; i = 16;
for (;;) { for (;;) {
grouplist = (GETGROUPS_T *) xmallocarray (i, sizeof (GETGROUPS_T)); grouplist = XMALLOCARRAY (i, GETGROUPS_T);
ngroups = getgroups (i, grouplist); ngroups = getgroups (i, grouplist);
if (i > ngroups && !(ngroups == -1 && errno == EINVAL)) { if (i > ngroups && !(ngroups == -1 && errno == EINVAL)) {
break; break;

8
src/newusers.c
View File

@ -29,6 +29,8 @@
#include <ctype.h> #include <ctype.h>
#include <errno.h> #include <errno.h>
#include <string.h> #include <string.h>
#include "alloc.h"
#ifdef ACCT_TOOLS_SETUID #ifdef ACCT_TOOLS_SETUID
#ifdef USE_PAM #ifdef USE_PAM
#include "pam_defs.h" #include "pam_defs.h"
@ -1200,9 +1202,9 @@ int main (int argc, char **argv)
#ifdef USE_PAM #ifdef USE_PAM
/* keep the list of user/password for later update by PAM */ /* keep the list of user/password for later update by PAM */
nusers++; nusers++;
lines = reallocf (lines, nusers, sizeof (lines[0])); lines = REALLOCARRAYF(lines, nusers, int);
usernames = reallocf (usernames, nusers, sizeof (usernames[0])); usernames = REALLOCARRAYF(usernames, nusers, char *);
passwords = reallocf (passwords, nusers, sizeof (passwords[0])); passwords = REALLOCARRAYF(passwords, nusers, char *);
if (lines == NULL || usernames == NULL || passwords == NULL) { if (lines == NULL || usernames == NULL || passwords == NULL) {
fprintf (stderr, fprintf (stderr,
_("%s: line %d: %s\n"), _("%s: line %d: %s\n"),

4
src/passwd.c
View File

@ -19,6 +19,8 @@
#include <stdio.h> #include <stdio.h>
#include <sys/types.h> #include <sys/types.h>
#include <time.h> #include <time.h>
#include "alloc.h"
#include "defines.h" #include "defines.h"
#include "getdef.h" #include "getdef.h"
#include "nscd.h" #include "nscd.h"
@ -524,7 +526,7 @@ static char *update_crypt_pw (char *cp)
} }
if (lflg && *cp != '!') { if (lflg && *cp != '!') {
char *newpw = xmalloc (strlen (cp) + 2); char *newpw = XMALLOCARRAY (strlen (cp) + 2, char);
strcpy (newpw, "!"); strcpy (newpw, "!");
strcat (newpw, cp); strcat (newpw, cp);

6
src/su.c
View File

@ -45,6 +45,8 @@
#include <sys/stat.h> #include <sys/stat.h>
#include <fcntl.h> #include <fcntl.h>
#endif /* !USE_PAM */ #endif /* !USE_PAM */
#include "alloc.h"
#include "prototypes.h" #include "prototypes.h"
#include "defines.h" #include "defines.h"
#include "pwauth.h" #include "pwauth.h"
@ -238,7 +240,7 @@ static void execve_shell (const char *shellname,
while (NULL != args[n_args]) { while (NULL != args[n_args]) {
n_args++; n_args++;
} }
targs = (char **) xmallocarray (n_args + 3, sizeof (args[0])); targs = XMALLOCARRAY (n_args + 3, char *);
targs[0] = "sh"; targs[0] = "sh";
targs[1] = "-"; targs[1] = "-";
targs[2] = xstrdup (shellname); targs[2] = xstrdup (shellname);
@ -1176,7 +1178,7 @@ int main (int argc, char **argv)
cp = Basename (shellstr); cp = Basename (shellstr);
} }
arg0 = xmalloc (strlen (cp) + 2); arg0 = XMALLOCARRAY (strlen (cp) + 2, char);
arg0[0] = '-'; arg0[0] = '-';
strcpy (arg0 + 1, cp); strcpy (arg0 + 1, cp);
cp = arg0; cp = arg0;

20
src/useradd.c
View File

@ -32,6 +32,8 @@
#include <sys/wait.h> #include <sys/wait.h>
#include <time.h> #include <time.h>
#include <unistd.h> #include <unistd.h>
#include "alloc.h"
#include "chkname.h" #include "chkname.h"
#include "defines.h" #include "defines.h"
#include "faillog.h" #include "faillog.h"
@ -355,7 +357,7 @@ static void get_defaults (void)
int wlen; int wlen;
len = strlen(prefix) + strlen(USER_DEFAULTS_FILE) + 2; len = strlen(prefix) + strlen(USER_DEFAULTS_FILE) + 2;
default_file = malloc(len); default_file = MALLOCARRAY(len, char);
if (default_file == NULL) if (default_file == NULL)
return; return;
wlen = snprintf(default_file, len, "%s/%s", prefix, USER_DEFAULTS_FILE); wlen = snprintf(default_file, len, "%s/%s", prefix, USER_DEFAULTS_FILE);
@ -468,7 +470,7 @@ static void get_defaults (void)
char* _def_template; /* avoid const warning */ char* _def_template; /* avoid const warning */
len = strlen(prefix) + strlen(cp) + 2; len = strlen(prefix) + strlen(cp) + 2;
_def_template = xmalloc(len); _def_template = XMALLOCARRAY(len, char);
wlen = snprintf(_def_template, len, "%s/%s", prefix, cp); wlen = snprintf(_def_template, len, "%s/%s", prefix, cp);
assert (wlen == (int) len -1); assert (wlen == (int) len -1);
def_template = _def_template; def_template = _def_template;
@ -492,7 +494,7 @@ static void get_defaults (void)
char* _def_usrtemplate; /* avoid const warning */ char* _def_usrtemplate; /* avoid const warning */
len = strlen(prefix) + strlen(cp) + 2; len = strlen(prefix) + strlen(cp) + 2;
_def_usrtemplate = xmalloc(len); _def_usrtemplate = XMALLOCARRAY(len, char);
wlen = snprintf(_def_usrtemplate, len, "%s/%s", prefix, cp); wlen = snprintf(_def_usrtemplate, len, "%s/%s", prefix, cp);
assert (wlen == (int) len -1); assert (wlen == (int) len -1);
def_usrtemplate = _def_usrtemplate; def_usrtemplate = _def_usrtemplate;
@ -582,7 +584,7 @@ static int set_defaults (void)
len = strlen(prefix) + strlen(NEW_USER_FILE) + 2; len = strlen(prefix) + strlen(NEW_USER_FILE) + 2;
new_file = malloc(len); new_file = MALLOCARRAY(len, char);
if (new_file == NULL) { if (new_file == NULL) {
fprintf (stderr, fprintf (stderr,
_("%s: cannot create new defaults file: %s\n"), _("%s: cannot create new defaults file: %s\n"),
@ -594,7 +596,7 @@ static int set_defaults (void)
if (prefix[0]) { if (prefix[0]) {
len = strlen(prefix) + strlen(USER_DEFAULTS_FILE) + 2; len = strlen(prefix) + strlen(USER_DEFAULTS_FILE) + 2;
default_file = malloc(len); default_file = MALLOCARRAY(len, char);
if (default_file == NULL) { if (default_file == NULL) {
fprintf (stderr, fprintf (stderr,
_("%s: cannot create new defaults file: %s\n"), _("%s: cannot create new defaults file: %s\n"),
@ -1610,7 +1612,7 @@ static void process_flags (int argc, char **argv)
size_t len = strlen (def_home) + strlen (user_name) + 2; size_t len = strlen (def_home) + strlen (user_name) + 2;
int wlen; int wlen;
uh = xmalloc (len); uh = XMALLOCARRAY (len, char);
wlen = snprintf (uh, len, "%s/%s", def_home, user_name); wlen = snprintf (uh, len, "%s/%s", def_home, user_name);
assert (wlen == (int) len -1); assert (wlen == (int) len -1);
@ -1620,7 +1622,7 @@ static void process_flags (int argc, char **argv)
size_t len = strlen(prefix) + strlen(user_home) + 2; size_t len = strlen(prefix) + strlen(user_home) + 2;
int wlen; int wlen;
char* _prefix_user_home; /* to avoid const warning */ char* _prefix_user_home; /* to avoid const warning */
_prefix_user_home = xmalloc(len); _prefix_user_home = XMALLOCARRAY(len, char);
wlen = snprintf(_prefix_user_home, len, "%s/%s", prefix, user_home); wlen = snprintf(_prefix_user_home, len, "%s/%s", prefix, user_home);
assert (wlen == (int) len -1); assert (wlen == (int) len -1);
prefix_user_home = _prefix_user_home; prefix_user_home = _prefix_user_home;
@ -2429,7 +2431,7 @@ static void create_mail (void)
if (NULL == spool) { if (NULL == spool) {
return; return;
} }
file = alloca (strlen (prefix) + strlen (spool) + strlen (user_name) + 3); file = ALLOCARRAY (strlen (prefix) + strlen (spool) + strlen (user_name) + 3, char);
if (prefix[0]) if (prefix[0])
sprintf (file, "%s/%s/%s", prefix, spool, user_name); sprintf (file, "%s/%s/%s", prefix, spool, user_name);
else else
@ -2539,7 +2541,7 @@ int main (int argc, char **argv)
#endif #endif
sys_ngroups = sysconf (_SC_NGROUPS_MAX); sys_ngroups = sysconf (_SC_NGROUPS_MAX);
user_groups = (char **) xmallocarray (1 + sys_ngroups, sizeof (char *)); user_groups = XMALLOCARRAY (1 + sys_ngroups, char *);
/* /*
* Initialize the list to be empty * Initialize the list to be empty
*/ */

8
src/userdel.c
View File

@ -19,6 +19,8 @@
#include <sys/stat.h> #include <sys/stat.h>
#include <sys/types.h> #include <sys/types.h>
#include <unistd.h> #include <unistd.h>
#include "alloc.h"
#ifdef ACCT_TOOLS_SETUID #ifdef ACCT_TOOLS_SETUID
#ifdef USE_PAM #ifdef USE_PAM
#include "pam_defs.h" #include "pam_defs.h"
@ -803,7 +805,7 @@ static int remove_mailbox (void)
} }
len = strlen (prefix) + strlen (maildir) + strlen (user_name) + 2; len = strlen (prefix) + strlen (maildir) + strlen (user_name) + 2;
mailfile = xmalloc (len); mailfile = XMALLOCARRAY (len, char);
if (prefix[0]) { if (prefix[0]) {
(void) snprintf (mailfile, len, "%s/%s/%s", (void) snprintf (mailfile, len, "%s/%s/%s",
@ -917,7 +919,7 @@ static int remove_tcbdir (const char *user_name, uid_t user_id)
return 0; return 0;
} }
buf = malloc (buflen); buf = MALLOCARRAY (buflen, char);
if (NULL == buf) { if (NULL == buf) {
fprintf (stderr, _("%s: Can't allocate memory, " fprintf (stderr, _("%s: Can't allocate memory, "
"tcb entry for %s not removed.\n"), "tcb entry for %s not removed.\n"),
@ -1129,7 +1131,7 @@ int main (int argc, char **argv)
size_t len = strlen(prefix) + strlen(pwd->pw_dir) + 2; size_t len = strlen(prefix) + strlen(pwd->pw_dir) + 2;
int wlen; int wlen;
user_home = xmalloc(len); user_home = XMALLOCARRAY(len, char);
wlen = snprintf(user_home, len, "%s/%s", prefix, pwd->pw_dir); wlen = snprintf(user_home, len, "%s/%s", prefix, pwd->pw_dir);
assert (wlen == (int) len -1); assert (wlen == (int) len -1);
} }

16
src/usermod.c
View File

@ -28,6 +28,8 @@
#include <sys/stat.h> #include <sys/stat.h>
#include <sys/types.h> #include <sys/types.h>
#include <time.h> #include <time.h>
#include "alloc.h"
#include "chkname.h" #include "chkname.h"
#include "defines.h" #include "defines.h"
#include "faillog.h" #include "faillog.h"
@ -342,7 +344,7 @@ static int prepend_range(const char *str, struct ulong_range_list_entry **head)
if (range.first > range.last) if (range.first > range.last)
return 0; return 0;
entry = malloc(sizeof(*entry)); entry = MALLOC(struct ulong_range_list_entry);
if (!entry) { if (!entry) {
fprintf (stderr, fprintf (stderr,
_("%s: failed to allocate memory: %s\n"), _("%s: failed to allocate memory: %s\n"),
@ -415,7 +417,7 @@ usage (int status)
static char *new_pw_passwd (char *pw_pass) static char *new_pw_passwd (char *pw_pass)
{ {
if (Lflg && ('!' != pw_pass[0])) { if (Lflg && ('!' != pw_pass[0])) {
char *buf = xmalloc (strlen (pw_pass) + 2); char *buf = XMALLOCARRAY (strlen (pw_pass) + 2, char);
#ifdef WITH_AUDIT #ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog, audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
@ -1258,12 +1260,12 @@ static void process_flags (int argc, char **argv)
if (prefix[0]) { if (prefix[0]) {
size_t len = strlen(prefix) + strlen(user_home) + 2; size_t len = strlen(prefix) + strlen(user_home) + 2;
int wlen; int wlen;
prefix_user_home = xmalloc(len); prefix_user_home = XMALLOCARRAY(len, char);
wlen = snprintf(prefix_user_home, len, "%s/%s", prefix, user_home); wlen = snprintf(prefix_user_home, len, "%s/%s", prefix, user_home);
assert (wlen == (int) len -1); assert (wlen == (int) len -1);
if (user_newhome) { if (user_newhome) {
len = strlen(prefix) + strlen(user_newhome) + 2; len = strlen(prefix) + strlen(user_newhome) + 2;
prefix_user_newhome = xmalloc(len); prefix_user_newhome = XMALLOCARRAY(len, char);
wlen = snprintf(prefix_user_newhome, len, "%s/%s", prefix, user_newhome); wlen = snprintf(prefix_user_newhome, len, "%s/%s", prefix, user_newhome);
assert (wlen == (int) len -1); assert (wlen == (int) len -1);
} }
@ -2038,7 +2040,7 @@ static void move_mailbox (void)
return; return;
} }
len = strlen (prefix) + strlen (maildir) + strlen (user_name) + 2; len = strlen (prefix) + strlen (maildir) + strlen (user_name) + 2;
mailfile = alloca (len); mailfile = ALLOCARRAY (len, char);
/* /*
* O_NONBLOCK is to make sure open won't hang on mandatory locks. * O_NONBLOCK is to make sure open won't hang on mandatory locks.
@ -2093,7 +2095,7 @@ static void move_mailbox (void)
if (lflg) { if (lflg) {
len = strlen (prefix) + strlen (maildir) + strlen (user_newname) + 2; len = strlen (prefix) + strlen (maildir) + strlen (user_newname) + 2;
newmailfile = alloca(len); newmailfile = ALLOCARRAY(len, char);
if (prefix[0]) { if (prefix[0]) {
(void) snprintf (newmailfile, len, "%s/%s/%s", (void) snprintf (newmailfile, len, "%s/%s/%s",
prefix, maildir, user_newname); prefix, maildir, user_newname);
@ -2150,7 +2152,7 @@ int main (int argc, char **argv)
#endif #endif
sys_ngroups = sysconf (_SC_NGROUPS_MAX); sys_ngroups = sysconf (_SC_NGROUPS_MAX);
user_groups = (char **) mallocarray (sys_ngroups + 1, sizeof (char *)); user_groups = MALLOCARRAY (sys_ngroups + 1, char *);
user_groups[0] = NULL; user_groups[0] = NULL;
is_shadow_pwd = spw_file_present (); is_shadow_pwd = spw_file_present ();

6
src/vipw.c
View File

@ -26,6 +26,8 @@
#include <sys/types.h> #include <sys/types.h>
#include <unistd.h> #include <unistd.h>
#include <utime.h> #include <utime.h>
#include "alloc.h"
#include "defines.h" #include "defines.h"
#include "groupio.h" #include "groupio.h"
#include "nscd.h" #include "nscd.h"
@ -302,7 +304,7 @@ vipwedit (const char *file, int (*file_lock) (void), int (*file_unlock) (void))
continue; continue;
} }
buf = (char *) malloc (strlen (editor) + strlen (fileedit) + 2); buf = MALLOCARRAY(strlen(editor) + strlen(fileedit) + 2, char);
snprintf (buf, strlen (editor) + strlen (fileedit) + 2, snprintf (buf, strlen (editor) + strlen (fileedit) + 2,
"%s %s", editor, fileedit); "%s %s", editor, fileedit);
status = system (buf); status = system (buf);
@ -418,7 +420,7 @@ vipwedit (const char *file, int (*file_lock) (void), int (*file_unlock) (void))
if (stat (file, &st1) != 0) { if (stat (file, &st1) != 0) {
vipwexit (_("failed to stat edited file"), errno, 1); vipwexit (_("failed to stat edited file"), errno, 1);
} }
to_rename = malloc (strlen (file) + 2); to_rename = MALLOCARRAY (strlen (file) + 2, char);
if (NULL == to_rename) { if (NULL == to_rename) {
vipwexit (_("failed to allocate memory"), errno, 1); vipwexit (_("failed to allocate memory"), errno, 1);
} }

4
tests/libsubid/04_nss/libsubid_zzz.c
View File

@ -76,7 +76,7 @@ static uid_t getnamuid(const char *name) {
} }
static int alloc_uid(uid_t **uids, uid_t id) { static int alloc_uid(uid_t **uids, uid_t id) {
*uids = malloc(sizeof(uid_t)); *uids = MALLOC(uid_t);
if (!*uids) if (!*uids)
return -1; return -1;
*uids[0] = id; *uids[0] = id;
@ -121,7 +121,7 @@ enum subid_status shadow_subid_list_owner_ranges(const char *owner, enum subid_t
return SUBID_STATUS_SUCCESS; return SUBID_STATUS_SUCCESS;
if (id_type == ID_TYPE_UID && strcmp(owner, "group1") == 0) if (id_type == ID_TYPE_UID && strcmp(owner, "group1") == 0)
return SUBID_STATUS_SUCCESS; return SUBID_STATUS_SUCCESS;
ranges = (struct subid_range *)malloc(sizeof(struct subid_range)); ranges = MALLOC(struct subid_range);
if (!ranges) if (!ranges)
return SUBID_STATUS_ERROR; return SUBID_STATUS_ERROR;
if (strcmp(owner, "user1") == 0 || strcmp(owner, "group1") == 0) { if (strcmp(owner, "user1") == 0 || strcmp(owner, "group1") == 0) {