Lines Matching refs:data
121 static void show_resolve_info(struct Curl_easy *data,
239 void Curl_hostcache_prune(struct Curl_easy *data)
243 int timeout = data->set.dns_cache_timeout;
245 if(!data->dns.hostcache)
249 if(data->share)
250 Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE);
256 time_t oldest = hostcache_prune(data->dns.hostcache, timeout, now);
265 } while(timeout && (data->dns.hostcache->size > MAX_DNS_CACHE_SIZE));
267 if(data->share)
268 Curl_share_unlock(data, CURL_LOCK_DATA_DNS);
280 static struct Curl_dns_entry *fetch_addr(struct Curl_easy *data,
292 dns = Curl_hash_pick(data->dns.hostcache, entry_id, entry_len + 1);
295 if(!dns && data->state.wildcard_resolve) {
299 dns = Curl_hash_pick(data->dns.hostcache, entry_id, entry_len + 1);
302 if(dns && (data->set.dns_cache_timeout != -1)) {
307 user.cache_timeout = data->set.dns_cache_timeout;
311 infof(data, "Hostname in DNS cache was stale, zapped");
313 Curl_hash_delete(data->dns.hostcache, entry_id, entry_len + 1);
318 if(dns && data->conn->ip_version != CURL_IPRESOLVE_WHATEVER) {
324 if(data->conn->ip_version == CURL_IPRESOLVE_V6)
337 infof(data, "Hostname in DNS cache doesn't have needed family, zapped");
339 Curl_hash_delete(data->dns.hostcache, entry_id, entry_len + 1);
356 * The returned data *MUST* be "unlocked" with Curl_resolv_unlock() after
360 Curl_fetch_addr(struct Curl_easy *data,
366 if(data->share)
367 Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE);
369 dns = fetch_addr(data, hostname, port);
374 if(data->share)
375 Curl_share_unlock(data, CURL_LOCK_DATA_DNS);
394 UNITTEST CURLcode Curl_shuffle_addr(struct Curl_easy *data,
408 UNITTEST CURLcode Curl_shuffle_addr(struct Curl_easy *data,
416 infof(data, "Shuffling %i addresses", num_addrs);
433 if(Curl_rand(data, (unsigned char *)rnd, rnd_size) == CURLE_OK) {
472 Curl_cache_addr(struct Curl_easy *data,
485 if(data->set.dns_shuffle_addresses) {
486 CURLcode result = Curl_shuffle_addr(data, &addr);
513 /* Store the resolved data in our DNS cache. */
514 dns2 = Curl_hash_add(data->dns.hostcache, entry_id, entry_len + 1,
607 bool Curl_ipv6works(struct Curl_easy *data)
609 if(data) {
613 DEBUGASSERT(data);
614 DEBUGASSERT(data->multi);
615 if(data->multi->ipv6_up == IPV6_UNKNOWN) {
617 data->multi->ipv6_up = works ? IPV6_WORKS : IPV6_DEAD;
619 return data->multi->ipv6_up == IPV6_WORKS;
684 enum resolve_t Curl_resolv(struct Curl_easy *data,
693 struct connectdata *conn = data->conn;
699 failf(data, "Not resolving .onion address (RFC 7686)");
709 if(data->share)
710 Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE);
712 dns = fetch_addr(data, hostname, port);
715 infof(data, "Hostname %s was found in DNS cache", hostname);
720 if(data->share)
721 Curl_share_unlock(data, CURL_LOCK_DATA_DNS);
739 if(data->set.resolver_start) {
741 Curl_set_in_callback(data, true);
742 st = data->set.resolver_start(
744 data->state.async.resolver,
749 data->set.resolver_start_client);
750 Curl_set_in_callback(data, false);
796 if(conn->ip_version == CURL_IPRESOLVE_V6 && !Curl_ipv6works(data))
803 else if(allowDOH && data->set.doh && !ipnum)
804 addr = Curl_doh(data, hostname, port, &respwait);
809 if(!Curl_ipvalid(data, conn))
814 addr = Curl_getaddrinfo(data, hostname, port, &respwait);
822 result = Curl_resolv_check(data, &dns);
832 if(data->share)
833 Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE);
836 dns = Curl_cache_addr(data, addr, hostname, 0, port);
838 if(data->share)
839 Curl_share_unlock(data, CURL_LOCK_DATA_DNS);
846 show_resolve_info(data, dns);
892 enum resolve_t Curl_resolv_timeout(struct Curl_easy *data,
920 if(data->set.no_signal)
928 return Curl_resolv(data, hostname, port, TRUE, entry);
933 failf(data,
948 failf(data, "name lookup timed out");
983 infof(data, "timeout on name lookup is not supported");
992 rc = Curl_resolv(data, hostname, port, TRUE, entry);
1021 data->conn->created) / 1000;
1034 failf(data, "Previous alarm fired off");
1049 * May be called with 'data' == NULL for global cache.
1051 void Curl_resolv_unlock(struct Curl_easy *data, struct Curl_dns_entry *dns)
1053 if(data && data->share)
1054 Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE);
1058 if(data && data->share)
1059 Curl_share_unlock(data, CURL_LOCK_DATA_DNS);
1089 * This _can_ be called with 'data' == NULL but then of course no locking
1093 void Curl_hostcache_clean(struct Curl_easy *data,
1096 if(data && data->share)
1097 Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE);
1101 if(data && data->share)
1102 Curl_share_unlock(data, CURL_LOCK_DATA_DNS);
1106 CURLcode Curl_loadhostpairs(struct Curl_easy *data)
1112 data->state.wildcard_resolve = false;
1114 for(hostp = data->state.resolve; hostp; hostp = hostp->next) {
1116 if(!hostp->data)
1118 if(hostp->data[0] == '-') {
1122 host_end = strchr(&hostp->data[1], ':');
1125 hlen = host_end - &hostp->data[1];
1131 infof(data, "Bad syntax CURLOPT_RESOLVE removal entry '%s'",
1132 hostp->data);
1136 entry_len = create_hostcache_id(&hostp->data[1], hlen, (int)num,
1138 if(data->share)
1139 Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE);
1142 Curl_hash_delete(data->dns.hostcache, entry_id, entry_len + 1);
1144 if(data->share)
1145 Curl_share_unlock(data, CURL_LOCK_DATA_DNS);
1163 char *host_begin = hostp->data;
1215 infof(data, "Ignoring resolve address '%s', missing IPv6 support.",
1223 infof(data, "Resolve address '%s' found illegal", address);
1242 failf(data, "Couldn't parse CURLOPT_RESOLVE entry '%s'",
1243 hostp->data);
1252 if(data->share)
1253 Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE);
1256 dns = Curl_hash_pick(data->dns.hostcache, entry_id, entry_len + 1);
1259 infof(data, "RESOLVE %.*s:%d - old addresses discarded",
1272 Curl_hash_delete(data->dns.hostcache, entry_id, entry_len + 1);
1276 dns = Curl_cache_addr(data, head, host_begin, hlen, port);
1285 if(data->share)
1286 Curl_share_unlock(data, CURL_LOCK_DATA_DNS);
1293 infof(data, "Added %.*s:%d:%s to DNS cache%s",
1300 infof(data, "RESOLVE *:%d using wildcard", port);
1301 data->state.wildcard_resolve = true;
1305 data->state.resolve = NULL; /* dealt with now */
1311 static void show_resolve_info(struct Curl_easy *data,
1321 DEBUGASSERT(data);
1324 if(!data->set.verbose ||
1331 infof(data, "Host %s:%d was resolved.",
1353 infof(data, "too many IP, can't show");
1361 infof(data, "IPv6: %s",
1364 infof(data, "IPv4: %s",
1375 CURLcode Curl_resolv_check(struct Curl_easy *data,
1380 (void)data;
1384 if(data->conn->bits.doh) {
1385 result = Curl_doh_is_resolved(data, dns);
1389 result = Curl_resolver_is_resolved(data, dns);
1391 show_resolve_info(data, *dns);
1395 int Curl_resolv_getsock(struct Curl_easy *data,
1400 if(data->conn->bits.doh)
1405 return Curl_resolver_getsock(data, socks);
1407 (void)data;
1416 Note: this function disconnects and frees the conn data in case of
1418 CURLcode Curl_once_resolved(struct Curl_easy *data, bool *protocol_done)
1421 struct connectdata *conn = data->conn;
1424 if(data->state.async.dns) {
1425 conn->dns_entry = data->state.async.dns;
1426 data->state.async.dns = NULL;
1430 result = Curl_setup_conn(data, protocol_done);
1433 Curl_detach_connection(data);
1434 Curl_conncache_remove_conn(data, conn, TRUE);
1435 Curl_disconnect(data, conn, TRUE);
1446 CURLcode Curl_resolver_error(struct Curl_easy *data)
1452 struct connectdata *conn = data->conn;
1464 failf(data, "Could not resolve %s: %s", host_or_proxy,
1465 data->state.async.hostname);