1 | #ifndef HEADER_CURL_HOSTIP_H |
2 | #define |
3 | /*************************************************************************** |
4 | * _ _ ____ _ |
5 | * Project ___| | | | _ \| | |
6 | * / __| | | | |_) | | |
7 | * | (__| |_| | _ <| |___ |
8 | * \___|\___/|_| \_\_____| |
9 | * |
10 | * Copyright (C) 1998 - 2019, 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 | #define CURLRESOLV_TIMEDOUT -2 |
83 | #define CURLRESOLV_ERROR -1 |
84 | #define CURLRESOLV_RESOLVED 0 |
85 | #define CURLRESOLV_PENDING 1 |
86 | int Curl_resolv(struct connectdata *conn, |
87 | const char *hostname, |
88 | int port, |
89 | bool allowDOH, |
90 | struct Curl_dns_entry **dnsentry); |
91 | int Curl_resolv_timeout(struct connectdata *conn, const char *hostname, |
92 | int port, struct Curl_dns_entry **dnsentry, |
93 | timediff_t timeoutms); |
94 | |
95 | #ifdef CURLRES_IPV6 |
96 | /* |
97 | * Curl_ipv6works() returns TRUE if IPv6 seems to work. |
98 | */ |
99 | bool Curl_ipv6works(void); |
100 | #else |
101 | #define Curl_ipv6works() FALSE |
102 | #endif |
103 | |
104 | /* |
105 | * Curl_ipvalid() checks what CURL_IPRESOLVE_* requirements that might've |
106 | * been set and returns TRUE if they are OK. |
107 | */ |
108 | bool Curl_ipvalid(struct connectdata *conn); |
109 | |
110 | |
111 | /* |
112 | * Curl_getaddrinfo() is the generic low-level name resolve API within this |
113 | * source file. There are several versions of this function - for different |
114 | * name resolve layers (selected at build-time). They all take this same set |
115 | * of arguments |
116 | */ |
117 | Curl_addrinfo *Curl_getaddrinfo(struct connectdata *conn, |
118 | const char *hostname, |
119 | int port, |
120 | int *waitp); |
121 | |
122 | |
123 | /* unlock a previously resolved dns entry */ |
124 | void Curl_resolv_unlock(struct Curl_easy *data, |
125 | struct Curl_dns_entry *dns); |
126 | |
127 | /* init a new dns cache and return success */ |
128 | int Curl_mk_dnscache(struct curl_hash *hash); |
129 | |
130 | /* prune old entries from the DNS cache */ |
131 | void Curl_hostcache_prune(struct Curl_easy *data); |
132 | |
133 | /* Return # of addresses in a Curl_addrinfo struct */ |
134 | int Curl_num_addresses(const Curl_addrinfo *addr); |
135 | |
136 | #if defined(CURLDEBUG) && defined(HAVE_GETNAMEINFO) |
137 | int curl_dogetnameinfo(GETNAMEINFO_QUAL_ARG1 GETNAMEINFO_TYPE_ARG1 sa, |
138 | GETNAMEINFO_TYPE_ARG2 salen, |
139 | char *host, GETNAMEINFO_TYPE_ARG46 hostlen, |
140 | char *serv, GETNAMEINFO_TYPE_ARG46 servlen, |
141 | GETNAMEINFO_TYPE_ARG7 flags, |
142 | int line, const char *source); |
143 | #endif |
144 | |
145 | /* IPv4 threadsafe resolve function used for synch and asynch builds */ |
146 | Curl_addrinfo *Curl_ipv4_resolve_r(const char *hostname, int port); |
147 | |
148 | CURLcode Curl_once_resolved(struct connectdata *conn, bool *protocol_connect); |
149 | |
150 | /* |
151 | * Curl_addrinfo_callback() is used when we build with any asynch specialty. |
152 | * Handles end of async request processing. Inserts ai into hostcache when |
153 | * status is CURL_ASYNC_SUCCESS. Twiddles fields in conn to indicate async |
154 | * request completed whether successful or failed. |
155 | */ |
156 | CURLcode Curl_addrinfo_callback(struct connectdata *conn, |
157 | int status, |
158 | Curl_addrinfo *ai); |
159 | |
160 | /* |
161 | * Curl_printable_address() returns a printable version of the 1st address |
162 | * given in the 'ip' argument. The result will be stored in the buf that is |
163 | * bufsize bytes big. |
164 | */ |
165 | const char *Curl_printable_address(const Curl_addrinfo *ip, |
166 | char *buf, size_t bufsize); |
167 | |
168 | /* |
169 | * Curl_fetch_addr() fetches a 'Curl_dns_entry' already in the DNS cache. |
170 | * |
171 | * Returns the Curl_dns_entry entry pointer or NULL if not in the cache. |
172 | * |
173 | * The returned data *MUST* be "unlocked" with Curl_resolv_unlock() after |
174 | * use, or we'll leak memory! |
175 | */ |
176 | struct Curl_dns_entry * |
177 | Curl_fetch_addr(struct connectdata *conn, |
178 | const char *hostname, |
179 | int port); |
180 | |
181 | /* |
182 | * Curl_cache_addr() stores a 'Curl_addrinfo' struct in the DNS cache. |
183 | * |
184 | * Returns the Curl_dns_entry entry pointer or NULL if the storage failed. |
185 | */ |
186 | struct Curl_dns_entry * |
187 | Curl_cache_addr(struct Curl_easy *data, Curl_addrinfo *addr, |
188 | const char *hostname, int port); |
189 | |
190 | #ifndef INADDR_NONE |
191 | #define CURL_INADDR_NONE (in_addr_t) ~0 |
192 | #else |
193 | #define CURL_INADDR_NONE INADDR_NONE |
194 | #endif |
195 | |
196 | #ifdef HAVE_SIGSETJMP |
197 | /* Forward-declaration of variable defined in hostip.c. Beware this |
198 | * is a global and unique instance. This is used to store the return |
199 | * address that we can jump back to from inside a signal handler. |
200 | * This is not thread-safe stuff. |
201 | */ |
202 | extern sigjmp_buf curl_jmpenv; |
203 | #endif |
204 | |
205 | /* |
206 | * Function provided by the resolver backend to set DNS servers to use. |
207 | */ |
208 | CURLcode Curl_set_dns_servers(struct Curl_easy *data, char *servers); |
209 | |
210 | /* |
211 | * Function provided by the resolver backend to set |
212 | * outgoing interface to use for DNS requests |
213 | */ |
214 | CURLcode Curl_set_dns_interface(struct Curl_easy *data, |
215 | const char *interf); |
216 | |
217 | /* |
218 | * Function provided by the resolver backend to set |
219 | * local IPv4 address to use as source address for DNS requests |
220 | */ |
221 | CURLcode Curl_set_dns_local_ip4(struct Curl_easy *data, |
222 | const char *local_ip4); |
223 | |
224 | /* |
225 | * Function provided by the resolver backend to set |
226 | * local IPv6 address to use as source address for DNS requests |
227 | */ |
228 | CURLcode Curl_set_dns_local_ip6(struct Curl_easy *data, |
229 | const char *local_ip6); |
230 | |
231 | /* |
232 | * Clean off entries from the cache |
233 | */ |
234 | void Curl_hostcache_clean(struct Curl_easy *data, struct curl_hash *hash); |
235 | |
236 | /* |
237 | * Populate the cache with specified entries from CURLOPT_RESOLVE. |
238 | */ |
239 | CURLcode Curl_loadhostpairs(struct Curl_easy *data); |
240 | |
241 | CURLcode Curl_resolv_check(struct connectdata *conn, |
242 | struct Curl_dns_entry **dns); |
243 | int Curl_resolv_getsock(struct connectdata *conn, |
244 | curl_socket_t *socks); |
245 | |
246 | #endif /* HEADER_CURL_HOSTIP_H */ |
247 | |