contrib/unbound/util/net_help.h

   1 /*
   2  * util/net_help.h - network help functions
   3  *
   4  * Copyright (c) 2007, NLnet Labs. All rights reserved.
   5  *
   6  * This software is open source.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  *
  12  * Redistributions of source code must retain the above copyright notice,
  13  * this list of conditions and the following disclaimer.
  14  *
  15  * Redistributions in binary form must reproduce the above copyright notice,
  16  * this list of conditions and the following disclaimer in the documentation
  17  * and/or other materials provided with the distribution.
  18  *
  19  * Neither the name of the NLNET LABS nor the names of its contributors may
  20  * be used to endorse or promote products derived from this software without
  21  * specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  24  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  25  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  26  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE
  27  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  28  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  29  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  30  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  31  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  32  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  33  * POSSIBILITY OF SUCH DAMAGE.
  34  */
  35
  36 /**
  37  * \file
  38  *
  39  * This file contains functions to perform network related tasks.
  40  */
  41
  42 #ifndef NET_HELP_H
  43 #define NET_HELP_H
  44 #include "util/log.h"
  45 struct sock_list;
  46 struct regional;
  47
  48 /** DNS constants for uint16_t style flag manipulation. host byteorder.
  49  *                                1  1  1  1  1  1
  50  *  0  1  2  3  4  5  6  7  8  9  0  1  2  3  4  5
  51  * +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
  52  * |QR|   Opcode  |AA|TC|RD|RA| Z|AD|CD|   RCODE   |
  53  * +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
  54  */
  55 /** CD flag */
  56 #define BIT_CD 0x0010
  57 /** AD flag */
  58 #define BIT_AD 0x0020
  59 /** Z flag */
  60 #define BIT_Z  0x0040
  61 /** RA flag */
  62 #define BIT_RA 0x0080
  63 /** RD flag */
  64 #define BIT_RD 0x0100
  65 /** TC flag */
  66 #define BIT_TC 0x0200
  67 /** AA flag */
  68 #define BIT_AA 0x0400
  69 /** QR flag */
  70 #define BIT_QR 0x8000
  71 /** get RCODE bits from uint16 flags */
  72 #define FLAGS_GET_RCODE(f) ((f) & 0xf)
  73 /** set RCODE bits in uint16 flags */
  74 #define FLAGS_SET_RCODE(f, r) (f = (((f) & 0xfff0) | (r)))
  75
  76 /** timeout in seconds for UDP queries to auth servers. */
  77 #define UDP_AUTH_QUERY_TIMEOUT 4
  78 /** timeout in seconds for TCP queries to auth servers. */
  79 #define TCP_AUTH_QUERY_TIMEOUT 30
  80 /** Advertised version of EDNS capabilities */
  81 #define EDNS_ADVERTISED_VERSION         0
  82 /** Advertised size of EDNS capabilities */
  83 extern uint16_t EDNS_ADVERTISED_SIZE;
  84 /** bits for EDNS bitfield */
  85 #define EDNS_DO 0x8000 /* Dnssec Ok */
  86 /** byte size of ip4 address */
  87 #define INET_SIZE 4
  88 /** byte size of ip6 address */
  89 #define INET6_SIZE 16
  90
  91 /** DNSKEY zone sign key flag */
  92 #define DNSKEY_BIT_ZSK 0x0100
  93 /** DNSKEY secure entry point, KSK flag */
  94 #define DNSKEY_BIT_SEP 0x0001
  95
  96 /** minimal responses when positive answer */
  97 extern int MINIMAL_RESPONSES;
  98
  99 /** rrset order roundrobin */
 100 extern int RRSET_ROUNDROBIN;
 101
 102 /**
 103  * See if string is ip4 or ip6.
 104  * @param str: IP specification.
 105  * @return: true if string addr is an ip6 specced address.
 106  */
 107 int str_is_ip6(const char* str);
 108
 109 /**
 110  * Set fd nonblocking.
 111  * @param s: file descriptor.
 112  * @return: 0 on error (error is printed to log).
 113  */
 114 int fd_set_nonblock(int s);
 115
 116 /**
 117  * Set fd (back to) blocking.
 118  * @param s: file descriptor.
 119  * @return: 0 on error (error is printed to log).
 120  */
 121 int fd_set_block(int s);
 122
 123 /**
 124  * See if number is a power of 2.
 125  * @param num: the value.
 126  * @return: true if the number is a power of 2.
 127  */
 128 int is_pow2(size_t num);
 129
 130 /**
 131  * Allocate memory and copy over contents.
 132  * @param data: what to copy over.
 133  * @param len: length of data.
 134  * @return: NULL on malloc failure, or newly malloced data.
 135  */
 136 void* memdup(void* data, size_t len);
 137
 138 /**
 139  * Prints the sockaddr in readable format with log_info. Debug helper.
 140  * @param v: at what verbosity level to print this.
 141  * @param str: descriptive string printed with it.
 142  * @param addr: the sockaddr to print. Can be ip4 or ip6.
 143  * @param addrlen: length of addr.
 144  */
 145 void log_addr(enum verbosity_value v, const char* str,
 146         struct sockaddr_storage* addr, socklen_t addrlen);
 147
 148 /**
 149  * Prints zone name and sockaddr in readable format with log_info. Debug.
 150  * @param v: at what verbosity level to print this.
 151  * @param str: descriptive string printed with it.
 152  * @param zone: DNS domain name, uncompressed wireformat.
 153  * @param addr: the sockaddr to print. Can be ip4 or ip6.
 154  * @param addrlen: length of addr.
 155  */
 156 void log_name_addr(enum verbosity_value v, const char* str, uint8_t* zone,
 157         struct sockaddr_storage* addr, socklen_t addrlen);
 158
 159 /**
 160  * Convert address string, with "@port" appendix, to sockaddr.
 161  * Uses DNS port by default.
 162  * @param str: the string
 163  * @param addr: where to store sockaddr.
 164  * @param addrlen: length of stored sockaddr is returned.
 165  * @return 0 on error.
 166  */
 167 int extstrtoaddr(const char* str, struct sockaddr_storage* addr,
 168         socklen_t* addrlen);
 169
 170 /**
 171  * Convert ip address string and port to sockaddr.
 172  * @param ip: ip4 or ip6 address string.
 173  * @param port: port number, host format.
 174  * @param addr: where to store sockaddr.
 175  * @param addrlen: length of stored sockaddr is returned.
 176  * @return 0 on error.
 177  */
 178 int ipstrtoaddr(const char* ip, int port, struct sockaddr_storage* addr,
 179         socklen_t* addrlen);
 180
 181 /**
 182  * Convert ip netblock (ip/netsize) string and port to sockaddr.
 183  * *SLOW*, does a malloc internally to avoid writing over 'ip' string.
 184  * @param ip: ip4 or ip6 address string.
 185  * @param port: port number, host format.
 186  * @param addr: where to store sockaddr.
 187  * @param addrlen: length of stored sockaddr is returned.
 188  * @param net: netblock size is returned.
 189  * @return 0 on error.
 190  */
 191 int netblockstrtoaddr(const char* ip, int port, struct sockaddr_storage* addr,
 192         socklen_t* addrlen, int* net);
 193
 194 /**
 195  * Print string with neat domain name, type and class.
 196  * @param v: at what verbosity level to print this.
 197  * @param str: string of message.
 198  * @param name: domain name uncompressed wireformat.
 199  * @param type: host format RR type.
 200  * @param dclass: host format RR class.
 201  */
 202 void log_nametypeclass(enum verbosity_value v, const char* str,
 203         uint8_t* name, uint16_t type, uint16_t dclass);
 204
 205 /**
 206  * Compare two sockaddrs. Imposes an ordering on the addresses.
 207  * Compares address and port.
 208  * @param addr1: address 1.
 209  * @param len1: lengths of addr1.
 210  * @param addr2: address 2.
 211  * @param len2: lengths of addr2.
 212  * @return: 0 if addr1 == addr2. -1 if addr1 is smaller, +1 if larger.
 213  */
 214 int sockaddr_cmp(struct sockaddr_storage* addr1, socklen_t len1,
 215         struct sockaddr_storage* addr2, socklen_t len2);
 216
 217 /**
 218  * Compare two sockaddrs. Compares address, not the port.
 219  * @param addr1: address 1.
 220  * @param len1: lengths of addr1.
 221  * @param addr2: address 2.
 222  * @param len2: lengths of addr2.
 223  * @return: 0 if addr1 == addr2. -1 if addr1 is smaller, +1 if larger.
 224  */
 225 int sockaddr_cmp_addr(struct sockaddr_storage* addr1, socklen_t len1,
 226         struct sockaddr_storage* addr2, socklen_t len2);
 227
 228 /**
 229  * Checkout address family.
 230  * @param addr: the sockaddr to examine.
 231  * @param len: the length of addr.
 232  * @return: true if sockaddr is ip6.
 233  */
 234 int addr_is_ip6(struct sockaddr_storage* addr, socklen_t len);
 235
 236 /**
 237  * Make sure the sockaddr ends in zeroes. For tree insertion and subsequent
 238  * comparison.
 239  * @param addr: the ip4 or ip6 addr.
 240  * @param len: length of addr.
 241  * @param net: number of bits to leave untouched, the rest of the netblock
 242  *      address is zeroed.
 243  */
 244 void addr_mask(struct sockaddr_storage* addr, socklen_t len, int net);
 245
 246 /**
 247  * See how many bits are shared, equal, between two addrs.
 248  * @param addr1: first addr.
 249  * @param net1: netblock size of first addr.
 250  * @param addr2: second addr.
 251  * @param net2: netblock size of second addr.
 252  * @param addrlen: length of first addr and of second addr.
 253  *      They must be of the same length (i.e. same type IP4, IP6).
 254  * @return: number of bits the same.
 255  */
 256 int addr_in_common(struct sockaddr_storage* addr1, int net1,
 257         struct sockaddr_storage* addr2, int net2, socklen_t addrlen);
 258
 259 /**
 260  * Put address into string, works for IPv4 and IPv6.
 261  * @param addr: address
 262  * @param addrlen: length of address
 263  * @param buf: result string stored here
 264  * @param len: length of buf.
 265  * On failure a string with "error" is stored inside.
 266  */
 267 void addr_to_str(struct sockaddr_storage* addr, socklen_t addrlen,
 268         char* buf, size_t len);
 269
 270 /**
 271  * See if sockaddr is an ipv6 mapped ipv4 address, "::ffff:0.0.0.0"
 272  * @param addr: address
 273  * @param addrlen: length of address
 274  * @return true if so
 275  */
 276 int addr_is_ip4mapped(struct sockaddr_storage* addr, socklen_t addrlen);
 277
 278 /**
 279  * See if sockaddr is 255.255.255.255.
 280  * @param addr: address
 281  * @param addrlen: length of address
 282  * @return true if so
 283  */
 284 int addr_is_broadcast(struct sockaddr_storage* addr, socklen_t addrlen);
 285
 286 /**
 287  * See if sockaddr is 0.0.0.0 or ::0.
 288  * @param addr: address
 289  * @param addrlen: length of address
 290  * @return true if so
 291  */
 292 int addr_is_any(struct sockaddr_storage* addr, socklen_t addrlen);
 293
 294 /**
 295  * Insert new socket list item. If fails logs error.
 296  * @param list: pointer to pointer to first item.
 297  * @param addr: address or NULL if 'cache'.
 298  * @param len: length of addr, or 0 if 'cache'.
 299  * @param region: where to allocate
 300  */
 301 void sock_list_insert(struct sock_list** list, struct sockaddr_storage* addr,
 302         socklen_t len, struct regional* region);
 303
 304 /**
 305  * Append one list to another.  Must both be from same qstate(regional).
 306  * @param list: pointer to result list that is modified.
 307  * @param add: item(s) to add.  They are prepended to list.
 308  */
 309 void sock_list_prepend(struct sock_list** list, struct sock_list* add);
 310
 311 /**
 312  * Find addr in list.
 313  * @param list: to search in
 314  * @param addr: address to look for.
 315  * @param len: length. Can be 0, look for 'cache entry'.
 316  * @return true if found.
 317  */
 318 int sock_list_find(struct sock_list* list, struct sockaddr_storage* addr,
 319         socklen_t len);
 320
 321 /**
 322  * Merge socklist into another socket list.  Allocates the new entries
 323  * freshly and copies them over, so also performs a region switchover.
 324  * Allocation failures are logged.
 325  * @param list: the destination list (checked for duplicates)
 326  * @param region: where to allocate
 327  * @param add: the list of entries to add.
 328  */
 329 void sock_list_merge(struct sock_list** list, struct regional* region,
 330         struct sock_list* add);
 331
 332 /**
 333  * Log libcrypto error with descriptive string. Calls log_err().
 334  * @param str: what failed.
 335  */
 336 void log_crypto_err(const char* str);
 337
 338 /**
 339  * create SSL listen context
 340  * @param key: private key file.
 341  * @param pem: public key cert.
 342  * @param verifypem: if nonNULL, verifylocation file.
 343  * return SSL_CTX* or NULL on failure (logged).
 344  */
 345 void* listen_sslctx_create(char* key, char* pem, char* verifypem);
 346
 347 /**
 348  * create SSL connect context
 349  * @param key: if nonNULL (also pem nonNULL), the client private key.
 350  * @param pem: client public key (or NULL if key is NULL).
 351  * @param verifypem: if nonNULL used for verifylocation file.
 352  * @return SSL_CTX* or NULL on failure (logged).
 353  */
 354 void* connect_sslctx_create(char* key, char* pem, char* verifypem);
 355
 356 /**
 357  * accept a new fd and wrap it in a BIO in SSL
 358  * @param sslctx: the SSL_CTX to use (from listen_sslctx_create()).
 359  * @param fd: from accept, nonblocking.
 360  * @return SSL or NULL on alloc failure.
 361  */
 362 void* incoming_ssl_fd(void* sslctx, int fd);
 363
 364 /**
 365  * connect a new fd and wrap it in a BIO in SSL
 366  * @param sslctx: the SSL_CTX to use (from connect_sslctx_create())
 367  * @param fd: from connect.
 368  * @return SSL or NULL on alloc failure
 369  */
 370 void* outgoing_ssl_fd(void* sslctx, int fd);
 371
 372 /**
 373  * Initialize openssl locking for thread safety
 374  * @return false on failure (alloc failure).
 375  */
 376 int ub_openssl_lock_init(void);
 377
 378 /**
 379  * De-init the allocated openssl locks
 380  */
 381 void ub_openssl_lock_delete(void);
 382
 383 #endif /* NET_HELP_H */