gsasl  1.10.0
About: GNU SASL is an implementation of the Simple Authentication and Security Layer (SASL). Development version.
  Fossies Dox: gsasl-1.10.0.tar.gz  ("unofficial" and yet experimental doxygen-generated source code documentation)  

xmalloc.c
Go to the documentation of this file.
1 /* xmalloc.c -- malloc with out of memory checking
2 
3  Copyright (C) 1990-2000, 2002-2006, 2008-2021 Free Software Foundation, Inc.
4 
5  This program is free software: you can redistribute it and/or modify
6  it under the terms of the GNU General Public License as published by
7  the Free Software Foundation; either version 3 of the License, or
8  (at your option) any later version.
9 
10  This program is distributed in the hope that it will be useful,
11  but WITHOUT ANY WARRANTY; without even the implied warranty of
12  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13  GNU General Public License for more details.
14 
15  You should have received a copy of the GNU General Public License
16  along with this program. If not, see <https://www.gnu.org/licenses/>. */
17 
18 #include <config.h>
19 
20 #define XALLOC_INLINE _GL_EXTERN_INLINE
21 
22 #include "xalloc.h"
23 
24 #include <stdlib.h>
25 #include <string.h>
26 
27 /* 1 if calloc, malloc and realloc are known to be compatible with GNU.
28  This matters if we are not also using the calloc-gnu, malloc-gnu
29  and realloc-gnu modules, which define HAVE_CALLOC_GNU,
30  HAVE_MALLOC_GNU and HAVE_REALLOC_GNU and support the GNU API even
31  on non-GNU platforms. */
32 #if defined HAVE_CALLOC_GNU || (defined __GLIBC__ && !defined __UCLIBC__)
33 enum { HAVE_GNU_CALLOC = 1 };
34 #else
35 enum { HAVE_GNU_CALLOC = 0 };
36 #endif
37 #if defined HAVE_MALLOC_GNU || (defined __GLIBC__ && !defined __UCLIBC__)
38 enum { HAVE_GNU_MALLOC = 1 };
39 #else
40 enum { HAVE_GNU_MALLOC = 0 };
41 #endif
42 #if defined HAVE_REALLOC_GNU || (defined __GLIBC__ && !defined __UCLIBC__)
43 enum { HAVE_GNU_REALLOC = 1 };
44 #else
45 enum { HAVE_GNU_REALLOC = 0 };
46 #endif
47 
48 /* Allocate N bytes of memory dynamically, with error checking. */
49 
50 void *
51 xmalloc (size_t n)
52 {
53  void *p = malloc (n);
54  if (!p && (HAVE_GNU_MALLOC || n))
55  xalloc_die ();
56  return p;
57 }
58 
59 /* Change the size of an allocated block of memory P to N bytes,
60  with error checking. */
61 
62 void *
63 xrealloc (void *p, size_t n)
64 {
65  if (!HAVE_GNU_REALLOC && !n && p)
66  {
67  /* The GNU and C99 realloc behaviors disagree here. Act like GNU. */
68  free (p);
69  return NULL;
70  }
71 
72  void *r = realloc (p, n);
73  if (!r && (n || (HAVE_GNU_REALLOC && !p)))
74  xalloc_die ();
75  return r;
76 }
77 
78 /* If P is null, allocate a block of at least *PN bytes; otherwise,
79  reallocate P so that it contains more than *PN bytes. *PN must be
80  nonzero unless P is null. Set *PN to the new block's size, and
81  return the pointer to the new block. *PN is never set to zero, and
82  the returned pointer is never null. */
83 
84 void *
85 x2realloc (void *p, size_t *pn)
86 {
87  return x2nrealloc (p, pn, 1);
88 }
89 
90 /* Allocate N bytes of zeroed memory dynamically, with error checking.
91  There's no need for xnzalloc (N, S), since it would be equivalent
92  to xcalloc (N, S). */
93 
94 void *
95 xzalloc (size_t n)
96 {
97  return xcalloc (n, 1);
98 }
99 
100 /* Allocate zeroed memory for N elements of S bytes, with error
101  checking. S must be nonzero. */
102 
103 void *
104 xcalloc (size_t n, size_t s)
105 {
106  void *p;
107  /* Test for overflow, since objects with size greater than
108  PTRDIFF_MAX cause pointer subtraction to go awry. Omit size-zero
109  tests if HAVE_GNU_CALLOC, since GNU calloc never returns NULL if
110  successful. */
111  if (xalloc_oversized (n, s)
112  || (! (p = calloc (n, s)) && (HAVE_GNU_CALLOC || n != 0)))
113  xalloc_die ();
114  return p;
115 }
116 
117 /* Clone an object P of size S, with error checking. There's no need
118  for xnmemdup (P, N, S), since xmemdup (P, N * S) works without any
119  need for an arithmetic overflow check. */
120 
121 void *
122 xmemdup (void const *p, size_t s)
123 {
124  return memcpy (xmalloc (s), p, s);
125 }
126 
127 /* Clone STRING. */
128 
129 char *
130 xstrdup (char const *string)
131 {
132  return xmemdup (string, strlen (string) + 1);
133 }
#define NULL
Definition: stddef.in.h:72
#define xalloc_oversized(n, s)
const char * p
Definition: mbrtowc-impl.h:42
void xalloc_die(void)
Definition: xalloc-die.c:32
@ HAVE_GNU_REALLOC
Definition: xmalloc.c:45
void * xrealloc(void *p, size_t n)
Definition: xmalloc.c:63
void * xmalloc(size_t n)
Definition: xmalloc.c:51
@ HAVE_GNU_CALLOC
Definition: xmalloc.c:35
char * xstrdup(char const *string)
Definition: xmalloc.c:130
void * xmemdup(void const *p, size_t s)
Definition: xmalloc.c:122
@ HAVE_GNU_MALLOC
Definition: xmalloc.c:40
void * xcalloc(size_t n, size_t s)
Definition: xmalloc.c:104
void * xzalloc(size_t n)
Definition: xmalloc.c:95
void * x2realloc(void *p, size_t *pn)
Definition: xmalloc.c:85