1 /* 2 * util.h -- set of various support routines. 3 * 4 * Copyright (c) 2001-2006, NLnet Labs. All rights reserved. 5 * 6 * See LICENSE for the license. 7 * 8 */ 9 10 #ifndef _UTIL_H_ 11 #define _UTIL_H_ 12 13 #include <sys/time.h> 14 #include <stdarg.h> 15 #include <stdio.h> 16 #include <time.h> 17 struct rr; 18 struct buffer; 19 struct region; 20 struct nsd; 21 22 #ifdef HAVE_SYSLOG_H 23 # include <syslog.h> 24 #else 25 # define LOG_ERR 3 26 # define LOG_WARNING 4 27 # define LOG_NOTICE 5 28 # define LOG_INFO 6 29 30 /* Unused, but passed to log_open. */ 31 # define LOG_PID 0x01 32 # define LOG_DAEMON (3<<3) 33 #endif 34 35 #define ALIGN_UP(n, alignment) \ 36 (((n) + (alignment) - 1) & (~((alignment) - 1))) 37 #define PADDING(n, alignment) \ 38 (ALIGN_UP((n), (alignment)) - (n)) 39 40 /* 41 * Initialize the logging system. All messages are logged to stderr 42 * until log_open and log_set_log_function are called. 43 */ 44 void log_init(const char *ident); 45 46 /* 47 * Open the system log. If FILENAME is not NULL, a log file is opened 48 * as well. 49 */ 50 void log_open(int option, int facility, const char *filename); 51 52 /* 53 * Reopen the logfile. 54 */ 55 void log_reopen(const char *filename, uint8_t verbose); 56 57 /* 58 * Finalize the logging system. 59 */ 60 void log_finalize(void); 61 62 /* 63 * Type of function to use for the actual logging. 64 */ 65 typedef void log_function_type(int priority, const char *message); 66 67 /* 68 * The function used to log to the log file. 69 */ 70 log_function_type log_file; 71 72 /* 73 * The function used to log to syslog. The messages are also logged 74 * using log_file. 75 */ 76 log_function_type log_syslog; 77 78 /* 79 * The function used to log to syslog only. 80 */ 81 log_function_type log_only_syslog; 82 83 /* 84 * Set the logging function to use (log_file or log_syslog). 85 */ 86 void log_set_log_function(log_function_type *log_function); 87 88 /* 89 * Log a message using the current log function. 90 */ 91 void log_msg(int priority, const char *format, ...) 92 ATTR_FORMAT(printf, 2, 3); 93 94 /* 95 * Log a message using the current log function. 96 */ 97 void log_vmsg(int priority, const char *format, va_list args); 98 99 /* 100 * Verbose output switch 101 */ 102 extern int verbosity; 103 #define VERBOSITY(level, args) \ 104 do { \ 105 if ((level) <= verbosity) { \ 106 log_msg args ; \ 107 } \ 108 } while (0) 109 110 /* 111 * Set the INDEXth bit of BITS to 1. 112 */ 113 void set_bit(uint8_t bits[], size_t index); 114 115 /* 116 * Set the INDEXth bit of BITS to 0. 117 */ 118 void clear_bit(uint8_t bits[], size_t index); 119 120 /* 121 * Return the value of the INDEXth bit of BITS. 122 */ 123 int get_bit(uint8_t bits[], size_t index); 124 125 /* A general purpose lookup table */ 126 typedef struct lookup_table lookup_table_type; 127 struct lookup_table { 128 int id; 129 const char *name; 130 }; 131 132 /* 133 * Looks up the table entry by name, returns NULL if not found. 134 */ 135 lookup_table_type *lookup_by_name(lookup_table_type table[], const char *name); 136 137 /* 138 * Looks up the table entry by id, returns NULL if not found. 139 */ 140 lookup_table_type *lookup_by_id(lookup_table_type table[], int id); 141 142 /* 143 * (Re-)allocate SIZE bytes of memory. Report an error if the memory 144 * could not be allocated and exit the program. These functions never 145 * return NULL. 146 */ 147 void *xalloc(size_t size); 148 void *xmallocarray(size_t num, size_t size); 149 void *xalloc_zero(size_t size); 150 void *xalloc_array_zero(size_t num, size_t size); 151 void *xrealloc(void *ptr, size_t size); 152 char *xstrdup(const char *src); 153 154 /* 155 * Mmap allocator routines. 156 * 157 */ 158 #ifdef USE_MMAP_ALLOC 159 void *mmap_alloc(size_t size); 160 void mmap_free(void *ptr); 161 #endif /* USE_MMAP_ALLOC */ 162 163 /* 164 * Write SIZE bytes of DATA to FILE. Report an error on failure. 165 * 166 * Returns 0 on failure, 1 on success. 167 */ 168 int write_data(FILE *file, const void *data, size_t size); 169 170 /* 171 * like write_data, but keeps track of crc 172 */ 173 int write_data_crc(FILE *file, const void *data, size_t size, uint32_t* crc); 174 175 /* 176 * Write the complete buffer to the socket, irrespective of short 177 * writes or interrupts. This function blocks to write the data. 178 * Returns 0 on error, 1 on success. 179 */ 180 int write_socket(int s, const void *data, size_t size); 181 182 /* 183 * Copy data allowing for unaligned accesses in network byte order 184 * (big endian). 185 */ 186 static inline void 187 write_uint16(void *dst, uint16_t data) 188 { 189 #ifdef ALLOW_UNALIGNED_ACCESSES 190 * (uint16_t *) dst = htons(data); 191 #else 192 uint8_t *p = (uint8_t *) dst; 193 p[0] = (uint8_t) ((data >> 8) & 0xff); 194 p[1] = (uint8_t) (data & 0xff); 195 #endif 196 } 197 198 static inline void 199 write_uint32(void *dst, uint32_t data) 200 { 201 #ifdef ALLOW_UNALIGNED_ACCESSES 202 * (uint32_t *) dst = htonl(data); 203 #else 204 uint8_t *p = (uint8_t *) dst; 205 p[0] = (uint8_t) ((data >> 24) & 0xff); 206 p[1] = (uint8_t) ((data >> 16) & 0xff); 207 p[2] = (uint8_t) ((data >> 8) & 0xff); 208 p[3] = (uint8_t) (data & 0xff); 209 #endif 210 } 211 212 static inline void 213 write_uint64(void *dst, uint64_t data) 214 { 215 uint8_t *p = (uint8_t *) dst; 216 p[0] = (uint8_t) ((data >> 56) & 0xff); 217 p[1] = (uint8_t) ((data >> 48) & 0xff); 218 p[2] = (uint8_t) ((data >> 40) & 0xff); 219 p[3] = (uint8_t) ((data >> 32) & 0xff); 220 p[4] = (uint8_t) ((data >> 24) & 0xff); 221 p[5] = (uint8_t) ((data >> 16) & 0xff); 222 p[6] = (uint8_t) ((data >> 8) & 0xff); 223 p[7] = (uint8_t) (data & 0xff); 224 } 225 226 /* 227 * Copy data allowing for unaligned accesses in network byte order 228 * (big endian). 229 */ 230 static inline uint16_t 231 read_uint16(const void *src) 232 { 233 #ifdef ALLOW_UNALIGNED_ACCESSES 234 return ntohs(* (const uint16_t *) src); 235 #else 236 const uint8_t *p = (const uint8_t *) src; 237 return (p[0] << 8) | p[1]; 238 #endif 239 } 240 241 static inline uint32_t 242 read_uint32(const void *src) 243 { 244 #ifdef ALLOW_UNALIGNED_ACCESSES 245 return ntohl(* (const uint32_t *) src); 246 #else 247 const uint8_t *p = (const uint8_t *) src; 248 return (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3]; 249 #endif 250 } 251 252 static inline uint64_t 253 read_uint64(const void *src) 254 { 255 const uint8_t *p = (const uint8_t *) src; 256 return 257 ((uint64_t)p[0] << 56) | 258 ((uint64_t)p[1] << 48) | 259 ((uint64_t)p[2] << 40) | 260 ((uint64_t)p[3] << 32) | 261 ((uint64_t)p[4] << 24) | 262 ((uint64_t)p[5] << 16) | 263 ((uint64_t)p[6] << 8) | 264 (uint64_t)p[7]; 265 } 266 267 /* 268 * Print debugging information using log_msg, 269 * set the logfile as /dev/stdout or /dev/stderr if you like. 270 * nsd -F 0xFFFF enables all debug facilities. 271 */ 272 #define DEBUG_PARSER 0x0001U 273 #define DEBUG_ZONEC 0x0002U 274 #define DEBUG_QUERY 0x0004U 275 #define DEBUG_DBACCESS 0x0008U 276 #define DEBUG_NAME_COMPRESSION 0x0010U 277 #define DEBUG_XFRD 0x0020U 278 #define DEBUG_IPC 0x0040U 279 280 extern unsigned nsd_debug_facilities; 281 extern int nsd_debug_level; 282 #ifdef NDEBUG 283 #define DEBUG(facility, level, args) /* empty */ 284 #else 285 #define DEBUG(facility, level, args) \ 286 do { \ 287 if ((facility) & nsd_debug_facilities && \ 288 (level) <= nsd_debug_level) { \ 289 log_msg args ; \ 290 } \ 291 } while (0) 292 #endif 293 294 /* set to true to log time prettyprinted, or false to print epoch */ 295 extern int log_time_asc; 296 297 /* 298 * Timespec functions. 299 */ 300 int timespec_compare(const struct timespec *left, const struct timespec *right); 301 void timespec_add(struct timespec *left, const struct timespec *right); 302 void timespec_subtract(struct timespec *left, const struct timespec *right); 303 304 static inline void 305 timeval_to_timespec(struct timespec *left, 306 const struct timeval *right) 307 { 308 left->tv_sec = right->tv_sec; 309 left->tv_nsec = 1000 * right->tv_usec; 310 } 311 312 /* get the time */ 313 void get_time(struct timespec* t); 314 315 /* 316 * Converts a string representation of a period of time into 317 * a long integer of seconds or serial value. 318 * 319 * Set the endptr to the first illegal character. 320 * 321 * Interface is similar as strtol(3) 322 * 323 * Returns: 324 * LONG_MIN if underflow occurs 325 * LONG_MAX if overflow occurs. 326 * otherwise number of seconds 327 * 328 * XXX These functions do not check the range. 329 * 330 */ 331 uint32_t strtoserial(const char *nptr, const char **endptr); 332 uint32_t strtottl(const char *nptr, const char **endptr); 333 334 /* 335 * Convert binary data to a string of hexadecimal characters. 336 */ 337 ssize_t hex_ntop(uint8_t const *src, size_t srclength, char *target, 338 size_t targsize); 339 ssize_t hex_pton(const char* src, uint8_t* target, size_t targsize); 340 341 /* 342 * convert base32 data from and to string. Returns length. 343 * -1 on error. Use (byte count*8)%5==0. 344 */ 345 int b32_pton(char const *src, uint8_t *target, size_t targsize); 346 int b32_ntop(uint8_t const *src, size_t srclength, char *target, 347 size_t targsize); 348 349 /* 350 * Strip trailing and leading whitespace from str. 351 */ 352 void strip_string(char *str); 353 354 /* 355 * Convert a single (hexadecimal) digit to its integer value. 356 */ 357 int hexdigit_to_int(char ch); 358 359 /* 360 * Convert TM to seconds since epoch (midnight, January 1st, 1970). 361 * Like timegm(3), which is not always available. 362 */ 363 time_t mktime_from_utc(const struct tm *tm); 364 365 /* 366 * Add bytes to given crc. Returns new CRC sum. 367 * Start crc val with 0xffffffff on first call. XOR crc with 368 * 0xffffffff at the end again to get final POSIX 1003.2 checksum. 369 */ 370 uint32_t compute_crc(uint32_t crc, uint8_t* data, size_t len); 371 372 /* 373 * Compares two 32-bit serial numbers as defined in RFC1982. Returns 374 * <0 if a < b, 0 if a == b, and >0 if a > b. The result is undefined 375 * if a != b but neither is greater or smaller (see RFC1982 section 376 * 3.2.). 377 */ 378 int compare_serial(uint32_t a, uint32_t b); 379 380 /* 381 * Generate a random query ID. 382 */ 383 uint16_t qid_generate(void); 384 /* value between 0 .. (max-1) inclusive */ 385 int random_generate(int max); 386 387 /* 388 * call region_destroy on (region*)data, useful for region_add_cleanup(). 389 */ 390 void cleanup_region(void *data); 391 392 /* 393 * Region used to store owner and origin of previous RR (used 394 * for pretty printing of zone data). 395 * Keep the same between calls to print_rr. 396 */ 397 struct state_pretty_rr { 398 struct region *previous_owner_region; 399 const struct dname *previous_owner; 400 const struct dname *previous_owner_origin; 401 }; 402 struct state_pretty_rr* create_pretty_rr(struct region* region); 403 /* print rr to file, returns 0 on failure(nothing is written) */ 404 int print_rr(FILE *out, struct state_pretty_rr* state, struct rr *record, 405 struct region* tmp_region, struct buffer* tmp_buffer); 406 407 /* 408 * Convert a numeric rcode value to a human readable string 409 */ 410 const char* rcode2str(int rc); 411 412 void addr2str( 413 #ifdef INET6 414 struct sockaddr_storage *addr 415 #else 416 struct sockaddr_in *addr 417 #endif 418 , char* str, size_t len); 419 420 /* print addr@port */ 421 void addrport2str( 422 #ifdef INET6 423 struct sockaddr_storage *addr 424 #else 425 struct sockaddr_in *addr 426 #endif 427 , char* str, size_t len); 428 429 /** copy dirname string and append slash. Previous dirname is leaked, 430 * but it is to be used once, at startup, for chroot */ 431 void append_trailing_slash(const char** dirname, struct region* region); 432 433 /** true if filename starts with chroot or is not absolute */ 434 int file_inside_chroot(const char* fname, const char* chr); 435 436 /** Something went wrong, give error messages and exit. */ 437 void error(const char *format, ...) ATTR_FORMAT(printf, 1, 2) ATTR_NORETURN; 438 439 #if HAVE_CPUSET_T 440 int number_of_cpus(void); 441 int set_cpu_affinity(cpuset_t *set); 442 #endif 443 444 /* Add a cookie secret. If there are no secrets yet, the secret will become 445 * the active secret. Otherwise it will become the staging secret. 446 * Active secrets are used to both verify and create new DNS Cookies. 447 * Staging secrets are only used to verify DNS Cookies. */ 448 void add_cookie_secret(struct nsd* nsd, uint8_t* secret); 449 /* Makes the staging cookie secret active and the active secret staging. */ 450 void activate_cookie_secret(struct nsd* nsd); 451 /* Drop a cookie secret. Drops the staging secret. An active secret will not 452 * be dropped. */ 453 void drop_cookie_secret(struct nsd* nsd); 454 #endif /* _UTIL_H_ */ 455