1b7579f77SDag-Erling Smørgrav /* 2b7579f77SDag-Erling Smørgrav * util/net_help.c - implementation of the network helper code 3b7579f77SDag-Erling Smørgrav * 4b7579f77SDag-Erling Smørgrav * Copyright (c) 2007, NLnet Labs. All rights reserved. 5b7579f77SDag-Erling Smørgrav * 6b7579f77SDag-Erling Smørgrav * This software is open source. 7b7579f77SDag-Erling Smørgrav * 8b7579f77SDag-Erling Smørgrav * Redistribution and use in source and binary forms, with or without 9b7579f77SDag-Erling Smørgrav * modification, are permitted provided that the following conditions 10b7579f77SDag-Erling Smørgrav * are met: 11b7579f77SDag-Erling Smørgrav * 12b7579f77SDag-Erling Smørgrav * Redistributions of source code must retain the above copyright notice, 13b7579f77SDag-Erling Smørgrav * this list of conditions and the following disclaimer. 14b7579f77SDag-Erling Smørgrav * 15b7579f77SDag-Erling Smørgrav * Redistributions in binary form must reproduce the above copyright notice, 16b7579f77SDag-Erling Smørgrav * this list of conditions and the following disclaimer in the documentation 17b7579f77SDag-Erling Smørgrav * and/or other materials provided with the distribution. 18b7579f77SDag-Erling Smørgrav * 19b7579f77SDag-Erling Smørgrav * Neither the name of the NLNET LABS nor the names of its contributors may 20b7579f77SDag-Erling Smørgrav * be used to endorse or promote products derived from this software without 21b7579f77SDag-Erling Smørgrav * specific prior written permission. 22b7579f77SDag-Erling Smørgrav * 23b7579f77SDag-Erling Smørgrav * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 2417d15b25SDag-Erling Smørgrav * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 2517d15b25SDag-Erling Smørgrav * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 2617d15b25SDag-Erling Smørgrav * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 2717d15b25SDag-Erling Smørgrav * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 2817d15b25SDag-Erling Smørgrav * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED 2917d15b25SDag-Erling Smørgrav * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 3017d15b25SDag-Erling Smørgrav * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 3117d15b25SDag-Erling Smørgrav * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 3217d15b25SDag-Erling Smørgrav * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 3317d15b25SDag-Erling Smørgrav * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 34b7579f77SDag-Erling Smørgrav */ 35b7579f77SDag-Erling Smørgrav /** 36b7579f77SDag-Erling Smørgrav * \file 37b7579f77SDag-Erling Smørgrav * Implementation of net_help.h. 38b7579f77SDag-Erling Smørgrav */ 39b7579f77SDag-Erling Smørgrav 40b7579f77SDag-Erling Smørgrav #include "config.h" 41b7579f77SDag-Erling Smørgrav #include "util/net_help.h" 42b7579f77SDag-Erling Smørgrav #include "util/log.h" 43b7579f77SDag-Erling Smørgrav #include "util/data/dname.h" 44b7579f77SDag-Erling Smørgrav #include "util/module.h" 45b7579f77SDag-Erling Smørgrav #include "util/regional.h" 4609a3aaf3SDag-Erling Smørgrav #include "sldns/parseutil.h" 4709a3aaf3SDag-Erling Smørgrav #include "sldns/wire2str.h" 48b7579f77SDag-Erling Smørgrav #include <fcntl.h> 498ed2b524SDag-Erling Smørgrav #ifdef HAVE_OPENSSL_SSL_H 50b7579f77SDag-Erling Smørgrav #include <openssl/ssl.h> 518ed2b524SDag-Erling Smørgrav #endif 528ed2b524SDag-Erling Smørgrav #ifdef HAVE_OPENSSL_ERR_H 53b7579f77SDag-Erling Smørgrav #include <openssl/err.h> 548ed2b524SDag-Erling Smørgrav #endif 55b7579f77SDag-Erling Smørgrav 56b7579f77SDag-Erling Smørgrav /** max length of an IP address (the address portion) that we allow */ 57b7579f77SDag-Erling Smørgrav #define MAX_ADDR_STRLEN 128 /* characters */ 58b7579f77SDag-Erling Smørgrav /** default value for EDNS ADVERTISED size */ 59b7579f77SDag-Erling Smørgrav uint16_t EDNS_ADVERTISED_SIZE = 4096; 60b7579f77SDag-Erling Smørgrav 61b7579f77SDag-Erling Smørgrav /** minimal responses when positive answer: default is no */ 62b7579f77SDag-Erling Smørgrav int MINIMAL_RESPONSES = 0; 63b7579f77SDag-Erling Smørgrav 64b7579f77SDag-Erling Smørgrav /** rrset order roundrobin: default is no */ 65b7579f77SDag-Erling Smørgrav int RRSET_ROUNDROBIN = 0; 66b7579f77SDag-Erling Smørgrav 67b7579f77SDag-Erling Smørgrav /* returns true is string addr is an ip6 specced address */ 68b7579f77SDag-Erling Smørgrav int 69b7579f77SDag-Erling Smørgrav str_is_ip6(const char* str) 70b7579f77SDag-Erling Smørgrav { 71b7579f77SDag-Erling Smørgrav if(strchr(str, ':')) 72b7579f77SDag-Erling Smørgrav return 1; 73b7579f77SDag-Erling Smørgrav else return 0; 74b7579f77SDag-Erling Smørgrav } 75b7579f77SDag-Erling Smørgrav 76b7579f77SDag-Erling Smørgrav int 77b7579f77SDag-Erling Smørgrav fd_set_nonblock(int s) 78b7579f77SDag-Erling Smørgrav { 79b7579f77SDag-Erling Smørgrav #ifdef HAVE_FCNTL 80b7579f77SDag-Erling Smørgrav int flag; 81b7579f77SDag-Erling Smørgrav if((flag = fcntl(s, F_GETFL)) == -1) { 82b7579f77SDag-Erling Smørgrav log_err("can't fcntl F_GETFL: %s", strerror(errno)); 83b7579f77SDag-Erling Smørgrav flag = 0; 84b7579f77SDag-Erling Smørgrav } 85b7579f77SDag-Erling Smørgrav flag |= O_NONBLOCK; 86b7579f77SDag-Erling Smørgrav if(fcntl(s, F_SETFL, flag) == -1) { 87b7579f77SDag-Erling Smørgrav log_err("can't fcntl F_SETFL: %s", strerror(errno)); 88b7579f77SDag-Erling Smørgrav return 0; 89b7579f77SDag-Erling Smørgrav } 90b7579f77SDag-Erling Smørgrav #elif defined(HAVE_IOCTLSOCKET) 91b7579f77SDag-Erling Smørgrav unsigned long on = 1; 92b7579f77SDag-Erling Smørgrav if(ioctlsocket(s, FIONBIO, &on) != 0) { 93b7579f77SDag-Erling Smørgrav log_err("can't ioctlsocket FIONBIO on: %s", 94b7579f77SDag-Erling Smørgrav wsa_strerror(WSAGetLastError())); 95b7579f77SDag-Erling Smørgrav } 96b7579f77SDag-Erling Smørgrav #endif 97b7579f77SDag-Erling Smørgrav return 1; 98b7579f77SDag-Erling Smørgrav } 99b7579f77SDag-Erling Smørgrav 100b7579f77SDag-Erling Smørgrav int 101b7579f77SDag-Erling Smørgrav fd_set_block(int s) 102b7579f77SDag-Erling Smørgrav { 103b7579f77SDag-Erling Smørgrav #ifdef HAVE_FCNTL 104b7579f77SDag-Erling Smørgrav int flag; 105b7579f77SDag-Erling Smørgrav if((flag = fcntl(s, F_GETFL)) == -1) { 106b7579f77SDag-Erling Smørgrav log_err("cannot fcntl F_GETFL: %s", strerror(errno)); 107b7579f77SDag-Erling Smørgrav flag = 0; 108b7579f77SDag-Erling Smørgrav } 109b7579f77SDag-Erling Smørgrav flag &= ~O_NONBLOCK; 110b7579f77SDag-Erling Smørgrav if(fcntl(s, F_SETFL, flag) == -1) { 111b7579f77SDag-Erling Smørgrav log_err("cannot fcntl F_SETFL: %s", strerror(errno)); 112b7579f77SDag-Erling Smørgrav return 0; 113b7579f77SDag-Erling Smørgrav } 114b7579f77SDag-Erling Smørgrav #elif defined(HAVE_IOCTLSOCKET) 115b7579f77SDag-Erling Smørgrav unsigned long off = 0; 116b7579f77SDag-Erling Smørgrav if(ioctlsocket(s, FIONBIO, &off) != 0) { 117971980c3SDag-Erling Smørgrav if(WSAGetLastError() != WSAEINVAL || verbosity >= 4) 118b7579f77SDag-Erling Smørgrav log_err("can't ioctlsocket FIONBIO off: %s", 119b7579f77SDag-Erling Smørgrav wsa_strerror(WSAGetLastError())); 120b7579f77SDag-Erling Smørgrav } 121b7579f77SDag-Erling Smørgrav #endif 122b7579f77SDag-Erling Smørgrav return 1; 123b7579f77SDag-Erling Smørgrav } 124b7579f77SDag-Erling Smørgrav 125b7579f77SDag-Erling Smørgrav int 126b7579f77SDag-Erling Smørgrav is_pow2(size_t num) 127b7579f77SDag-Erling Smørgrav { 128b7579f77SDag-Erling Smørgrav if(num == 0) return 1; 129b7579f77SDag-Erling Smørgrav return (num & (num-1)) == 0; 130b7579f77SDag-Erling Smørgrav } 131b7579f77SDag-Erling Smørgrav 132b7579f77SDag-Erling Smørgrav void* 133b7579f77SDag-Erling Smørgrav memdup(void* data, size_t len) 134b7579f77SDag-Erling Smørgrav { 135b7579f77SDag-Erling Smørgrav void* d; 136b7579f77SDag-Erling Smørgrav if(!data) return NULL; 137b7579f77SDag-Erling Smørgrav if(len == 0) return NULL; 138b7579f77SDag-Erling Smørgrav d = malloc(len); 139b7579f77SDag-Erling Smørgrav if(!d) return NULL; 140b7579f77SDag-Erling Smørgrav memcpy(d, data, len); 141b7579f77SDag-Erling Smørgrav return d; 142b7579f77SDag-Erling Smørgrav } 143b7579f77SDag-Erling Smørgrav 144b7579f77SDag-Erling Smørgrav void 145b7579f77SDag-Erling Smørgrav log_addr(enum verbosity_value v, const char* str, 146b7579f77SDag-Erling Smørgrav struct sockaddr_storage* addr, socklen_t addrlen) 147b7579f77SDag-Erling Smørgrav { 148b7579f77SDag-Erling Smørgrav uint16_t port; 149b7579f77SDag-Erling Smørgrav const char* family = "unknown"; 150b7579f77SDag-Erling Smørgrav char dest[100]; 151b7579f77SDag-Erling Smørgrav int af = (int)((struct sockaddr_in*)addr)->sin_family; 152b7579f77SDag-Erling Smørgrav void* sinaddr = &((struct sockaddr_in*)addr)->sin_addr; 153b7579f77SDag-Erling Smørgrav if(verbosity < v) 154b7579f77SDag-Erling Smørgrav return; 155b7579f77SDag-Erling Smørgrav switch(af) { 156b7579f77SDag-Erling Smørgrav case AF_INET: family="ip4"; break; 157b7579f77SDag-Erling Smørgrav case AF_INET6: family="ip6"; 158b7579f77SDag-Erling Smørgrav sinaddr = &((struct sockaddr_in6*)addr)->sin6_addr; 159b7579f77SDag-Erling Smørgrav break; 1606480faa8SDag-Erling Smørgrav case AF_LOCAL: 1616480faa8SDag-Erling Smørgrav dest[0]=0; 1626480faa8SDag-Erling Smørgrav (void)inet_ntop(af, sinaddr, dest, 1636480faa8SDag-Erling Smørgrav (socklen_t)sizeof(dest)); 1646480faa8SDag-Erling Smørgrav verbose(v, "%s local %s", str, dest); 1656480faa8SDag-Erling Smørgrav return; /* do not continue and try to get port */ 166b7579f77SDag-Erling Smørgrav default: break; 167b7579f77SDag-Erling Smørgrav } 168b7579f77SDag-Erling Smørgrav if(inet_ntop(af, sinaddr, dest, (socklen_t)sizeof(dest)) == 0) { 16917d15b25SDag-Erling Smørgrav (void)strlcpy(dest, "(inet_ntop error)", sizeof(dest)); 170b7579f77SDag-Erling Smørgrav } 171b7579f77SDag-Erling Smørgrav dest[sizeof(dest)-1] = 0; 172b7579f77SDag-Erling Smørgrav port = ntohs(((struct sockaddr_in*)addr)->sin_port); 173b7579f77SDag-Erling Smørgrav if(verbosity >= 4) 174b7579f77SDag-Erling Smørgrav verbose(v, "%s %s %s port %d (len %d)", str, family, dest, 175b7579f77SDag-Erling Smørgrav (int)port, (int)addrlen); 176b7579f77SDag-Erling Smørgrav else verbose(v, "%s %s port %d", str, dest, (int)port); 177b7579f77SDag-Erling Smørgrav } 178b7579f77SDag-Erling Smørgrav 179b7579f77SDag-Erling Smørgrav int 180b7579f77SDag-Erling Smørgrav extstrtoaddr(const char* str, struct sockaddr_storage* addr, 181b7579f77SDag-Erling Smørgrav socklen_t* addrlen) 182b7579f77SDag-Erling Smørgrav { 183b7579f77SDag-Erling Smørgrav char* s; 184b7579f77SDag-Erling Smørgrav int port = UNBOUND_DNS_PORT; 185b7579f77SDag-Erling Smørgrav if((s=strchr(str, '@'))) { 186b7579f77SDag-Erling Smørgrav char buf[MAX_ADDR_STRLEN]; 187b7579f77SDag-Erling Smørgrav if(s-str >= MAX_ADDR_STRLEN) { 188b7579f77SDag-Erling Smørgrav return 0; 189b7579f77SDag-Erling Smørgrav } 19017d15b25SDag-Erling Smørgrav (void)strlcpy(buf, str, sizeof(buf)); 191b7579f77SDag-Erling Smørgrav buf[s-str] = 0; 192b7579f77SDag-Erling Smørgrav port = atoi(s+1); 193b7579f77SDag-Erling Smørgrav if(port == 0 && strcmp(s+1,"0")!=0) { 194b7579f77SDag-Erling Smørgrav return 0; 195b7579f77SDag-Erling Smørgrav } 196b7579f77SDag-Erling Smørgrav return ipstrtoaddr(buf, port, addr, addrlen); 197b7579f77SDag-Erling Smørgrav } 198b7579f77SDag-Erling Smørgrav return ipstrtoaddr(str, port, addr, addrlen); 199b7579f77SDag-Erling Smørgrav } 200b7579f77SDag-Erling Smørgrav 201b7579f77SDag-Erling Smørgrav 202b7579f77SDag-Erling Smørgrav int 203b7579f77SDag-Erling Smørgrav ipstrtoaddr(const char* ip, int port, struct sockaddr_storage* addr, 204b7579f77SDag-Erling Smørgrav socklen_t* addrlen) 205b7579f77SDag-Erling Smørgrav { 206b7579f77SDag-Erling Smørgrav uint16_t p; 207b7579f77SDag-Erling Smørgrav if(!ip) return 0; 208b7579f77SDag-Erling Smørgrav p = (uint16_t) port; 209b7579f77SDag-Erling Smørgrav if(str_is_ip6(ip)) { 210b7579f77SDag-Erling Smørgrav char buf[MAX_ADDR_STRLEN]; 211b7579f77SDag-Erling Smørgrav char* s; 212b7579f77SDag-Erling Smørgrav struct sockaddr_in6* sa = (struct sockaddr_in6*)addr; 213b7579f77SDag-Erling Smørgrav *addrlen = (socklen_t)sizeof(struct sockaddr_in6); 214b7579f77SDag-Erling Smørgrav memset(sa, 0, *addrlen); 215b7579f77SDag-Erling Smørgrav sa->sin6_family = AF_INET6; 216b7579f77SDag-Erling Smørgrav sa->sin6_port = (in_port_t)htons(p); 217b7579f77SDag-Erling Smørgrav if((s=strchr(ip, '%'))) { /* ip6%interface, rfc 4007 */ 218b7579f77SDag-Erling Smørgrav if(s-ip >= MAX_ADDR_STRLEN) 219b7579f77SDag-Erling Smørgrav return 0; 22017d15b25SDag-Erling Smørgrav (void)strlcpy(buf, ip, sizeof(buf)); 221b7579f77SDag-Erling Smørgrav buf[s-ip]=0; 222b7579f77SDag-Erling Smørgrav sa->sin6_scope_id = (uint32_t)atoi(s+1); 223b7579f77SDag-Erling Smørgrav ip = buf; 224b7579f77SDag-Erling Smørgrav } 225b7579f77SDag-Erling Smørgrav if(inet_pton((int)sa->sin6_family, ip, &sa->sin6_addr) <= 0) { 226b7579f77SDag-Erling Smørgrav return 0; 227b7579f77SDag-Erling Smørgrav } 228b7579f77SDag-Erling Smørgrav } else { /* ip4 */ 229b7579f77SDag-Erling Smørgrav struct sockaddr_in* sa = (struct sockaddr_in*)addr; 230b7579f77SDag-Erling Smørgrav *addrlen = (socklen_t)sizeof(struct sockaddr_in); 231b7579f77SDag-Erling Smørgrav memset(sa, 0, *addrlen); 232b7579f77SDag-Erling Smørgrav sa->sin_family = AF_INET; 233b7579f77SDag-Erling Smørgrav sa->sin_port = (in_port_t)htons(p); 234b7579f77SDag-Erling Smørgrav if(inet_pton((int)sa->sin_family, ip, &sa->sin_addr) <= 0) { 235b7579f77SDag-Erling Smørgrav return 0; 236b7579f77SDag-Erling Smørgrav } 237b7579f77SDag-Erling Smørgrav } 238b7579f77SDag-Erling Smørgrav return 1; 239b7579f77SDag-Erling Smørgrav } 240b7579f77SDag-Erling Smørgrav 241b7579f77SDag-Erling Smørgrav int netblockstrtoaddr(const char* str, int port, struct sockaddr_storage* addr, 242b7579f77SDag-Erling Smørgrav socklen_t* addrlen, int* net) 243b7579f77SDag-Erling Smørgrav { 244b7579f77SDag-Erling Smørgrav char* s = NULL; 245b7579f77SDag-Erling Smørgrav *net = (str_is_ip6(str)?128:32); 246b7579f77SDag-Erling Smørgrav if((s=strchr(str, '/'))) { 247b7579f77SDag-Erling Smørgrav if(atoi(s+1) > *net) { 248b7579f77SDag-Erling Smørgrav log_err("netblock too large: %s", str); 249b7579f77SDag-Erling Smørgrav return 0; 250b7579f77SDag-Erling Smørgrav } 251b7579f77SDag-Erling Smørgrav *net = atoi(s+1); 252b7579f77SDag-Erling Smørgrav if(*net == 0 && strcmp(s+1, "0") != 0) { 253b7579f77SDag-Erling Smørgrav log_err("cannot parse netblock: '%s'", str); 254b7579f77SDag-Erling Smørgrav return 0; 255b7579f77SDag-Erling Smørgrav } 256b7579f77SDag-Erling Smørgrav if(!(s = strdup(str))) { 257b7579f77SDag-Erling Smørgrav log_err("out of memory"); 258b7579f77SDag-Erling Smørgrav return 0; 259b7579f77SDag-Erling Smørgrav } 260b7579f77SDag-Erling Smørgrav *strchr(s, '/') = '\0'; 261b7579f77SDag-Erling Smørgrav } 262b7579f77SDag-Erling Smørgrav if(!ipstrtoaddr(s?s:str, port, addr, addrlen)) { 263b7579f77SDag-Erling Smørgrav free(s); 264b7579f77SDag-Erling Smørgrav log_err("cannot parse ip address: '%s'", str); 265b7579f77SDag-Erling Smørgrav return 0; 266b7579f77SDag-Erling Smørgrav } 267b7579f77SDag-Erling Smørgrav if(s) { 268b7579f77SDag-Erling Smørgrav free(s); 269b7579f77SDag-Erling Smørgrav addr_mask(addr, *addrlen, *net); 270b7579f77SDag-Erling Smørgrav } 271b7579f77SDag-Erling Smørgrav return 1; 272b7579f77SDag-Erling Smørgrav } 273b7579f77SDag-Erling Smørgrav 274*57bddd21SDag-Erling Smørgrav /** store port number into sockaddr structure */ 275*57bddd21SDag-Erling Smørgrav void 276*57bddd21SDag-Erling Smørgrav sockaddr_store_port(struct sockaddr_storage* addr, socklen_t addrlen, int port) 277*57bddd21SDag-Erling Smørgrav { 278*57bddd21SDag-Erling Smørgrav if(addr_is_ip6(addr, addrlen)) { 279*57bddd21SDag-Erling Smørgrav struct sockaddr_in6* sa = (struct sockaddr_in6*)addr; 280*57bddd21SDag-Erling Smørgrav sa->sin6_port = (in_port_t)htons((uint16_t)port); 281*57bddd21SDag-Erling Smørgrav } else { 282*57bddd21SDag-Erling Smørgrav struct sockaddr_in* sa = (struct sockaddr_in*)addr; 283*57bddd21SDag-Erling Smørgrav sa->sin_port = (in_port_t)htons((uint16_t)port); 284*57bddd21SDag-Erling Smørgrav } 285*57bddd21SDag-Erling Smørgrav } 286*57bddd21SDag-Erling Smørgrav 287b7579f77SDag-Erling Smørgrav void 288b7579f77SDag-Erling Smørgrav log_nametypeclass(enum verbosity_value v, const char* str, uint8_t* name, 289b7579f77SDag-Erling Smørgrav uint16_t type, uint16_t dclass) 290b7579f77SDag-Erling Smørgrav { 291b7579f77SDag-Erling Smørgrav char buf[LDNS_MAX_DOMAINLEN+1]; 292b7579f77SDag-Erling Smørgrav char t[12], c[12]; 293b7579f77SDag-Erling Smørgrav const char *ts, *cs; 294b7579f77SDag-Erling Smørgrav if(verbosity < v) 295b7579f77SDag-Erling Smørgrav return; 296b7579f77SDag-Erling Smørgrav dname_str(name, buf); 297b7579f77SDag-Erling Smørgrav if(type == LDNS_RR_TYPE_TSIG) ts = "TSIG"; 298b7579f77SDag-Erling Smørgrav else if(type == LDNS_RR_TYPE_IXFR) ts = "IXFR"; 299b7579f77SDag-Erling Smørgrav else if(type == LDNS_RR_TYPE_AXFR) ts = "AXFR"; 300b7579f77SDag-Erling Smørgrav else if(type == LDNS_RR_TYPE_MAILB) ts = "MAILB"; 301b7579f77SDag-Erling Smørgrav else if(type == LDNS_RR_TYPE_MAILA) ts = "MAILA"; 302b7579f77SDag-Erling Smørgrav else if(type == LDNS_RR_TYPE_ANY) ts = "ANY"; 30317d15b25SDag-Erling Smørgrav else if(sldns_rr_descript(type) && sldns_rr_descript(type)->_name) 30417d15b25SDag-Erling Smørgrav ts = sldns_rr_descript(type)->_name; 305b7579f77SDag-Erling Smørgrav else { 306b7579f77SDag-Erling Smørgrav snprintf(t, sizeof(t), "TYPE%d", (int)type); 307b7579f77SDag-Erling Smørgrav ts = t; 308b7579f77SDag-Erling Smørgrav } 30917d15b25SDag-Erling Smørgrav if(sldns_lookup_by_id(sldns_rr_classes, (int)dclass) && 31017d15b25SDag-Erling Smørgrav sldns_lookup_by_id(sldns_rr_classes, (int)dclass)->name) 31117d15b25SDag-Erling Smørgrav cs = sldns_lookup_by_id(sldns_rr_classes, (int)dclass)->name; 312b7579f77SDag-Erling Smørgrav else { 313b7579f77SDag-Erling Smørgrav snprintf(c, sizeof(c), "CLASS%d", (int)dclass); 314b7579f77SDag-Erling Smørgrav cs = c; 315b7579f77SDag-Erling Smørgrav } 316b7579f77SDag-Erling Smørgrav log_info("%s %s %s %s", str, buf, ts, cs); 317b7579f77SDag-Erling Smørgrav } 318b7579f77SDag-Erling Smørgrav 319b7579f77SDag-Erling Smørgrav void log_name_addr(enum verbosity_value v, const char* str, uint8_t* zone, 320b7579f77SDag-Erling Smørgrav struct sockaddr_storage* addr, socklen_t addrlen) 321b7579f77SDag-Erling Smørgrav { 322b7579f77SDag-Erling Smørgrav uint16_t port; 323b7579f77SDag-Erling Smørgrav const char* family = "unknown_family "; 324b7579f77SDag-Erling Smørgrav char namebuf[LDNS_MAX_DOMAINLEN+1]; 325b7579f77SDag-Erling Smørgrav char dest[100]; 326b7579f77SDag-Erling Smørgrav int af = (int)((struct sockaddr_in*)addr)->sin_family; 327b7579f77SDag-Erling Smørgrav void* sinaddr = &((struct sockaddr_in*)addr)->sin_addr; 328b7579f77SDag-Erling Smørgrav if(verbosity < v) 329b7579f77SDag-Erling Smørgrav return; 330b7579f77SDag-Erling Smørgrav switch(af) { 331b7579f77SDag-Erling Smørgrav case AF_INET: family=""; break; 332b7579f77SDag-Erling Smørgrav case AF_INET6: family=""; 333b7579f77SDag-Erling Smørgrav sinaddr = &((struct sockaddr_in6*)addr)->sin6_addr; 334b7579f77SDag-Erling Smørgrav break; 33531099b50SDag-Erling Smørgrav case AF_LOCAL: family="local "; break; 336b7579f77SDag-Erling Smørgrav default: break; 337b7579f77SDag-Erling Smørgrav } 338b7579f77SDag-Erling Smørgrav if(inet_ntop(af, sinaddr, dest, (socklen_t)sizeof(dest)) == 0) { 33917d15b25SDag-Erling Smørgrav (void)strlcpy(dest, "(inet_ntop error)", sizeof(dest)); 340b7579f77SDag-Erling Smørgrav } 341b7579f77SDag-Erling Smørgrav dest[sizeof(dest)-1] = 0; 342b7579f77SDag-Erling Smørgrav port = ntohs(((struct sockaddr_in*)addr)->sin_port); 343b7579f77SDag-Erling Smørgrav dname_str(zone, namebuf); 344b7579f77SDag-Erling Smørgrav if(af != AF_INET && af != AF_INET6) 345b7579f77SDag-Erling Smørgrav verbose(v, "%s <%s> %s%s#%d (addrlen %d)", 346b7579f77SDag-Erling Smørgrav str, namebuf, family, dest, (int)port, (int)addrlen); 347b7579f77SDag-Erling Smørgrav else verbose(v, "%s <%s> %s%s#%d", 348b7579f77SDag-Erling Smørgrav str, namebuf, family, dest, (int)port); 349b7579f77SDag-Erling Smørgrav } 350b7579f77SDag-Erling Smørgrav 351ff825849SDag-Erling Smørgrav void log_err_addr(const char* str, const char* err, 352ff825849SDag-Erling Smørgrav struct sockaddr_storage* addr, socklen_t addrlen) 353ff825849SDag-Erling Smørgrav { 354ff825849SDag-Erling Smørgrav uint16_t port; 355ff825849SDag-Erling Smørgrav char dest[100]; 356ff825849SDag-Erling Smørgrav int af = (int)((struct sockaddr_in*)addr)->sin_family; 357ff825849SDag-Erling Smørgrav void* sinaddr = &((struct sockaddr_in*)addr)->sin_addr; 358ff825849SDag-Erling Smørgrav if(af == AF_INET6) 359ff825849SDag-Erling Smørgrav sinaddr = &((struct sockaddr_in6*)addr)->sin6_addr; 360ff825849SDag-Erling Smørgrav if(inet_ntop(af, sinaddr, dest, (socklen_t)sizeof(dest)) == 0) { 361ff825849SDag-Erling Smørgrav (void)strlcpy(dest, "(inet_ntop error)", sizeof(dest)); 362ff825849SDag-Erling Smørgrav } 363ff825849SDag-Erling Smørgrav dest[sizeof(dest)-1] = 0; 364ff825849SDag-Erling Smørgrav port = ntohs(((struct sockaddr_in*)addr)->sin_port); 365ff825849SDag-Erling Smørgrav if(verbosity >= 4) 366ff825849SDag-Erling Smørgrav log_err("%s: %s for %s port %d (len %d)", str, err, dest, 367ff825849SDag-Erling Smørgrav (int)port, (int)addrlen); 368ff825849SDag-Erling Smørgrav else log_err("%s: %s for %s", str, err, dest); 369ff825849SDag-Erling Smørgrav } 370ff825849SDag-Erling Smørgrav 371b7579f77SDag-Erling Smørgrav int 372b7579f77SDag-Erling Smørgrav sockaddr_cmp(struct sockaddr_storage* addr1, socklen_t len1, 373b7579f77SDag-Erling Smørgrav struct sockaddr_storage* addr2, socklen_t len2) 374b7579f77SDag-Erling Smørgrav { 375b7579f77SDag-Erling Smørgrav struct sockaddr_in* p1_in = (struct sockaddr_in*)addr1; 376b7579f77SDag-Erling Smørgrav struct sockaddr_in* p2_in = (struct sockaddr_in*)addr2; 377b7579f77SDag-Erling Smørgrav struct sockaddr_in6* p1_in6 = (struct sockaddr_in6*)addr1; 378b7579f77SDag-Erling Smørgrav struct sockaddr_in6* p2_in6 = (struct sockaddr_in6*)addr2; 379b7579f77SDag-Erling Smørgrav if(len1 < len2) 380b7579f77SDag-Erling Smørgrav return -1; 381b7579f77SDag-Erling Smørgrav if(len1 > len2) 382b7579f77SDag-Erling Smørgrav return 1; 383b7579f77SDag-Erling Smørgrav log_assert(len1 == len2); 384b7579f77SDag-Erling Smørgrav if( p1_in->sin_family < p2_in->sin_family) 385b7579f77SDag-Erling Smørgrav return -1; 386b7579f77SDag-Erling Smørgrav if( p1_in->sin_family > p2_in->sin_family) 387b7579f77SDag-Erling Smørgrav return 1; 388b7579f77SDag-Erling Smørgrav log_assert( p1_in->sin_family == p2_in->sin_family ); 389b7579f77SDag-Erling Smørgrav /* compare ip4 */ 390b7579f77SDag-Erling Smørgrav if( p1_in->sin_family == AF_INET ) { 391b7579f77SDag-Erling Smørgrav /* just order it, ntohs not required */ 392b7579f77SDag-Erling Smørgrav if(p1_in->sin_port < p2_in->sin_port) 393b7579f77SDag-Erling Smørgrav return -1; 394b7579f77SDag-Erling Smørgrav if(p1_in->sin_port > p2_in->sin_port) 395b7579f77SDag-Erling Smørgrav return 1; 396b7579f77SDag-Erling Smørgrav log_assert(p1_in->sin_port == p2_in->sin_port); 397b7579f77SDag-Erling Smørgrav return memcmp(&p1_in->sin_addr, &p2_in->sin_addr, INET_SIZE); 398b7579f77SDag-Erling Smørgrav } else if (p1_in6->sin6_family == AF_INET6) { 399b7579f77SDag-Erling Smørgrav /* just order it, ntohs not required */ 400b7579f77SDag-Erling Smørgrav if(p1_in6->sin6_port < p2_in6->sin6_port) 401b7579f77SDag-Erling Smørgrav return -1; 402b7579f77SDag-Erling Smørgrav if(p1_in6->sin6_port > p2_in6->sin6_port) 403b7579f77SDag-Erling Smørgrav return 1; 404b7579f77SDag-Erling Smørgrav log_assert(p1_in6->sin6_port == p2_in6->sin6_port); 405b7579f77SDag-Erling Smørgrav return memcmp(&p1_in6->sin6_addr, &p2_in6->sin6_addr, 406b7579f77SDag-Erling Smørgrav INET6_SIZE); 407b7579f77SDag-Erling Smørgrav } else { 408b7579f77SDag-Erling Smørgrav /* eek unknown type, perform this comparison for sanity. */ 409b7579f77SDag-Erling Smørgrav return memcmp(addr1, addr2, len1); 410b7579f77SDag-Erling Smørgrav } 411b7579f77SDag-Erling Smørgrav } 412b7579f77SDag-Erling Smørgrav 413b7579f77SDag-Erling Smørgrav int 414b7579f77SDag-Erling Smørgrav sockaddr_cmp_addr(struct sockaddr_storage* addr1, socklen_t len1, 415b7579f77SDag-Erling Smørgrav struct sockaddr_storage* addr2, socklen_t len2) 416b7579f77SDag-Erling Smørgrav { 417b7579f77SDag-Erling Smørgrav struct sockaddr_in* p1_in = (struct sockaddr_in*)addr1; 418b7579f77SDag-Erling Smørgrav struct sockaddr_in* p2_in = (struct sockaddr_in*)addr2; 419b7579f77SDag-Erling Smørgrav struct sockaddr_in6* p1_in6 = (struct sockaddr_in6*)addr1; 420b7579f77SDag-Erling Smørgrav struct sockaddr_in6* p2_in6 = (struct sockaddr_in6*)addr2; 421b7579f77SDag-Erling Smørgrav if(len1 < len2) 422b7579f77SDag-Erling Smørgrav return -1; 423b7579f77SDag-Erling Smørgrav if(len1 > len2) 424b7579f77SDag-Erling Smørgrav return 1; 425b7579f77SDag-Erling Smørgrav log_assert(len1 == len2); 426b7579f77SDag-Erling Smørgrav if( p1_in->sin_family < p2_in->sin_family) 427b7579f77SDag-Erling Smørgrav return -1; 428b7579f77SDag-Erling Smørgrav if( p1_in->sin_family > p2_in->sin_family) 429b7579f77SDag-Erling Smørgrav return 1; 430b7579f77SDag-Erling Smørgrav log_assert( p1_in->sin_family == p2_in->sin_family ); 431b7579f77SDag-Erling Smørgrav /* compare ip4 */ 432b7579f77SDag-Erling Smørgrav if( p1_in->sin_family == AF_INET ) { 433b7579f77SDag-Erling Smørgrav return memcmp(&p1_in->sin_addr, &p2_in->sin_addr, INET_SIZE); 434b7579f77SDag-Erling Smørgrav } else if (p1_in6->sin6_family == AF_INET6) { 435b7579f77SDag-Erling Smørgrav return memcmp(&p1_in6->sin6_addr, &p2_in6->sin6_addr, 436b7579f77SDag-Erling Smørgrav INET6_SIZE); 437b7579f77SDag-Erling Smørgrav } else { 438b7579f77SDag-Erling Smørgrav /* eek unknown type, perform this comparison for sanity. */ 439b7579f77SDag-Erling Smørgrav return memcmp(addr1, addr2, len1); 440b7579f77SDag-Erling Smørgrav } 441b7579f77SDag-Erling Smørgrav } 442b7579f77SDag-Erling Smørgrav 443b7579f77SDag-Erling Smørgrav int 444b7579f77SDag-Erling Smørgrav addr_is_ip6(struct sockaddr_storage* addr, socklen_t len) 445b7579f77SDag-Erling Smørgrav { 446b7579f77SDag-Erling Smørgrav if(len == (socklen_t)sizeof(struct sockaddr_in6) && 447b7579f77SDag-Erling Smørgrav ((struct sockaddr_in6*)addr)->sin6_family == AF_INET6) 448b7579f77SDag-Erling Smørgrav return 1; 449b7579f77SDag-Erling Smørgrav else return 0; 450b7579f77SDag-Erling Smørgrav } 451b7579f77SDag-Erling Smørgrav 452b7579f77SDag-Erling Smørgrav void 453b7579f77SDag-Erling Smørgrav addr_mask(struct sockaddr_storage* addr, socklen_t len, int net) 454b7579f77SDag-Erling Smørgrav { 455b7579f77SDag-Erling Smørgrav uint8_t mask[8] = {0x0, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe}; 456b7579f77SDag-Erling Smørgrav int i, max; 457b7579f77SDag-Erling Smørgrav uint8_t* s; 458b7579f77SDag-Erling Smørgrav if(addr_is_ip6(addr, len)) { 459b7579f77SDag-Erling Smørgrav s = (uint8_t*)&((struct sockaddr_in6*)addr)->sin6_addr; 460b7579f77SDag-Erling Smørgrav max = 128; 461b7579f77SDag-Erling Smørgrav } else { 462b7579f77SDag-Erling Smørgrav s = (uint8_t*)&((struct sockaddr_in*)addr)->sin_addr; 463b7579f77SDag-Erling Smørgrav max = 32; 464b7579f77SDag-Erling Smørgrav } 465b7579f77SDag-Erling Smørgrav if(net >= max) 466b7579f77SDag-Erling Smørgrav return; 467b7579f77SDag-Erling Smørgrav for(i=net/8+1; i<max/8; i++) { 468b7579f77SDag-Erling Smørgrav s[i] = 0; 469b7579f77SDag-Erling Smørgrav } 470b7579f77SDag-Erling Smørgrav s[net/8] &= mask[net&0x7]; 471b7579f77SDag-Erling Smørgrav } 472b7579f77SDag-Erling Smørgrav 473b7579f77SDag-Erling Smørgrav int 474b7579f77SDag-Erling Smørgrav addr_in_common(struct sockaddr_storage* addr1, int net1, 475b7579f77SDag-Erling Smørgrav struct sockaddr_storage* addr2, int net2, socklen_t addrlen) 476b7579f77SDag-Erling Smørgrav { 477b7579f77SDag-Erling Smørgrav int min = (net1<net2)?net1:net2; 478b7579f77SDag-Erling Smørgrav int i, to; 479b7579f77SDag-Erling Smørgrav int match = 0; 480b7579f77SDag-Erling Smørgrav uint8_t* s1, *s2; 481b7579f77SDag-Erling Smørgrav if(addr_is_ip6(addr1, addrlen)) { 482b7579f77SDag-Erling Smørgrav s1 = (uint8_t*)&((struct sockaddr_in6*)addr1)->sin6_addr; 483b7579f77SDag-Erling Smørgrav s2 = (uint8_t*)&((struct sockaddr_in6*)addr2)->sin6_addr; 484b7579f77SDag-Erling Smørgrav to = 16; 485b7579f77SDag-Erling Smørgrav } else { 486b7579f77SDag-Erling Smørgrav s1 = (uint8_t*)&((struct sockaddr_in*)addr1)->sin_addr; 487b7579f77SDag-Erling Smørgrav s2 = (uint8_t*)&((struct sockaddr_in*)addr2)->sin_addr; 488b7579f77SDag-Erling Smørgrav to = 4; 489b7579f77SDag-Erling Smørgrav } 490b7579f77SDag-Erling Smørgrav /* match = bits_in_common(s1, s2, to); */ 491b7579f77SDag-Erling Smørgrav for(i=0; i<to; i++) { 492b7579f77SDag-Erling Smørgrav if(s1[i] == s2[i]) { 493b7579f77SDag-Erling Smørgrav match += 8; 494b7579f77SDag-Erling Smørgrav } else { 495b7579f77SDag-Erling Smørgrav uint8_t z = s1[i]^s2[i]; 496b7579f77SDag-Erling Smørgrav log_assert(z); 497b7579f77SDag-Erling Smørgrav while(!(z&0x80)) { 498b7579f77SDag-Erling Smørgrav match++; 499b7579f77SDag-Erling Smørgrav z<<=1; 500b7579f77SDag-Erling Smørgrav } 501b7579f77SDag-Erling Smørgrav break; 502b7579f77SDag-Erling Smørgrav } 503b7579f77SDag-Erling Smørgrav } 504b7579f77SDag-Erling Smørgrav if(match > min) match = min; 505b7579f77SDag-Erling Smørgrav return match; 506b7579f77SDag-Erling Smørgrav } 507b7579f77SDag-Erling Smørgrav 508b7579f77SDag-Erling Smørgrav void 509b7579f77SDag-Erling Smørgrav addr_to_str(struct sockaddr_storage* addr, socklen_t addrlen, 510b7579f77SDag-Erling Smørgrav char* buf, size_t len) 511b7579f77SDag-Erling Smørgrav { 512b7579f77SDag-Erling Smørgrav int af = (int)((struct sockaddr_in*)addr)->sin_family; 513b7579f77SDag-Erling Smørgrav void* sinaddr = &((struct sockaddr_in*)addr)->sin_addr; 514b7579f77SDag-Erling Smørgrav if(addr_is_ip6(addr, addrlen)) 515b7579f77SDag-Erling Smørgrav sinaddr = &((struct sockaddr_in6*)addr)->sin6_addr; 516b7579f77SDag-Erling Smørgrav if(inet_ntop(af, sinaddr, buf, (socklen_t)len) == 0) { 517b7579f77SDag-Erling Smørgrav snprintf(buf, len, "(inet_ntop_error)"); 518b7579f77SDag-Erling Smørgrav } 519b7579f77SDag-Erling Smørgrav } 520b7579f77SDag-Erling Smørgrav 521b7579f77SDag-Erling Smørgrav int 522b7579f77SDag-Erling Smørgrav addr_is_ip4mapped(struct sockaddr_storage* addr, socklen_t addrlen) 523b7579f77SDag-Erling Smørgrav { 524b7579f77SDag-Erling Smørgrav /* prefix for ipv4 into ipv6 mapping is ::ffff:x.x.x.x */ 525b7579f77SDag-Erling Smørgrav const uint8_t map_prefix[16] = 526b7579f77SDag-Erling Smørgrav {0,0,0,0, 0,0,0,0, 0,0,0xff,0xff, 0,0,0,0}; 527b7579f77SDag-Erling Smørgrav uint8_t* s; 528b7579f77SDag-Erling Smørgrav if(!addr_is_ip6(addr, addrlen)) 529b7579f77SDag-Erling Smørgrav return 0; 530b7579f77SDag-Erling Smørgrav /* s is 16 octet ipv6 address string */ 531b7579f77SDag-Erling Smørgrav s = (uint8_t*)&((struct sockaddr_in6*)addr)->sin6_addr; 532b7579f77SDag-Erling Smørgrav return (memcmp(s, map_prefix, 12) == 0); 533b7579f77SDag-Erling Smørgrav } 534b7579f77SDag-Erling Smørgrav 535b7579f77SDag-Erling Smørgrav int addr_is_broadcast(struct sockaddr_storage* addr, socklen_t addrlen) 536b7579f77SDag-Erling Smørgrav { 537b7579f77SDag-Erling Smørgrav int af = (int)((struct sockaddr_in*)addr)->sin_family; 538b7579f77SDag-Erling Smørgrav void* sinaddr = &((struct sockaddr_in*)addr)->sin_addr; 539b7579f77SDag-Erling Smørgrav return af == AF_INET && addrlen>=(socklen_t)sizeof(struct sockaddr_in) 540b7579f77SDag-Erling Smørgrav && memcmp(sinaddr, "\377\377\377\377", 4) == 0; 541b7579f77SDag-Erling Smørgrav } 542b7579f77SDag-Erling Smørgrav 543b7579f77SDag-Erling Smørgrav int addr_is_any(struct sockaddr_storage* addr, socklen_t addrlen) 544b7579f77SDag-Erling Smørgrav { 545b7579f77SDag-Erling Smørgrav int af = (int)((struct sockaddr_in*)addr)->sin_family; 546b7579f77SDag-Erling Smørgrav void* sinaddr = &((struct sockaddr_in*)addr)->sin_addr; 547b7579f77SDag-Erling Smørgrav void* sin6addr = &((struct sockaddr_in6*)addr)->sin6_addr; 548b7579f77SDag-Erling Smørgrav if(af == AF_INET && addrlen>=(socklen_t)sizeof(struct sockaddr_in) 549b7579f77SDag-Erling Smørgrav && memcmp(sinaddr, "\000\000\000\000", 4) == 0) 550b7579f77SDag-Erling Smørgrav return 1; 551b7579f77SDag-Erling Smørgrav else if(af==AF_INET6 && addrlen>=(socklen_t)sizeof(struct sockaddr_in6) 552b7579f77SDag-Erling Smørgrav && memcmp(sin6addr, "\000\000\000\000\000\000\000\000" 553b7579f77SDag-Erling Smørgrav "\000\000\000\000\000\000\000\000", 16) == 0) 554b7579f77SDag-Erling Smørgrav return 1; 555b7579f77SDag-Erling Smørgrav return 0; 556b7579f77SDag-Erling Smørgrav } 557b7579f77SDag-Erling Smørgrav 558b7579f77SDag-Erling Smørgrav void sock_list_insert(struct sock_list** list, struct sockaddr_storage* addr, 559b7579f77SDag-Erling Smørgrav socklen_t len, struct regional* region) 560b7579f77SDag-Erling Smørgrav { 561b7579f77SDag-Erling Smørgrav struct sock_list* add = (struct sock_list*)regional_alloc(region, 562b7579f77SDag-Erling Smørgrav sizeof(*add) - sizeof(add->addr) + (size_t)len); 563b7579f77SDag-Erling Smørgrav if(!add) { 564b7579f77SDag-Erling Smørgrav log_err("out of memory in socketlist insert"); 565b7579f77SDag-Erling Smørgrav return; 566b7579f77SDag-Erling Smørgrav } 567b7579f77SDag-Erling Smørgrav log_assert(list); 568b7579f77SDag-Erling Smørgrav add->next = *list; 569b7579f77SDag-Erling Smørgrav add->len = len; 570b7579f77SDag-Erling Smørgrav *list = add; 571b7579f77SDag-Erling Smørgrav if(len) memmove(&add->addr, addr, len); 572b7579f77SDag-Erling Smørgrav } 573b7579f77SDag-Erling Smørgrav 574b7579f77SDag-Erling Smørgrav void sock_list_prepend(struct sock_list** list, struct sock_list* add) 575b7579f77SDag-Erling Smørgrav { 576b7579f77SDag-Erling Smørgrav struct sock_list* last = add; 577b7579f77SDag-Erling Smørgrav if(!last) 578b7579f77SDag-Erling Smørgrav return; 579b7579f77SDag-Erling Smørgrav while(last->next) 580b7579f77SDag-Erling Smørgrav last = last->next; 581b7579f77SDag-Erling Smørgrav last->next = *list; 582b7579f77SDag-Erling Smørgrav *list = add; 583b7579f77SDag-Erling Smørgrav } 584b7579f77SDag-Erling Smørgrav 585b7579f77SDag-Erling Smørgrav int sock_list_find(struct sock_list* list, struct sockaddr_storage* addr, 586b7579f77SDag-Erling Smørgrav socklen_t len) 587b7579f77SDag-Erling Smørgrav { 588b7579f77SDag-Erling Smørgrav while(list) { 589b7579f77SDag-Erling Smørgrav if(len == list->len) { 590b7579f77SDag-Erling Smørgrav if(len == 0 || sockaddr_cmp_addr(addr, len, 591b7579f77SDag-Erling Smørgrav &list->addr, list->len) == 0) 592b7579f77SDag-Erling Smørgrav return 1; 593b7579f77SDag-Erling Smørgrav } 594b7579f77SDag-Erling Smørgrav list = list->next; 595b7579f77SDag-Erling Smørgrav } 596b7579f77SDag-Erling Smørgrav return 0; 597b7579f77SDag-Erling Smørgrav } 598b7579f77SDag-Erling Smørgrav 599b7579f77SDag-Erling Smørgrav void sock_list_merge(struct sock_list** list, struct regional* region, 600b7579f77SDag-Erling Smørgrav struct sock_list* add) 601b7579f77SDag-Erling Smørgrav { 602b7579f77SDag-Erling Smørgrav struct sock_list* p; 603b7579f77SDag-Erling Smørgrav for(p=add; p; p=p->next) { 604b7579f77SDag-Erling Smørgrav if(!sock_list_find(*list, &p->addr, p->len)) 605b7579f77SDag-Erling Smørgrav sock_list_insert(list, &p->addr, p->len, region); 606b7579f77SDag-Erling Smørgrav } 607b7579f77SDag-Erling Smørgrav } 608b7579f77SDag-Erling Smørgrav 609b7579f77SDag-Erling Smørgrav void 610b7579f77SDag-Erling Smørgrav log_crypto_err(const char* str) 611b7579f77SDag-Erling Smørgrav { 6128ed2b524SDag-Erling Smørgrav #ifdef HAVE_SSL 613b7579f77SDag-Erling Smørgrav /* error:[error code]:[library name]:[function name]:[reason string] */ 614b7579f77SDag-Erling Smørgrav char buf[128]; 615b7579f77SDag-Erling Smørgrav unsigned long e; 616b7579f77SDag-Erling Smørgrav ERR_error_string_n(ERR_get_error(), buf, sizeof(buf)); 617b7579f77SDag-Erling Smørgrav log_err("%s crypto %s", str, buf); 618b7579f77SDag-Erling Smørgrav while( (e=ERR_get_error()) ) { 619b7579f77SDag-Erling Smørgrav ERR_error_string_n(e, buf, sizeof(buf)); 620b7579f77SDag-Erling Smørgrav log_err("and additionally crypto %s", buf); 621b7579f77SDag-Erling Smørgrav } 6228ed2b524SDag-Erling Smørgrav #else 6238ed2b524SDag-Erling Smørgrav (void)str; 6248ed2b524SDag-Erling Smørgrav #endif /* HAVE_SSL */ 625b7579f77SDag-Erling Smørgrav } 626b7579f77SDag-Erling Smørgrav 627971980c3SDag-Erling Smørgrav int 628971980c3SDag-Erling Smørgrav listen_sslctx_setup(void* ctxt) 629971980c3SDag-Erling Smørgrav { 630971980c3SDag-Erling Smørgrav #ifdef HAVE_SSL 631971980c3SDag-Erling Smørgrav SSL_CTX* ctx = (SSL_CTX*)ctxt; 632971980c3SDag-Erling Smørgrav /* no SSLv2, SSLv3 because has defects */ 633971980c3SDag-Erling Smørgrav if((SSL_CTX_set_options(ctx, SSL_OP_NO_SSLv2) & SSL_OP_NO_SSLv2) 634971980c3SDag-Erling Smørgrav != SSL_OP_NO_SSLv2){ 635971980c3SDag-Erling Smørgrav log_crypto_err("could not set SSL_OP_NO_SSLv2"); 636971980c3SDag-Erling Smørgrav return 0; 637971980c3SDag-Erling Smørgrav } 638971980c3SDag-Erling Smørgrav if((SSL_CTX_set_options(ctx, SSL_OP_NO_SSLv3) & SSL_OP_NO_SSLv3) 639971980c3SDag-Erling Smørgrav != SSL_OP_NO_SSLv3){ 640971980c3SDag-Erling Smørgrav log_crypto_err("could not set SSL_OP_NO_SSLv3"); 641971980c3SDag-Erling Smørgrav return 0; 642971980c3SDag-Erling Smørgrav } 643971980c3SDag-Erling Smørgrav #if defined(SSL_OP_NO_TLSv1) && defined(SSL_OP_NO_TLSv1_1) 644971980c3SDag-Erling Smørgrav /* if we have tls 1.1 disable 1.0 */ 645971980c3SDag-Erling Smørgrav if((SSL_CTX_set_options(ctx, SSL_OP_NO_TLSv1) & SSL_OP_NO_TLSv1) 646971980c3SDag-Erling Smørgrav != SSL_OP_NO_TLSv1){ 647971980c3SDag-Erling Smørgrav log_crypto_err("could not set SSL_OP_NO_TLSv1"); 648971980c3SDag-Erling Smørgrav return 0; 649971980c3SDag-Erling Smørgrav } 650971980c3SDag-Erling Smørgrav #endif 651971980c3SDag-Erling Smørgrav #if defined(SSL_OP_NO_TLSv1_1) && defined(SSL_OP_NO_TLSv1_2) 652971980c3SDag-Erling Smørgrav /* if we have tls 1.2 disable 1.1 */ 653971980c3SDag-Erling Smørgrav if((SSL_CTX_set_options(ctx, SSL_OP_NO_TLSv1_1) & SSL_OP_NO_TLSv1_1) 654971980c3SDag-Erling Smørgrav != SSL_OP_NO_TLSv1_1){ 655971980c3SDag-Erling Smørgrav log_crypto_err("could not set SSL_OP_NO_TLSv1_1"); 656971980c3SDag-Erling Smørgrav return 0; 657971980c3SDag-Erling Smørgrav } 658971980c3SDag-Erling Smørgrav #endif 659971980c3SDag-Erling Smørgrav #if defined(SHA256_DIGEST_LENGTH) && defined(USE_ECDSA) 660971980c3SDag-Erling Smørgrav /* if we have sha256, set the cipher list to have no known vulns */ 661*57bddd21SDag-Erling Smørgrav if(!SSL_CTX_set_cipher_list(ctx, "TLS13-CHACHA20-POLY1305-SHA256:TLS13-AES-256-GCM-SHA384:TLS13-AES-128-GCM-SHA256:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256")) 662971980c3SDag-Erling Smørgrav log_crypto_err("could not set cipher list with SSL_CTX_set_cipher_list"); 663971980c3SDag-Erling Smørgrav #endif 664971980c3SDag-Erling Smørgrav 665971980c3SDag-Erling Smørgrav if((SSL_CTX_set_options(ctx, SSL_OP_CIPHER_SERVER_PREFERENCE) & 666971980c3SDag-Erling Smørgrav SSL_OP_CIPHER_SERVER_PREFERENCE) != 667971980c3SDag-Erling Smørgrav SSL_OP_CIPHER_SERVER_PREFERENCE) { 668971980c3SDag-Erling Smørgrav log_crypto_err("could not set SSL_OP_CIPHER_SERVER_PREFERENCE"); 669971980c3SDag-Erling Smørgrav return 0; 670971980c3SDag-Erling Smørgrav } 671971980c3SDag-Erling Smørgrav 672971980c3SDag-Erling Smørgrav #ifdef HAVE_SSL_CTX_SET_SECURITY_LEVEL 673971980c3SDag-Erling Smørgrav SSL_CTX_set_security_level(ctx, 0); 674971980c3SDag-Erling Smørgrav #endif 675971980c3SDag-Erling Smørgrav #else 676971980c3SDag-Erling Smørgrav (void)ctxt; 677971980c3SDag-Erling Smørgrav #endif /* HAVE_SSL */ 678971980c3SDag-Erling Smørgrav return 1; 679971980c3SDag-Erling Smørgrav } 680971980c3SDag-Erling Smørgrav 681971980c3SDag-Erling Smørgrav void 682971980c3SDag-Erling Smørgrav listen_sslctx_setup_2(void* ctxt) 683971980c3SDag-Erling Smørgrav { 684971980c3SDag-Erling Smørgrav #ifdef HAVE_SSL 685971980c3SDag-Erling Smørgrav SSL_CTX* ctx = (SSL_CTX*)ctxt; 686971980c3SDag-Erling Smørgrav (void)ctx; 687971980c3SDag-Erling Smørgrav #if HAVE_DECL_SSL_CTX_SET_ECDH_AUTO 688971980c3SDag-Erling Smørgrav if(!SSL_CTX_set_ecdh_auto(ctx,1)) { 689971980c3SDag-Erling Smørgrav log_crypto_err("Error in SSL_CTX_ecdh_auto, not enabling ECDHE"); 690971980c3SDag-Erling Smørgrav } 691971980c3SDag-Erling Smørgrav #elif defined(USE_ECDSA) 692971980c3SDag-Erling Smørgrav if(1) { 693971980c3SDag-Erling Smørgrav EC_KEY *ecdh = EC_KEY_new_by_curve_name (NID_X9_62_prime256v1); 694971980c3SDag-Erling Smørgrav if (!ecdh) { 695971980c3SDag-Erling Smørgrav log_crypto_err("could not find p256, not enabling ECDHE"); 696971980c3SDag-Erling Smørgrav } else { 697971980c3SDag-Erling Smørgrav if (1 != SSL_CTX_set_tmp_ecdh (ctx, ecdh)) { 698971980c3SDag-Erling Smørgrav log_crypto_err("Error in SSL_CTX_set_tmp_ecdh, not enabling ECDHE"); 699971980c3SDag-Erling Smørgrav } 700971980c3SDag-Erling Smørgrav EC_KEY_free (ecdh); 701971980c3SDag-Erling Smørgrav } 702971980c3SDag-Erling Smørgrav } 703971980c3SDag-Erling Smørgrav #endif 704971980c3SDag-Erling Smørgrav #else 705971980c3SDag-Erling Smørgrav (void)ctxt; 706971980c3SDag-Erling Smørgrav #endif /* HAVE_SSL */ 707971980c3SDag-Erling Smørgrav } 708971980c3SDag-Erling Smørgrav 709b7579f77SDag-Erling Smørgrav void* listen_sslctx_create(char* key, char* pem, char* verifypem) 710b7579f77SDag-Erling Smørgrav { 7118ed2b524SDag-Erling Smørgrav #ifdef HAVE_SSL 712b7579f77SDag-Erling Smørgrav SSL_CTX* ctx = SSL_CTX_new(SSLv23_server_method()); 713b7579f77SDag-Erling Smørgrav if(!ctx) { 714b7579f77SDag-Erling Smørgrav log_crypto_err("could not SSL_CTX_new"); 715b7579f77SDag-Erling Smørgrav return NULL; 716b7579f77SDag-Erling Smørgrav } 717971980c3SDag-Erling Smørgrav if(!listen_sslctx_setup(ctx)) { 718ff825849SDag-Erling Smørgrav SSL_CTX_free(ctx); 719ff825849SDag-Erling Smørgrav return NULL; 720ff825849SDag-Erling Smørgrav } 721b75612f8SDag-Erling Smørgrav if(!SSL_CTX_use_certificate_chain_file(ctx, pem)) { 722b7579f77SDag-Erling Smørgrav log_err("error for cert file: %s", pem); 723b75612f8SDag-Erling Smørgrav log_crypto_err("error in SSL_CTX use_certificate_chain_file"); 724b7579f77SDag-Erling Smørgrav SSL_CTX_free(ctx); 725b7579f77SDag-Erling Smørgrav return NULL; 726b7579f77SDag-Erling Smørgrav } 727b7579f77SDag-Erling Smørgrav if(!SSL_CTX_use_PrivateKey_file(ctx, key, SSL_FILETYPE_PEM)) { 728b7579f77SDag-Erling Smørgrav log_err("error for private key file: %s", key); 729b7579f77SDag-Erling Smørgrav log_crypto_err("Error in SSL_CTX use_PrivateKey_file"); 730b7579f77SDag-Erling Smørgrav SSL_CTX_free(ctx); 731b7579f77SDag-Erling Smørgrav return NULL; 732b7579f77SDag-Erling Smørgrav } 733b7579f77SDag-Erling Smørgrav if(!SSL_CTX_check_private_key(ctx)) { 734b7579f77SDag-Erling Smørgrav log_err("error for key file: %s", key); 735b7579f77SDag-Erling Smørgrav log_crypto_err("Error in SSL_CTX check_private_key"); 736b7579f77SDag-Erling Smørgrav SSL_CTX_free(ctx); 737b7579f77SDag-Erling Smørgrav return NULL; 738b7579f77SDag-Erling Smørgrav } 739971980c3SDag-Erling Smørgrav listen_sslctx_setup_2(ctx); 740b7579f77SDag-Erling Smørgrav if(verifypem && verifypem[0]) { 741b7579f77SDag-Erling Smørgrav if(!SSL_CTX_load_verify_locations(ctx, verifypem, NULL)) { 742b7579f77SDag-Erling Smørgrav log_crypto_err("Error in SSL_CTX verify locations"); 743b7579f77SDag-Erling Smørgrav SSL_CTX_free(ctx); 744b7579f77SDag-Erling Smørgrav return NULL; 745b7579f77SDag-Erling Smørgrav } 746b7579f77SDag-Erling Smørgrav SSL_CTX_set_client_CA_list(ctx, SSL_load_client_CA_file( 747b7579f77SDag-Erling Smørgrav verifypem)); 748b7579f77SDag-Erling Smørgrav SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, NULL); 749b7579f77SDag-Erling Smørgrav } 750b7579f77SDag-Erling Smørgrav return ctx; 7518ed2b524SDag-Erling Smørgrav #else 7528ed2b524SDag-Erling Smørgrav (void)key; (void)pem; (void)verifypem; 7538ed2b524SDag-Erling Smørgrav return NULL; 7548ed2b524SDag-Erling Smørgrav #endif 755b7579f77SDag-Erling Smørgrav } 756b7579f77SDag-Erling Smørgrav 757b7579f77SDag-Erling Smørgrav void* connect_sslctx_create(char* key, char* pem, char* verifypem) 758b7579f77SDag-Erling Smørgrav { 7598ed2b524SDag-Erling Smørgrav #ifdef HAVE_SSL 760b7579f77SDag-Erling Smørgrav SSL_CTX* ctx = SSL_CTX_new(SSLv23_client_method()); 761b7579f77SDag-Erling Smørgrav if(!ctx) { 762b7579f77SDag-Erling Smørgrav log_crypto_err("could not allocate SSL_CTX pointer"); 763b7579f77SDag-Erling Smørgrav return NULL; 764b7579f77SDag-Erling Smørgrav } 76505ab2901SDag-Erling Smørgrav if((SSL_CTX_set_options(ctx, SSL_OP_NO_SSLv2) & SSL_OP_NO_SSLv2) 76605ab2901SDag-Erling Smørgrav != SSL_OP_NO_SSLv2) { 767b7579f77SDag-Erling Smørgrav log_crypto_err("could not set SSL_OP_NO_SSLv2"); 768b7579f77SDag-Erling Smørgrav SSL_CTX_free(ctx); 769b7579f77SDag-Erling Smørgrav return NULL; 770b7579f77SDag-Erling Smørgrav } 77105ab2901SDag-Erling Smørgrav if((SSL_CTX_set_options(ctx, SSL_OP_NO_SSLv3) & SSL_OP_NO_SSLv3) 77205ab2901SDag-Erling Smørgrav != SSL_OP_NO_SSLv3) { 773ff825849SDag-Erling Smørgrav log_crypto_err("could not set SSL_OP_NO_SSLv3"); 774ff825849SDag-Erling Smørgrav SSL_CTX_free(ctx); 775ff825849SDag-Erling Smørgrav return NULL; 776ff825849SDag-Erling Smørgrav } 777b7579f77SDag-Erling Smørgrav if(key && key[0]) { 778b75612f8SDag-Erling Smørgrav if(!SSL_CTX_use_certificate_chain_file(ctx, pem)) { 779b7579f77SDag-Erling Smørgrav log_err("error in client certificate %s", pem); 780b7579f77SDag-Erling Smørgrav log_crypto_err("error in certificate file"); 781b7579f77SDag-Erling Smørgrav SSL_CTX_free(ctx); 782b7579f77SDag-Erling Smørgrav return NULL; 783b7579f77SDag-Erling Smørgrav } 784b7579f77SDag-Erling Smørgrav if(!SSL_CTX_use_PrivateKey_file(ctx, key, SSL_FILETYPE_PEM)) { 785b7579f77SDag-Erling Smørgrav log_err("error in client private key %s", key); 786b7579f77SDag-Erling Smørgrav log_crypto_err("error in key file"); 787b7579f77SDag-Erling Smørgrav SSL_CTX_free(ctx); 788b7579f77SDag-Erling Smørgrav return NULL; 789b7579f77SDag-Erling Smørgrav } 790b7579f77SDag-Erling Smørgrav if(!SSL_CTX_check_private_key(ctx)) { 791b7579f77SDag-Erling Smørgrav log_err("error in client key %s", key); 792b7579f77SDag-Erling Smørgrav log_crypto_err("error in SSL_CTX_check_private_key"); 793b7579f77SDag-Erling Smørgrav SSL_CTX_free(ctx); 794b7579f77SDag-Erling Smørgrav return NULL; 795b7579f77SDag-Erling Smørgrav } 796b7579f77SDag-Erling Smørgrav } 797b7579f77SDag-Erling Smørgrav if(verifypem && verifypem[0]) { 798ff825849SDag-Erling Smørgrav if(!SSL_CTX_load_verify_locations(ctx, verifypem, NULL)) { 799b7579f77SDag-Erling Smørgrav log_crypto_err("error in SSL_CTX verify"); 800b7579f77SDag-Erling Smørgrav SSL_CTX_free(ctx); 801b7579f77SDag-Erling Smørgrav return NULL; 802b7579f77SDag-Erling Smørgrav } 803b7579f77SDag-Erling Smørgrav SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, NULL); 804b7579f77SDag-Erling Smørgrav } 805b7579f77SDag-Erling Smørgrav return ctx; 8068ed2b524SDag-Erling Smørgrav #else 8078ed2b524SDag-Erling Smørgrav (void)key; (void)pem; (void)verifypem; 8088ed2b524SDag-Erling Smørgrav return NULL; 8098ed2b524SDag-Erling Smørgrav #endif 810b7579f77SDag-Erling Smørgrav } 811b7579f77SDag-Erling Smørgrav 812b7579f77SDag-Erling Smørgrav void* incoming_ssl_fd(void* sslctx, int fd) 813b7579f77SDag-Erling Smørgrav { 8148ed2b524SDag-Erling Smørgrav #ifdef HAVE_SSL 815b7579f77SDag-Erling Smørgrav SSL* ssl = SSL_new((SSL_CTX*)sslctx); 816b7579f77SDag-Erling Smørgrav if(!ssl) { 817b7579f77SDag-Erling Smørgrav log_crypto_err("could not SSL_new"); 818b7579f77SDag-Erling Smørgrav return NULL; 819b7579f77SDag-Erling Smørgrav } 820b7579f77SDag-Erling Smørgrav SSL_set_accept_state(ssl); 821b7579f77SDag-Erling Smørgrav (void)SSL_set_mode(ssl, SSL_MODE_AUTO_RETRY); 822b7579f77SDag-Erling Smørgrav if(!SSL_set_fd(ssl, fd)) { 823b7579f77SDag-Erling Smørgrav log_crypto_err("could not SSL_set_fd"); 824b7579f77SDag-Erling Smørgrav SSL_free(ssl); 825b7579f77SDag-Erling Smørgrav return NULL; 826b7579f77SDag-Erling Smørgrav } 827b7579f77SDag-Erling Smørgrav return ssl; 8288ed2b524SDag-Erling Smørgrav #else 8298ed2b524SDag-Erling Smørgrav (void)sslctx; (void)fd; 8308ed2b524SDag-Erling Smørgrav return NULL; 8318ed2b524SDag-Erling Smørgrav #endif 832b7579f77SDag-Erling Smørgrav } 833b7579f77SDag-Erling Smørgrav 834b7579f77SDag-Erling Smørgrav void* outgoing_ssl_fd(void* sslctx, int fd) 835b7579f77SDag-Erling Smørgrav { 8368ed2b524SDag-Erling Smørgrav #ifdef HAVE_SSL 837b7579f77SDag-Erling Smørgrav SSL* ssl = SSL_new((SSL_CTX*)sslctx); 838b7579f77SDag-Erling Smørgrav if(!ssl) { 839b7579f77SDag-Erling Smørgrav log_crypto_err("could not SSL_new"); 840b7579f77SDag-Erling Smørgrav return NULL; 841b7579f77SDag-Erling Smørgrav } 842b7579f77SDag-Erling Smørgrav SSL_set_connect_state(ssl); 843b7579f77SDag-Erling Smørgrav (void)SSL_set_mode(ssl, SSL_MODE_AUTO_RETRY); 844b7579f77SDag-Erling Smørgrav if(!SSL_set_fd(ssl, fd)) { 845b7579f77SDag-Erling Smørgrav log_crypto_err("could not SSL_set_fd"); 846b7579f77SDag-Erling Smørgrav SSL_free(ssl); 847b7579f77SDag-Erling Smørgrav return NULL; 848b7579f77SDag-Erling Smørgrav } 849b7579f77SDag-Erling Smørgrav return ssl; 8508ed2b524SDag-Erling Smørgrav #else 8518ed2b524SDag-Erling Smørgrav (void)sslctx; (void)fd; 8528ed2b524SDag-Erling Smørgrav return NULL; 8538ed2b524SDag-Erling Smørgrav #endif 854b7579f77SDag-Erling Smørgrav } 8558ed2b524SDag-Erling Smørgrav 856b5663de9SDag-Erling Smørgrav #if defined(HAVE_SSL) && defined(OPENSSL_THREADS) && !defined(THREADS_DISABLED) && defined(CRYPTO_LOCK) && OPENSSL_VERSION_NUMBER < 0x10100000L 8578ed2b524SDag-Erling Smørgrav /** global lock list for openssl locks */ 8583005e0a3SDag-Erling Smørgrav static lock_basic_type *ub_openssl_locks = NULL; 8598ed2b524SDag-Erling Smørgrav 8608ed2b524SDag-Erling Smørgrav /** callback that gets thread id for openssl */ 8618ed2b524SDag-Erling Smørgrav static unsigned long 8628ed2b524SDag-Erling Smørgrav ub_crypto_id_cb(void) 8638ed2b524SDag-Erling Smørgrav { 86409a3aaf3SDag-Erling Smørgrav return (unsigned long)log_thread_get(); 8658ed2b524SDag-Erling Smørgrav } 8668ed2b524SDag-Erling Smørgrav 8678ed2b524SDag-Erling Smørgrav static void 8688ed2b524SDag-Erling Smørgrav ub_crypto_lock_cb(int mode, int type, const char *ATTR_UNUSED(file), 8698ed2b524SDag-Erling Smørgrav int ATTR_UNUSED(line)) 8708ed2b524SDag-Erling Smørgrav { 8718ed2b524SDag-Erling Smørgrav if((mode&CRYPTO_LOCK)) { 8728ed2b524SDag-Erling Smørgrav lock_basic_lock(&ub_openssl_locks[type]); 8738ed2b524SDag-Erling Smørgrav } else { 8748ed2b524SDag-Erling Smørgrav lock_basic_unlock(&ub_openssl_locks[type]); 8758ed2b524SDag-Erling Smørgrav } 8768ed2b524SDag-Erling Smørgrav } 8778ed2b524SDag-Erling Smørgrav #endif /* OPENSSL_THREADS */ 8788ed2b524SDag-Erling Smørgrav 8798ed2b524SDag-Erling Smørgrav int ub_openssl_lock_init(void) 8808ed2b524SDag-Erling Smørgrav { 881b5663de9SDag-Erling Smørgrav #if defined(HAVE_SSL) && defined(OPENSSL_THREADS) && !defined(THREADS_DISABLED) && defined(CRYPTO_LOCK) && OPENSSL_VERSION_NUMBER < 0x10100000L 8828ed2b524SDag-Erling Smørgrav int i; 8833005e0a3SDag-Erling Smørgrav ub_openssl_locks = (lock_basic_type*)reallocarray( 8843005e0a3SDag-Erling Smørgrav NULL, (size_t)CRYPTO_num_locks(), sizeof(lock_basic_type)); 8858ed2b524SDag-Erling Smørgrav if(!ub_openssl_locks) 8868ed2b524SDag-Erling Smørgrav return 0; 8878ed2b524SDag-Erling Smørgrav for(i=0; i<CRYPTO_num_locks(); i++) { 8888ed2b524SDag-Erling Smørgrav lock_basic_init(&ub_openssl_locks[i]); 8898ed2b524SDag-Erling Smørgrav } 8908ed2b524SDag-Erling Smørgrav CRYPTO_set_id_callback(&ub_crypto_id_cb); 8918ed2b524SDag-Erling Smørgrav CRYPTO_set_locking_callback(&ub_crypto_lock_cb); 8928ed2b524SDag-Erling Smørgrav #endif /* OPENSSL_THREADS */ 8938ed2b524SDag-Erling Smørgrav return 1; 8948ed2b524SDag-Erling Smørgrav } 8958ed2b524SDag-Erling Smørgrav 8968ed2b524SDag-Erling Smørgrav void ub_openssl_lock_delete(void) 8978ed2b524SDag-Erling Smørgrav { 898b5663de9SDag-Erling Smørgrav #if defined(HAVE_SSL) && defined(OPENSSL_THREADS) && !defined(THREADS_DISABLED) && defined(CRYPTO_LOCK) && OPENSSL_VERSION_NUMBER < 0x10100000L 8998ed2b524SDag-Erling Smørgrav int i; 9008ed2b524SDag-Erling Smørgrav if(!ub_openssl_locks) 9018ed2b524SDag-Erling Smørgrav return; 9028ed2b524SDag-Erling Smørgrav CRYPTO_set_id_callback(NULL); 9038ed2b524SDag-Erling Smørgrav CRYPTO_set_locking_callback(NULL); 9048ed2b524SDag-Erling Smørgrav for(i=0; i<CRYPTO_num_locks(); i++) { 9058ed2b524SDag-Erling Smørgrav lock_basic_destroy(&ub_openssl_locks[i]); 9068ed2b524SDag-Erling Smørgrav } 9078ed2b524SDag-Erling Smørgrav free(ub_openssl_locks); 9088ed2b524SDag-Erling Smørgrav #endif /* OPENSSL_THREADS */ 9098ed2b524SDag-Erling Smørgrav } 9108ed2b524SDag-Erling Smørgrav 911