Annotation of embedaddon/curl/lib/hostip.h, revision 1.1
1.1 ! misho 1: #ifndef HEADER_CURL_HOSTIP_H
! 2: #define HEADER_CURL_HOSTIP_H
! 3: /***************************************************************************
! 4: * _ _ ____ _
! 5: * Project ___| | | | _ \| |
! 6: * / __| | | | |_) | |
! 7: * | (__| |_| | _ <| |___
! 8: * \___|\___/|_| \_\_____|
! 9: *
! 10: * Copyright (C) 1998 - 2020, Daniel Stenberg, <daniel@haxx.se>, et al.
! 11: *
! 12: * This software is licensed as described in the file COPYING, which
! 13: * you should have received as part of this distribution. The terms
! 14: * are also available at https://curl.haxx.se/docs/copyright.html.
! 15: *
! 16: * You may opt to use, copy, modify, merge, publish, distribute and/or sell
! 17: * copies of the Software, and permit persons to whom the Software is
! 18: * furnished to do so, under the terms of the COPYING file.
! 19: *
! 20: * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
! 21: * KIND, either express or implied.
! 22: *
! 23: ***************************************************************************/
! 24:
! 25: #include "curl_setup.h"
! 26: #include "hash.h"
! 27: #include "curl_addrinfo.h"
! 28: #include "timeval.h" /* for timediff_t */
! 29: #include "asyn.h"
! 30:
! 31: #ifdef HAVE_SETJMP_H
! 32: #include <setjmp.h>
! 33: #endif
! 34:
! 35: #ifdef NETWARE
! 36: #undef in_addr_t
! 37: #define in_addr_t unsigned long
! 38: #endif
! 39:
! 40: /* Allocate enough memory to hold the full name information structs and
! 41: * everything. OSF1 is known to require at least 8872 bytes. The buffer
! 42: * required for storing all possible aliases and IP numbers is according to
! 43: * Stevens' Unix Network Programming 2nd edition, p. 304: 8192 bytes!
! 44: */
! 45: #define CURL_HOSTENT_SIZE 9000
! 46:
! 47: #define CURL_TIMEOUT_RESOLVE 300 /* when using asynch methods, we allow this
! 48: many seconds for a name resolve */
! 49:
! 50: #define CURL_ASYNC_SUCCESS CURLE_OK
! 51:
! 52: struct addrinfo;
! 53: struct hostent;
! 54: struct Curl_easy;
! 55: struct connectdata;
! 56:
! 57: /*
! 58: * Curl_global_host_cache_init() initializes and sets up a global DNS cache.
! 59: * Global DNS cache is general badness. Do not use. This will be removed in
! 60: * a future version. Use the share interface instead!
! 61: *
! 62: * Returns a struct curl_hash pointer on success, NULL on failure.
! 63: */
! 64: struct curl_hash *Curl_global_host_cache_init(void);
! 65:
! 66: struct Curl_dns_entry {
! 67: Curl_addrinfo *addr;
! 68: /* timestamp == 0 -- CURLOPT_RESOLVE entry, doesn't timeout */
! 69: time_t timestamp;
! 70: /* use-counter, use Curl_resolv_unlock to release reference */
! 71: long inuse;
! 72: };
! 73:
! 74: /*
! 75: * Curl_resolv() returns an entry with the info for the specified host
! 76: * and port.
! 77: *
! 78: * The returned data *MUST* be "unlocked" with Curl_resolv_unlock() after
! 79: * use, or we'll leak memory!
! 80: */
! 81: /* return codes */
! 82: enum resolve_t {
! 83: CURLRESOLV_TIMEDOUT = -2,
! 84: CURLRESOLV_ERROR = -1,
! 85: CURLRESOLV_RESOLVED = 0,
! 86: CURLRESOLV_PENDING = 1
! 87: };
! 88: enum resolve_t Curl_resolv(struct connectdata *conn,
! 89: const char *hostname,
! 90: int port,
! 91: bool allowDOH,
! 92: struct Curl_dns_entry **dnsentry);
! 93: enum resolve_t Curl_resolv_timeout(struct connectdata *conn,
! 94: const char *hostname, int port,
! 95: struct Curl_dns_entry **dnsentry,
! 96: timediff_t timeoutms);
! 97:
! 98: #ifdef CURLRES_IPV6
! 99: /*
! 100: * Curl_ipv6works() returns TRUE if IPv6 seems to work.
! 101: */
! 102: bool Curl_ipv6works(struct connectdata *conn);
! 103: #else
! 104: #define Curl_ipv6works(x) FALSE
! 105: #endif
! 106:
! 107: /*
! 108: * Curl_ipvalid() checks what CURL_IPRESOLVE_* requirements that might've
! 109: * been set and returns TRUE if they are OK.
! 110: */
! 111: bool Curl_ipvalid(struct connectdata *conn);
! 112:
! 113:
! 114: /*
! 115: * Curl_getaddrinfo() is the generic low-level name resolve API within this
! 116: * source file. There are several versions of this function - for different
! 117: * name resolve layers (selected at build-time). They all take this same set
! 118: * of arguments
! 119: */
! 120: Curl_addrinfo *Curl_getaddrinfo(struct connectdata *conn,
! 121: const char *hostname,
! 122: int port,
! 123: int *waitp);
! 124:
! 125:
! 126: /* unlock a previously resolved dns entry */
! 127: void Curl_resolv_unlock(struct Curl_easy *data,
! 128: struct Curl_dns_entry *dns);
! 129:
! 130: /* init a new dns cache and return success */
! 131: int Curl_mk_dnscache(struct curl_hash *hash);
! 132:
! 133: /* prune old entries from the DNS cache */
! 134: void Curl_hostcache_prune(struct Curl_easy *data);
! 135:
! 136: /* Return # of addresses in a Curl_addrinfo struct */
! 137: int Curl_num_addresses(const Curl_addrinfo *addr);
! 138:
! 139: #if defined(CURLDEBUG) && defined(HAVE_GETNAMEINFO)
! 140: int curl_dogetnameinfo(GETNAMEINFO_QUAL_ARG1 GETNAMEINFO_TYPE_ARG1 sa,
! 141: GETNAMEINFO_TYPE_ARG2 salen,
! 142: char *host, GETNAMEINFO_TYPE_ARG46 hostlen,
! 143: char *serv, GETNAMEINFO_TYPE_ARG46 servlen,
! 144: GETNAMEINFO_TYPE_ARG7 flags,
! 145: int line, const char *source);
! 146: #endif
! 147:
! 148: /* IPv4 threadsafe resolve function used for synch and asynch builds */
! 149: Curl_addrinfo *Curl_ipv4_resolve_r(const char *hostname, int port);
! 150:
! 151: CURLcode Curl_once_resolved(struct connectdata *conn, bool *protocol_connect);
! 152:
! 153: /*
! 154: * Curl_addrinfo_callback() is used when we build with any asynch specialty.
! 155: * Handles end of async request processing. Inserts ai into hostcache when
! 156: * status is CURL_ASYNC_SUCCESS. Twiddles fields in conn to indicate async
! 157: * request completed whether successful or failed.
! 158: */
! 159: CURLcode Curl_addrinfo_callback(struct connectdata *conn,
! 160: int status,
! 161: Curl_addrinfo *ai);
! 162:
! 163: /*
! 164: * Curl_printable_address() returns a printable version of the 1st address
! 165: * given in the 'ip' argument. The result will be stored in the buf that is
! 166: * bufsize bytes big.
! 167: */
! 168: const char *Curl_printable_address(const Curl_addrinfo *ip,
! 169: char *buf, size_t bufsize);
! 170:
! 171: /*
! 172: * Curl_fetch_addr() fetches a 'Curl_dns_entry' already in the DNS cache.
! 173: *
! 174: * Returns the Curl_dns_entry entry pointer or NULL if not in the cache.
! 175: *
! 176: * The returned data *MUST* be "unlocked" with Curl_resolv_unlock() after
! 177: * use, or we'll leak memory!
! 178: */
! 179: struct Curl_dns_entry *
! 180: Curl_fetch_addr(struct connectdata *conn,
! 181: const char *hostname,
! 182: int port);
! 183:
! 184: /*
! 185: * Curl_cache_addr() stores a 'Curl_addrinfo' struct in the DNS cache.
! 186: *
! 187: * Returns the Curl_dns_entry entry pointer or NULL if the storage failed.
! 188: */
! 189: struct Curl_dns_entry *
! 190: Curl_cache_addr(struct Curl_easy *data, Curl_addrinfo *addr,
! 191: const char *hostname, int port);
! 192:
! 193: #ifndef INADDR_NONE
! 194: #define CURL_INADDR_NONE (in_addr_t) ~0
! 195: #else
! 196: #define CURL_INADDR_NONE INADDR_NONE
! 197: #endif
! 198:
! 199: #ifdef HAVE_SIGSETJMP
! 200: /* Forward-declaration of variable defined in hostip.c. Beware this
! 201: * is a global and unique instance. This is used to store the return
! 202: * address that we can jump back to from inside a signal handler.
! 203: * This is not thread-safe stuff.
! 204: */
! 205: extern sigjmp_buf curl_jmpenv;
! 206: #endif
! 207:
! 208: /*
! 209: * Function provided by the resolver backend to set DNS servers to use.
! 210: */
! 211: CURLcode Curl_set_dns_servers(struct Curl_easy *data, char *servers);
! 212:
! 213: /*
! 214: * Function provided by the resolver backend to set
! 215: * outgoing interface to use for DNS requests
! 216: */
! 217: CURLcode Curl_set_dns_interface(struct Curl_easy *data,
! 218: const char *interf);
! 219:
! 220: /*
! 221: * Function provided by the resolver backend to set
! 222: * local IPv4 address to use as source address for DNS requests
! 223: */
! 224: CURLcode Curl_set_dns_local_ip4(struct Curl_easy *data,
! 225: const char *local_ip4);
! 226:
! 227: /*
! 228: * Function provided by the resolver backend to set
! 229: * local IPv6 address to use as source address for DNS requests
! 230: */
! 231: CURLcode Curl_set_dns_local_ip6(struct Curl_easy *data,
! 232: const char *local_ip6);
! 233:
! 234: /*
! 235: * Clean off entries from the cache
! 236: */
! 237: void Curl_hostcache_clean(struct Curl_easy *data, struct curl_hash *hash);
! 238:
! 239: /*
! 240: * Populate the cache with specified entries from CURLOPT_RESOLVE.
! 241: */
! 242: CURLcode Curl_loadhostpairs(struct Curl_easy *data);
! 243:
! 244: CURLcode Curl_resolv_check(struct connectdata *conn,
! 245: struct Curl_dns_entry **dns);
! 246: int Curl_resolv_getsock(struct connectdata *conn,
! 247: curl_socket_t *socks);
! 248:
! 249: #endif /* HEADER_CURL_HOSTIP_H */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to hostip.h CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / curl / lib