Lines Matching refs:data
133 static void data_priority_cleanup(struct Curl_easy *data);
171 void Curl_freeset(struct Curl_easy *data)
173 /* Free all dynamic strings stored in the data->set substructure. */
178 Curl_safefree(data->set.str[i]);
182 Curl_safefree(data->set.blobs[j]);
185 if(data->state.referer_alloc) {
186 Curl_safefree(data->state.referer);
187 data->state.referer_alloc = FALSE;
189 data->state.referer = NULL;
190 if(data->state.url_alloc) {
191 Curl_safefree(data->state.url);
192 data->state.url_alloc = FALSE;
194 data->state.url = NULL;
196 Curl_mime_cleanpart(&data->set.mimepost);
199 curl_slist_free_all(data->state.cookielist);
200 data->state.cookielist = NULL;
205 static void up_free(struct Curl_easy *data)
207 struct urlpieces *up = &data->state.up;
216 curl_url_cleanup(data->state.uh);
217 data->state.uh = NULL;
229 struct Curl_easy *data;
234 data = *datap;
237 Curl_expire_clear(data); /* shut off timers */
241 Curl_detach_connection(data);
242 if(!data->state.internal) {
243 if(data->multi)
246 curl_multi_remove_handle(data->multi, data);
248 if(data->multi_easy) {
251 curl_multi_cleanup(data->multi_easy);
252 data->multi_easy = NULL;
256 data->magic = 0; /* force a clear AFTER the possibly enforced removal from
260 if(data->state.rangestringalloc)
261 free(data->state.range);
264 Curl_free_request_state(data);
267 Curl_ssl_close_all(data);
268 Curl_safefree(data->state.first_host);
269 Curl_safefree(data->state.scratch);
270 Curl_ssl_free_certinfo(data);
273 free(data->req.newurl);
274 data->req.newurl = NULL;
276 if(data->state.referer_alloc) {
277 Curl_safefree(data->state.referer);
278 data->state.referer_alloc = FALSE;
280 data->state.referer = NULL;
282 up_free(data);
283 Curl_safefree(data->state.buffer);
284 Curl_dyn_free(&data->state.headerb);
285 Curl_safefree(data->state.ulbuf);
286 Curl_flush_cookies(data, TRUE);
287 Curl_altsvc_save(data, data->asi, data->set.str[STRING_ALTSVC]);
288 Curl_altsvc_cleanup(&data->asi);
289 Curl_hsts_save(data, data->hsts, data->set.str[STRING_HSTS]);
291 if(!data->share || !data->share->hsts)
292 Curl_hsts_cleanup(&data->hsts);
293 curl_slist_free_all(data->state.hstslist); /* clean up list */
296 Curl_http_auth_cleanup_digest(data);
298 Curl_safefree(data->info.contenttype);
299 Curl_safefree(data->info.wouldredirect);
302 Curl_resolver_cancel(data);
303 Curl_resolver_cleanup(data->state.async.resolver);
305 data_priority_cleanup(data);
308 if(data->share) {
309 Curl_share_lock(data, CURL_LOCK_DATA_SHARE, CURL_LOCK_ACCESS_SINGLE);
310 data->share->dirty--;
311 Curl_share_unlock(data, CURL_LOCK_DATA_SHARE);
314 Curl_safefree(data->state.aptr.proxyuserpwd);
315 Curl_safefree(data->state.aptr.uagent);
316 Curl_safefree(data->state.aptr.userpwd);
317 Curl_safefree(data->state.aptr.accept_encoding);
318 Curl_safefree(data->state.aptr.te);
319 Curl_safefree(data->state.aptr.rangeline);
320 Curl_safefree(data->state.aptr.ref);
321 Curl_safefree(data->state.aptr.host);
322 Curl_safefree(data->state.aptr.cookiehost);
323 Curl_safefree(data->state.aptr.rtsp_transport);
324 Curl_safefree(data->state.aptr.user);
325 Curl_safefree(data->state.aptr.passwd);
326 Curl_safefree(data->state.aptr.proxyuser);
327 Curl_safefree(data->state.aptr.proxypasswd);
330 if(data->req.doh) {
331 Curl_dyn_free(&data->req.doh->probe[0].serverdoh);
332 Curl_dyn_free(&data->req.doh->probe[1].serverdoh);
333 curl_slist_free_all(data->req.doh->headers);
334 Curl_safefree(data->req.doh);
339 Curl_mime_cleanpart(data->state.formp);
340 Curl_safefree(data->state.formp);
344 Curl_wildcard_dtor(&data->wildcard);
345 Curl_freeset(data);
346 Curl_headers_cleanup(data);
347 free(data);
355 CURLcode Curl_init_userdefined(struct Curl_easy *data)
357 struct UserDefined *set = &data->set;
411 Curl_ssl_easy_config_init(data);
511 struct Curl_easy *data;
514 data = calloc(1, sizeof(struct Curl_easy));
515 if(!data) {
521 data->magic = CURLEASY_MAGIC_NUMBER;
523 result = Curl_resolver_init(data, &data->state.async.resolver);
526 free(data);
530 result = Curl_init_userdefined(data);
532 Curl_dyn_init(&data->state.headerb, CURL_MAX_HTTP_HEADER);
533 Curl_initinfo(data);
536 data->state.lastconnect_id = -1;
537 data->state.recent_conn_id = -1;
539 data->id = -1;
541 data->progress.flags |= PGRS_HIDE;
542 data->state.current_speed = -1; /* init to negative == impossible */
546 Curl_resolver_cleanup(data->state.async.resolver);
547 Curl_dyn_free(&data->state.headerb);
548 Curl_freeset(data);
549 free(data);
550 data = NULL;
553 *curl = data;
558 static void conn_shutdown(struct Curl_easy *data)
560 DEBUGASSERT(data);
561 infof(data, "Closing connection");
564 Curl_resolver_cancel(data);
566 Curl_conn_close(data, SECONDARYSOCKET);
567 Curl_conn_close(data, FIRSTSOCKET);
570 static void conn_free(struct Curl_easy *data, struct connectdata *conn)
577 Curl_conn_cf_discard_all(data, conn, (int)i);
608 free(conn); /* free all the connection oriented data */
625 void Curl_disconnect(struct Curl_easy *data,
635 DEBUGASSERT(data);
638 DEBUGASSERT(!data->conn);
640 DEBUGF(infof(data, "Curl_disconnect(conn #%"
648 DEBUGF(infof(data, "Curl_disconnect when inuse: %zu", CONN_INUSE(conn)));
653 Curl_resolv_unlock(data, conn->dns_entry);
657 /* Cleanup NTLM connection-related data */
660 /* Cleanup NEGOTIATE connection-related data */
669 Curl_attach_connection(data, conn);
673 conn->handler->disconnect(data, conn, dead_connection);
675 conn_shutdown(data);
678 Curl_detach_connection(data);
680 conn_free(data, conn);
708 proxy_info_matches(const struct proxy_info *data,
711 if((data->proxytype == needle->proxytype) &&
712 (data->port == needle->port) &&
713 strcasecompare(data->host.name, needle->host.name))
720 socks_proxy_info_matches(const struct proxy_info *data,
723 if(!proxy_info_matches(data, needle))
732 if(Curl_timestrcmp(data->user, needle->user) ||
733 Curl_timestrcmp(data->passwd, needle->passwd))
747 static bool conn_maxage(struct Curl_easy *data,
756 if(idletime > data->set.maxage_conn) {
757 infof(data, "Too old connection (%" CURL_FORMAT_TIMEDIFF_T
765 if(data->set.maxlifetime_conn && lifetime > data->set.maxlifetime_conn) {
766 infof(data,
786 struct Curl_easy *data)
793 if(conn_maxage(data, conn, now)) {
804 Curl_attach_connection(data, conn);
806 state = conn->handler->connection_check(data, conn, CONNCHECK_ISDEAD);
809 Curl_detach_connection(data);
815 Curl_attach_connection(data, conn);
816 dead = !Curl_conn_is_alive(data, conn, &input_pending);
819 * that we expect - in general - no waiting input data. Input
822 * For protocols where data from other end may arrive at
828 Curl_detach_connection(data);
832 infof(data, "Connection %" CURL_FORMAT_CURL_OFF_T " seems to be dead",
834 Curl_conncache_remove_conn(data, conn, FALSE);
842 struct Curl_easy *data;
850 static int call_extract_if_dead(struct Curl_easy *data,
854 if(extract_if_dead(conn, data)) {
868 static void prune_dead_connections(struct Curl_easy *data)
873 DEBUGASSERT(!data->conn); /* no connection */
874 CONNCACHE_LOCK(data);
876 Curl_timediff(now, data->state.conn_cache->last_cleanup);
877 CONNCACHE_UNLOCK(data);
881 prune.data = data;
883 while(Curl_conncache_foreach(data, data->state.conn_cache, &prune,
888 Curl_conncache_remove_conn(data, prune.extracted, TRUE);
891 Curl_disconnect(data, prune.extracted, TRUE);
893 CONNCACHE_LOCK(data);
894 data->state.conn_cache->last_cleanup = now;
895 CONNCACHE_UNLOCK(data);
922 ConnectionExists(struct Curl_easy *data,
935 bool wantNTLMhttp = ((data->state.authhost.want &
940 ((data->state.authproxy.want &
948 bool h2upgrade = (data->state.httpwant == CURL_HTTP_VERSION_2_0) &&
957 bundle = Curl_conncache_find_bundle(data, needle, data->state.conn_cache);
959 CONNCACHE_UNLOCK(data);
962 infof(data, "Found bundle for host: %p [%s]",
969 if(IsMultiplexingPossible(data, needle)) {
971 if(data->set.pipewait) {
972 infof(data, "Server doesn't support multiplex yet, wait");
974 CONNCACHE_UNLOCK(data);
977 infof(data, "Server doesn't support multiplex (yet)");
980 if(Curl_multiplex_wanted(data->multi))
983 infof(data, "Could multiplex, but not asked to");
986 infof(data, "Can not multiplex, even if we wanted to");
1004 if(data->set.ipver != CURL_IPRESOLVE_WHATEVER
1005 && data->set.ipver != check->ip_version) {
1027 if(entry->multi != data->multi)
1035 infof(data, "Connection #%" CURL_FORMAT_CURL_OFF_T
1099 if(!Curl_ssl_conn_config_match(data, check, TRUE)) {
1100 DEBUGF(infof(data,
1113 if(data->set.pipewait) {
1114 infof(data, "Server upgrade doesn't support multiplex yet, wait");
1116 CONNCACHE_UNLOCK(data);
1119 infof(data, "Server upgrade cannot be used");
1163 (data->state.httpwant < CURL_HTTP_VERSION_2_0))
1165 (data->state.httpwant < CURL_HTTP_VERSION_3))))
1214 !Curl_ssl_conn_config_match(data, check, FALSE)) {
1215 DEBUGF(infof(data,
1289 Curl_multi_max_concurrent_streams(data->multi)) {
1290 infof(data, "client side MAX_CONCURRENT_STREAMS reached"
1295 Curl_conn_get_max_concurrent(data, check, FIRSTSOCKET)) {
1296 infof(data, "MAX_CONCURRENT_STREAMS reached, skip (%zu)",
1301 infof(data, "Multiplexed connection found");
1303 else if(extract_if_dead(check, data)) {
1305 Curl_disconnect(data, check, TRUE);
1316 Curl_attach_connection(data, chosen);
1317 CONNCACHE_UNLOCK(data);
1321 CONNCACHE_UNLOCK(data);
1323 if(foundPendingCandidate && data->set.pipewait) {
1324 infof(data,
1336 void Curl_verboseconnect(struct Curl_easy *data,
1339 if(data->set.verbose)
1340 infof(data, "Connected to %s (%s) port %u",
1348 static struct connectdata *allocate_conn(struct Curl_easy *data)
1376 conn->http_proxy.proxytype = data->set.proxytype;
1381 conn->bits.proxy = (data->set.str[STRING_PROXY] &&
1382 *data->set.str[STRING_PROXY]) ? TRUE : FALSE;
1391 if(data->set.str[STRING_PRE_PROXY] && *data->set.str[STRING_PRE_PROXY]) {
1397 (data->state.aptr.proxyuser) ? TRUE : FALSE;
1398 conn->bits.tunnel_proxy = data->set.tunnel_thru_httpproxy;
1402 conn->bits.ftp_use_epsv = data->set.ftp_use_epsv;
1403 conn->bits.ftp_use_eprt = data->set.ftp_use_eprt;
1405 conn->ip_version = data->set.ipver;
1406 conn->connect_only = data->set.connect_only;
1423 if(data->set.str[STRING_DEVICE]) {
1424 conn->localdev = strdup(data->set.str[STRING_DEVICE]);
1429 conn->localportrange = data->set.localportrange;
1430 conn->localport = data->set.localport;
1435 conn->fclosesocket = data->set.fclosesocket;
1436 conn->closesocket_client = data->set.closesocket_client;
1438 conn->gssapi_delegation = data->set.gssapi_delegation;
1668 static CURLcode findprotocol(struct Curl_easy *data,
1675 (data->set.allowed_protocols & p->protocol)) {
1679 if(data->state.this_is_a_follow &&
1680 !(data->set.redir_protocols & p->protocol))
1694 failf(data, "Protocol \"%s\" %s%s", protostr,
1696 data->state.this_is_a_follow ? " (in redirect)":"");
1722 static void zonefrom_url(CURLU *uh, struct Curl_easy *data,
1728 (void)data;
1754 infof(data, "Invalid zoneid: %s; %s", zoneid,
1773 static CURLcode parseurlandfillconn(struct Curl_easy *data,
1780 bool use_set_uh = (data->set.uh && !data->state.this_is_a_follow);
1782 up_free(data); /* cleanup previous leftovers first */
1786 uh = data->state.uh = curl_url_dup(data->set.uh);
1789 uh = data->state.uh = curl_url();
1795 if(data->set.str[STRING_DEFAULT_PROTOCOL] &&
1796 !Curl_is_absolute_url(data->state.url, NULL, 0, TRUE)) {
1797 char *url = aprintf("%s://%s", data->set.str[STRING_DEFAULT_PROTOCOL],
1798 data->state.url);
1801 if(data->state.url_alloc)
1802 free(data->state.url);
1803 data->state.url = url;
1804 data->state.url_alloc = TRUE;
1809 uc = curl_url_set(uh, CURLUPART_URL, data->state.url,
1812 (data->set.disallow_username_in_url ?
1814 (data->set.path_as_is ? CURLU_PATH_AS_IS : 0));
1816 failf(data, "URL rejected: %s", curl_url_strerror(uc));
1824 if(data->state.url_alloc)
1825 free(data->state.url);
1826 data->state.url = newurl;
1827 data->state.url_alloc = TRUE;
1830 uc = curl_url_get(uh, CURLUPART_SCHEME, &data->state.up.scheme, 0);
1834 uc = curl_url_get(uh, CURLUPART_HOST, &data->state.up.hostname, 0);
1836 if(!strcasecompare("file", data->state.up.scheme))
1839 else if(strlen(data->state.up.hostname) > MAX_URL_LEN) {
1840 failf(data, "Too long host name (maximum is %d)", MAX_URL_LEN);
1843 hostname = data->state.up.hostname;
1855 zonefrom_url(uh, data, conn);
1873 if(data->hsts && strcasecompare("http", data->state.up.scheme)) {
1875 if(Curl_hsts(data->hsts, conn->host.name, TRUE)) {
1877 Curl_safefree(data->state.up.scheme);
1881 if(data->state.url_alloc)
1882 Curl_safefree(data->state.url);
1887 uc = curl_url_get(uh, CURLUPART_SCHEME, &data->state.up.scheme, 0);
1892 data->state.url = url;
1893 data->state.url_alloc = TRUE;
1894 infof(data, "Switched from HTTP to HTTPS due to HSTS => %s",
1895 data->state.url);
1900 result = findprotocol(data, conn, data->state.up.scheme);
1908 if(!data->set.str[STRING_PASSWORD]) {
1909 uc = curl_url_get(uh, CURLUPART_PASSWORD, &data->state.up.password, 0);
1912 result = Curl_urldecode(data->state.up.password, 0, &decoded, NULL,
1918 result = Curl_setstropt(&data->state.aptr.passwd, decoded);
1926 if(!data->set.str[STRING_USERNAME]) {
1930 uc = curl_url_get(uh, CURLUPART_USER, &data->state.up.user, 0);
1933 result = Curl_urldecode(data->state.up.user, 0, &decoded, NULL,
1939 result = Curl_setstropt(&data->state.aptr.user, decoded);
1943 else if(data->state.aptr.passwd) {
1945 result = Curl_setstropt(&data->state.aptr.user, "");
1951 uc = curl_url_get(uh, CURLUPART_OPTIONS, &data->state.up.options,
1954 conn->options = strdup(data->state.up.options);
1961 uc = curl_url_get(uh, CURLUPART_PATH, &data->state.up.path,
1966 uc = curl_url_get(uh, CURLUPART_PORT, &data->state.up.port,
1969 if(!strcasecompare("file", data->state.up.scheme))
1973 unsigned long port = strtoul(data->state.up.port, NULL, 10);
1975 (data->set.use_port && data->state.allow_port) ?
1976 data->set.use_port : curlx_ultous(port);
1979 (void)curl_url_get(uh, CURLUPART_QUERY, &data->state.up.query, 0);
1982 if(data->set.scope_id)
1984 conn->scope_id = data->set.scope_id;
1995 static CURLcode setup_range(struct Curl_easy *data)
1997 struct UrlState *s = &data->state;
1998 s->resume_from = data->set.set_resume_from;
1999 if(s->resume_from || data->set.str[STRING_SET_RANGE]) {
2006 s->range = strdup(data->set.str[STRING_SET_RANGE]);
2032 static CURLcode setup_connection_internals(struct Curl_easy *data,
2042 result = (*p->setup_connection)(data, conn);
2059 * Curl_free_request_state() should free temp data that was allocated in the
2063 void Curl_free_request_state(struct Curl_easy *data)
2065 Curl_safefree(data->req.p.http);
2066 Curl_safefree(data->req.newurl);
2068 if(data->req.doh) {
2069 Curl_close(&data->req.doh->probe[0].easy);
2070 Curl_close(&data->req.doh->probe[1].easy);
2073 Curl_client_cleanup(data);
2085 static char *detect_proxy(struct Curl_easy *data,
2111 (void)data;
2167 infof(data, "Uses proxy env variable %s == '%s'", envp, proxy);
2178 static CURLcode parse_proxy(struct Curl_easy *data,
2235 failf(data, "Unsupported proxy scheme for \'%s\'", proxy);
2241 failf(data, "Unsupported proxy syntax in \'%s\': %s", proxy,
2248 if(!Curl_ssl_supports(data, SSLSUPP_HTTPS_PROXY))
2251 failf(data, "Unsupported proxy \'%s\', libcurl is built without the "
2277 result = Curl_setstropt(&data->state.aptr.proxyuser, proxyuser);
2290 result = Curl_setstropt(&data->state.aptr.proxypasswd, proxypasswd);
2304 if(data->set.proxyport)
2307 port = (int)data->set.proxyport;
2359 zonefrom_url(uhp, data, conn);
2382 static CURLcode parse_proxy_auth(struct Curl_easy *data,
2385 const char *proxyuser = data->state.aptr.proxyuser ?
2386 data->state.aptr.proxyuser : "";
2387 const char *proxypasswd = data->state.aptr.proxypasswd ?
2388 data->state.aptr.proxypasswd : "";
2392 result = Curl_setstropt(&data->state.aptr.proxyuser,
2398 result = Curl_setstropt(&data->state.aptr.proxypasswd,
2405 static CURLcode create_conn_helper_init_proxy(struct Curl_easy *data,
2418 result = parse_proxy_auth(data, conn);
2426 if(data->set.str[STRING_PROXY]) {
2427 proxy = strdup(data->set.str[STRING_PROXY]);
2430 failf(data, "memory shortage");
2436 if(data->set.str[STRING_PRE_PROXY]) {
2437 socksproxy = strdup(data->set.str[STRING_PRE_PROXY]);
2440 failf(data, "memory shortage");
2446 if(!data->set.str[STRING_NOPROXY]) {
2454 infof(data, "Uses proxy env variable %s == '%s'", p, no_proxy);
2458 if(Curl_check_noproxy(conn->host.name, data->set.str[STRING_NOPROXY] ?
2459 data->set.str[STRING_NOPROXY] : no_proxy,
2467 proxy = detect_proxy(data, conn);
2470 infof(data, "space-separated NOPROXY patterns are deprecated");
2502 result = parse_proxy(data, conn, proxy, ptype);
2509 result = parse_proxy(data, conn, socksproxy, ptype);
2706 static CURLcode parse_remote_port(struct Curl_easy *data,
2710 if(data->set.use_port && data->state.allow_port) {
2714 conn->remote_port = data->set.use_port;
2716 uc = curl_url_set(data->state.uh, CURLUPART_PORT, portbuf, 0);
2728 static CURLcode override_login(struct Curl_easy *data,
2736 if(data->set.str[STRING_OPTIONS]) {
2738 *optionsp = strdup(data->set.str[STRING_OPTIONS]);
2744 if(data->set.use_netrc == CURL_NETRC_REQUIRED) {
2749 if(data->set.use_netrc && !data->set.str[STRING_USERNAME]) {
2753 if(data->state.aptr.user) {
2755 userp = &data->state.aptr.user;
2761 data->set.str[STRING_NETRC_FILE]);
2763 infof(data, "Couldn't find host %s in the %s file; using defaults",
2765 (data->set.str[STRING_NETRC_FILE] ?
2766 data->set.str[STRING_NETRC_FILE] : ".netrc"));
2769 failf(data, ".netrc parser error");
2796 if(data->state.aptr.user != *userp) {
2798 result = Curl_setstropt(&data->state.aptr.user, *userp);
2803 if(data->state.aptr.user) {
2804 uc = curl_url_set(data->state.uh, CURLUPART_USER, data->state.aptr.user,
2809 *userp = strdup(data->state.aptr.user);
2815 CURLcode result = Curl_setstropt(&data->state.aptr.passwd, *passwdp);
2819 if(data->state.aptr.passwd) {
2820 uc = curl_url_set(data->state.uh, CURLUPART_PASSWORD,
2821 data->state.aptr.passwd, CURLU_URLENCODE);
2825 *passwdp = strdup(data->state.aptr.passwd);
2837 static CURLcode set_login(struct Curl_easy *data,
2845 if((conn->handler->flags & PROTOPT_NEEDSPWD) && !data->state.aptr.user)
2873 static CURLcode parse_connect_to_host_port(struct Curl_easy *data,
2886 (void) data;
2913 infof(data, "Please URL encode %% as %%25, see RFC 6874.");
2924 infof(data, "Invalid IPv6 address format");
2931 failf(data, "Use of IPv6 in *_CONNECT_TO without IPv6 support built-in");
2946 failf(data, "No valid port number in connect to host string (%s)",
2975 static CURLcode parse_connect_to_string(struct Curl_easy *data,
3035 result = parse_connect_to_host_port(data, ptr, host_result, port_result);
3045 static CURLcode parse_connect_to_slist(struct Curl_easy *data,
3054 result = parse_connect_to_string(data, conn, conn_to_host->data,
3064 infof(data, "Connecting to hostname: %s", host);
3075 infof(data, "Connecting to port: %d", port);
3087 if(data->asi && !host && (port == -1) &&
3107 ) & data->asi->flags;
3113 hit = Curl_altsvc_lookup(data->asi,
3121 hit = Curl_altsvc_lookup(data->asi,
3136 infof(data, "Alt-svc connecting from [%s]%s:%d to [%s]%s:%d",
3164 static CURLcode resolve_unix(struct Curl_easy *data,
3186 failf(data, "Unix socket path too long: '%s'", unix_path);
3198 static CURLcode resolve_proxy(struct Curl_easy *data,
3204 timediff_t timeout_ms = Curl_timeleft(data, NULL, TRUE);
3216 rc = Curl_resolv_timeout(data, conn->hostname_resolve, (int)conn->port,
3224 failf(data, "Couldn't resolve proxy '%s'", host->dispname);
3232 static CURLcode resolve_host(struct Curl_easy *data,
3238 timediff_t timeout_ms = Curl_timeleft(data, NULL, TRUE);
3255 rc = Curl_resolv_timeout(data, conn->hostname_resolve, (int)conn->port,
3261 failf(data, "Failed to resolve host '%s' with timeout after %"
3263 Curl_timediff(Curl_now(), data->progress.t_startsingle));
3267 failf(data, "Could not resolve host: %s", connhost->dispname);
3275 static CURLcode resolve_fresh(struct Curl_easy *data,
3291 return resolve_unix(data, conn, unix_path);
3297 return resolve_proxy(data, conn, async);
3300 return resolve_host(data, conn, async);
3306 static CURLcode resolve_server(struct Curl_easy *data,
3311 DEBUGASSERT(data);
3322 return resolve_fresh(data, conn, async);
3326 * Cleanup the connection `temp`, just allocated for `data`, before using the
3327 * previously `existing` one for `data`. All relevant info is copied over
3330 static void reuse_conn(struct Curl_easy *data,
3398 conn_free(data, temp);
3409 * @param data The sessionhandle pointer
3410 * @param in_connect is set to the next connection data pointer
3416 static CURLcode create_conn(struct Curl_easy *data,
3427 size_t max_host_connections = Curl_multi_max_host_connections(data->multi);
3428 size_t max_total_connections = Curl_multi_max_total_connections(data->multi);
3434 * Check input data
3436 if(!data->state.url) {
3444 connection data struct and fill in for comparison purposes. */
3445 conn = allocate_conn(data);
3457 result = parseurlandfillconn(data, conn);
3461 if(data->set.str[STRING_SASL_AUTHZID]) {
3462 conn->sasl_authzid = strdup(data->set.str[STRING_SASL_AUTHZID]);
3469 if(data->set.str[STRING_BEARER]) {
3470 conn->oauth_bearer = strdup(data->set.str[STRING_BEARER]);
3478 if(data->set.str[STRING_UNIX_SOCKET_PATH]) {
3479 conn->unix_domain_socket = strdup(data->set.str[STRING_UNIX_SOCKET_PATH]);
3484 conn->bits.abstract_unix_socket = data->set.abstract_unix_socket;
3491 result = create_conn_helper_init_proxy(data, conn);
3506 result = parse_remote_port(data, conn);
3512 result = override_login(data, conn);
3516 result = set_login(data, conn); /* default credentials */
3524 result = parse_connect_to_slist(data, conn, data->set.connect_to);
3580 result = setup_connection_internals(data, conn);
3593 Curl_persistconninfo(data, conn, NULL, -1);
3594 result = conn->handler->connect_it(data, &done);
3598 Curl_attach_connection(data, conn);
3599 result = Curl_conncache_add_conn(data);
3606 result = setup_range(data);
3610 (void)conn->handler->done(data, result, FALSE);
3613 Curl_setup_transfer(data, -1, -1, FALSE, -1);
3617 Curl_init_do(data, conn);
3628 conn->bits.tcp_fastopen = data->set.tcp_fastopen;
3631 result = Curl_ssl_easy_config_complete(data);
3635 prune_dead_connections(data);
3650 if((data->set.reuse_fresh && !data->state.followlocation) ||
3651 data->set.connect_only)
3654 reuse = ConnectionExists(data, conn, &existing, &force_reuse, &waitpipe);
3662 reuse_conn(data, conn, existing);
3667 infof(data, "Re-using existing connection with %s %s",
3673 infof(data, "Re-using existing connection with host %s",
3685 if(data->set.ssl_enable_alpn)
3696 Curl_conncache_find_bundle(data, conn, data->state.conn_cache);
3703 conn_candidate = Curl_conncache_extract_bundle(data, bundle);
3704 CONNCACHE_UNLOCK(data);
3707 Curl_disconnect(data, conn_candidate, FALSE);
3709 infof(data, "No more connections allowed to host: %zu",
3715 CONNCACHE_UNLOCK(data);
3721 (Curl_conncache_size(data) >= max_total_connections)) {
3725 conn_candidate = Curl_conncache_extract_oldest(data);
3727 Curl_disconnect(data, conn_candidate, FALSE);
3729 infof(data, "No connections available in cache");
3735 infof(data, "No connections available.");
3737 conn_free(data, conn);
3748 result = Curl_ssl_conn_config_init(data, conn);
3754 Curl_attach_connection(data, conn);
3755 result = Curl_conncache_add_conn(data);
3764 if((data->state.authhost.picked & (CURLAUTH_NTLM | CURLAUTH_NTLM_WB)) &&
3765 data->state.authhost.done) {
3766 infof(data, "NTLM picked AND auth done set, clear picked");
3767 data->state.authhost.picked = CURLAUTH_NONE;
3768 data->state.authhost.done = FALSE;
3771 if((data->state.authproxy.picked & (CURLAUTH_NTLM | CURLAUTH_NTLM_WB)) &&
3772 data->state.authproxy.done) {
3773 infof(data, "NTLM-proxy picked AND auth done set, clear picked");
3774 data->state.authproxy.picked = CURLAUTH_NONE;
3775 data->state.authproxy.done = FALSE;
3781 Curl_init_do(data, conn);
3786 result = setup_range(data);
3796 conn->seek_func = data->set.seek_func;
3797 conn->seek_client = data->set.seek_client;
3802 result = resolve_server(data, conn, async);
3807 * to prepare for a data transfer.
3809 result = Curl_conn_ev_data_setup(data);
3820 CURLcode Curl_setup_conn(struct Curl_easy *data,
3824 struct connectdata *conn = data->conn;
3826 Curl_pgrsTime(data, TIMER_NAMELOOKUP);
3843 data->state.crlf_conversions = 0; /* reset CRLF conversion counter */
3850 result = Curl_conn_setup(data, conn, FIRSTSOCKET, conn->dns_entry,
3857 CURLcode Curl_connect(struct Curl_easy *data,
3866 /* init the single-transfer specific data */
3867 Curl_free_request_state(data);
3868 memset(&data->req, 0, sizeof(struct SingleRequest));
3869 data->req.size = data->req.maxdownload = -1;
3870 data->req.no_body = data->set.opt_no_body;
3873 result = create_conn(data, &conn, asyncp);
3883 result = Curl_setup_conn(data, protocol_done);
3893 Curl_detach_connection(data);
3894 Curl_conncache_remove_conn(data, conn, TRUE);
3895 Curl_disconnect(data, conn, TRUE);
3911 CURLcode Curl_init_do(struct Curl_easy *data, struct connectdata *conn)
3913 struct SingleRequest *k = &data->req;
3916 CURLcode result = Curl_preconnect(data);
3924 if(data->state.wildcardmatch &&
3926 data->state.wildcardmatch = FALSE;
3929 data->state.done = FALSE; /* *_done() is not called yet */
3930 data->state.expect100header = FALSE;
3932 if(data->req.no_body)
3934 data->state.httpreq = HTTPREQ_HEAD;
3941 Curl_client_cleanup(data);
3942 Curl_speedinit(data);
3943 Curl_pgrsSetUploadCounter(data, 0);
3944 Curl_pgrsSetDownloadCounter(data, 0);
3960 while(pnode && pnode->data != child) {
3990 pnode->data = child;
3996 node->data->set.priority.parent = child;
4011 (*tail)->data->set.priority.exclusive = FALSE;
4027 static void data_priority_cleanup(struct Curl_easy *data)
4029 while(data->set.priority.children) {
4030 struct Curl_easy *tmp = data->set.priority.children->data;
4031 priority_remove_child(data, tmp);
4032 if(data->set.priority.parent)
4033 Curl_data_priority_add_child(data->set.priority.parent, tmp, FALSE);
4036 if(data->set.priority.parent)
4037 priority_remove_child(data->set.priority.parent, data);
4041 void Curl_data_priority_clear_state(struct Curl_easy *data)
4043 memset(&data->state.priority, 0, sizeof(data->state.priority));