vendor/ldns: add missing header files
[dragonfly.git] / contrib / ldns / ldns / util.h
1 /*
2  * util.h
3  *  
4  * helper function header file
5  * 
6  * a Net::DNS like library for C
7  * 
8  * (c) NLnet Labs, 2004
9  * 
10  * See the file LICENSE for the license
11  */
12
13 #ifndef _UTIL_H
14 #define _UTIL_H
15
16 #include <inttypes.h>
17 #include <sys/types.h>
18 #include <unistd.h>
19 #include <ldns/common.h>
20 #include <time.h>
21 #include <stdio.h>
22
23 #ifdef __cplusplus
24 extern "C" {
25 #endif
26
27 #define dprintf(X,Y) fprintf(stderr, (X), (Y))
28 /* #define      dprintf(X, Y)  */
29
30 #define LDNS_VERSION "1.7.1"
31 #define LDNS_REVISION ((1<<16)|(7<<8)|(1))
32
33 /**
34  * splint static inline workaround
35  */
36 #ifdef S_SPLINT_S
37 #  define INLINE 
38 #else
39 #  ifdef SWIG
40 #    define INLINE static
41 #  else
42 #    define INLINE static inline
43 #  endif
44 #endif
45
46 /**
47  * Memory management macros
48  */
49 #define LDNS_MALLOC(type)               LDNS_XMALLOC(type, 1)
50
51 #define LDNS_XMALLOC(type, count)       ((type *) malloc((count) * sizeof(type)))
52
53 #define LDNS_CALLOC(type, count)        ((type *) calloc((count), sizeof(type)))
54
55 #define LDNS_REALLOC(ptr, type)         LDNS_XREALLOC((ptr), type, 1)
56
57 #define LDNS_XREALLOC(ptr, type, count)                         \
58         ((type *) realloc((ptr), (count) * sizeof(type)))
59
60 #define LDNS_FREE(ptr) \
61         do { free((ptr)); (ptr) = NULL; } while (0)
62
63 #define LDNS_DEP     printf("DEPRECATED FUNCTION!\n");
64
65 /*
66  * Copy data allowing for unaligned accesses in network byte order
67  * (big endian).
68  */
69 INLINE uint16_t
70 ldns_read_uint16(const void *src)
71 {
72 #ifdef ALLOW_UNALIGNED_ACCESSES
73         return ntohs(*(const uint16_t *) src);
74 #else
75         const uint8_t *p = (const uint8_t *) src;
76         return ((uint16_t) p[0] << 8) | (uint16_t) p[1];
77 #endif
78 }
79
80 INLINE uint32_t
81 ldns_read_uint32(const void *src)
82 {
83 #ifdef ALLOW_UNALIGNED_ACCESSES
84         return ntohl(*(const uint32_t *) src);
85 #else
86         const uint8_t *p = (const uint8_t *) src;
87         return (  ((uint32_t) p[0] << 24)
88                 | ((uint32_t) p[1] << 16)
89                 | ((uint32_t) p[2] << 8)
90                 |  (uint32_t) p[3]);
91 #endif
92 }
93
94 /*
95  * Copy data allowing for unaligned accesses in network byte order
96  * (big endian).
97  */
98 INLINE void
99 ldns_write_uint16(void *dst, uint16_t data)
100 {
101 #ifdef ALLOW_UNALIGNED_ACCESSES
102         * (uint16_t *) dst = htons(data);
103 #else
104         uint8_t *p = (uint8_t *) dst;
105         p[0] = (uint8_t) ((data >> 8) & 0xff);
106         p[1] = (uint8_t) (data & 0xff);
107 #endif
108 }
109
110 INLINE void
111 ldns_write_uint32(void *dst, uint32_t data)
112 {
113 #ifdef ALLOW_UNALIGNED_ACCESSES
114         * (uint32_t *) dst = htonl(data);
115 #else
116         uint8_t *p = (uint8_t *) dst;
117         p[0] = (uint8_t) ((data >> 24) & 0xff);
118         p[1] = (uint8_t) ((data >> 16) & 0xff);
119         p[2] = (uint8_t) ((data >> 8) & 0xff);
120         p[3] = (uint8_t) (data & 0xff);
121 #endif
122 }
123
124 /* warning. */
125 INLINE void
126 ldns_write_uint64_as_uint48(void *dst, uint64_t data)
127 {
128         uint8_t *p = (uint8_t *) dst;
129         p[0] = (uint8_t) ((data >> 40) & 0xff);
130         p[1] = (uint8_t) ((data >> 32) & 0xff);
131         p[2] = (uint8_t) ((data >> 24) & 0xff);
132         p[3] = (uint8_t) ((data >> 16) & 0xff);
133         p[4] = (uint8_t) ((data >> 8) & 0xff);
134         p[5] = (uint8_t) (data & 0xff);
135 }
136
137
138 /**
139  * Structure to do a Schwartzian-like transformation, for instance when
140  * sorting. If you need a transformation on the objects that are sorted,
141  * you can sue this to store the transformed values, so you do not
142  * need to do the transformation again for each comparison
143  */
144 struct ldns_schwartzian_compare_struct {
145         void *original_object;
146         void *transformed_object;
147 };
148
149 /** A general purpose lookup table
150  *  
151  *  Lookup tables are arrays of (id, name) pairs,
152  *  So you can for instance lookup the RCODE 3, which is "NXDOMAIN",
153  *  and vice versa. The lookup tables themselves are defined wherever needed,
154  *  for instance in \ref host2str.c
155  */
156 struct ldns_struct_lookup_table {
157         int id;
158         const char *name;
159 };
160 typedef struct ldns_struct_lookup_table ldns_lookup_table;
161   
162 /**
163  * Looks up the table entry by name, returns NULL if not found.
164  * \param[in] table the lookup table to search in
165  * \param[in] name what to search for
166  * \return the item found
167  */
168 ldns_lookup_table *ldns_lookup_by_name(ldns_lookup_table table[],
169                                        const char *name);
170
171 /**
172  * Looks up the table entry by id, returns NULL if not found.
173  * \param[in] table the lookup table to search in
174  * \param[in] id what to search for
175  * \return the item found
176  */
177 ldns_lookup_table *ldns_lookup_by_id(ldns_lookup_table table[], int id);
178
179 /**
180  * Returns the value of the specified bit
181  * The bits are counted from left to right, so bit #0 is the
182  * left most bit.
183  * \param[in] bits array holding the bits
184  * \param[in] index to the wanted bit
185  * \return 
186  */
187 int ldns_get_bit(uint8_t bits[], size_t index);
188
189
190 /**
191  * Returns the value of the specified bit
192  * The bits are counted from right to left, so bit #0 is the
193  * right most bit.
194  * \param[in] bits array holding the bits
195  * \param[in] index to the wanted bit
196  * \return 1 or 0 depending no the bit state
197  */
198 int ldns_get_bit_r(uint8_t bits[], size_t index);
199
200 /**
201  * sets the specified bit in the specified byte to
202  * 1 if value is true, 0 if false
203  * The bits are counted from right to left, so bit #0 is the
204  * right most bit.
205  * \param[in] byte the bit to set the bit in
206  * \param[in] bit_nr the bit to set (0 <= n <= 7)
207  * \param[in] value whether to set the bit to 1 or 0
208  * \return 1 or 0 depending no the bit state
209  */
210 void ldns_set_bit(uint8_t *byte, int bit_nr, bool value);
211
212 /**
213  * Returns the value of a to the power of b
214  * (or 1 of b < 1)
215  */
216 /*@unused@*/
217 INLINE long
218 ldns_power(long a, long b) {
219         long result = 1;
220         while (b > 0) {
221                 if (b & 1) {
222                         result *= a;
223                         if (b == 1) {
224                                 return result;
225                         }
226                 }
227                 a *= a;
228                 b /= 2;
229         }
230         return result;
231 }
232
233 /**
234  * Returns the int value of the given (hex) digit
235  * \param[in] ch the hex char to convert
236  * \return the converted decimal value
237  */
238 int ldns_hexdigit_to_int(char ch);
239
240 /**
241  * Returns the char (hex) representation of the given int
242  * \param[in] ch the int to convert
243  * \return the converted hex char
244  */
245 char ldns_int_to_hexdigit(int ch);
246
247 /**
248  * Converts a hex string to binary data
249  *
250  * \param[out] data The binary result is placed here.
251  * At least strlen(str)/2 bytes should be allocated
252  * \param[in] str The hex string to convert.
253  * This string should not contain spaces
254  * \return The number of bytes of converted data, or -1 if one of the arguments * is NULL, or -2 if the string length is not an even number
255  */
256 int
257 ldns_hexstring_to_data(uint8_t *data, const char *str);
258
259 /**
260  * Show the internal library version
261  * \return a string with the version in it
262  */
263 const char * ldns_version(void);
264
265 /**
266  * Convert TM to seconds since epoch (midnight, January 1st, 1970).
267  * Like timegm(3), which is not always available.
268  * \param[in] tm a struct tm* with the date
269  * \return the seconds since epoch
270  */
271 time_t ldns_mktime_from_utc(const struct tm *tm);
272
273 time_t mktime_from_utc(const struct tm *tm);
274
275 /**
276  * The function interprets time as the number of seconds since epoch
277  * with respect to now using serial arithmitics (rfc1982).
278  * That number of seconds is then converted to broken-out time information.
279  * This is especially useful when converting the inception and expiration
280  * fields of RRSIG records.
281  *
282  * \param[in] time number of seconds since epoch (midnight, January 1st, 1970)
283  *            to be intepreted as a serial arithmitics number relative to now.
284  * \param[in] now number of seconds since epoch (midnight, January 1st, 1970)
285  *            to which the time value is compared to determine the final value.
286  * \param[out] result the struct with the broken-out time information
287  * \return result on success or NULL on error
288  */
289 struct tm * ldns_serial_arithmitics_gmtime_r(int32_t time, time_t now, struct tm *result);
290  
291 /**
292  * Seed the random function.
293  * If the file descriptor is specified, the random generator is seeded with
294  * data from that file. If not, /dev/urandom is used.
295  *
296  * applications should call this if they need entropy data within ldns
297  * If openSSL is available, it is automatically seeded from /dev/urandom
298  * or /dev/random.
299  *
300  * If you need more entropy, or have no openssl available, this function
301  * MUST be called at the start of the program
302  *
303  * If openssl *is* available, this function just adds more entropy
304  *
305  * \param[in] fd a file providing entropy data for the seed
306  * \param[in] size the number of bytes to use as entropy data. If this is 0,
307  *            only the minimal amount is taken (usually 4 bytes)
308  * \return 0 if seeding succeeds, 1 if it fails
309  */
310 int ldns_init_random(FILE *fd, unsigned int size);
311
312 /**
313  * Get random number.
314  * \return random number.
315  *
316  */
317 uint16_t ldns_get_random(void);
318
319 /**
320  * Encode data as BubbleBabble
321  *
322  * \param[in] data a pointer to data to be encoded
323  * \param[in] len size the number of bytes of data
324  * \return a string of BubbleBabble
325  */
326 char *ldns_bubblebabble(uint8_t *data, size_t len);
327
328
329 INLINE time_t ldns_time(time_t *t) { return time(t); }
330
331
332 /**
333  * calculates the size needed to store the result of b32_ntop
334  */
335 /*@unused@*/
336 INLINE size_t ldns_b32_ntop_calculate_size(size_t src_data_length)
337 {
338         return src_data_length == 0 ? 0 : ((src_data_length - 1) / 5 + 1) * 8;
339 }
340
341 INLINE size_t ldns_b32_ntop_calculate_size_no_padding(size_t src_data_length)
342 {
343         return ((src_data_length + 3) * 8 / 5) - 4;
344 }
345
346 int ldns_b32_ntop(const uint8_t* src_data, size_t src_data_length,
347              char* target_text_buffer, size_t target_text_buffer_size);
348
349 int ldns_b32_ntop_extended_hex(const uint8_t* src_data, size_t src_data_length,
350              char* target_text_buffer, size_t target_text_buffer_size);
351
352 #if ! LDNS_BUILD_CONFIG_HAVE_B32_NTOP
353
354 int b32_ntop(const uint8_t* src_data, size_t src_data_length,
355              char* target_text_buffer, size_t target_text_buffer_size);
356
357 int b32_ntop_extended_hex(const uint8_t* src_data, size_t src_data_length,
358              char* target_text_buffer, size_t target_text_buffer_size);
359
360 #endif /* ! LDNS_BUILD_CONFIG_HAVE_B32_NTOP */
361
362
363 /**
364  * calculates the size needed to store the result of b32_pton
365  */
366 /*@unused@*/
367 INLINE size_t ldns_b32_pton_calculate_size(size_t src_text_length)
368 {
369         return src_text_length * 5 / 8;
370 }
371
372 int ldns_b32_pton(const char* src_text, size_t src_text_length,
373                 uint8_t* target_data_buffer, size_t target_data_buffer_size);
374
375 int ldns_b32_pton_extended_hex(const char* src_text, size_t src_text_length,
376                 uint8_t* target_data_buffer, size_t target_data_buffer_size);
377
378 #if ! LDNS_BUILD_CONFIG_HAVE_B32_PTON
379
380 int b32_pton(const char* src_text, size_t src_text_length,
381                 uint8_t* target_data_buffer, size_t target_data_buffer_size);
382
383 int b32_pton_extended_hex(const char* src_text, size_t src_text_length,
384                 uint8_t* target_data_buffer, size_t target_data_buffer_size);
385
386 #endif /* ! LDNS_BUILD_CONFIG_HAVE_B32_PTON */
387
388
389 #ifdef __cplusplus
390 }
391 #endif
392
393 #endif /* !_UTIL_H */