4 * some general memory functions
6 * a Net::DNS like library for C
8 * (c) NLnet Labs, 2004-2006
10 * See the file LICENSE for the license
13 #include <ldns/config.h>
15 #include <ldns/rdata.h>
17 #include <ldns/util.h>
26 #include <openssl/rand.h>
30 ldns_lookup_by_name(ldns_lookup_table
*table
, const char *name
)
32 while (table
->name
!= NULL
) {
33 if (strcasecmp(name
, table
->name
) == 0)
41 ldns_lookup_by_id(ldns_lookup_table
*table
, int id
)
43 while (table
->name
!= NULL
) {
52 ldns_get_bit(uint8_t bits
[], size_t index
)
55 * The bits are counted from left to right, so bit #0 is the
58 return (int) (bits
[index
/ 8] & (1 << (7 - index
% 8)));
62 ldns_get_bit_r(uint8_t bits
[], size_t index
)
65 * The bits are counted from right to left, so bit #0 is the
68 return (int) bits
[index
/ 8] & (1 << (index
% 8));
72 ldns_set_bit(uint8_t *byte
, int bit_nr
, bool value
)
75 * The bits are counted from right to left, so bit #0 is the
78 if (bit_nr
>= 0 && bit_nr
< 8) {
80 *byte
= *byte
| (0x01 << bit_nr
);
82 *byte
= *byte
& ~(0x01 << bit_nr
);
88 ldns_hexdigit_to_int(char ch
)
101 case 'a': case 'A': return 10;
102 case 'b': case 'B': return 11;
103 case 'c': case 'C': return 12;
104 case 'd': case 'D': return 13;
105 case 'e': case 'E': return 14;
106 case 'f': case 'F': return 15;
113 ldns_int_to_hexdigit(int i
)
138 ldns_hexstring_to_data(uint8_t *data
, const char *str
)
146 if (strlen(str
) % 2 != 0) {
150 for (i
= 0; i
< strlen(str
) / 2; i
++) {
152 16 * (uint8_t) ldns_hexdigit_to_int(str
[i
*2]) +
153 (uint8_t) ldns_hexdigit_to_int(str
[i
*2 + 1]);
162 return (char*)LDNS_VERSION
;
165 /* Number of days per month (except for February in leap years). */
166 static const int mdays
[] = {
167 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
170 #define LDNS_MOD(x,y) (((x) % (y) < 0) ? ((x) % (y) + (y)) : ((x) % (y)))
171 #define LDNS_DIV(x,y) (((x) % (y) < 0) ? ((x) / (y) - 1 ) : ((x) / (y)))
174 is_leap_year(int year
)
176 return LDNS_MOD(year
, 4) == 0 && (LDNS_MOD(year
, 100) != 0
177 || LDNS_MOD(year
, 400) == 0);
181 leap_days(int y1
, int y2
)
185 return (LDNS_DIV(y2
, 4) - LDNS_DIV(y1
, 4)) -
186 (LDNS_DIV(y2
, 100) - LDNS_DIV(y1
, 100)) +
187 (LDNS_DIV(y2
, 400) - LDNS_DIV(y1
, 400));
191 * Code adapted from Python 2.4.1 sources (Lib/calendar.py).
194 ldns_mktime_from_utc(const struct tm
*tm
)
196 int year
= 1900 + tm
->tm_year
;
197 time_t days
= 365 * ((time_t) year
- 1970) + leap_days(1970, year
);
203 for (i
= 0; i
< tm
->tm_mon
; ++i
) {
206 if (tm
->tm_mon
> 1 && is_leap_year(year
)) {
209 days
+= tm
->tm_mday
- 1;
211 hours
= days
* 24 + tm
->tm_hour
;
212 minutes
= hours
* 60 + tm
->tm_min
;
213 seconds
= minutes
* 60 + tm
->tm_sec
;
219 mktime_from_utc(const struct tm
*tm
)
221 return ldns_mktime_from_utc(tm
);
224 #if SIZEOF_TIME_T <= 4
227 ldns_year_and_yday_from_days_since_epoch(int64_t days
, struct tm
*result
)
232 while (days
< 0 || days
>= (int64_t) (is_leap_year(year
) ? 366 : 365)) {
233 new_year
= year
+ (int) LDNS_DIV(days
, 365);
234 days
-= (new_year
- year
) * 365;
235 days
-= leap_days(year
, new_year
);
238 result
->tm_year
= year
;
239 result
->tm_yday
= (int) days
;
242 /* Number of days per month in a leap year. */
243 static const int leap_year_mdays
[] = {
244 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
248 ldns_mon_and_mday_from_year_and_yday(struct tm
*result
)
250 int idays
= result
->tm_yday
;
251 const int *mon_lengths
= is_leap_year(result
->tm_year
) ?
252 leap_year_mdays
: mdays
;
255 while (idays
>= mon_lengths
[result
->tm_mon
]) {
256 idays
-= mon_lengths
[result
->tm_mon
++];
258 result
->tm_mday
= idays
+ 1;
262 ldns_wday_from_year_and_yday(struct tm
*result
)
264 result
->tm_wday
= 4 /* 1-1-1970 was a thursday */
265 + LDNS_MOD((result
->tm_year
- 1970), 7) * LDNS_MOD(365, 7)
266 + leap_days(1970, result
->tm_year
)
268 result
->tm_wday
= LDNS_MOD(result
->tm_wday
, 7);
269 if (result
->tm_wday
< 0) {
270 result
->tm_wday
+= 7;
275 ldns_gmtime64_r(int64_t clock
, struct tm
*result
)
277 result
->tm_isdst
= 0;
278 result
->tm_sec
= (int) LDNS_MOD(clock
, 60);
279 clock
= LDNS_DIV(clock
, 60);
280 result
->tm_min
= (int) LDNS_MOD(clock
, 60);
281 clock
= LDNS_DIV(clock
, 60);
282 result
->tm_hour
= (int) LDNS_MOD(clock
, 24);
283 clock
= LDNS_DIV(clock
, 24);
285 ldns_year_and_yday_from_days_since_epoch(clock
, result
);
286 ldns_mon_and_mday_from_year_and_yday(result
);
287 ldns_wday_from_year_and_yday(result
);
288 result
->tm_year
-= 1900;
293 #endif /* SIZEOF_TIME_T <= 4 */
296 ldns_serial_arithmetics_time(int32_t time
, time_t now
)
298 /* Casting due to https://github.com/NLnetLabs/ldns/issues/71 */
299 int32_t offset
= (int32_t) ((uint32_t) time
- (uint32_t) now
);
300 return (int64_t) now
+ offset
;
304 ldns_serial_arithmetics_gmtime_r(int32_t time
, time_t now
, struct tm
*result
)
306 #if SIZEOF_TIME_T <= 4
307 int64_t secs_since_epoch
= ldns_serial_arithmetics_time(time
, now
);
308 return ldns_gmtime64_r(secs_since_epoch
, result
);
310 time_t secs_since_epoch
= ldns_serial_arithmetics_time(time
, now
);
311 return gmtime_r(&secs_since_epoch
, result
);
315 #ifdef ldns_serial_arithmitics_gmtime_r
316 #undef ldns_serial_arithmitics_gmtime_r
318 /* alias function because of previously used wrong spelling */
320 ldns_serial_arithmitics_gmtime_r(int32_t time
, time_t now
, struct tm
*result
)
322 return ldns_serial_arithmetics_gmtime_r(time
, now
, result
);
326 * Init the random source
327 * applications should call this if they need entropy data within ldns
328 * If openSSL is available, it is automatically seeded from /dev/urandom
331 * If you need more entropy, or have no openssl available, this function
332 * MUST be called at the start of the program
334 * If openssl *is* available, this function just adds more entropy
337 ldns_init_random(FILE *fd
, unsigned int size
)
339 /* if fp is given, seed srandom with data from file
340 otherwise use /dev/urandom */
347 /* we'll need at least sizeof(unsigned int) bytes for the
348 standard prng seed */
349 if (size
< (unsigned int) sizeof(seed_i
)){
350 size
= (unsigned int) sizeof(seed_i
);
353 seed
= LDNS_XMALLOC(uint8_t, size
);
359 if ((rand_f
= fopen("/dev/urandom", "r")) == NULL
) {
360 /* no readable /dev/urandom, try /dev/random */
361 if ((rand_f
= fopen("/dev/random", "r")) == NULL
) {
362 /* no readable /dev/random either, and no entropy
363 source given. we'll have to improvise */
364 for (read
= 0; read
< size
; read
++) {
365 gettimeofday(&tv
, NULL
);
366 seed
[read
] = (uint8_t) (tv
.tv_usec
% 256);
369 read
= fread(seed
, 1, size
, rand_f
);
372 read
= fread(seed
, 1, size
, rand_f
);
376 read
= fread(seed
, 1, size
, rand_f
);
381 if (!fd
) fclose(rand_f
);
385 /* Seed the OpenSSL prng (most systems have it seeded
386 automatically, in that case this call just adds entropy */
387 RAND_seed(seed
, (int) size
);
389 /* Seed the standard prng, only uses the first
390 * unsigned sizeof(unsigned int) bytes found in the entropy pool
392 memcpy(&seed_i
, seed
, sizeof(seed_i
));
399 if (rand_f
) fclose(rand_f
);
410 ldns_get_random(void)
414 if (RAND_bytes((unsigned char*)&rid
, 2) != 1) {
415 rid
= (uint16_t) random();
418 rid
= (uint16_t) random();
424 * BubbleBabble code taken from OpenSSH
425 * Copyright (c) 2001 Carsten Raskgaard. All rights reserved.
428 ldns_bubblebabble(uint8_t *data
, size_t len
)
430 char vowels
[] = { 'a', 'e', 'i', 'o', 'u', 'y' };
431 char consonants
[] = { 'b', 'c', 'd', 'f', 'g', 'h', 'k', 'l', 'm',
432 'n', 'p', 'r', 's', 't', 'v', 'z', 'x' };
433 size_t i
, j
= 0, rounds
, seed
= 1;
436 rounds
= (len
/ 2) + 1;
437 retval
= LDNS_XMALLOC(char, rounds
* 6);
438 if(!retval
) return NULL
;
440 for (i
= 0; i
< rounds
; i
++) {
441 size_t idx0
, idx1
, idx2
, idx3
, idx4
;
442 if ((i
+ 1 < rounds
) || (len
% 2 != 0)) {
443 idx0
= (((((size_t)(data
[2 * i
])) >> 6) & 3) +
445 idx1
= (((size_t)(data
[2 * i
])) >> 2) & 15;
446 idx2
= ((((size_t)(data
[2 * i
])) & 3) +
448 retval
[j
++] = vowels
[idx0
];
449 retval
[j
++] = consonants
[idx1
];
450 retval
[j
++] = vowels
[idx2
];
451 if ((i
+ 1) < rounds
) {
452 idx3
= (((size_t)(data
[(2 * i
) + 1])) >> 4) & 15;
453 idx4
= (((size_t)(data
[(2 * i
) + 1]))) & 15;
454 retval
[j
++] = consonants
[idx3
];
456 retval
[j
++] = consonants
[idx4
];
458 ((((size_t)(data
[2 * i
])) * 7) +
459 ((size_t)(data
[(2 * i
) + 1])))) % 36;
465 retval
[j
++] = vowels
[idx0
];
466 retval
[j
++] = consonants
[idx1
];
467 retval
[j
++] = vowels
[idx2
];
476 * For backwards compatibility, because we have always exported this symbol.
479 int ldns_b64_ntop(const uint8_t* src
, size_t srclength
,
480 char *target
, size_t targsize
);
482 return b64_ntop(src
, srclength
, target
, targsize
);
487 * For backwards compatibility, because we have always exported this symbol.
490 int ldns_b64_pton(const char* src
, uint8_t *target
, size_t targsize
)
492 return b64_pton(src
, target
, targsize
);
498 ldns_b32_ntop_base(const uint8_t* src
, size_t src_sz
,
499 char* dst
, size_t dst_sz
,
500 bool extended_hex
, bool add_padding
)
503 const char* b32
= extended_hex
? "0123456789abcdefghijklmnopqrstuv"
504 : "abcdefghijklmnopqrstuvwxyz234567";
506 size_t c
= 0; /* c is used to carry partial base32 character over
507 * byte boundaries for sizes with a remainder.
508 * (i.e. src_sz % 5 != 0)
511 ret_sz
= add_padding
? ldns_b32_ntop_calculate_size(src_sz
)
512 : ldns_b32_ntop_calculate_size_no_padding(src_sz
);
514 /* Do we have enough space? */
515 if (dst_sz
< ret_sz
+ 1)
518 /* We know the size; terminate the string */
521 /* First process all chunks of five */
522 while (src_sz
>= 5) {
523 /* 00000... ........ ........ ........ ........ */
524 dst
[0] = b32
[(src
[0] ) >> 3];
526 /* .....111 11...... ........ ........ ........ */
527 dst
[1] = b32
[(src
[0] & 0x07) << 2 | src
[1] >> 6];
529 /* ........ ..22222. ........ ........ ........ */
530 dst
[2] = b32
[(src
[1] & 0x3e) >> 1];
532 /* ........ .......3 3333.... ........ ........ */
533 dst
[3] = b32
[(src
[1] & 0x01) << 4 | src
[2] >> 4];
535 /* ........ ........ ....4444 4....... ........ */
536 dst
[4] = b32
[(src
[2] & 0x0f) << 1 | src
[3] >> 7];
538 /* ........ ........ ........ .55555.. ........ */
539 dst
[5] = b32
[(src
[3] & 0x7c) >> 2];
541 /* ........ ........ ........ ......66 666..... */
542 dst
[6] = b32
[(src
[3] & 0x03) << 3 | src
[4] >> 5];
544 /* ........ ........ ........ ........ ...77777 */
545 dst
[7] = b32
[(src
[4] & 0x1f) ];
551 /* Process what remains */
553 case 4: /* ........ ........ ........ ......66 666..... */
554 dst
[6] = b32
[(src
[3] & 0x03) << 3];
556 /* ........ ........ ........ .55555.. ........ */
557 dst
[5] = b32
[(src
[3] & 0x7c) >> 2];
559 /* ........ ........ ....4444 4....... ........ */
562 case 3: dst
[4] = b32
[(src
[2] & 0x0f) << 1 | c
];
564 /* ........ .......3 3333.... ........ ........ */
567 case 2: dst
[3] = b32
[(src
[1] & 0x01) << 4 | c
];
569 /* ........ ..22222. ........ ........ ........ */
570 dst
[2] = b32
[(src
[1] & 0x3e) >> 1];
572 /* .....111 11...... ........ ........ ........ */
575 case 1: dst
[1] = b32
[(src
[0] & 0x07) << 2 | c
];
577 /* 00000... ........ ........ ........ ........ */
578 dst
[0] = b32
[ src
[0] >> 3];
583 case 1: dst
[2] = '=';
586 case 2: dst
[4] = '=';
588 case 3: dst
[5] = '=';
591 case 4: dst
[7] = '=';
598 ldns_b32_ntop(const uint8_t* src
, size_t src_sz
, char* dst
, size_t dst_sz
)
600 return ldns_b32_ntop_base(src
, src_sz
, dst
, dst_sz
, false, true);
604 ldns_b32_ntop_extended_hex(const uint8_t* src
, size_t src_sz
,
605 char* dst
, size_t dst_sz
)
607 return ldns_b32_ntop_base(src
, src_sz
, dst
, dst_sz
, true, true);
610 #ifndef HAVE_B32_NTOP
613 b32_ntop(const uint8_t* src
, size_t src_sz
, char* dst
, size_t dst_sz
)
615 return ldns_b32_ntop_base(src
, src_sz
, dst
, dst_sz
, false, true);
619 b32_ntop_extended_hex(const uint8_t* src
, size_t src_sz
,
620 char* dst
, size_t dst_sz
)
622 return ldns_b32_ntop_base(src
, src_sz
, dst
, dst_sz
, true, true);
625 #endif /* ! HAVE_B32_NTOP */
628 ldns_b32_pton_base(const char* src
, size_t src_sz
,
629 uint8_t* dst
, size_t dst_sz
,
630 bool extended_hex
, bool check_padding
)
635 uint8_t* start
= dst
;
638 /* Collect 8 characters in buf (if possible) */
639 for (i
= 0; i
< 8; i
++) {
645 } while (isspace((unsigned char)ch
) && src_sz
> 0);
647 if (ch
== '=' || ch
== '\0')
650 else if (extended_hex
)
652 if (ch
>= '0' && ch
<= '9')
653 buf
[i
] = (uint8_t)ch
- '0';
654 else if (ch
>= 'a' && ch
<= 'v')
655 buf
[i
] = (uint8_t)ch
- 'a' + 10;
656 else if (ch
>= 'A' && ch
<= 'V')
657 buf
[i
] = (uint8_t)ch
- 'A' + 10;
661 else if (ch
>= 'a' && ch
<= 'z')
662 buf
[i
] = (uint8_t)ch
- 'a';
663 else if (ch
>= 'A' && ch
<= 'Z')
664 buf
[i
] = (uint8_t)ch
- 'A';
665 else if (ch
>= '2' && ch
<= '7')
666 buf
[i
] = (uint8_t)ch
- '2' + 26;
670 /* Less that 8 characters. We're done. */
674 /* Enough space available at the destination? */
678 /* 00000... ........ ........ ........ ........ */
679 /* .....111 11...... ........ ........ ........ */
680 dst
[0] = buf
[0] << 3 | buf
[1] >> 2;
682 /* .....111 11...... ........ ........ ........ */
683 /* ........ ..22222. ........ ........ ........ */
684 /* ........ .......3 3333.... ........ ........ */
685 dst
[1] = buf
[1] << 6 | buf
[2] << 1 | buf
[3] >> 4;
687 /* ........ .......3 3333.... ........ ........ */
688 /* ........ ........ ....4444 4....... ........ */
689 dst
[2] = buf
[3] << 4 | buf
[4] >> 1;
691 /* ........ ........ ....4444 4....... ........ */
692 /* ........ ........ ........ .55555.. ........ */
693 /* ........ ........ ........ ......66 666..... */
694 dst
[3] = buf
[4] << 7 | buf
[5] << 2 | buf
[6] >> 3;
696 /* ........ ........ ........ ......66 666..... */
697 /* ........ ........ ........ ........ ...77777 */
698 dst
[4] = buf
[6] << 5 | buf
[7];
703 /* Not ending on a eight byte boundary? */
704 if (i
> 0 && i
< 8) {
706 /* Enough space available at the destination? */
707 if (dst_sz
< (i
+ 1) / 2)
711 case 7: /* ........ ........ ........ ......66 666..... */
712 /* ........ ........ ........ .55555.. ........ */
713 /* ........ ........ ....4444 4....... ........ */
714 dst
[3] = buf
[4] << 7 | buf
[5] << 2 | buf
[6] >> 3;
717 case 5: /* ........ ........ ....4444 4....... ........ */
718 /* ........ .......3 3333.... ........ ........ */
719 dst
[2] = buf
[3] << 4 | buf
[4] >> 1;
722 case 4: /* ........ .......3 3333.... ........ ........ */
723 /* ........ ..22222. ........ ........ ........ */
724 /* .....111 11...... ........ ........ ........ */
725 dst
[1] = buf
[1] << 6 | buf
[2] << 1 | buf
[3] >> 4;
728 case 2: /* .....111 11...... ........ ........ ........ */
729 /* 00000... ........ ........ ........ ........ */
730 dst
[0] = buf
[0] << 3 | buf
[1] >> 2;
740 /* Check remaining padding characters */
744 /* One down, 8 - i - 1 more to come... */
745 for (i
= 8 - i
- 1; i
> 0; i
--) {
753 } while (isspace((unsigned char)ch
));
764 ldns_b32_pton(const char* src
, size_t src_sz
, uint8_t* dst
, size_t dst_sz
)
766 return ldns_b32_pton_base(src
, src_sz
, dst
, dst_sz
, false, true);
770 ldns_b32_pton_extended_hex(const char* src
, size_t src_sz
,
771 uint8_t* dst
, size_t dst_sz
)
773 return ldns_b32_pton_base(src
, src_sz
, dst
, dst_sz
, true, true);
776 #ifndef HAVE_B32_PTON
779 b32_pton(const char* src
, size_t src_sz
, uint8_t* dst
, size_t dst_sz
)
781 return ldns_b32_pton_base(src
, src_sz
, dst
, dst_sz
, false, true);
785 b32_pton_extended_hex(const char* src
, size_t src_sz
,
786 uint8_t* dst
, size_t dst_sz
)
788 return ldns_b32_pton_base(src
, src_sz
, dst
, dst_sz
, true, true);
791 #endif /* ! HAVE_B32_PTON */