/[imapfilter]/imapfilter/memory.c
ViewVC logotype

Contents of /imapfilter/memory.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.16.2.2 - (show annotations)
Fri Aug 8 12:25:51 2003 UTC (20 years, 7 months ago) by lefcha
Branch: release-0_9-patches
Changes since 1.16.2.1: +2 -0 lines
File MIME type: text/plain
Added header includes to compile on systems that don't conform to IEEE Std 1003.1-2001 (POSIX.1).

1 #include <stdlib.h>
2 #include <stdlib.h>
3 #include <unistd.h>
4 #include <string.h>
5 #include <errno.h>
6 #include <sys/types.h> /* IEEE Std 1003.1-2001 non-conformance. */
7 #include <sys/time.h> /* IEEE Std 1003.1-2001 non-conformance. */
8 #include <sys/resource.h>
9
10 #include "config.h"
11 #include "imapfilter.h"
12
13
14 /* Secure memory information. */
15 typedef struct secmem {
16 void *buf; /* Allocated memory buffer. */
17 size_t size; /* Size of the buffer. */
18 struct secmem *prev, *next; /* Previous/next node of doubly linked
19 * list. */
20 } secmem_t;
21
22
23 extern unsigned int options;
24
25 static secmem_t *smem = NULL; /* First node of secure memory linked list. */
26
27
28 void secmem_append(secmem_t * node);
29 secmem_t *secmem_find(void *ptr);
30 void secmem_remove(secmem_t * node);
31
32
33 /*
34 * A malloc() that checks the results and dies in case of error.
35 */
36 void *
37 xmalloc(size_t size)
38 {
39 void *ptr;
40
41 ptr = (void *)malloc(size);
42
43 if (ptr == NULL)
44 fatal(ERROR_MEMORY_ALLOCATION,
45 "allocating memory; %s\n", strerror(errno));
46
47 return ptr;
48 }
49
50
51 /*
52 * A realloc() that checks the results and dies in case of error.
53 */
54 void *
55 xrealloc(void *ptr, size_t size)
56 {
57 ptr = (void *)realloc(ptr, size);
58
59 if (ptr == NULL)
60 fatal(ERROR_MEMORY_ALLOCATION,
61 "allocating memory; %s\n", strerror(errno));
62
63 return ptr;
64 }
65
66
67 /*
68 * A free() that dies if fed with NULL pointer.
69 */
70 void
71 xfree(void *ptr)
72 {
73 if (ptr == NULL)
74 fatal(ERROR_MEMORY_ALLOCATION,
75 "NULL pointer given as argument");
76 free(ptr);
77 }
78
79
80 /*
81 * A strdup() that checks the results and dies in case of error.
82 */
83 char *
84 xstrdup(const char *s)
85 {
86 char *cp;
87
88 cp = strdup(s);
89
90 if (cp == NULL)
91 fatal(ERROR_MEMORY_ALLOCATION,
92 "allocating memory; %s\n", strerror(errno));
93
94 return cp;
95 }
96
97
98 /*
99 * Secure memory malloc(). Locks memory and keeps information about the
100 * chunk that was allocated.
101 */
102 void *
103 smalloc(size_t size)
104 {
105 void *ptr;
106 secmem_t *node;
107
108 ptr = xmalloc(size);
109
110 node = (secmem_t *) xmalloc(sizeof(secmem_t));
111
112 node->buf = ptr;
113 node->size = size;
114 node->prev = node->next = NULL;
115
116 secmem_append(node);
117
118 return ptr;
119 }
120
121
122 /*
123 * Secure memory realloc(). Resize memory by allocating a new memory chunk
124 * and NULL fill old memory, in order to protect sensitive data.
125 */
126 void *
127 srealloc(void *ptr, size_t size)
128 {
129 void *p;
130 secmem_t *node;
131
132 if (!(node = (secmem_t *) secmem_find(ptr))) {
133 ptr = xrealloc(ptr, size);
134 return ptr;
135 }
136 p = smalloc(size);
137 memcpy(p, node->buf, min(node->size, size));
138
139 memset(node->buf, 0, node->size);
140 secmem_remove(node);
141 xfree(node->buf);
142 xfree(node);
143
144 return p;
145 }
146
147
148 /*
149 * Secure memory free(). NULL fill memory before freeing it.
150 */
151 void
152 sfree(void *ptr)
153 {
154 secmem_t *node;
155
156 if (!(node = (secmem_t *) secmem_find(ptr))) {
157 xfree(ptr);
158 return;
159 }
160 memset(node->buf, 0, node->size);
161 secmem_remove(node);
162 xfree(node->buf);
163 xfree(node);
164 }
165
166
167 /*
168 * Secure memory strdup(). Uses secure memory allocation.
169 */
170 char *
171 sstrdup(const char *s)
172 {
173 char *p;
174
175 p = (char *)smalloc(strlen(s) + 1);
176 xstrncpy(p, s, strlen(s));
177
178 return p;
179 }
180
181
182 /*
183 * Append information about the newly allocated memory buffer.
184 */
185 void
186 secmem_append(secmem_t * node)
187 {
188 secmem_t *pos;
189 secmem_t **app;
190
191 app = &smem;
192 pos = smem;
193
194 while (pos) {
195 node->prev = pos;
196 app = &(pos->next);
197 pos = pos->next;
198 }
199
200 *app = node;
201 }
202
203
204 /*
205 * Find the record of a memory buffer in the secure memory linked list.
206 */
207 secmem_t *
208 secmem_find(void *ptr)
209 {
210 secmem_t *pos;
211
212 pos = smem;
213
214 while (pos != NULL && pos->buf != ptr)
215 pos = pos->next;
216
217 return pos;
218 }
219
220
221 /*
222 * Remove a record of a secure memory buffer.
223 */
224 void
225 secmem_remove(secmem_t * node)
226 {
227 if (node->prev != NULL)
228 node->prev->next = node->next;
229 if (node->next != NULL)
230 node->next->prev = node->prev;
231 if (smem == node)
232 smem = node->next;
233
234 }
235
236
237 /*
238 * Overwrite/clear all secure memory.
239 */
240 void
241 secmem_clear(void)
242 {
243 secmem_t *p, *t;
244
245 for (p = smem; p != NULL; p = t) {
246 t = p->next;
247 sfree(p->buf);
248 }
249 }
250
251
252 /*
253 * Disable core file dumping.
254 */
255 void
256 corefile_disable(void)
257 {
258 struct rlimit rl;
259
260 getrlimit(RLIMIT_CORE, &rl);
261
262 rl.rlim_cur = rl.rlim_max = 0;
263 setrlimit(RLIMIT_CORE, &rl);
264 }

webmaster@linux.gr
ViewVC Help
Powered by ViewVC 1.1.26