Lines Matching defs:conn
570 static void conn_free(struct Curl_easy *data, struct connectdata *conn)
574 DEBUGASSERT(conn);
576 for(i = 0; i < ARRAYSIZE(conn->cfilter); ++i) {
577 Curl_conn_cf_discard_all(data, conn, (int)i);
580 Curl_free_idnconverted_hostname(&conn->host);
581 Curl_free_idnconverted_hostname(&conn->conn_to_host);
583 Curl_free_idnconverted_hostname(&conn->http_proxy.host);
584 Curl_free_idnconverted_hostname(&conn->socks_proxy.host);
585 Curl_safefree(conn->http_proxy.user);
586 Curl_safefree(conn->socks_proxy.user);
587 Curl_safefree(conn->http_proxy.passwd);
588 Curl_safefree(conn->socks_proxy.passwd);
589 Curl_safefree(conn->http_proxy.host.rawalloc); /* http proxy name buffer */
590 Curl_safefree(conn->socks_proxy.host.rawalloc); /* socks proxy name buffer */
592 Curl_safefree(conn->user);
593 Curl_safefree(conn->passwd);
594 Curl_safefree(conn->sasl_authzid);
595 Curl_safefree(conn->options);
596 Curl_safefree(conn->oauth_bearer);
597 Curl_safefree(conn->host.rawalloc); /* host name buffer */
598 Curl_safefree(conn->conn_to_host.rawalloc); /* host name buffer */
599 Curl_safefree(conn->hostname_resolve);
600 Curl_safefree(conn->secondaryhostname);
601 Curl_safefree(conn->localdev);
602 Curl_ssl_conn_config_cleanup(conn);
605 Curl_safefree(conn->unix_domain_socket);
608 free(conn); /* free all the connection oriented data */
626 struct connectdata *conn, bool dead_connection)
629 DEBUGASSERT(conn);
632 DEBUGASSERT(!conn->bundle);
638 DEBUGASSERT(!data->conn);
640 DEBUGF(infof(data, "Curl_disconnect(conn #%"
642 conn->connection_id, dead_connection));
647 if(CONN_INUSE(conn) && !dead_connection) {
648 DEBUGF(infof(data, "Curl_disconnect when inuse: %zu", CONN_INUSE(conn)));
652 if(conn->dns_entry) {
653 Curl_resolv_unlock(data, conn->dns_entry);
654 conn->dns_entry = NULL;
658 Curl_http_auth_cleanup_ntlm(conn);
661 Curl_http_auth_cleanup_negotiate(conn);
663 if(conn->connect_only)
669 Curl_attach_connection(data, conn);
671 if(conn->handler && conn->handler->disconnect)
673 conn->handler->disconnect(data, conn, dead_connection);
680 conn_free(data, conn);
690 const struct connectdata *conn)
695 if((conn->handler->protocol & PROTO_FAMILY_HTTP) &&
696 (!conn->bits.protoconnstart || !conn->bits.close)) {
748 struct connectdata *conn,
753 idletime = Curl_timediff(now, conn->lastused);
762 lifetime = Curl_timediff(now, conn->created);
785 static bool extract_if_dead(struct connectdata *conn,
788 if(!CONN_INUSE(conn)) {
793 if(conn_maxage(data, conn, now)) {
797 else if(conn->handler->connection_check) {
804 Curl_attach_connection(data, conn);
806 state = conn->handler->connection_check(data, conn, CONNCHECK_ISDEAD);
815 Curl_attach_connection(data, conn);
816 dead = !Curl_conn_is_alive(data, conn, &input_pending);
833 conn->connection_id);
834 Curl_conncache_remove_conn(data, conn, FALSE);
851 struct connectdata *conn, void *param)
854 if(extract_if_dead(conn, data)) {
856 p->extracted = conn;
873 DEBUGASSERT(!data->conn); /* no connection */
1337 struct connectdata *conn)
1341 CURL_CONN_HOST_DISPNAME(conn), conn->primary_ip, conn->port);
1350 struct connectdata *conn = calloc(1, sizeof(struct connectdata));
1351 if(!conn)
1356 conn->sock[FIRSTSOCKET] = CURL_SOCKET_BAD; /* no file descriptor */
1357 conn->sock[SECONDARYSOCKET] = CURL_SOCKET_BAD; /* no file descriptor */
1358 conn->sockfd = CURL_SOCKET_BAD;
1359 conn->writesockfd = CURL_SOCKET_BAD;
1360 conn->connection_id = -1; /* no ID */
1361 conn->port = -1; /* unknown at this point */
1362 conn->remote_port = -1; /* unknown at this point */
1367 connclose(conn, "Default to force-close");
1370 conn->created = Curl_now();
1373 conn->keepalive = conn->created;
1376 conn->http_proxy.proxytype = data->set.proxytype;
1377 conn->socks_proxy.proxytype = CURLPROXY_SOCKS4;
1381 conn->bits.proxy = (data->set.str[STRING_PROXY] &&
1383 conn->bits.httpproxy = (conn->bits.proxy &&
1384 (conn->http_proxy.proxytype == CURLPROXY_HTTP ||
1385 conn->http_proxy.proxytype == CURLPROXY_HTTP_1_0 ||
1386 IS_HTTPS_PROXY(conn->http_proxy.proxytype))) ?
1388 conn->bits.socksproxy = (conn->bits.proxy &&
1389 !conn->bits.httpproxy) ? TRUE : FALSE;
1392 conn->bits.proxy = TRUE;
1393 conn->bits.socksproxy = TRUE;
1396 conn->bits.proxy_user_passwd =
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;
1407 conn->transport = TRNSPRT_TCP; /* most of them are TCP streams */
1411 conn->ntlm.ntlm_auth_hlpr_socket = CURL_SOCKET_BAD;
1412 conn->proxyntlm.ntlm_auth_hlpr_socket = CURL_SOCKET_BAD;
1416 Curl_llist_init(&conn->easyq, NULL);
1419 conn->data_prot = PROT_CLEAR;
1424 conn->localdev = strdup(data->set.str[STRING_DEVICE]);
1425 if(!conn->localdev)
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;
1437 conn->lastused = conn->created;
1438 conn->gssapi_delegation = data->set.gssapi_delegation;
1440 return conn;
1443 free(conn->localdev);
1444 free(conn);
1669 struct connectdata *conn,
1685 conn->handler = conn->given = p;
1723 struct connectdata *conn)
1736 conn->scope_id = (unsigned int)scope;
1759 conn->scope_id = scopeidx;
1774 struct connectdata *conn)
1849 conn->bits.ipv6_ip = TRUE;
1855 zonefrom_url(uh, data, conn);
1859 conn->host.rawalloc = strdup(hostname ? hostname : "");
1860 if(!conn->host.rawalloc)
1862 conn->host.name = conn->host.rawalloc;
1867 result = Curl_idnconvert_hostname(&conn->host);
1875 if(Curl_hsts(data->hsts, conn->host.name, TRUE)) {
1900 result = findprotocol(data, conn, data->state.up.scheme);
1913 conn->handler->flags&PROTOPT_USERPWDCTRL ?
1917 conn->passwd = decoded;
1934 conn->handler->flags&PROTOPT_USERPWDCTRL ?
1938 conn->user = decoded;
1954 conn->options = strdup(data->state.up.options);
1955 if(!conn->options)
1974 conn->port = conn->remote_port =
1984 conn->scope_id = data->set.scope_id;
2033 struct connectdata *conn)
2039 p = conn->handler;
2042 result = (*p->setup_connection)(data, conn);
2047 p = conn->handler; /* May have changed. */
2050 if(conn->port < 0)
2053 conn->port = p->defport;
2086 struct connectdata *conn)
2108 const char *protop = conn->handler->scheme;
2179 struct connectdata *conn, char *proxy,
2263 proxyinfo = sockstype ? &conn->socks_proxy : &conn->http_proxy;
2294 conn->bits.proxy_user_passwd = TRUE; /* enable it */
2317 if(conn->port < 0 || sockstype || !conn->socks_proxy.host.rawalloc)
2318 conn->port = port;
2359 zonefrom_url(uhp, data, conn);
2383 struct connectdata *conn)
2389 CURLcode result = Curl_urldecode(proxyuser, 0, &conn->http_proxy.user, NULL,
2393 conn->http_proxy.user);
2395 result = Curl_urldecode(proxypasswd, 0, &conn->http_proxy.passwd,
2399 conn->http_proxy.passwd);
2406 struct connectdata *conn)
2417 if(conn->bits.proxy_user_passwd) {
2418 result = parse_proxy_auth(data, conn);
2458 if(Curl_check_noproxy(conn->host.name, data->set.str[STRING_NOPROXY] ?
2467 proxy = detect_proxy(data, conn);
2476 if(proxy && conn->unix_domain_socket) {
2482 if(proxy && (!*proxy || (conn->handler->flags & PROTOPT_NONETWORK))) {
2488 (conn->handler->flags & PROTOPT_NONETWORK))) {
2500 curl_proxytype ptype = (curl_proxytype)conn->http_proxy.proxytype;
2502 result = parse_proxy(data, conn, proxy, ptype);
2509 result = parse_proxy(data, conn, socksproxy, ptype);
2516 if(conn->http_proxy.host.rawalloc) {
2523 if(!(conn->handler->protocol & PROTO_FAMILY_HTTP)) {
2524 if((conn->handler->flags & PROTOPT_PROXY_AS_HTTP) &&
2525 !conn->bits.tunnel_proxy)
2526 conn->handler = &Curl_handler_http;
2529 conn->bits.tunnel_proxy = TRUE;
2531 conn->bits.httpproxy = TRUE;
2535 conn->bits.httpproxy = FALSE; /* not an HTTP proxy */
2536 conn->bits.tunnel_proxy = FALSE; /* no tunneling if not HTTP */
2539 if(conn->socks_proxy.host.rawalloc) {
2540 if(!conn->http_proxy.host.rawalloc) {
2542 if(!conn->socks_proxy.user) {
2543 conn->socks_proxy.user = conn->http_proxy.user;
2544 conn->http_proxy.user = NULL;
2545 Curl_safefree(conn->socks_proxy.passwd);
2546 conn->socks_proxy.passwd = conn->http_proxy.passwd;
2547 conn->http_proxy.passwd = NULL;
2550 conn->bits.socksproxy = TRUE;
2553 conn->bits.socksproxy = FALSE; /* not a socks proxy */
2556 conn->bits.socksproxy = FALSE;
2557 conn->bits.httpproxy = FALSE;
2559 conn->bits.proxy = conn->bits.httpproxy || conn->bits.socksproxy;
2561 if(!conn->bits.proxy) {
2563 conn->bits.proxy = FALSE;
2564 conn->bits.httpproxy = FALSE;
2565 conn->bits.socksproxy = FALSE;
2566 conn->bits.proxy_user_passwd = FALSE;
2567 conn->bits.tunnel_proxy = FALSE;
2568 /* CURLPROXY_HTTPS does not have its own flag in conn->bits, yet we need
2570 conn->http_proxy.proxytype = CURLPROXY_HTTP;
2707 struct connectdata *conn)
2714 conn->remote_port = data->set.use_port;
2715 msnprintf(portbuf, sizeof(portbuf), "%d", conn->remote_port);
2729 struct connectdata *conn)
2732 char **userp = &conn->user;
2733 char **passwdp = &conn->passwd;
2734 char **optionsp = &conn->options;
2748 conn->bits.netrc = FALSE;
2759 ret = Curl_parsenetrc(conn->host.name,
2764 conn->host.name,
2776 conn->bits.netrc = TRUE;
2779 Curl_safefree(conn->user);
2780 conn->user = strdup(*userp);
2781 if(!conn->user)
2838 struct connectdata *conn)
2845 if((conn->handler->flags & PROTOPT_NEEDSPWD) && !data->state.aptr.user)
2852 if(!conn->user) {
2853 conn->user = strdup(setuser);
2854 if(!conn->user)
2859 if(!conn->passwd) {
2860 conn->passwd = strdup(setpasswd);
2861 if(!conn->passwd)
2976 struct connectdata *conn,
2998 conn->bits.ipv6_ip ? "[" : "",
2999 conn->host.name,
3000 conn->bits.ipv6_ip ? "]" : "");
3025 if((endp == ptr_next) && (port_to_match == conn->remote_port)) {
3046 struct connectdata *conn,
3054 result = parse_connect_to_string(data, conn, conn_to_host->data,
3060 conn->conn_to_host.rawalloc = host;
3061 conn->conn_to_host.name = host;
3062 conn->bits.conn_to_host = TRUE;
3068 conn->bits.conn_to_host = FALSE;
3073 conn->conn_to_port = port;
3074 conn->bits.conn_to_port = TRUE;
3079 conn->bits.conn_to_port = FALSE;
3088 ((conn->handler->protocol == CURLPROTO_HTTPS) ||
3109 host = conn->host.rawalloc;
3114 srcalpnid, host, conn->remote_port, /* from */
3122 srcalpnid, host, conn->remote_port, /* from */
3130 conn->conn_to_host.rawalloc = hostd;
3131 conn->conn_to_host.name = hostd;
3132 conn->bits.conn_to_host = TRUE;
3133 conn->conn_to_port = as->dst.port;
3134 conn->bits.conn_to_port = TRUE;
3135 conn->bits.altused = TRUE;
3137 Curl_alpnid2str(srcalpnid), host, conn->remote_port,
3143 conn->httpversion = 11;
3146 conn->httpversion = 20;
3149 conn->transport = TRNSPRT_QUIC;
3150 conn->httpversion = 30;
3165 struct connectdata *conn,
3172 DEBUGASSERT(conn->dns_entry == NULL);
3182 conn->bits.abstract_unix_socket);
3192 conn->dns_entry = hostaddr;
3199 struct connectdata *conn,
3207 DEBUGASSERT(conn->dns_entry == NULL);
3209 host = conn->bits.socksproxy ? &conn->socks_proxy.host :
3210 &conn->http_proxy.host;
3212 conn->hostname_resolve = strdup(host->name);
3213 if(!conn->hostname_resolve)
3216 rc = Curl_resolv_timeout(data, conn->hostname_resolve, (int)conn->port,
3218 conn->dns_entry = hostaddr;
3233 struct connectdata *conn,
3241 DEBUGASSERT(conn->dns_entry == NULL);
3243 connhost = conn->bits.conn_to_host ? &conn->conn_to_host : &conn->host;
3247 conn->port = conn->bits.conn_to_port ? conn->conn_to_port :
3248 conn->remote_port;
3251 conn->hostname_resolve = strdup(connhost->name);
3252 if(!conn->hostname_resolve)
3255 rc = Curl_resolv_timeout(data, conn->hostname_resolve, (int)conn->port,
3257 conn->dns_entry = hostaddr;
3276 struct connectdata *conn,
3280 char *unix_path = conn->unix_domain_socket;
3283 if(!unix_path && conn->socks_proxy.host.name &&
3285 conn->socks_proxy.host.name, sizeof(UNIX_SOCKET_PREFIX)))
3286 unix_path = conn->socks_proxy.host.name + sizeof(UNIX_SOCKET_PREFIX) - 1;
3290 conn->transport = TRNSPRT_UNIX;
3291 return resolve_unix(data, conn, unix_path);
3296 if(CONN_IS_PROXIED(conn))
3297 return resolve_proxy(data, conn, async);
3300 return resolve_host(data, conn, async);
3307 struct connectdata *conn,
3310 DEBUGASSERT(conn);
3314 if(conn->bits.reuse) {
3322 return resolve_fresh(data, conn, async);
3367 * the authority of the URL, e.g. conn->host. For example:
3371 * a new request to the same remote endpoint of an existing conn.
3372 * We want to reuse an existing conn to the remote endpoint.
3373 * Since connection reuse does not match on conn->host necessarily, we
3374 * switch `existing` conn to `temp` conn's host settings.
3421 struct connectdata *conn;
3445 conn = allocate_conn(data);
3447 if(!conn) {
3455 *in_connect = conn;
3457 result = parseurlandfillconn(data, conn);
3462 conn->sasl_authzid = strdup(data->set.str[STRING_SASL_AUTHZID]);
3463 if(!conn->sasl_authzid) {
3470 conn->oauth_bearer = strdup(data->set.str[STRING_BEARER]);
3471 if(!conn->oauth_bearer) {
3479 conn->unix_domain_socket = strdup(data->set.str[STRING_UNIX_SOCKET_PATH]);
3480 if(!conn->unix_domain_socket) {
3484 conn->bits.abstract_unix_socket = data->set.abstract_unix_socket;
3491 result = create_conn_helper_init_proxy(data, conn);
3499 if((conn->given->flags&PROTOPT_SSL) && conn->bits.httpproxy)
3500 conn->bits.tunnel_proxy = TRUE;
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);
3532 if(conn->bits.httpproxy) {
3533 result = Curl_idnconvert_hostname(&conn->http_proxy.host);
3537 if(conn->bits.socksproxy) {
3538 result = Curl_idnconvert_hostname(&conn->socks_proxy.host);
3543 if(conn->bits.conn_to_host) {
3544 result = Curl_idnconvert_hostname(&conn->conn_to_host);
3553 if(conn->bits.conn_to_host &&
3554 strcasecompare(conn->conn_to_host.name, conn->host.name)) {
3555 conn->bits.conn_to_host = FALSE;
3562 if(conn->bits.conn_to_port && conn->conn_to_port == conn->remote_port) {
3563 conn->bits.conn_to_port = FALSE;
3571 if((conn->bits.conn_to_host || conn->bits.conn_to_port) &&
3572 conn->bits.httpproxy)
3573 conn->bits.tunnel_proxy = TRUE;
3580 result = setup_connection_internals(data, conn);
3588 if(conn->handler->flags & PROTOPT_NONETWORK) {
3592 DEBUGASSERT(conn->handler->connect_it);
3593 Curl_persistconninfo(data, conn, NULL, -1);
3594 result = conn->handler->connect_it(data, &done);
3598 Curl_attach_connection(data, conn);
3608 DEBUGASSERT(conn->handler->done);
3610 (void)conn->handler->done(data, result, FALSE);
3617 Curl_init_do(data, conn);
3624 conn->recv[FIRSTSOCKET] = Curl_conn_recv;
3625 conn->send[FIRSTSOCKET] = Curl_conn_send;
3626 conn->recv[SECONDARYSOCKET] = Curl_conn_recv;
3627 conn->send[SECONDARYSOCKET] = Curl_conn_send;
3628 conn->bits.tcp_fastopen = data->set.tcp_fastopen;
3643 DEBUGASSERT(conn->user);
3644 DEBUGASSERT(conn->passwd);
3654 reuse = ConnectionExists(data, conn, &existing, &force_reuse, &waitpipe);
3662 reuse_conn(data, conn, existing);
3663 conn = existing;
3664 *in_connect = conn;
3668 conn->bits.proxy?"proxy":"host",
3669 conn->socks_proxy.host.name ? conn->socks_proxy.host.dispname :
3670 conn->http_proxy.host.name ? conn->http_proxy.host.dispname :
3671 conn->host.dispname);
3674 conn->host.dispname);
3682 if(conn->handler->flags & PROTOPT_ALPN) {
3686 conn->bits.tls_enable_alpn = TRUE;
3696 Curl_conncache_find_bundle(data, conn, data->state.conn_cache);
3737 conn_free(data, conn);
3748 result = Curl_ssl_conn_config_init(data, conn);
3754 Curl_attach_connection(data, conn);
3781 Curl_init_do(data, conn);
3796 conn->seek_func = data->set.seek_func;
3797 conn->seek_client = data->set.seek_client;
3802 result = resolve_server(data, conn, async);
3824 struct connectdata *conn = data->conn;
3828 if(conn->handler->flags & PROTOPT_NONETWORK) {
3839 conn->bits.proxy_connect_closed = FALSE;
3848 conn->now = Curl_now();
3849 if(!conn->bits.reuse)
3850 result = Curl_conn_setup(data, conn, FIRSTSOCKET, conn->dns_entry,
3862 struct connectdata *conn;
3873 result = create_conn(data, &conn, asyncp);
3876 if(CONN_INUSE(conn) > 1)
3890 else if(result && conn) {
3894 Curl_conncache_remove_conn(data, conn, TRUE);
3895 Curl_disconnect(data, conn, TRUE);
3908 * Allow this function to get called with 'conn' set to NULL.
3911 CURLcode Curl_init_do(struct Curl_easy *data, struct connectdata *conn)
3920 if(conn) {
3921 conn->bits.do_more = FALSE; /* by default there's no curl_do_more() to
3925 !(conn->handler->flags & PROTOPT_WILDCARD))