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

Contents of /imapfilter/memory.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.22 - (show annotations)
Sat Feb 14 19:14:43 2004 UTC (16 years, 7 months ago) by lefcha
Branch: MAIN
CVS Tags: HEAD
Changes since 1.21: +2 -1 lines
File MIME type: text/plain
Indentation.

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> /* For POSIX.1-2001 non-conformant systems. */
7 #include <sys/time.h> /* For POSIX.1-2001 non-conformant systems. */
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 *secmem = NULL; /* First node of secure memory linked list. */
26
27
28 void secmem_append(secmem_t * sm);
29 secmem_t *secmem_find(void *ptr);
30 void secmem_remove(secmem_t * sm);
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_MEMALLOC,
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_MEMALLOC,
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
74 if (ptr == NULL)
75 fatal(ERROR_MEMALLOC,
76 "NULL pointer given as argument");
77 free(ptr);
78 }
79
80
81 /*
82 * A strdup() that checks the results and dies in case of error.
83 */
84 char *
85 xstrdup(const char *s)
86 {
87 char *cp;
88
89 cp = strdup(s);
90
91 if (cp == NULL)
92 fatal(ERROR_MEMALLOC, "allocating memory; %s\n",
93 strerror(errno));
94
95 return cp;
96 }
97
98
99 /*
100 * Secure memory malloc(). Locks memory and keeps information about the
101 * chunk that was allocated.
102 */
103 void *
104 smalloc(size_t size)
105 {
106 void *ptr;
107 secmem_t *sm;
108
109 ptr = xmalloc(size);
110
111 sm = (secmem_t *) xmalloc(sizeof(secmem_t));
112
113 sm->buf = ptr;
114 sm->size = size;
115 sm->prev = sm->next = NULL;
116
117 secmem_append(sm);
118
119 return ptr;
120 }
121
122
123 /*
124 * Secure memory realloc(). Resize memory by allocating a new memory chunk
125 * and NULL fill old memory, in order to protect sensitive data.
126 */
127 void *
128 srealloc(void *ptr, size_t size)
129 {
130 void *p;
131 secmem_t *sm;
132
133 if (!(sm = (secmem_t *) secmem_find(ptr))) {
134 ptr = xrealloc(ptr, size);
135 return ptr;
136 }
137 p = smalloc(size);
138 memcpy(p, sm->buf, min(sm->size, size));
139
140 memset(sm->buf, 0, sm->size);
141 secmem_remove(sm);
142 xfree(sm->buf);
143 xfree(sm);
144
145 return p;
146 }
147
148
149 /*
150 * Secure memory free(). NULL fill memory before freeing it.
151 */
152 void
153 sfree(void *ptr)
154 {
155 secmem_t *sm;
156
157 if (!(sm = (secmem_t *) secmem_find(ptr))) {
158 xfree(ptr);
159 return;
160 }
161 memset(sm->buf, 0, sm->size);
162 secmem_remove(sm);
163 xfree(sm->buf);
164 xfree(sm);
165 }
166
167
168 /*
169 * Secure memory strdup(). Uses secure memory allocation.
170 */
171 char *
172 sstrdup(const char *s)
173 {
174 char *p;
175
176 p = (char *)smalloc(strlen(s) + 1);
177 xstrncpy(p, s, strlen(s));
178
179 return p;
180 }
181
182
183 /*
184 * Append information about the newly allocated memory buffer.
185 */
186 void
187 secmem_append(secmem_t * sm)
188 {
189 secmem_t *pos;
190 secmem_t **app;
191
192 app = &secmem;
193 pos = secmem;
194
195 while (pos) {
196 sm->prev = pos;
197 app = &(pos->next);
198 pos = pos->next;
199 }
200
201 *app = sm;
202 }
203
204
205 /*
206 * Find the record of a memory buffer in the secure memory linked list.
207 */
208 secmem_t *
209 secmem_find(void *ptr)
210 {
211 secmem_t *pos;
212
213 pos = secmem;
214
215 while (pos != NULL && pos->buf != ptr)
216 pos = pos->next;
217
218 return pos;
219 }
220
221
222 /*
223 * Remove a record of a secure memory buffer.
224 */
225 void
226 secmem_remove(secmem_t * sm)
227 {
228
229 if (sm->prev != NULL)
230 sm->prev->next = sm->next;
231 if (sm->next != NULL)
232 sm->next->prev = sm->prev;
233 if (secmem == sm)
234 secmem = sm->next;
235
236 }
237
238
239 /*
240 * Overwrite/clear all secure memory.
241 */
242 void
243 secmem_clear(void)
244 {
245 secmem_t *p, *t;
246
247 for (p = secmem; p != NULL; p = t) {
248 t = p->next;
249 sfree(p->buf);
250 }
251 }
252
253
254 /*
255 * Disable core file dumping.
256 */
257 void
258 corefile_disable(void)
259 {
260 struct rlimit rl;
261
262 getrlimit(RLIMIT_CORE, &rl);
263
264 rl.rlim_cur = rl.rlim_max = 0;
265 setrlimit(RLIMIT_CORE, &rl);
266 }

webmaster@linux.gr
ViewVC Help
Powered by ViewVC 1.1.26