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.6.9" 31 #define LDNS_REVISION ((1<<16)|(6<<8)|(9)) 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_REALLOC(ptr, type) LDNS_XREALLOC((ptr), type, 1) 54 55 #define LDNS_XREALLOC(ptr, type, count) \ 56 ((type *) realloc((ptr), (count) * sizeof(type))) 57 58 #define LDNS_FREE(ptr) \ 59 do { free((ptr)); (ptr) = NULL; } while (0) 60 61 #define LDNS_DEP printf("DEPRECATED FUNCTION!\n"); 62 63 /* 64 * Copy data allowing for unaligned accesses in network byte order 65 * (big endian). 66 */ 67 INLINE uint16_t 68 ldns_read_uint16(const void *src) 69 { 70 #ifdef ALLOW_UNALIGNED_ACCESSES 71 return ntohs(*(uint16_t *) src); 72 #else 73 uint8_t *p = (uint8_t *) src; 74 return ((uint16_t) p[0] << 8) | (uint16_t) p[1]; 75 #endif 76 } 77 78 INLINE uint32_t 79 ldns_read_uint32(const void *src) 80 { 81 #ifdef ALLOW_UNALIGNED_ACCESSES 82 return ntohl(*(uint32_t *) src); 83 #else 84 uint8_t *p = (uint8_t *) src; 85 return ( ((uint32_t) p[0] << 24) 86 | ((uint32_t) p[1] << 16) 87 | ((uint32_t) p[2] << 8) 88 | (uint32_t) p[3]); 89 #endif 90 } 91 92 /* 93 * Copy data allowing for unaligned accesses in network byte order 94 * (big endian). 95 */ 96 INLINE void 97 ldns_write_uint16(void *dst, uint16_t data) 98 { 99 #ifdef ALLOW_UNALIGNED_ACCESSES 100 * (uint16_t *) dst = htons(data); 101 #else 102 uint8_t *p = (uint8_t *) dst; 103 p[0] = (uint8_t) ((data >> 8) & 0xff); 104 p[1] = (uint8_t) (data & 0xff); 105 #endif 106 } 107 108 INLINE void 109 ldns_write_uint32(void *dst, uint32_t data) 110 { 111 #ifdef ALLOW_UNALIGNED_ACCESSES 112 * (uint32_t *) dst = htonl(data); 113 #else 114 uint8_t *p = (uint8_t *) dst; 115 p[0] = (uint8_t) ((data >> 24) & 0xff); 116 p[1] = (uint8_t) ((data >> 16) & 0xff); 117 p[2] = (uint8_t) ((data >> 8) & 0xff); 118 p[3] = (uint8_t) (data & 0xff); 119 #endif 120 } 121 122 /* warning. */ 123 INLINE void 124 ldns_write_uint64_as_uint48(void *dst, uint64_t data) 125 { 126 uint8_t *p = (uint8_t *) dst; 127 p[0] = (uint8_t) ((data >> 40) & 0xff); 128 p[1] = (uint8_t) ((data >> 32) & 0xff); 129 p[2] = (uint8_t) ((data >> 24) & 0xff); 130 p[3] = (uint8_t) ((data >> 16) & 0xff); 131 p[4] = (uint8_t) ((data >> 8) & 0xff); 132 p[5] = (uint8_t) (data & 0xff); 133 } 134 135 136 /** 137 * Structure to do a Schwartzian-like transformation, for instance when 138 * sorting. If you need a transformation on the objects that are sorted, 139 * you can sue this to store the transformed values, so you do not 140 * need to do the transformation again for each comparison 141 */ 142 struct ldns_schwartzian_compare_struct { 143 void *original_object; 144 void *transformed_object; 145 }; 146 147 /** A general purpose lookup table 148 * 149 * Lookup tables are arrays of (id, name) pairs, 150 * So you can for instance lookup the RCODE 3, which is "NXDOMAIN", 151 * and vice versa. The lookup tables themselves are defined wherever needed, 152 * for instance in \ref host2str.c 153 */ 154 struct ldns_struct_lookup_table { 155 int id; 156 const char *name; 157 }; 158 typedef struct ldns_struct_lookup_table ldns_lookup_table; 159 160 /** 161 * Looks up the table entry by name, returns NULL if not found. 162 * \param[in] table the lookup table to search in 163 * \param[in] name what to search for 164 * \return the item found 165 */ 166 ldns_lookup_table *ldns_lookup_by_name(ldns_lookup_table table[], 167 const char *name); 168 169 /** 170 * Looks up the table entry by id, returns NULL if not found. 171 * \param[in] table the lookup table to search in 172 * \param[in] id what to search for 173 * \return the item found 174 */ 175 ldns_lookup_table *ldns_lookup_by_id(ldns_lookup_table table[], int id); 176 177 /** 178 * Returns the value of the specified bit 179 * The bits are counted from left to right, so bit #0 is the 180 * left most bit. 181 * \param[in] bits array holding the bits 182 * \param[in] index to the wanted bit 183 * \return 184 */ 185 int ldns_get_bit(uint8_t bits[], size_t index); 186 187 188 /** 189 * Returns the value of the specified bit 190 * The bits are counted from right to left, so bit #0 is the 191 * right most bit. 192 * \param[in] bits array holding the bits 193 * \param[in] index to the wanted bit 194 * \return 1 or 0 depending no the bit state 195 */ 196 int ldns_get_bit_r(uint8_t bits[], size_t index); 197 198 /** 199 * sets the specified bit in the specified byte to 200 * 1 if value is true, 0 if false 201 * The bits are counted from right to left, so bit #0 is the 202 * right most bit. 203 * \param[in] byte the bit to set the bit in 204 * \param[in] bit_nr the bit to set (0 <= n <= 7) 205 * \param[in] value whether to set the bit to 1 or 0 206 * \return 1 or 0 depending no the bit state 207 */ 208 void ldns_set_bit(uint8_t *byte, int bit_nr, bool value); 209 210 /** 211 * Returns the value of a to the power of b 212 * (or 1 of b < 1) 213 */ 214 /*@unused@*/ 215 INLINE long 216 ldns_power(long a, long b) { 217 long result = 1; 218 while (b > 0) { 219 if (b & 1) { 220 result *= a; 221 if (b == 1) { 222 return result; 223 } 224 } 225 a *= a; 226 b /= 2; 227 } 228 return result; 229 } 230 231 /** 232 * Returns the int value of the given (hex) digit 233 * \param[in] ch the hex char to convert 234 * \return the converted decimal value 235 */ 236 int ldns_hexdigit_to_int(char ch); 237 238 /** 239 * Returns the char (hex) representation of the given int 240 * \param[in] ch the int to convert 241 * \return the converted hex char 242 */ 243 char ldns_int_to_hexdigit(int ch); 244 245 /** 246 * Converts a hex string to binary data 247 * 248 * \param[out] data The binary result is placed here. 249 * At least strlen(str)/2 bytes should be allocated 250 * \param[in] str The hex string to convert. 251 * This string should not contain spaces 252 * \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 253 */ 254 int 255 ldns_hexstring_to_data(uint8_t *data, const char *str); 256 257 /** 258 * Show the internal library version 259 * \return a string with the version in it 260 */ 261 const char * ldns_version(void); 262 263 /** 264 * Convert TM to seconds since epoch (midnight, January 1st, 1970). 265 * Like timegm(3), which is not always available. 266 * \param[in] tm a struct tm* with the date 267 * \return the seconds since epoch 268 */ 269 time_t mktime_from_utc(const struct tm *tm); 270 271 /** 272 * Seed the random function. 273 * If the file descriptor is specified, the random generator is seeded with 274 * data from that file. If not, /dev/urandom is used. 275 * 276 * applications should call this if they need entropy data within ldns 277 * If openSSL is available, it is automatically seeded from /dev/urandom 278 * or /dev/random. 279 * 280 * If you need more entropy, or have no openssl available, this function 281 * MUST be called at the start of the program 282 * 283 * If openssl *is* available, this function just adds more entropy 284 * 285 * \param[in] fd a file providing entropy data for the seed 286 * \param[in] size the number of bytes to use as entropy data. If this is 0, 287 * only the minimal amount is taken (usually 4 bytes) 288 * \return 0 if seeding succeeds, 1 if it fails 289 */ 290 int ldns_init_random(FILE *fd, unsigned int size); 291 292 /** 293 * Get random number. 294 * \return random number. 295 * 296 */ 297 uint16_t ldns_get_random(void); 298 299 /** 300 * Encode data as BubbleBabble 301 * 302 * \param[in] data a pointer to data to be encoded 303 * \param[in] len size the number of bytes of data 304 * \return a string of BubbleBabble 305 */ 306 char *ldns_bubblebabble(uint8_t *data, size_t len); 307 308 #ifndef B32_NTOP 309 int ldns_b32_ntop(uint8_t const *src, size_t srclength, 310 char *target, size_t targsize); 311 int b32_ntop(uint8_t const *src, size_t srclength, 312 char *target, size_t targsize); 313 int ldns_b32_ntop_extended_hex(uint8_t const *src, size_t srclength, 314 char *target, size_t targsize); 315 int b32_ntop_extended_hex(uint8_t const *src, size_t srclength, 316 char *target, size_t targsize); 317 /** 318 * calculates the size needed to store the result of b32_ntop 319 */ 320 /*@unused@*/ 321 INLINE size_t ldns_b32_ntop_calculate_size(size_t srcsize) 322 { 323 size_t result = ((((srcsize / 5) * 8) - 2) + 2); 324 return result; 325 } 326 #endif /* !B32_NTOP */ 327 #ifndef B32_PTON 328 int ldns_b32_pton(char const *src, size_t hashed_owner_str_len, uint8_t *target, size_t targsize); 329 int b32_pton(char const *src, size_t hashed_owner_str_len, uint8_t *target, size_t targsize); 330 int ldns_b32_pton_extended_hex(char const *src, size_t hashed_owner_str_len, uint8_t *target, size_t targsize); 331 int b32_pton_extended_hex(char const *src, size_t hashed_owner_str_len, uint8_t *target, size_t targsize); 332 /** 333 * calculates the size needed to store the result of b32_pton 334 */ 335 /*@unused@*/ 336 INLINE size_t ldns_b32_pton_calculate_size(size_t srcsize) 337 { 338 size_t result = ((((srcsize) / 8) * 5)); 339 return result; 340 } 341 #endif /* !B32_PTON */ 342 343 #ifdef __cplusplus 344 } 345 #endif 346 347 #endif /* !_UTIL_H */ 348