chiark / gitweb /
make-secnet-sites: new "include" keyword
[secnet.git] / util.c
1 /*
2  * util.c
3  * - output and logging support
4  * - program lifetime support
5  * - IP address and subnet munging routines
6  * - MPI convenience functions
7  */
8 /*
9  *  This file is
10  *    Copyright (C) 1995--2001 Stephen Early <steve@greenend.org.uk>
11  *
12  *  It is part of secnet, which is
13  *    Copyright (C) 1995--2001 Stephen Early <steve@greenend.org.uk>
14  *    Copyright (C) 1998 Ross Anderson, Eli Biham, Lars Knudsen
15  *  
16  *  This program is free software; you can redistribute it and/or modify
17  *  it under the terms of the GNU General Public License as published by
18  *  the Free Software Foundation; either version 2, or (at your option)
19  *  any later version.
20  *  
21  *  This program is distributed in the hope that it will be useful,
22  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
23  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
24  *  GNU General Public License for more details.
25  *  
26  *  You should have received a copy of the GNU General Public License
27  *  along with this program; if not, write to the Free Software Foundation,
28  *  Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 
29  */
30
31 #include "secnet.h"
32 #include <stdio.h>
33 #include <string.h>
34 #include <errno.h>
35 #include <unistd.h>
36 #include <limits.h>
37 #include <assert.h>
38 #include <sys/wait.h>
39 #include "util.h"
40 #include "unaligned.h"
41
42 #define MIN_BUFFER_SIZE 64
43 #define DEFAULT_BUFFER_SIZE 4096
44 #define MAX_BUFFER_SIZE 131072
45
46 static const char *hexdigits="0123456789abcdef";
47
48 uint32_t current_phase=0;
49
50 struct phase_hook {
51     hook_fn *fn;
52     void *state;
53     struct phase_hook *next;
54 };
55
56 static struct phase_hook *hooks[NR_PHASES]={NULL,};
57
58 char *safe_strdup(const char *s, const char *message)
59 {
60     char *d;
61     d=strdup(s);
62     if (!d) {
63         fatal_perror(message);
64     }
65     return d;
66 }
67
68 void *safe_malloc(size_t size, const char *message)
69 {
70     void *r;
71     r=malloc(size);
72     if (!r) {
73         fatal_perror(message);
74     }
75     return r;
76 }
77 void *safe_malloc_ary(size_t size, size_t count, const char *message) {
78     if (count >= INT_MAX/size) {
79         fatal("array allocation overflow: %s", message);
80     }
81     return safe_malloc(size*count, message);
82 }
83
84 /* Convert a buffer into its MP_INT representation */
85 void read_mpbin(MP_INT *a, uint8_t *bin, int binsize)
86 {
87     char *buff;
88     int i;
89
90     buff=safe_malloc(binsize*2 + 1,"read_mpbin");
91
92     for (i=0; i<binsize; i++) {
93         buff[i*2]=hexdigits[(bin[i] & 0xf0) >> 4];
94         buff[i*2+1]=hexdigits[(bin[i] & 0xf)];
95     }
96     buff[binsize*2]=0;
97
98     mpz_set_str(a, buff, 16);
99     free(buff);
100 }
101
102 /* Convert a MP_INT into a hex string */
103 char *write_mpstring(MP_INT *a)
104 {
105     char *buff;
106
107     buff=safe_malloc(mpz_sizeinbase(a,16)+2,"write_mpstring");
108     mpz_get_str(buff, 16, a);
109     return buff;
110 }
111
112 static uint8_t hexval(uint8_t c)
113 {
114     switch (c) {
115     case '0': return 0;
116     case '1': return 1;
117     case '2': return 2;
118     case '3': return 3;
119     case '4': return 4;
120     case '5': return 5;
121     case '6': return 6;
122     case '7': return 7;
123     case '8': return 8;
124     case '9': return 9;
125     case 'a': return 10;
126     case 'A': return 10;
127     case 'b': return 11;
128     case 'B': return 11;
129     case 'c': return 12;
130     case 'C': return 12;
131     case 'd': return 13;
132     case 'D': return 13;
133     case 'e': return 14;
134     case 'E': return 14;
135     case 'f': return 15;
136     case 'F': return 15;
137     }
138     return -1;
139 }
140
141 /* Convert a MP_INT into a buffer; return length; truncate if necessary */
142 int32_t write_mpbin(MP_INT *a, uint8_t *buffer, int32_t buflen)
143 {
144     char *hb;
145     int i,j,l;
146     
147     if (buflen==0) return 0;
148     hb=write_mpstring(a);
149     
150     l=strlen(hb);
151     i=0; j=0;
152     if (l&1) {
153         /* The number starts with a half-byte */
154         buffer[i++]=hexval(hb[j++]);
155     }
156     for (; hb[j] && i<buflen; i++) {
157         buffer[i]=(hexval(hb[j])<<4)|hexval(hb[j+1]);
158         j+=2;
159     }
160     free(hb);
161     return i;
162 }
163
164 static const char *phases[NR_PHASES]={
165     "PHASE_INIT",
166     "PHASE_GETOPTS",
167     "PHASE_READCONFIG",
168     "PHASE_SETUP",
169     "PHASE_DAEMONIZE",
170     "PHASE_GETRESOURCES",
171     "PHASE_DROPPRIV",
172     "PHASE_RUN",
173     "PHASE_SHUTDOWN"
174 };
175
176 void enter_phase(uint32_t new_phase)
177 {
178     struct phase_hook *i;
179
180     if (hooks[new_phase])
181         Message(M_DEBUG_PHASE,"Running hooks for %s...\n", phases[new_phase]);
182     current_phase=new_phase;
183
184     for (i=hooks[new_phase]; i; i=i->next)
185         i->fn(i->state, new_phase);
186     Message(M_DEBUG_PHASE,"Now in %s\n",phases[new_phase]);
187 }
188
189 bool_t add_hook(uint32_t phase, hook_fn *fn, void *state)
190 {
191     struct phase_hook *h;
192
193     h=safe_malloc(sizeof(*h),"add_hook");
194     h->fn=fn;
195     h->state=state;
196     h->next=hooks[phase];
197     hooks[phase]=h;
198     return True;
199 }
200
201 bool_t remove_hook(uint32_t phase, hook_fn *fn, void *state)
202 {
203     fatal("remove_hook: not implemented");
204
205     return False;
206 }
207
208 void vslilog(struct log_if *lf, int priority, const char *message, va_list ap)
209 {
210     lf->vlog(lf->st,priority,message,ap);
211 }
212
213 void slilog(struct log_if *lf, int priority, const char *message, ...)
214 {
215     va_list ap;
216     
217     va_start(ap,message);
218     vslilog(lf,priority,message,ap);
219     va_end(ap);
220 }
221
222 struct buffer {
223     closure_t cl;
224     struct buffer_if ops;
225 };
226
227 void buffer_assert_free(struct buffer_if *buffer, cstring_t file,
228                         int line)
229 {
230     if (!buffer->free) {
231         fatal("BUF_ASSERT_FREE, %s line %d, owned by %s",
232               file,line,buffer->owner);
233     }
234 }
235
236 void buffer_assert_used(struct buffer_if *buffer, cstring_t file,
237                         int line)
238 {
239     if (buffer->free) {
240         fatal("BUF_ASSERT_USED, %s line %d, last owned by %s",
241               file,line,buffer->owner);
242     }
243 }
244
245 void buffer_init(struct buffer_if *buffer, int32_t max_start_pad)
246 {
247     buffer->start=buffer->base+max_start_pad;
248     buffer->size=0;
249 }
250
251 void *buf_append(struct buffer_if *buf, int32_t amount) {
252     void *p;
253     assert(buf->size <= buf->len - amount);
254     p=buf->start + buf->size;
255     buf->size+=amount;
256     return p;
257 }
258
259 void *buf_prepend(struct buffer_if *buf, int32_t amount) {
260     assert(amount <= buf->start - buf->base);
261     buf->size+=amount;
262     return buf->start-=amount;
263 }
264
265 void *buf_unappend(struct buffer_if *buf, int32_t amount) {
266     if (buf->size < amount) return 0;
267     return buf->start+(buf->size-=amount);
268 }
269
270 void *buf_unprepend(struct buffer_if *buf, int32_t amount) {
271     void *p;
272     p=buf->start;
273     buf->start+=amount;
274     buf->size-=amount;
275     return p;
276 }
277
278 /* Append a two-byte length and the string to the buffer. Length is in
279    network byte order. */
280 void buf_append_string(struct buffer_if *buf, cstring_t s)
281 {
282     size_t len;
283
284     len=strlen(s);
285     /* fixme: if string is longer than 65535, result is a corrupted packet */
286     buf_append_uint16(buf,len);
287     memcpy(buf_append(buf,len),s,len);
288 }
289
290 void buffer_new(struct buffer_if *buf, int32_t len)
291 {
292     buf->free=True;
293     buf->owner=NULL;
294     buf->flags=0;
295     buf->loc.file=NULL;
296     buf->loc.line=0;
297     buf->size=0;
298     buf->len=len;
299     buf->start=NULL;
300     buf->base=safe_malloc(len,"buffer_new");
301 }
302
303 static list_t *buffer_apply(closure_t *self, struct cloc loc, dict_t *context,
304                             list_t *args)
305 {
306     struct buffer *st;
307     item_t *item;
308     dict_t *dict;
309     bool_t lockdown=False;
310     uint32_t len=DEFAULT_BUFFER_SIZE;
311     
312     st=safe_malloc(sizeof(*st),"buffer_apply");
313     st->cl.description="buffer";
314     st->cl.type=CL_BUFFER;
315     st->cl.apply=NULL;
316     st->cl.interface=&st->ops;
317
318     /* First argument, if present, is buffer length */
319     item=list_elem(args,0);
320     if (item) {
321         if (item->type!=t_number) {
322             cfgfatal(st->ops.loc,"buffer","first parameter must be a "
323                      "number (buffer size)\n");
324         }
325         len=item->data.number;
326         if (len<MIN_BUFFER_SIZE) {
327             cfgfatal(st->ops.loc,"buffer","ludicrously small buffer size\n");
328         }
329         if (len>MAX_BUFFER_SIZE) {
330             cfgfatal(st->ops.loc,"buffer","ludicrously large buffer size\n");
331         }
332     }
333     /* Second argument, if present, is a dictionary */
334     item=list_elem(args,1);
335     if (item) {
336         if (item->type!=t_dict) {
337             cfgfatal(st->ops.loc,"buffer","second parameter must be a "
338                      "dictionary\n");
339         }
340         dict=item->data.dict;
341         lockdown=dict_read_bool(dict,"lockdown",False,"buffer",st->ops.loc,
342                                 False);
343     }
344
345     buffer_new(&st->ops,len);
346     if (lockdown) {
347         /* XXX mlock the buffer if possible */
348     }
349     
350     return new_closure(&st->cl);
351 }
352
353 void util_module(dict_t *dict)
354 {
355     add_closure(dict,"sysbuffer",buffer_apply);
356 }