Lines Matching defs:conn
142 static void conn_free(struct connectdata *conn);
144 static CURLcode do_init(struct connectdata *conn);
146 struct connectdata *conn,
2509 static void conn_free(struct connectdata *conn)
2511 if(!conn)
2515 Curl_resolver_cancel(conn);
2519 Curl_ssl_close(conn, FIRSTSOCKET);
2520 Curl_ssl_close(conn, SECONDARYSOCKET);
2523 if(CURL_SOCKET_BAD != conn->sock[SECONDARYSOCKET])
2524 Curl_closesocket(conn, conn->sock[SECONDARYSOCKET]);
2525 if(CURL_SOCKET_BAD != conn->sock[FIRSTSOCKET])
2526 Curl_closesocket(conn, conn->sock[FIRSTSOCKET]);
2527 if(CURL_SOCKET_BAD != conn->tempsock[0])
2528 Curl_closesocket(conn, conn->tempsock[0]);
2529 if(CURL_SOCKET_BAD != conn->tempsock[1])
2530 Curl_closesocket(conn, conn->tempsock[1]);
2533 Curl_ntlm_wb_cleanup(conn);
2536 Curl_safefree(conn->user);
2537 Curl_safefree(conn->passwd);
2538 Curl_safefree(conn->xoauth2_bearer);
2539 Curl_safefree(conn->options);
2540 Curl_safefree(conn->proxyuser);
2541 Curl_safefree(conn->proxypasswd);
2542 Curl_safefree(conn->allocptr.proxyuserpwd);
2543 Curl_safefree(conn->allocptr.uagent);
2544 Curl_safefree(conn->allocptr.userpwd);
2545 Curl_safefree(conn->allocptr.accept_encoding);
2546 Curl_safefree(conn->allocptr.te);
2547 Curl_safefree(conn->allocptr.rangeline);
2548 Curl_safefree(conn->allocptr.ref);
2549 Curl_safefree(conn->allocptr.host);
2550 Curl_safefree(conn->allocptr.cookiehost);
2551 Curl_safefree(conn->allocptr.rtsp_transport);
2552 Curl_safefree(conn->trailer);
2553 Curl_safefree(conn->host.rawalloc); /* host name buffer */
2554 Curl_safefree(conn->proxy.rawalloc); /* proxy name buffer */
2555 Curl_safefree(conn->master_buffer);
2557 Curl_llist_destroy(conn->send_pipe, NULL);
2558 Curl_llist_destroy(conn->recv_pipe, NULL);
2560 conn->send_pipe = NULL;
2561 conn->recv_pipe = NULL;
2563 Curl_safefree(conn->localdev);
2564 Curl_free_ssl_config(&conn->ssl_config);
2566 free(conn); /* free all the connection oriented data */
2569 CURLcode Curl_disconnect(struct connectdata *conn, bool dead_connection)
2572 if(!conn)
2574 data = conn->data;
2581 if(conn->dns_entry != NULL) {
2582 Curl_resolv_unlock(data, conn->dns_entry);
2583 conn->dns_entry = NULL;
2589 int has_host_ntlm = (conn->ntlm.state != NTLMSTATE_NONE);
2590 int has_proxy_ntlm = (conn->proxyntlm.state != NTLMSTATE_NONE);
2613 Curl_http_ntlm_cleanup(conn);
2621 if(conn->handler->disconnect)
2623 conn->handler->disconnect(conn, dead_connection);
2626 infof(data, "Closing connection %ld\n", conn->connection_id);
2627 Curl_conncache_remove_conn(data->state.conn_cache, conn);
2630 if(conn->host.encalloc)
2631 idn_free(conn->host.encalloc); /* encoded host name buffer, must be freed
2634 if(conn->proxy.encalloc)
2635 idn_free(conn->proxy.encalloc); /* encoded proxy name buffer, must be
2639 free(conn->host.encalloc); /* encoded host name buffer, must be freed with
2642 if(conn->proxy.encalloc)
2643 free(conn->proxy.encalloc); /* encoded proxy name buffer, must be freed
2648 Curl_ssl_close(conn, FIRSTSOCKET);
2652 signalPipeClose(conn->send_pipe, TRUE);
2653 signalPipeClose(conn->recv_pipe, TRUE);
2656 conn_free(conn);
2682 const struct connectdata *conn)
2684 if((conn->handler->protocol & CURLPROTO_HTTP) &&
2751 struct connectdata *conn)
2753 bool recv_head = (conn->readchannel_inuse &&
2754 (gethandleathead(conn->recv_pipe) == data)) ? TRUE : FALSE;
2756 bool send_head = (conn->writechannel_inuse &&
2757 (gethandleathead(conn->send_pipe) == data)) ? TRUE : FALSE;
2759 if(Curl_removeHandleFromPipeline(data, conn->recv_pipe) && recv_head)
2760 conn->readchannel_inuse = FALSE;
2761 if(Curl_removeHandleFromPipeline(data, conn->send_pipe) && send_head)
2762 conn->writechannel_inuse = FALSE;
2818 struct connectdata *conn;
2824 conn = curr->ptr;
2826 if(!conn->inuse) {
2828 score = Curl_tvdiff(now, conn->now);
2832 conn_candidate = conn;
2860 struct connectdata *conn;
2868 conn = curr->ptr;
2870 if(!conn->inuse) {
2872 score = Curl_tvdiff(now, conn->now);
2876 conn_candidate = conn;
3190 ConnectionDone(struct SessionHandle *data, struct connectdata *conn)
3199 conn->inuse = FALSE;
3216 return (conn_candidate == conn) ? FALSE : TRUE;
3228 struct connectdata *conn)
3236 conn->connection_id = connection_id_counter++;
3238 result = Curl_conncache_add_conn(data->state.conn_cache, conn);
3240 conn->connection_id = -1;
3251 CURLcode Curl_connected_proxy(struct connectdata *conn,
3254 if(!conn->bits.proxy || sockindex)
3259 switch(conn->proxytype) {
3263 return Curl_SOCKS5(conn->proxyuser, conn->proxypasswd,
3264 conn->host.name, conn->remote_port,
3265 FIRSTSOCKET, conn);
3268 return Curl_SOCKS4(conn->proxyuser, conn->host.name,
3269 conn->remote_port, FIRSTSOCKET, conn, FALSE);
3272 return Curl_SOCKS4(conn->proxyuser, conn->host.name,
3273 conn->remote_port, FIRSTSOCKET, conn, TRUE);
3291 void Curl_verboseconnect(struct connectdata *conn)
3293 if(conn->data->set.verbose)
3294 infof(conn->data, "Connected to %s (%s) port %ld (#%ld)\n",
3295 conn->bits.proxy ? conn->proxy.dispname : conn->host.dispname,
3296 conn->ip_addr_str, conn->port, conn->connection_id);
3300 int Curl_protocol_getsock(struct connectdata *conn,
3304 if(conn->handler->proto_getsock)
3305 return conn->handler->proto_getsock(conn, socks, numsocks);
3309 int Curl_doing_getsock(struct connectdata *conn,
3313 if(conn && conn->handler->doing_getsock)
3314 return conn->handler->doing_getsock(conn, socks, numsocks);
3324 CURLcode Curl_protocol_connecting(struct connectdata *conn,
3329 if(conn && conn->handler->connecting) {
3331 result = conn->handler->connecting(conn, done);
3344 CURLcode Curl_protocol_doing(struct connectdata *conn, bool *done)
3348 if(conn && conn->handler->doing) {
3350 result = conn->handler->doing(conn, done);
3363 CURLcode Curl_protocol_connect(struct connectdata *conn,
3370 if(conn->bits.tcpconnect[FIRSTSOCKET] && conn->bits.protoconnstart) {
3377 if(!conn->handler->connecting)
3383 if(!conn->bits.protoconnstart) {
3385 result = Curl_proxy_connect(conn);
3389 if(conn->bits.tunnel_proxy && conn->bits.httpproxy &&
3390 (conn->tunnel_state[FIRSTSOCKET] != TUNNEL_COMPLETE))
3395 if(conn->handler->connect_it) {
3399 result = conn->handler->connect_it(conn, protocol_done);
3407 conn->bits.protoconnstart = TRUE;
3475 struct connectdata *conn, struct hostname *host)
3479 (void)conn;
3481 (void)conn;
3498 host->name, Curl_idn_strerror(conn,rc));
3541 struct connectdata *conn = calloc(1, sizeof(struct connectdata));
3542 if(!conn)
3545 conn->handler = &Curl_handler_dummy; /* Be sure we have a handler defined
3551 conn->sock[FIRSTSOCKET] = CURL_SOCKET_BAD; /* no file descriptor */
3552 conn->sock[SECONDARYSOCKET] = CURL_SOCKET_BAD; /* no file descriptor */
3553 conn->tempsock[0] = CURL_SOCKET_BAD; /* no file descriptor */
3554 conn->tempsock[1] = CURL_SOCKET_BAD; /* no file descriptor */
3555 conn->connection_id = -1; /* no ID */
3556 conn->port = -1; /* unknown at this point */
3557 conn->remote_port = -1; /* unknown */
3562 conn->bits.close = TRUE;
3565 conn->created = Curl_tvnow();
3567 conn->data = data; /* Setup the association between this connection
3570 conn->proxytype = data->set.proxytype; /* type */
3574 conn->bits.proxy = FALSE;
3575 conn->bits.httpproxy = FALSE;
3576 conn->bits.proxy_user_passwd = FALSE;
3577 conn->bits.tunnel_proxy = FALSE;
3583 conn->bits.proxy = (data->set.str[STRING_PROXY] &&
3585 conn->bits.httpproxy = (conn->bits.proxy &&
3586 (conn->proxytype == CURLPROXY_HTTP ||
3587 conn->proxytype == CURLPROXY_HTTP_1_0))?TRUE:FALSE;
3588 conn->bits.proxy_user_passwd =
3590 conn->bits.tunnel_proxy = data->set.tunnel_thru_httpproxy;
3594 conn->bits.user_passwd = (NULL != data->set.str[STRING_USERNAME])?TRUE:FALSE;
3595 conn->bits.ftp_use_epsv = data->set.ftp_use_epsv;
3596 conn->bits.ftp_use_eprt = data->set.ftp_use_eprt;
3598 conn->verifypeer = data->set.ssl.verifypeer;
3599 conn->verifyhost = data->set.ssl.verifyhost;
3601 conn->ip_version = data->set.ipver;
3604 conn->ntlm_auth_hlpr_socket = CURL_SOCKET_BAD;
3605 conn->ntlm_auth_hlpr_pid = 0;
3606 conn->challenge_header = NULL;
3607 conn->response_header = NULL;
3611 !conn->master_buffer) {
3613 conn->master_buffer = calloc(BUFSIZE, sizeof (char));
3614 if(!conn->master_buffer)
3619 conn->send_pipe = Curl_llist_alloc((curl_llist_dtor) llist_dtor);
3620 conn->recv_pipe = Curl_llist_alloc((curl_llist_dtor) llist_dtor);
3621 if(!conn->send_pipe || !conn->recv_pipe)
3625 conn->data_prot = PROT_CLEAR;
3630 conn->localdev = strdup(data->set.str[STRING_DEVICE]);
3631 if(!conn->localdev)
3634 conn->localportrange = data->set.localportrange;
3635 conn->localport = data->set.localport;
3639 conn->fclosesocket = data->set.fclosesocket;
3640 conn->closesocket_client = data->set.closesocket_client;
3642 return conn;
3645 Curl_llist_destroy(conn->send_pipe, NULL);
3646 Curl_llist_destroy(conn->recv_pipe, NULL);
3648 conn->send_pipe = NULL;
3649 conn->recv_pipe = NULL;
3651 Curl_safefree(conn->master_buffer);
3652 Curl_safefree(conn->localdev);
3653 Curl_safefree(conn);
3658 struct connectdata *conn,
3682 conn->handler = conn->given = p;
3703 struct connectdata *conn,
3785 conn->host.name, path)) {
3791 rc = sscanf(data->change.url, "%[^\n/?]%[^\n]", conn->host.name, path);
3795 * djgpp 2.04 has a sscanf() bug where 'conn->host.name' is
3799 if(!(rc == -1 && *conn->host.name))
3815 if(checkprefix("FTP.", conn->host.name))
3817 else if(checkprefix("DICT.", conn->host.name))
3819 else if(checkprefix("LDAP.", conn->host.name))
3821 else if(checkprefix("IMAP.", conn->host.name))
3823 else if(checkprefix("SMTP.", conn->host.name))
3825 else if(checkprefix("POP3.", conn->host.name))
3841 at = strchr(conn->host.name, '@');
3845 query = strchr(conn->host.name, '?');
3919 size_t prefixlen = strlen(conn->host.name);
3950 result = parse_url_login(data, conn, userp, passwdp, optionsp);
3954 if(conn->host.name[0] == '[') {
3957 char *percent = strstr (conn->host.name, "%25");
3967 conn->scope = (unsigned int)scope;
3976 conn->scope = data->set.scope;
3996 * conn->host.name is B
4000 return findprotocol(data, conn, protop);
4044 static CURLcode setup_connection_internals(struct connectdata *conn)
4054 Curl_free_request_state(conn->data);
4056 memset(&conn->data->req, 0, sizeof(struct SingleRequest));
4057 conn->data->req.maxdownload = -1;
4059 conn->socktype = SOCK_STREAM; /* most of them are TCP streams */
4062 p = conn->handler;
4065 result = (*p->setup_connection)(conn);
4070 p = conn->handler; /* May have changed. */
4073 if(conn->port < 0)
4076 conn->port = p->defport;
4080 if(conn->remote_port < 0)
4081 conn->remote_port = (unsigned short)conn->given->defport;
4177 static char *detect_proxy(struct connectdata *conn)
4206 if(!check_noproxy(conn->host.name, no_proxy)) {
4208 const char *protop = conn->handler->scheme;
4248 } /* if(!check_noproxy(conn->host.name, no_proxy)) - it wasn't specified
4255 (void)conn;
4268 struct connectdata *conn, char *proxy)
4287 conn->proxytype = CURLPROXY_SOCKS5_HOSTNAME;
4289 conn->proxytype = CURLPROXY_SOCKS5;
4291 conn->proxytype = CURLPROXY_SOCKS4A;
4293 conn->proxytype = CURLPROXY_SOCKS4;
4313 Curl_safefree(conn->proxyuser);
4315 conn->proxyuser = curl_easy_unescape(data, proxyuser, 0, NULL);
4317 conn->proxyuser = strdup("");
4319 if(!conn->proxyuser)
4322 Curl_safefree(conn->proxypasswd);
4324 conn->proxypasswd = curl_easy_unescape(data, proxypasswd, 0, NULL);
4326 conn->proxypasswd = strdup("");
4328 if(!conn->proxypasswd)
4333 conn->bits.proxy_user_passwd = TRUE; /* enable it */
4377 conn->port = strtol(prox_portno, NULL, 10);
4395 conn->port = data->set.proxyport;
4399 conn->proxy.rawalloc = strdup(proxyptr);
4400 conn->proxy.name = conn->proxy.rawalloc;
4402 if(!conn->proxy.rawalloc)
4412 struct connectdata *conn)
4428 conn->proxyuser = curl_easy_unescape(data, proxyuser, 0, NULL);
4429 if(!conn->proxyuser)
4432 conn->proxypasswd = curl_easy_unescape(data, proxypasswd, 0, NULL);
4433 if(!conn->proxypasswd)
4447 * conn->host.name
4450 * conn->bits.user_passwd - non-zero if non-default passwords exist
4454 * conn->host.name - remove user name and password
4457 struct connectdata *conn,
4466 * been taken care of, so conn->host.name is at most
4472 char *ptr = strchr(conn->host.name, '@');
4473 char *login = conn->host.name;
4485 conn->host.name = ++ptr;
4506 conn->bits.userpwd_in_url = TRUE;
4507 conn->bits.user_passwd = TRUE; /* enable user+password */
4690 * The conn->host.name is currently [user:passwd@]host[:port] where host
4696 struct connectdata *conn)
4704 if((1 == sscanf(conn->host.name, "[%*45[0123456789abcdefABCDEF:.]%c",
4708 conn->bits.ipv6_ip = TRUE;
4710 conn->host.name++; /* skip over the starting bracket */
4711 portptr = strchr(conn->host.name, ']');
4721 if(Curl_inet_pton(AF_INET6, conn->host.name, &in6) > 0) {
4729 portptr = strrchr(conn->host.name, ':');
4734 conn->remote_port = (unsigned short)data->set.use_port;
4738 if(conn->bits.httpproxy) {
4743 if(conn->bits.type_set)
4753 url = aprintf("%s://%s%s%s:%hu%s%s%s", conn->given->scheme,
4754 conn->bits.ipv6_ip?"[":"", conn->host.name,
4755 conn->bits.ipv6_ip?"]":"", conn->remote_port,
4786 conn->remote_port = curlx_ultous(port);
4802 struct connectdata *conn,
4826 conn->bits.netrc = FALSE;
4828 int ret = Curl_parsenetrc(conn->host.name,
4834 conn->host.name);
4843 conn->bits.netrc = TRUE;
4845 conn->bits.user_passwd = TRUE; /* enable user+password */
4855 static CURLcode set_login(struct connectdata *conn,
4862 if((conn->handler->flags & PROTOPT_NEEDSPWD) && !conn->bits.user_passwd) {
4864 conn->user = strdup(CURL_DEFAULT_USER);
4867 if(conn->user)
4868 conn->passwd = strdup(CURL_DEFAULT_PASSWORD);
4870 conn->passwd = NULL;
4872 /* This is the default password, so DON'T set conn->bits.user_passwd */
4876 conn->user = strdup(user);
4879 if(conn->user)
4880 conn->passwd = strdup(passwd);
4882 conn->passwd = NULL;
4885 if(!conn->user || !conn->passwd)
4890 conn->options = strdup(options);
4892 if(!conn->options)
4903 struct connectdata *conn,
4912 if(conn->bits.reuse)
4924 fix_hostname(data, conn, &conn->host);
4926 if(!conn->proxy.name || !*conn->proxy.name) {
4929 conn->port = conn->remote_port; /* it is the same port */
4932 rc = Curl_resolv_timeout(conn, conn->host.name, (int)conn->port,
4941 failf(data, "Couldn't resolve host '%s'", conn->host.dispname);
4950 fix_hostname(data, conn, &conn->proxy);
4953 rc = Curl_resolv_timeout(conn, conn->proxy.name, (int)conn->port,
4963 failf(data, "Couldn't resolve proxy '%s'", conn->proxy.dispname);
4968 DEBUGASSERT(conn->dns_entry == NULL);
4969 conn->dns_entry = hostaddr;
4981 struct connectdata *conn)
4990 conn->data = old_conn->data;
4994 conn->bits.user_passwd = old_conn->bits.user_passwd;
4995 if(conn->bits.user_passwd) {
4997 Curl_safefree(conn->user);
4998 Curl_safefree(conn->passwd);
4999 conn->user = old_conn->user;
5000 conn->passwd = old_conn->passwd;
5005 conn->bits.proxy_user_passwd = old_conn->bits.proxy_user_passwd;
5006 if(conn->bits.proxy_user_passwd) {
5008 Curl_safefree(conn->proxyuser);
5009 Curl_safefree(conn->proxypasswd);
5010 conn->proxyuser = old_conn->proxyuser;
5011 conn->proxypasswd = old_conn->proxypasswd;
5018 Curl_safefree(conn->host.rawalloc);
5019 conn->host=old_conn->host;
5022 Curl_persistconninfo(conn);
5025 conn->bits.reuse = TRUE; /* yes, we're re-using here */
5055 * *NOTE* this function assigns the conn->data pointer!
5063 struct connectdata *conn;
5092 conn = allocate_conn(data);
5094 if(!conn) {
5102 *in_connect = conn;
5133 conn->host.rawalloc = malloc(urllen+2);
5134 if(NULL == conn->host.rawalloc) {
5141 conn->host.name = conn->host.rawalloc;
5142 conn->host.name[0] = 0;
5152 result = parseurlandfillconn(data, conn, &prot_missing, &user, &passwd,
5166 reurl = aprintf("%s://%s", conn->handler->scheme, data->change.url);
5186 if((conn->given->flags&PROTOPT_NOURLQUERY)) {
5187 char *path_q_sep = strchr(conn->data->state.path, '?');
5201 conn->xoauth2_bearer = strdup(data->set.str[STRING_BEARER]);
5202 if(!conn->xoauth2_bearer) {
5212 if(conn->bits.proxy_user_passwd) {
5213 result = parse_proxy_auth(data, conn);
5232 check_noproxy(conn->host.name, data->set.str[STRING_NOPROXY])) {
5239 proxy = detect_proxy(conn);
5241 if(proxy && (!*proxy || (conn->handler->flags & PROTOPT_NONETWORK))) {
5253 result = parse_proxy(data, conn, proxy);
5260 if((conn->proxytype == CURLPROXY_HTTP) ||
5261 (conn->proxytype == CURLPROXY_HTTP_1_0)) {
5269 if(!(conn->handler->protocol & CURLPROTO_HTTP) &&
5270 !conn->bits.tunnel_proxy)
5271 conn->handler = &Curl_handler_http;
5273 conn->bits.httpproxy = TRUE;
5277 conn->bits.httpproxy = FALSE; /* not a HTTP proxy */
5278 conn->bits.proxy = TRUE;
5282 conn->bits.proxy = FALSE;
5283 conn->bits.httpproxy = FALSE;
5284 conn->bits.proxy_user_passwd = FALSE;
5285 conn->bits.tunnel_proxy = FALSE;
5294 if((conn->given->flags&PROTOPT_SSL) && conn->bits.httpproxy)
5295 conn->bits.tunnel_proxy = TRUE;
5300 result = parse_remote_port(data, conn);
5306 result = override_login(data, conn, &user, &passwd, &options);
5309 result = set_login(conn, user, passwd, options);
5317 result = setup_connection_internals(conn);
5321 conn->recv[FIRSTSOCKET] = Curl_recv_plain;
5322 conn->send[FIRSTSOCKET] = Curl_send_plain;
5323 conn->recv[SECONDARYSOCKET] = Curl_recv_plain;
5324 conn->send[SECONDARYSOCKET] = Curl_send_plain;
5330 if(conn->handler->flags & PROTOPT_NONETWORK) {
5334 DEBUGASSERT(conn->handler->connect_it);
5335 result = conn->handler->connect_it(conn, &done);
5339 conn->data = data;
5340 conn->bits.tcpconnect[FIRSTSOCKET] = TRUE; /* we are "connected */
5342 ConnectionStore(data, conn);
5349 DEBUGASSERT(conn->handler->done);
5351 (void)conn->handler->done(conn, result, FALSE);
5355 Curl_setup_transfer(conn, -1, -1, FALSE, NULL, /* no download */
5360 do_init(conn);
5387 if(!Curl_clone_ssl_config(&data->set.ssl, &conn->ssl_config)) {
5405 reuse = ConnectionExists(data, conn, &conn_temp, &force_reuse);
5434 reuse_conn(conn, conn_temp);
5435 free(conn); /* we don't need this anymore */
5436 conn = conn_temp;
5437 *in_connect = conn;
5440 fix_hostname(data, conn, &conn->host);
5443 conn->connection_id,
5444 conn->proxy.name?conn->proxy.dispname:conn->host.dispname);
5453 conn->host.name);
5490 conn_free(conn);
5501 ConnectionStore(data, conn);
5506 conn->inuse = TRUE;
5509 do_init(conn);
5524 conn->fread_func = data->set.fread_func;
5525 conn->fread_in = data->set.in;
5526 conn->seek_func = data->set.seek_func;
5527 conn->seek_client = data->set.seek_client;
5532 result = resolve_server(data, conn, async);
5548 * conn->data MUST already have been setup fine (in create_conn)
5551 CURLcode Curl_setup_conn(struct connectdata *conn,
5555 struct SessionHandle *data = conn->data;
5559 if(conn->handler->flags & PROTOPT_NONETWORK) {
5570 conn->bits.proxy_connect_closed = FALSE;
5578 Curl_safefree(conn->allocptr.uagent);
5579 conn->allocptr.uagent =
5581 if(!conn->allocptr.uagent)
5593 conn->now = Curl_tvnow();
5595 if(CURL_SOCKET_BAD == conn->sock[FIRSTSOCKET]) {
5596 conn->bits.tcpconnect[FIRSTSOCKET] = FALSE;
5597 result = Curl_connecthost(conn, conn->dns_entry);
5604 conn->bits.tcpconnect[FIRSTSOCKET] = TRUE;
5606 Curl_updateconninfo(conn, conn->sock[FIRSTSOCKET]);
5607 Curl_verboseconnect(conn);
5610 conn->now = Curl_tvnow(); /* time this *after* the connect is done, we
5675 struct connectdata *conn;
5680 conn = *connp;
5681 data = conn->data;
5683 if(conn->bits.done)
5687 Curl_getoff_all_pipelines(data, conn);
5689 if((conn->send_pipe->size + conn->recv_pipe->size != 0 &&
5691 !conn->bits.close))
5696 conn->bits.done = TRUE; /* called just now! */
5708 Curl_resolver_cancel(conn);
5710 if(conn->dns_entry) {
5711 Curl_resolv_unlock(data, conn->dns_entry); /* done with this */
5712 conn->dns_entry = NULL;
5729 if(conn->handler->done)
5730 result = conn->handler->done(conn, status, premature);
5734 if(Curl_pgrsDone(conn) && !result)
5747 if conn->bits.close is TRUE, it means that the connection should be
5757 if(data->set.reuse_forbid || conn->bits.close || premature) {
5758 CURLcode res2 = Curl_disconnect(conn, premature); /* close connection */
5767 if(ConnectionDone(data, conn)) {
5769 data->state.lastconnect = conn;
5772 conn->connection_id,
5773 conn->bits.httpproxy?conn->proxy.dispname:conn->host.dispname);
5796 static CURLcode do_init(struct connectdata *conn)
5798 struct SessionHandle *data = conn->data;
5801 conn->bits.done = FALSE; /* Curl_done() is not called yet */
5802 conn->bits.do_more = FALSE; /* by default there's no curl_do_more() to use */
5841 static void do_complete(struct connectdata *conn)
5843 conn->data->req.chunk=FALSE;
5844 conn->data->req.maxfd = (conn->sockfd>conn->writesockfd?
5845 conn->sockfd:conn->writesockfd)+1;
5846 Curl_pgrsTime(conn->data, TIMER_PRETRANSFER);
5852 struct connectdata *conn = *connp;
5853 struct SessionHandle *data = conn->data;
5855 if(conn->handler->do_it) {
5857 result = conn->handler->do_it(conn, done);
5860 if((CURLE_SEND_ERROR == result) && conn->bits.reuse) {
5871 conn = *connp; /* re-assign conn since Curl_reconnect_request
5873 result = conn->handler->do_it(conn, done);
5882 do_complete(conn);
5898 CURLcode Curl_do_more(struct connectdata *conn, int *complete)
5904 if(conn->handler->do_more)
5905 result = conn->handler->do_more(conn, complete);
5909 do_complete(conn);