Change the kernel dev_t, representing a pointer to a specinfo structure,
[dragonfly.git] / contrib / bind-9.2.4rc7 / lib / bind / dst / support.c
1 static const char rcsid[] = "$Header: /proj/cvs/prod/bind9/lib/bind/dst/support.c,v 1.2.2.1 2001/11/02 22:25:29 gson Exp $";
2
3
4 /*
5  * Portions Copyright (c) 1995-1998 by Trusted Information Systems, Inc.
6  *
7  * Permission to use, copy modify, and distribute this software for any
8  * purpose with or without fee is hereby granted, provided that the above
9  * copyright notice and this permission notice appear in all copies.
10  *
11  * THE SOFTWARE IS PROVIDED "AS IS" AND TRUSTED INFORMATION SYSTEMS
12  * DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
13  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.  IN NO EVENT SHALL
14  * TRUSTED INFORMATION SYSTEMS BE LIABLE FOR ANY SPECIAL, DIRECT,
15  * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING
16  * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
17  * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
18  * WITH THE USE OR PERFORMANCE OF THE SOFTWARE.
19  */
20
21 #include "port_before.h"
22
23 #include <stdio.h>
24 #include <unistd.h>
25 #include <memory.h>
26 #include <string.h>
27 #include <errno.h>
28 #include <sys/stat.h>
29 #include <netinet/in.h>
30 #include <arpa/nameser.h>
31 #include <resolv.h>
32
33 #include "dst_internal.h"
34
35 #include "port_after.h"
36
37 /*
38  * dst_s_verify_str()
39  *     Validate that the input string(*str) is at the head of the input
40  *     buffer(**buf).  If so, move the buffer head pointer (*buf) to
41  *     the first byte of data following the string(*str).
42  * Parameters
43  *     buf     Input buffer.
44  *     str     Input string.
45  * Return
46  *      0       *str is not the head of **buff
47  *      1       *str is the head of **buff, *buf is is advanced to
48  *      the tail of **buf.
49  */
50
51 int
52 dst_s_verify_str(const char **buf, const char *str)
53 {
54         int b, s;
55         if (*buf == NULL)       /* error checks */
56                 return (0);
57         if (str == NULL || *str == '\0')
58                 return (1);
59
60         b = strlen(*buf);       /* get length of strings */
61         s = strlen(str);
62         if (s > b || strncmp(*buf, str, s))     /* check if same */
63                 return (0);     /* not a match */
64         (*buf) += s;            /* advance pointer */
65         return (1);
66 }
67
68 /*
69  * dst_s_calculate_bits
70  *     Given a binary number represented in a u_char[], determine
71  *     the number of significant bits used.
72  * Parameters
73  *     str       An input character string containing a binary number.
74  *     max_bits The maximum possible significant bits.
75  * Return
76  *     N       The number of significant bits in str.
77  */
78
79 int
80 dst_s_calculate_bits(const u_char *str, const int max_bits)
81 {
82         const u_char *p = str;
83         u_char i, j = 0x80;
84         int bits;
85         for (bits = max_bits; *p == 0x00 && bits > 0; p++)
86                 bits -= 8;
87         for (i = *p; (i & j) != j; j >>= 1)
88                 bits--;
89         return (bits);
90 }
91
92
93 /*
94  * calculates a checksum used in dst for an id.
95  * takes an array of bytes and a length.
96  * returns a 16  bit checksum.
97  */
98 u_int16_t
99 dst_s_id_calc(const u_char *key, const int keysize)
100 {
101         u_int32_t ac;
102         const u_char *kp = key;
103         int size = keysize;
104
105         if (!key || (keysize <= 0))
106                 return (-1);
107  
108         for (ac = 0; size > 1; size -= 2, kp += 2)
109                 ac += ((*kp) << 8) + *(kp + 1);
110
111         if (size > 0)
112                 ac += ((*kp) << 8);
113         ac += (ac >> 16) & 0xffff;
114
115         return (ac & 0xffff);
116 }
117
118 /* 
119  * dst_s_dns_key_id() Function to calculate DNSSEC footprint from KEY record
120  *   rdata
121  * Input:
122  *      dns_key_rdata: the raw data in wire format 
123  *      rdata_len: the size of the input data 
124  * Output:
125  *      the key footprint/id calculated from the key data 
126  */ 
127 u_int16_t
128 dst_s_dns_key_id(const u_char *dns_key_rdata, const int rdata_len)
129 {
130         if (!dns_key_rdata)
131                 return 0;
132
133         /* compute id */
134         if (dns_key_rdata[3] == KEY_RSA)        /* Algorithm RSA */
135                 return dst_s_get_int16((const u_char *)
136                                        &dns_key_rdata[rdata_len - 3]);
137         else if (dns_key_rdata[3] == KEY_HMAC_MD5)
138                 /* compatibility */
139                 return 0;
140         else
141                 /* compute a checksum on the key part of the key rr */
142                 return dst_s_id_calc(dns_key_rdata, rdata_len);
143 }
144
145 /*
146  * dst_s_get_int16
147  *     This routine extracts a 16 bit integer from a two byte character
148  *     string.  The character string is assumed to be in network byte
149  *     order and may be unaligned.  The number returned is in host order.
150  * Parameter
151  *     buf     A two byte character string.
152  * Return
153  *     The converted integer value.
154  */
155
156 u_int16_t
157 dst_s_get_int16(const u_char *buf)
158 {
159         register u_int16_t a = 0;
160         a = ((u_int16_t)(buf[0] << 8)) | ((u_int16_t)(buf[1]));
161         return (a);
162 }
163
164
165 /*
166  * dst_s_get_int32
167  *     This routine extracts a 32 bit integer from a four byte character
168  *     string.  The character string is assumed to be in network byte
169  *     order and may be unaligned.  The number returned is in host order.
170  * Parameter
171  *     buf     A four byte character string.
172  * Return
173  *     The converted integer value.
174  */
175
176 u_int32_t
177 dst_s_get_int32(const u_char *buf)
178 {
179         register u_int32_t a = 0;
180         a = ((u_int32_t)(buf[0] << 24)) | ((u_int32_t)(buf[1] << 16)) |
181                 ((u_int32_t)(buf[2] << 8)) | ((u_int32_t)(buf[3]));
182         return (a);
183 }
184
185
186 /*
187  * dst_s_put_int16
188  *     Take a 16 bit integer and store the value in a two byte
189  *     character string.  The integer is assumed to be in network
190  *     order and the string is returned in host order.
191  *
192  * Parameters
193  *     buf     Storage for a two byte character string.
194  *     val     16 bit integer.
195  */
196
197 void
198 dst_s_put_int16(u_int8_t *buf, const u_int16_t val)
199 {
200         buf[0] = (u_int8_t)(val >> 8);
201         buf[1] = (u_int8_t)(val);
202 }
203
204
205 /*
206  * dst_s_put_int32
207  *     Take a 32 bit integer and store the value in a four byte
208  *     character string.  The integer is assumed to be in network
209  *     order and the string is returned in host order.
210  *
211  * Parameters
212  *     buf     Storage for a four byte character string.
213  *     val     32 bit integer.
214  */
215
216 void
217 dst_s_put_int32(u_int8_t *buf, const u_int32_t val)
218 {
219         buf[0] = (u_int8_t)(val >> 24);
220         buf[1] = (u_int8_t)(val >> 16);
221         buf[2] = (u_int8_t)(val >> 8);
222         buf[3] = (u_int8_t)(val);
223 }
224
225
226 /*
227  *  dst_s_filename_length
228  *
229  *      This function returns the number of bytes needed to hold the
230  *      filename for a key file.  '/', '\' and ':' are not allowed.
231  *      form:  K<keyname>+<alg>+<id>.<suffix>
232  *
233  *      Returns 0 if the filename would contain either '\', '/' or ':'
234  */
235 size_t
236 dst_s_filename_length(const char *name, const char *suffix)
237 {
238         if (name == NULL)
239                 return (0);
240         if (strrchr(name, '\\'))
241                 return (0);
242         if (strrchr(name, '/'))
243                 return (0);
244         if (strrchr(name, ':'))
245                 return (0);
246         if (suffix == NULL)
247                 return (0);
248         if (strrchr(suffix, '\\'))
249                 return (0);
250         if (strrchr(suffix, '/'))
251                 return (0);
252         if (strrchr(suffix, ':'))
253                 return (0);
254         return (1 + strlen(name) + 6 + strlen(suffix));
255 }
256
257
258 /*
259  *  dst_s_build_filename ()
260  *      Builds a key filename from the key name, it's id, and a
261  *      suffix.  '\', '/' and ':' are not allowed. fA filename is of the
262  *      form:  K<keyname><id>.<suffix>
263  *      form: K<keyname>+<alg>+<id>.<suffix>
264  *
265  *      Returns -1 if the conversion fails:
266  *        if the filename would be too long for space allotted
267  *        if the filename would contain a '\', '/' or ':'
268  *      Returns 0 on success
269  */
270
271 int
272 dst_s_build_filename(char *filename, const char *name, u_int16_t id,
273                      int alg, const char *suffix, size_t filename_length)
274 {
275         u_int32_t my_id;
276         if (filename == NULL)
277                 return (-1);
278         memset(filename, 0, filename_length);
279         if (name == NULL)
280                 return (-1);
281         if (suffix == NULL)
282                 return (-1);
283         if (filename_length < 1 + strlen(name) + 4 + 6 + 1 + strlen(suffix))
284                 return (-1);
285         my_id = id;
286         sprintf(filename, "K%s+%03d+%05d.%s", name, alg, my_id,
287                 (const char *) suffix);
288         if (strrchr(filename, '/'))
289                 return (-1);
290         if (strrchr(filename, '\\'))
291                 return (-1);
292         if (strrchr(filename, ':'))
293                 return (-1);
294         return (0);
295 }
296
297 /*
298  *  dst_s_fopen ()
299  *     Open a file in the dst_path directory.  If perm is specified, the
300  *     file is checked for existence first, and not opened if it exists.
301  *  Parameters
302  *     filename  File to open
303  *     mode       Mode to open the file (passed directly to fopen)
304  *     perm       File permission, if creating a new file.
305  *  Returns
306  *     NULL       Failure
307  *     NON-NULL  (FILE *) of opened file.
308  */
309 FILE *
310 dst_s_fopen(const char *filename, const char *mode, int perm)
311 {
312         FILE *fp;
313         char pathname[PATH_MAX];
314         size_t plen = sizeof(pathname);
315
316         if (*dst_path != '\0') {
317                 strcpy(pathname, dst_path);
318                 plen -= strlen(pathname);
319         }
320         else 
321                 pathname[0] = '\0';
322
323         if (plen > strlen(filename))
324                 strncpy(&pathname[PATH_MAX - plen], filename, plen-1);
325         else 
326                 return (NULL);
327         
328         fp = fopen(pathname, mode);
329         if (perm)
330                 chmod(pathname, perm);
331         return (fp);
332 }
333
334 void
335 dst_s_dump(const int mode, const u_char *data, const int size, 
336             const char *msg)
337 {
338         UNUSED(data);
339
340         if (size > 0) {
341 #ifdef LONG_TEST
342                 static u_char scratch[1000];
343                 int n ;
344                 n = b64_ntop(data, scratch, size, sizeof(scratch));
345                 printf("%s: %x %d %s\n", msg, mode, n, scratch);
346 #else
347                 printf("%s,%x %d\n", msg, mode, size);
348 #endif
349         }
350 }