chiark / gitweb /
debian/changelog: Start new version 0.3.2~~
[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 #include "magic.h"
42
43 #define MIN_BUFFER_SIZE 64
44 #define DEFAULT_BUFFER_SIZE 4096
45 #define MAX_BUFFER_SIZE 131072
46
47 static const char *hexdigits="0123456789abcdef";
48
49 uint32_t current_phase=0;
50
51 struct phase_hook {
52     hook_fn *fn;
53     void *state;
54     struct phase_hook *next;
55 };
56
57 static struct phase_hook *hooks[NR_PHASES]={NULL,};
58
59 char *safe_strdup(const char *s, const char *message)
60 {
61     char *d;
62     d=strdup(s);
63     if (!d) {
64         fatal_perror("%s",message);
65     }
66     return d;
67 }
68
69 void *safe_malloc(size_t size, const char *message)
70 {
71     void *r;
72     r=malloc(size);
73     if (!r) {
74         fatal_perror("%s",message);
75     }
76     return r;
77 }
78 void *safe_malloc_ary(size_t size, size_t count, const char *message) {
79     if (count >= INT_MAX/size) {
80         fatal("array allocation overflow: %s", message);
81     }
82     return safe_malloc(size*count, message);
83 }
84
85 /* Convert a buffer into its MP_INT representation */
86 void read_mpbin(MP_INT *a, uint8_t *bin, int binsize)
87 {
88     char *buff;
89     int i;
90
91     buff=safe_malloc(binsize*2 + 1,"read_mpbin");
92
93     for (i=0; i<binsize; i++) {
94         buff[i*2]=hexdigits[(bin[i] & 0xf0) >> 4];
95         buff[i*2+1]=hexdigits[(bin[i] & 0xf)];
96     }
97     buff[binsize*2]=0;
98
99     mpz_set_str(a, buff, 16);
100     free(buff);
101 }
102
103 /* Convert a MP_INT into a hex string */
104 char *write_mpstring(MP_INT *a)
105 {
106     char *buff;
107
108     buff=safe_malloc(mpz_sizeinbase(a,16)+2,"write_mpstring");
109     mpz_get_str(buff, 16, a);
110     return buff;
111 }
112
113 static uint8_t hexval(uint8_t c)
114 {
115     switch (c) {
116     case '0': return 0;
117     case '1': return 1;
118     case '2': return 2;
119     case '3': return 3;
120     case '4': return 4;
121     case '5': return 5;
122     case '6': return 6;
123     case '7': return 7;
124     case '8': return 8;
125     case '9': return 9;
126     case 'a': return 10;
127     case 'A': return 10;
128     case 'b': return 11;
129     case 'B': return 11;
130     case 'c': return 12;
131     case 'C': return 12;
132     case 'd': return 13;
133     case 'D': return 13;
134     case 'e': return 14;
135     case 'E': return 14;
136     case 'f': return 15;
137     case 'F': return 15;
138     }
139     return -1;
140 }
141
142 /* Convert a MP_INT into a buffer; return length; truncate if necessary */
143 int32_t write_mpbin(MP_INT *a, uint8_t *buffer, int32_t buflen)
144 {
145     char *hb;
146     int i,j,l;
147     
148     if (buflen==0) return 0;
149     hb=write_mpstring(a);
150     
151     l=strlen(hb);
152     i=0; j=0;
153     if (l&1) {
154         /* The number starts with a half-byte */
155         buffer[i++]=hexval(hb[j++]);
156     }
157     for (; hb[j] && i<buflen; i++) {
158         buffer[i]=(hexval(hb[j])<<4)|hexval(hb[j+1]);
159         j+=2;
160     }
161     free(hb);
162     return i;
163 }
164
165 static const char *phases[NR_PHASES]={
166     "PHASE_INIT",
167     "PHASE_GETOPTS",
168     "PHASE_READCONFIG",
169     "PHASE_SETUP",
170     "PHASE_DAEMONIZE",
171     "PHASE_GETRESOURCES",
172     "PHASE_DROPPRIV",
173     "PHASE_RUN",
174     "PHASE_SHUTDOWN"
175 };
176
177 void enter_phase(uint32_t new_phase)
178 {
179     struct phase_hook *i;
180
181     if (hooks[new_phase])
182         Message(M_DEBUG_PHASE,"Running hooks for %s...\n", phases[new_phase]);
183     current_phase=new_phase;
184
185     for (i=hooks[new_phase]; i; i=i->next)
186         i->fn(i->state, new_phase);
187     Message(M_DEBUG_PHASE,"Now in %s\n",phases[new_phase]);
188 }
189
190 bool_t add_hook(uint32_t phase, hook_fn *fn, void *state)
191 {
192     struct phase_hook *h;
193
194     h=safe_malloc(sizeof(*h),"add_hook");
195     h->fn=fn;
196     h->state=state;
197     h->next=hooks[phase];
198     hooks[phase]=h;
199     return True;
200 }
201
202 bool_t remove_hook(uint32_t phase, hook_fn *fn, void *state)
203 {
204     fatal("remove_hook: not implemented");
205
206     return False;
207 }
208
209 void vslilog(struct log_if *lf, int priority, const char *message, va_list ap)
210 {
211     lf->vlogfn(lf->st,priority,message,ap);
212 }
213
214 void slilog(struct log_if *lf, int priority, const char *message, ...)
215 {
216     va_list ap;
217     
218     va_start(ap,message);
219     vslilog(lf,priority,message,ap);
220     va_end(ap);
221 }
222
223 struct buffer {
224     closure_t cl;
225     struct buffer_if ops;
226 };
227
228 void buffer_assert_free(struct buffer_if *buffer, cstring_t file,
229                         int line)
230 {
231     if (!buffer->free) {
232         fprintf(stderr,"secnet: BUF_ASSERT_FREE, %s line %d, owned by %s",
233                 file,line,buffer->owner);
234         assert(!"buffer_assert_free failure");
235     }
236 }
237
238 void buffer_assert_used(struct buffer_if *buffer, cstring_t file,
239                         int line)
240 {
241     if (buffer->free) {
242         fprintf(stderr,"secnet: BUF_ASSERT_USED, %s line %d, last owned by %s",
243                 file,line,buffer->owner);
244         assert(!"buffer_assert_used failure");
245     }
246 }
247
248 void buffer_init(struct buffer_if *buffer, int32_t max_start_pad)
249 {
250     assert(max_start_pad<=buffer->len);
251     buffer->start=buffer->base+max_start_pad;
252     buffer->size=0;
253 }
254
255 void *buf_append(struct buffer_if *buf, int32_t amount) {
256     void *p;
257     assert(buf->size <= buf->len - amount);
258     p=buf->start + buf->size;
259     buf->size+=amount;
260     return p;
261 }
262
263 void *buf_prepend(struct buffer_if *buf, int32_t amount) {
264     assert(amount <= buf->start - buf->base);
265     buf->size+=amount;
266     return buf->start-=amount;
267 }
268
269 void *buf_unappend(struct buffer_if *buf, int32_t amount) {
270     if (buf->size < amount) return 0;
271     return buf->start+(buf->size-=amount);
272 }
273
274 void *buf_unprepend(struct buffer_if *buf, int32_t amount) {
275     void *p;
276     if (buf->size < amount) return 0;
277     p=buf->start;
278     buf->start+=amount;
279     buf->size-=amount;
280     return p;
281 }
282
283 /* Append a two-byte length and the string to the buffer. Length is in
284    network byte order. */
285 void buf_append_string(struct buffer_if *buf, cstring_t s)
286 {
287     size_t len;
288
289     len=strlen(s);
290     /* fixme: if string is longer than 65535, result is a corrupted packet */
291     buf_append_uint16(buf,len);
292     memcpy(buf_append(buf,len),s,len);
293 }
294
295 void buffer_new(struct buffer_if *buf, int32_t len)
296 {
297     buf->free=True;
298     buf->owner=NULL;
299     buf->flags=0;
300     buf->loc.file=NULL;
301     buf->loc.line=0;
302     buf->size=0;
303     buf->len=len;
304     buf->start=NULL;
305     buf->base=safe_malloc(len,"buffer_new");
306 }
307
308 void buffer_readonly_view(struct buffer_if *buf, const void *data, int32_t len)
309 {
310     buf->free=False;
311     buf->owner="READONLY";
312     buf->flags=0;
313     buf->loc.file=NULL;
314     buf->loc.line=0;
315     buf->size=buf->len=len;
316     buf->base=buf->start=(uint8_t*)data;
317 }
318
319 void buffer_readonly_clone(struct buffer_if *out, const struct buffer_if *in)
320 {
321     buffer_readonly_view(out,in->start,in->size);
322 }
323
324 void buffer_copy(struct buffer_if *dst, const struct buffer_if *src)
325 {
326     if (dst->len < src->len) {
327         dst->base=realloc(dst->base,src->len);
328         if (!dst->base) fatal_perror("buffer_copy");
329         dst->len = src->len;
330     }
331     dst->start = dst->base + (src->start - src->base);
332     dst->size = src->size;
333     memcpy(dst->start, src->start, dst->size);
334 }
335
336 static list_t *buffer_apply(closure_t *self, struct cloc loc, dict_t *context,
337                             list_t *args)
338 {
339     struct buffer *st;
340     item_t *item;
341     dict_t *dict;
342     bool_t lockdown=False;
343     uint32_t len=DEFAULT_BUFFER_SIZE;
344     
345     st=safe_malloc(sizeof(*st),"buffer_apply");
346     st->cl.description="buffer";
347     st->cl.type=CL_BUFFER;
348     st->cl.apply=NULL;
349     st->cl.interface=&st->ops;
350
351     /* First argument, if present, is buffer length */
352     item=list_elem(args,0);
353     if (item) {
354         if (item->type!=t_number) {
355             cfgfatal(st->ops.loc,"buffer","first parameter must be a "
356                      "number (buffer size)\n");
357         }
358         len=item->data.number;
359         if (len<MIN_BUFFER_SIZE) {
360             cfgfatal(st->ops.loc,"buffer","ludicrously small buffer size\n");
361         }
362         if (len>MAX_BUFFER_SIZE) {
363             cfgfatal(st->ops.loc,"buffer","ludicrously large buffer size\n");
364         }
365     }
366     /* Second argument, if present, is a dictionary */
367     item=list_elem(args,1);
368     if (item) {
369         if (item->type!=t_dict) {
370             cfgfatal(st->ops.loc,"buffer","second parameter must be a "
371                      "dictionary\n");
372         }
373         dict=item->data.dict;
374         lockdown=dict_read_bool(dict,"lockdown",False,"buffer",st->ops.loc,
375                                 False);
376     }
377
378     buffer_new(&st->ops,len);
379     if (lockdown) {
380         /* XXX mlock the buffer if possible */
381     }
382     
383     return new_closure(&st->cl);
384 }
385
386 void send_nak(const struct comm_addr *dest, uint32_t our_index,
387               uint32_t their_index, uint32_t msgtype,
388               struct buffer_if *buf, const char *logwhy)
389 {
390     buffer_init(buf,calculate_max_start_pad());
391     buf_append_uint32(buf,their_index);
392     buf_append_uint32(buf,our_index);
393     buf_append_uint32(buf,LABEL_NAK);
394     if (logwhy)
395         Message(M_INFO,"%s: %08"PRIx32"<-%08"PRIx32": %08"PRIx32":"
396                 " %s; sending NAK\n",
397                 dest->comm->addr_to_string(dest->comm->st,dest),
398                 our_index, their_index, msgtype, logwhy);
399     dest->comm->sendmsg(dest->comm->st, buf, dest);
400 }
401
402 int consttime_memeq(const void *s1in, const void *s2in, size_t n)
403 {
404     const uint8_t *s1=s1in, *s2=s2in;
405     register volatile uint8_t accumulator=0;
406
407     while (n-- > 0) {
408         accumulator |= (*s1++ ^ *s2++);
409     }
410     accumulator |= accumulator >> 4; /* constant-time             */
411     accumulator |= accumulator >> 2; /*  boolean canonicalisation */
412     accumulator |= accumulator >> 1;
413     accumulator &= 1;
414     accumulator ^= 1;
415     return accumulator;
416 }
417
418 void util_module(dict_t *dict)
419 {
420     add_closure(dict,"sysbuffer",buffer_apply);
421 }
422
423 void update_max_start_pad(int32_t *our_module_global, int32_t our_instance)
424 {
425     if (*our_module_global < our_instance)
426         *our_module_global=our_instance;
427 }
428
429 int32_t transform_max_start_pad, comm_max_start_pad;
430
431 int32_t calculate_max_start_pad(void)
432 {
433     return
434         site_max_start_pad +
435         transform_max_start_pad +
436         comm_max_start_pad;
437 }