lib/libldns/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.0"
  31 #define LDNS_REVISION ((1<<16)|(7<<8)|(0))
  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 */