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