Annotation of embedaddon/curl/lib/url.c, revision 1.1
1.1 ! misho 1: /***************************************************************************
! 2: * _ _ ____ _
! 3: * Project ___| | | | _ \| |
! 4: * / __| | | | |_) | |
! 5: * | (__| |_| | _ <| |___
! 6: * \___|\___/|_| \_\_____|
! 7: *
! 8: * Copyright (C) 1998 - 2020, Daniel Stenberg, <daniel@haxx.se>, et al.
! 9: *
! 10: * This software is licensed as described in the file COPYING, which
! 11: * you should have received as part of this distribution. The terms
! 12: * are also available at https://curl.haxx.se/docs/copyright.html.
! 13: *
! 14: * You may opt to use, copy, modify, merge, publish, distribute and/or sell
! 15: * copies of the Software, and permit persons to whom the Software is
! 16: * furnished to do so, under the terms of the COPYING file.
! 17: *
! 18: * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
! 19: * KIND, either express or implied.
! 20: *
! 21: ***************************************************************************/
! 22:
! 23: #include "curl_setup.h"
! 24:
! 25: #ifdef HAVE_NETINET_IN_H
! 26: #include <netinet/in.h>
! 27: #endif
! 28: #ifdef HAVE_NETDB_H
! 29: #include <netdb.h>
! 30: #endif
! 31: #ifdef HAVE_ARPA_INET_H
! 32: #include <arpa/inet.h>
! 33: #endif
! 34: #ifdef HAVE_NET_IF_H
! 35: #include <net/if.h>
! 36: #endif
! 37: #ifdef HAVE_IPHLPAPI_H
! 38: #include <Iphlpapi.h>
! 39: #endif
! 40: #ifdef HAVE_SYS_IOCTL_H
! 41: #include <sys/ioctl.h>
! 42: #endif
! 43: #ifdef HAVE_SYS_PARAM_H
! 44: #include <sys/param.h>
! 45: #endif
! 46:
! 47: #ifdef __VMS
! 48: #include <in.h>
! 49: #include <inet.h>
! 50: #endif
! 51:
! 52: #ifdef HAVE_SYS_UN_H
! 53: #include <sys/un.h>
! 54: #endif
! 55:
! 56: #ifndef HAVE_SOCKET
! 57: #error "We can't compile without socket() support!"
! 58: #endif
! 59:
! 60: #include <limits.h>
! 61:
! 62: #ifdef USE_LIBIDN2
! 63: #include <idn2.h>
! 64:
! 65: #elif defined(USE_WIN32_IDN)
! 66: /* prototype for curl_win32_idn_to_ascii() */
! 67: bool curl_win32_idn_to_ascii(const char *in, char **out);
! 68: #endif /* USE_LIBIDN2 */
! 69:
! 70: #include "urldata.h"
! 71: #include "netrc.h"
! 72:
! 73: #include "formdata.h"
! 74: #include "mime.h"
! 75: #include "vtls/vtls.h"
! 76: #include "hostip.h"
! 77: #include "transfer.h"
! 78: #include "sendf.h"
! 79: #include "progress.h"
! 80: #include "cookie.h"
! 81: #include "strcase.h"
! 82: #include "strerror.h"
! 83: #include "escape.h"
! 84: #include "strtok.h"
! 85: #include "share.h"
! 86: #include "content_encoding.h"
! 87: #include "http_digest.h"
! 88: #include "http_negotiate.h"
! 89: #include "select.h"
! 90: #include "multiif.h"
! 91: #include "easyif.h"
! 92: #include "speedcheck.h"
! 93: #include "warnless.h"
! 94: #include "non-ascii.h"
! 95: #include "inet_pton.h"
! 96: #include "getinfo.h"
! 97: #include "urlapi-int.h"
! 98: #include "system_win32.h"
! 99:
! 100: /* And now for the protocols */
! 101: #include "ftp.h"
! 102: #include "dict.h"
! 103: #include "telnet.h"
! 104: #include "tftp.h"
! 105: #include "http.h"
! 106: #include "http2.h"
! 107: #include "file.h"
! 108: #include "curl_ldap.h"
! 109: #include "vssh/ssh.h"
! 110: #include "imap.h"
! 111: #include "url.h"
! 112: #include "connect.h"
! 113: #include "inet_ntop.h"
! 114: #include "http_ntlm.h"
! 115: #include "curl_rtmp.h"
! 116: #include "gopher.h"
! 117: #include "mqtt.h"
! 118: #include "http_proxy.h"
! 119: #include "conncache.h"
! 120: #include "multihandle.h"
! 121: #include "dotdot.h"
! 122: #include "strdup.h"
! 123: #include "setopt.h"
! 124: #include "altsvc.h"
! 125:
! 126: /* The last 3 #include files should be in this order */
! 127: #include "curl_printf.h"
! 128: #include "curl_memory.h"
! 129: #include "memdebug.h"
! 130:
! 131: static void conn_free(struct connectdata *conn);
! 132: static unsigned int get_protocol_family(unsigned int protocol);
! 133:
! 134: /* Some parts of the code (e.g. chunked encoding) assume this buffer has at
! 135: * more than just a few bytes to play with. Don't let it become too small or
! 136: * bad things will happen.
! 137: */
! 138: #if READBUFFER_SIZE < READBUFFER_MIN
! 139: # error READBUFFER_SIZE is too small
! 140: #endif
! 141:
! 142:
! 143: /*
! 144: * Protocol table.
! 145: */
! 146:
! 147: static const struct Curl_handler * const protocols[] = {
! 148:
! 149: #ifndef CURL_DISABLE_HTTP
! 150: &Curl_handler_http,
! 151: #endif
! 152:
! 153: #if defined(USE_SSL) && !defined(CURL_DISABLE_HTTP)
! 154: &Curl_handler_https,
! 155: #endif
! 156:
! 157: #ifndef CURL_DISABLE_FTP
! 158: &Curl_handler_ftp,
! 159: #endif
! 160:
! 161: #if defined(USE_SSL) && !defined(CURL_DISABLE_FTP)
! 162: &Curl_handler_ftps,
! 163: #endif
! 164:
! 165: #ifndef CURL_DISABLE_TELNET
! 166: &Curl_handler_telnet,
! 167: #endif
! 168:
! 169: #ifndef CURL_DISABLE_DICT
! 170: &Curl_handler_dict,
! 171: #endif
! 172:
! 173: #ifndef CURL_DISABLE_LDAP
! 174: &Curl_handler_ldap,
! 175: #if !defined(CURL_DISABLE_LDAPS) && \
! 176: ((defined(USE_OPENLDAP) && defined(USE_SSL)) || \
! 177: (!defined(USE_OPENLDAP) && defined(HAVE_LDAP_SSL)))
! 178: &Curl_handler_ldaps,
! 179: #endif
! 180: #endif
! 181:
! 182: #ifndef CURL_DISABLE_FILE
! 183: &Curl_handler_file,
! 184: #endif
! 185:
! 186: #ifndef CURL_DISABLE_TFTP
! 187: &Curl_handler_tftp,
! 188: #endif
! 189:
! 190: #if defined(USE_SSH) && !defined(USE_WOLFSSH)
! 191: &Curl_handler_scp,
! 192: #endif
! 193:
! 194: #if defined(USE_SSH)
! 195: &Curl_handler_sftp,
! 196: #endif
! 197:
! 198: #ifndef CURL_DISABLE_IMAP
! 199: &Curl_handler_imap,
! 200: #ifdef USE_SSL
! 201: &Curl_handler_imaps,
! 202: #endif
! 203: #endif
! 204:
! 205: #ifndef CURL_DISABLE_POP3
! 206: &Curl_handler_pop3,
! 207: #ifdef USE_SSL
! 208: &Curl_handler_pop3s,
! 209: #endif
! 210: #endif
! 211:
! 212: #if !defined(CURL_DISABLE_SMB) && defined(USE_NTLM) && \
! 213: (CURL_SIZEOF_CURL_OFF_T > 4) && \
! 214: (!defined(USE_WINDOWS_SSPI) || defined(USE_WIN32_CRYPTO))
! 215: &Curl_handler_smb,
! 216: #ifdef USE_SSL
! 217: &Curl_handler_smbs,
! 218: #endif
! 219: #endif
! 220:
! 221: #ifndef CURL_DISABLE_SMTP
! 222: &Curl_handler_smtp,
! 223: #ifdef USE_SSL
! 224: &Curl_handler_smtps,
! 225: #endif
! 226: #endif
! 227:
! 228: #ifndef CURL_DISABLE_RTSP
! 229: &Curl_handler_rtsp,
! 230: #endif
! 231:
! 232: #ifndef CURL_DISABLE_GOPHER
! 233: &Curl_handler_gopher,
! 234: #endif
! 235:
! 236: #ifdef CURL_ENABLE_MQTT
! 237: &Curl_handler_mqtt,
! 238: #endif
! 239:
! 240: #ifdef USE_LIBRTMP
! 241: &Curl_handler_rtmp,
! 242: &Curl_handler_rtmpt,
! 243: &Curl_handler_rtmpe,
! 244: &Curl_handler_rtmpte,
! 245: &Curl_handler_rtmps,
! 246: &Curl_handler_rtmpts,
! 247: #endif
! 248:
! 249: (struct Curl_handler *) NULL
! 250: };
! 251:
! 252: /*
! 253: * Dummy handler for undefined protocol schemes.
! 254: */
! 255:
! 256: static const struct Curl_handler Curl_handler_dummy = {
! 257: "<no protocol>", /* scheme */
! 258: ZERO_NULL, /* setup_connection */
! 259: ZERO_NULL, /* do_it */
! 260: ZERO_NULL, /* done */
! 261: ZERO_NULL, /* do_more */
! 262: ZERO_NULL, /* connect_it */
! 263: ZERO_NULL, /* connecting */
! 264: ZERO_NULL, /* doing */
! 265: ZERO_NULL, /* proto_getsock */
! 266: ZERO_NULL, /* doing_getsock */
! 267: ZERO_NULL, /* domore_getsock */
! 268: ZERO_NULL, /* perform_getsock */
! 269: ZERO_NULL, /* disconnect */
! 270: ZERO_NULL, /* readwrite */
! 271: ZERO_NULL, /* connection_check */
! 272: 0, /* defport */
! 273: 0, /* protocol */
! 274: PROTOPT_NONE /* flags */
! 275: };
! 276:
! 277: void Curl_freeset(struct Curl_easy *data)
! 278: {
! 279: /* Free all dynamic strings stored in the data->set substructure. */
! 280: enum dupstring i;
! 281: for(i = (enum dupstring)0; i < STRING_LAST; i++) {
! 282: Curl_safefree(data->set.str[i]);
! 283: }
! 284:
! 285: if(data->change.referer_alloc) {
! 286: Curl_safefree(data->change.referer);
! 287: data->change.referer_alloc = FALSE;
! 288: }
! 289: data->change.referer = NULL;
! 290: if(data->change.url_alloc) {
! 291: Curl_safefree(data->change.url);
! 292: data->change.url_alloc = FALSE;
! 293: }
! 294: data->change.url = NULL;
! 295:
! 296: Curl_mime_cleanpart(&data->set.mimepost);
! 297: }
! 298:
! 299: /* free the URL pieces */
! 300: static void up_free(struct Curl_easy *data)
! 301: {
! 302: struct urlpieces *up = &data->state.up;
! 303: Curl_safefree(up->scheme);
! 304: Curl_safefree(up->hostname);
! 305: Curl_safefree(up->port);
! 306: Curl_safefree(up->user);
! 307: Curl_safefree(up->password);
! 308: Curl_safefree(up->options);
! 309: Curl_safefree(up->path);
! 310: Curl_safefree(up->query);
! 311: curl_url_cleanup(data->state.uh);
! 312: data->state.uh = NULL;
! 313: }
! 314:
! 315: /*
! 316: * This is the internal function curl_easy_cleanup() calls. This should
! 317: * cleanup and free all resources associated with this sessionhandle.
! 318: *
! 319: * NOTE: if we ever add something that attempts to write to a socket or
! 320: * similar here, we must ignore SIGPIPE first. It is currently only done
! 321: * when curl_easy_perform() is invoked.
! 322: */
! 323:
! 324: CURLcode Curl_close(struct Curl_easy **datap)
! 325: {
! 326: struct Curl_multi *m;
! 327: struct Curl_easy *data;
! 328:
! 329: if(!datap || !*datap)
! 330: return CURLE_OK;
! 331:
! 332: data = *datap;
! 333: *datap = NULL;
! 334:
! 335: Curl_expire_clear(data); /* shut off timers */
! 336:
! 337: m = data->multi;
! 338: if(m)
! 339: /* This handle is still part of a multi handle, take care of this first
! 340: and detach this handle from there. */
! 341: curl_multi_remove_handle(data->multi, data);
! 342:
! 343: if(data->multi_easy) {
! 344: /* when curl_easy_perform() is used, it creates its own multi handle to
! 345: use and this is the one */
! 346: curl_multi_cleanup(data->multi_easy);
! 347: data->multi_easy = NULL;
! 348: }
! 349:
! 350: /* Destroy the timeout list that is held in the easy handle. It is
! 351: /normally/ done by curl_multi_remove_handle() but this is "just in
! 352: case" */
! 353: Curl_llist_destroy(&data->state.timeoutlist, NULL);
! 354:
! 355: data->magic = 0; /* force a clear AFTER the possibly enforced removal from
! 356: the multi handle, since that function uses the magic
! 357: field! */
! 358:
! 359: if(data->state.rangestringalloc)
! 360: free(data->state.range);
! 361:
! 362: /* freed here just in case DONE wasn't called */
! 363: Curl_free_request_state(data);
! 364:
! 365: /* Close down all open SSL info and sessions */
! 366: Curl_ssl_close_all(data);
! 367: Curl_safefree(data->state.first_host);
! 368: Curl_safefree(data->state.scratch);
! 369: Curl_ssl_free_certinfo(data);
! 370:
! 371: /* Cleanup possible redirect junk */
! 372: free(data->req.newurl);
! 373: data->req.newurl = NULL;
! 374:
! 375: if(data->change.referer_alloc) {
! 376: Curl_safefree(data->change.referer);
! 377: data->change.referer_alloc = FALSE;
! 378: }
! 379: data->change.referer = NULL;
! 380:
! 381: up_free(data);
! 382: Curl_safefree(data->state.buffer);
! 383: Curl_safefree(data->state.headerbuff);
! 384: Curl_safefree(data->state.ulbuf);
! 385: Curl_flush_cookies(data, TRUE);
! 386: #ifdef USE_ALTSVC
! 387: Curl_altsvc_save(data, data->asi, data->set.str[STRING_ALTSVC]);
! 388: Curl_altsvc_cleanup(data->asi);
! 389: data->asi = NULL;
! 390: #endif
! 391: #if !defined(CURL_DISABLE_HTTP) && !defined(CURL_DISABLE_CRYPTO_AUTH)
! 392: Curl_http_auth_cleanup_digest(data);
! 393: #endif
! 394: Curl_safefree(data->info.contenttype);
! 395: Curl_safefree(data->info.wouldredirect);
! 396:
! 397: /* this destroys the channel and we cannot use it anymore after this */
! 398: Curl_resolver_cleanup(data->state.resolver);
! 399:
! 400: Curl_http2_cleanup_dependencies(data);
! 401: Curl_convert_close(data);
! 402:
! 403: /* No longer a dirty share, if it exists */
! 404: if(data->share) {
! 405: Curl_share_lock(data, CURL_LOCK_DATA_SHARE, CURL_LOCK_ACCESS_SINGLE);
! 406: data->share->dirty--;
! 407: Curl_share_unlock(data, CURL_LOCK_DATA_SHARE);
! 408: }
! 409:
! 410: #ifndef CURL_DISABLE_DOH
! 411: free(data->req.doh.probe[0].serverdoh.memory);
! 412: free(data->req.doh.probe[1].serverdoh.memory);
! 413: curl_slist_free_all(data->req.doh.headers);
! 414: #endif
! 415:
! 416: /* destruct wildcard structures if it is needed */
! 417: Curl_wildcard_dtor(&data->wildcard);
! 418: Curl_freeset(data);
! 419: free(data);
! 420: return CURLE_OK;
! 421: }
! 422:
! 423: /*
! 424: * Initialize the UserDefined fields within a Curl_easy.
! 425: * This may be safely called on a new or existing Curl_easy.
! 426: */
! 427: CURLcode Curl_init_userdefined(struct Curl_easy *data)
! 428: {
! 429: struct UserDefined *set = &data->set;
! 430: CURLcode result = CURLE_OK;
! 431:
! 432: set->out = stdout; /* default output to stdout */
! 433: set->in_set = stdin; /* default input from stdin */
! 434: set->err = stderr; /* default stderr to stderr */
! 435:
! 436: /* use fwrite as default function to store output */
! 437: set->fwrite_func = (curl_write_callback)fwrite;
! 438:
! 439: /* use fread as default function to read input */
! 440: set->fread_func_set = (curl_read_callback)fread;
! 441: set->is_fread_set = 0;
! 442: set->is_fwrite_set = 0;
! 443:
! 444: set->seek_func = ZERO_NULL;
! 445: set->seek_client = ZERO_NULL;
! 446:
! 447: /* conversion callbacks for non-ASCII hosts */
! 448: set->convfromnetwork = ZERO_NULL;
! 449: set->convtonetwork = ZERO_NULL;
! 450: set->convfromutf8 = ZERO_NULL;
! 451:
! 452: set->filesize = -1; /* we don't know the size */
! 453: set->postfieldsize = -1; /* unknown size */
! 454: set->maxredirs = -1; /* allow any amount by default */
! 455:
! 456: set->httpreq = HTTPREQ_GET; /* Default HTTP request */
! 457: set->rtspreq = RTSPREQ_OPTIONS; /* Default RTSP request */
! 458: #ifndef CURL_DISABLE_FTP
! 459: set->ftp_use_epsv = TRUE; /* FTP defaults to EPSV operations */
! 460: set->ftp_use_eprt = TRUE; /* FTP defaults to EPRT operations */
! 461: set->ftp_use_pret = FALSE; /* mainly useful for drftpd servers */
! 462: set->ftp_filemethod = FTPFILE_MULTICWD;
! 463: #endif
! 464: set->dns_cache_timeout = 60; /* Timeout every 60 seconds by default */
! 465:
! 466: /* Set the default size of the SSL session ID cache */
! 467: set->general_ssl.max_ssl_sessions = 5;
! 468:
! 469: set->proxyport = 0;
! 470: set->proxytype = CURLPROXY_HTTP; /* defaults to HTTP proxy */
! 471: set->httpauth = CURLAUTH_BASIC; /* defaults to basic */
! 472: set->proxyauth = CURLAUTH_BASIC; /* defaults to basic */
! 473:
! 474: /* SOCKS5 proxy auth defaults to username/password + GSS-API */
! 475: set->socks5auth = CURLAUTH_BASIC | CURLAUTH_GSSAPI;
! 476:
! 477: /* make libcurl quiet by default: */
! 478: set->hide_progress = TRUE; /* CURLOPT_NOPROGRESS changes these */
! 479:
! 480: Curl_mime_initpart(&set->mimepost, data);
! 481:
! 482: /*
! 483: * libcurl 7.10 introduced SSL verification *by default*! This needs to be
! 484: * switched off unless wanted.
! 485: */
! 486: set->ssl.primary.verifypeer = TRUE;
! 487: set->ssl.primary.verifyhost = TRUE;
! 488: #ifdef USE_TLS_SRP
! 489: set->ssl.authtype = CURL_TLSAUTH_NONE;
! 490: #endif
! 491: set->ssh_auth_types = CURLSSH_AUTH_DEFAULT; /* defaults to any auth
! 492: type */
! 493: set->ssl.primary.sessionid = TRUE; /* session ID caching enabled by
! 494: default */
! 495: set->proxy_ssl = set->ssl;
! 496:
! 497: set->new_file_perms = 0644; /* Default permissions */
! 498: set->new_directory_perms = 0755; /* Default permissions */
! 499:
! 500: /* for the *protocols fields we don't use the CURLPROTO_ALL convenience
! 501: define since we internally only use the lower 16 bits for the passed
! 502: in bitmask to not conflict with the private bits */
! 503: set->allowed_protocols = CURLPROTO_ALL;
! 504: set->redir_protocols = CURLPROTO_HTTP | CURLPROTO_HTTPS | CURLPROTO_FTP |
! 505: CURLPROTO_FTPS;
! 506:
! 507: #if defined(HAVE_GSSAPI) || defined(USE_WINDOWS_SSPI)
! 508: /*
! 509: * disallow unprotected protection negotiation NEC reference implementation
! 510: * seem not to follow rfc1961 section 4.3/4.4
! 511: */
! 512: set->socks5_gssapi_nec = FALSE;
! 513: #endif
! 514:
! 515: /* Set the default CA cert bundle/path detected/specified at build time.
! 516: *
! 517: * If Schannel is the selected SSL backend then these locations are
! 518: * ignored. We allow setting CA location for schannel only when explicitly
! 519: * specified by the user via CURLOPT_CAINFO / --cacert.
! 520: */
! 521: if(Curl_ssl_backend() != CURLSSLBACKEND_SCHANNEL) {
! 522: #if defined(CURL_CA_BUNDLE)
! 523: result = Curl_setstropt(&set->str[STRING_SSL_CAFILE_ORIG], CURL_CA_BUNDLE);
! 524: if(result)
! 525: return result;
! 526:
! 527: result = Curl_setstropt(&set->str[STRING_SSL_CAFILE_PROXY],
! 528: CURL_CA_BUNDLE);
! 529: if(result)
! 530: return result;
! 531: #endif
! 532: #if defined(CURL_CA_PATH)
! 533: result = Curl_setstropt(&set->str[STRING_SSL_CAPATH_ORIG], CURL_CA_PATH);
! 534: if(result)
! 535: return result;
! 536:
! 537: result = Curl_setstropt(&set->str[STRING_SSL_CAPATH_PROXY], CURL_CA_PATH);
! 538: if(result)
! 539: return result;
! 540: #endif
! 541: }
! 542:
! 543: set->wildcard_enabled = FALSE;
! 544: set->chunk_bgn = ZERO_NULL;
! 545: set->chunk_end = ZERO_NULL;
! 546: set->tcp_keepalive = FALSE;
! 547: set->tcp_keepintvl = 60;
! 548: set->tcp_keepidle = 60;
! 549: set->tcp_fastopen = FALSE;
! 550: set->tcp_nodelay = TRUE;
! 551: set->ssl_enable_npn = TRUE;
! 552: set->ssl_enable_alpn = TRUE;
! 553: set->expect_100_timeout = 1000L; /* Wait for a second by default. */
! 554: set->sep_headers = TRUE; /* separated header lists by default */
! 555: set->buffer_size = READBUFFER_SIZE;
! 556: set->upload_buffer_size = UPLOADBUFFER_DEFAULT;
! 557: set->happy_eyeballs_timeout = CURL_HET_DEFAULT;
! 558: set->fnmatch = ZERO_NULL;
! 559: set->upkeep_interval_ms = CURL_UPKEEP_INTERVAL_DEFAULT;
! 560: set->maxconnects = DEFAULT_CONNCACHE_SIZE; /* for easy handles */
! 561: set->maxage_conn = 118;
! 562: set->http09_allowed = FALSE;
! 563: set->httpversion =
! 564: #ifdef USE_NGHTTP2
! 565: CURL_HTTP_VERSION_2TLS
! 566: #else
! 567: CURL_HTTP_VERSION_1_1
! 568: #endif
! 569: ;
! 570: #if defined(__FreeBSD_version)
! 571: /* different handling of signals and threads */
! 572: set->no_signal = TRUE;
! 573: #endif
! 574: Curl_http2_init_userset(set);
! 575: return result;
! 576: }
! 577:
! 578: /**
! 579: * Curl_open()
! 580: *
! 581: * @param curl is a pointer to a sessionhandle pointer that gets set by this
! 582: * function.
! 583: * @return CURLcode
! 584: */
! 585:
! 586: CURLcode Curl_open(struct Curl_easy **curl)
! 587: {
! 588: CURLcode result;
! 589: struct Curl_easy *data;
! 590:
! 591: /* Very simple start-up: alloc the struct, init it with zeroes and return */
! 592: data = calloc(1, sizeof(struct Curl_easy));
! 593: if(!data) {
! 594: /* this is a very serious error */
! 595: DEBUGF(fprintf(stderr, "Error: calloc of Curl_easy failed\n"));
! 596: return CURLE_OUT_OF_MEMORY;
! 597: }
! 598:
! 599: data->magic = CURLEASY_MAGIC_NUMBER;
! 600:
! 601: result = Curl_resolver_init(data, &data->state.resolver);
! 602: if(result) {
! 603: DEBUGF(fprintf(stderr, "Error: resolver_init failed\n"));
! 604: free(data);
! 605: return result;
! 606: }
! 607:
! 608: /* We do some initial setup here, all those fields that can't be just 0 */
! 609:
! 610: data->state.buffer = malloc(READBUFFER_SIZE + 1);
! 611: if(!data->state.buffer) {
! 612: DEBUGF(fprintf(stderr, "Error: malloc of buffer failed\n"));
! 613: result = CURLE_OUT_OF_MEMORY;
! 614: }
! 615: else {
! 616: data->state.headerbuff = malloc(HEADERSIZE);
! 617: if(!data->state.headerbuff) {
! 618: DEBUGF(fprintf(stderr, "Error: malloc of headerbuff failed\n"));
! 619: result = CURLE_OUT_OF_MEMORY;
! 620: }
! 621: else {
! 622: result = Curl_init_userdefined(data);
! 623:
! 624: data->state.headersize = HEADERSIZE;
! 625: Curl_convert_init(data);
! 626: Curl_initinfo(data);
! 627:
! 628: /* most recent connection is not yet defined */
! 629: data->state.lastconnect = NULL;
! 630:
! 631: data->progress.flags |= PGRS_HIDE;
! 632: data->state.current_speed = -1; /* init to negative == impossible */
! 633: }
! 634: }
! 635:
! 636: if(result) {
! 637: Curl_resolver_cleanup(data->state.resolver);
! 638: free(data->state.buffer);
! 639: free(data->state.headerbuff);
! 640: Curl_freeset(data);
! 641: free(data);
! 642: data = NULL;
! 643: }
! 644: else
! 645: *curl = data;
! 646:
! 647: return result;
! 648: }
! 649:
! 650: #ifdef USE_RECV_BEFORE_SEND_WORKAROUND
! 651: static void conn_reset_postponed_data(struct connectdata *conn, int num)
! 652: {
! 653: struct postponed_data * const psnd = &(conn->postponed[num]);
! 654: if(psnd->buffer) {
! 655: DEBUGASSERT(psnd->allocated_size > 0);
! 656: DEBUGASSERT(psnd->recv_size <= psnd->allocated_size);
! 657: DEBUGASSERT(psnd->recv_size ?
! 658: (psnd->recv_processed < psnd->recv_size) :
! 659: (psnd->recv_processed == 0));
! 660: DEBUGASSERT(psnd->bindsock != CURL_SOCKET_BAD);
! 661: free(psnd->buffer);
! 662: psnd->buffer = NULL;
! 663: psnd->allocated_size = 0;
! 664: psnd->recv_size = 0;
! 665: psnd->recv_processed = 0;
! 666: #ifdef DEBUGBUILD
! 667: psnd->bindsock = CURL_SOCKET_BAD; /* used only for DEBUGASSERT */
! 668: #endif /* DEBUGBUILD */
! 669: }
! 670: else {
! 671: DEBUGASSERT(psnd->allocated_size == 0);
! 672: DEBUGASSERT(psnd->recv_size == 0);
! 673: DEBUGASSERT(psnd->recv_processed == 0);
! 674: DEBUGASSERT(psnd->bindsock == CURL_SOCKET_BAD);
! 675: }
! 676: }
! 677:
! 678: static void conn_reset_all_postponed_data(struct connectdata *conn)
! 679: {
! 680: conn_reset_postponed_data(conn, 0);
! 681: conn_reset_postponed_data(conn, 1);
! 682: }
! 683: #else /* ! USE_RECV_BEFORE_SEND_WORKAROUND */
! 684: /* Use "do-nothing" macro instead of function when workaround not used */
! 685: #define conn_reset_all_postponed_data(c) do {} while(0)
! 686: #endif /* ! USE_RECV_BEFORE_SEND_WORKAROUND */
! 687:
! 688:
! 689: static void conn_shutdown(struct connectdata *conn)
! 690: {
! 691: if(!conn)
! 692: return;
! 693:
! 694: infof(conn->data, "Closing connection %ld\n", conn->connection_id);
! 695: DEBUGASSERT(conn->data);
! 696:
! 697: /* possible left-overs from the async name resolvers */
! 698: Curl_resolver_cancel(conn);
! 699:
! 700: /* close the SSL stuff before we close any sockets since they will/may
! 701: write to the sockets */
! 702: Curl_ssl_close(conn, FIRSTSOCKET);
! 703: Curl_ssl_close(conn, SECONDARYSOCKET);
! 704:
! 705: /* close possibly still open sockets */
! 706: if(CURL_SOCKET_BAD != conn->sock[SECONDARYSOCKET])
! 707: Curl_closesocket(conn, conn->sock[SECONDARYSOCKET]);
! 708: if(CURL_SOCKET_BAD != conn->sock[FIRSTSOCKET])
! 709: Curl_closesocket(conn, conn->sock[FIRSTSOCKET]);
! 710: if(CURL_SOCKET_BAD != conn->tempsock[0])
! 711: Curl_closesocket(conn, conn->tempsock[0]);
! 712: if(CURL_SOCKET_BAD != conn->tempsock[1])
! 713: Curl_closesocket(conn, conn->tempsock[1]);
! 714:
! 715: /* unlink ourselves. this should be called last since other shutdown
! 716: procedures need a valid conn->data and this may clear it. */
! 717: Curl_conncache_remove_conn(conn->data, conn, TRUE);
! 718: }
! 719:
! 720: static void conn_free(struct connectdata *conn)
! 721: {
! 722: if(!conn)
! 723: return;
! 724:
! 725: Curl_free_idnconverted_hostname(&conn->host);
! 726: Curl_free_idnconverted_hostname(&conn->conn_to_host);
! 727: Curl_free_idnconverted_hostname(&conn->http_proxy.host);
! 728: Curl_free_idnconverted_hostname(&conn->socks_proxy.host);
! 729:
! 730: Curl_safefree(conn->user);
! 731: Curl_safefree(conn->passwd);
! 732: Curl_safefree(conn->sasl_authzid);
! 733: Curl_safefree(conn->options);
! 734: Curl_safefree(conn->http_proxy.user);
! 735: Curl_safefree(conn->socks_proxy.user);
! 736: Curl_safefree(conn->http_proxy.passwd);
! 737: Curl_safefree(conn->socks_proxy.passwd);
! 738: Curl_safefree(conn->allocptr.proxyuserpwd);
! 739: Curl_safefree(conn->allocptr.uagent);
! 740: Curl_safefree(conn->allocptr.userpwd);
! 741: Curl_safefree(conn->allocptr.accept_encoding);
! 742: Curl_safefree(conn->allocptr.te);
! 743: Curl_safefree(conn->allocptr.rangeline);
! 744: Curl_safefree(conn->allocptr.ref);
! 745: Curl_safefree(conn->allocptr.host);
! 746: Curl_safefree(conn->allocptr.cookiehost);
! 747: Curl_safefree(conn->allocptr.rtsp_transport);
! 748: Curl_safefree(conn->trailer);
! 749: Curl_safefree(conn->host.rawalloc); /* host name buffer */
! 750: Curl_safefree(conn->conn_to_host.rawalloc); /* host name buffer */
! 751: Curl_safefree(conn->hostname_resolve);
! 752: Curl_safefree(conn->secondaryhostname);
! 753: Curl_safefree(conn->http_proxy.host.rawalloc); /* http proxy name buffer */
! 754: Curl_safefree(conn->socks_proxy.host.rawalloc); /* socks proxy name buffer */
! 755: Curl_safefree(conn->connect_state);
! 756:
! 757: conn_reset_all_postponed_data(conn);
! 758: Curl_llist_destroy(&conn->easyq, NULL);
! 759: Curl_safefree(conn->localdev);
! 760: Curl_free_primary_ssl_config(&conn->ssl_config);
! 761: Curl_free_primary_ssl_config(&conn->proxy_ssl_config);
! 762:
! 763: #ifdef USE_UNIX_SOCKETS
! 764: Curl_safefree(conn->unix_domain_socket);
! 765: #endif
! 766:
! 767: #ifdef USE_SSL
! 768: Curl_safefree(conn->ssl_extra);
! 769: #endif
! 770: free(conn); /* free all the connection oriented data */
! 771: }
! 772:
! 773: /*
! 774: * Disconnects the given connection. Note the connection may not be the
! 775: * primary connection, like when freeing room in the connection cache or
! 776: * killing of a dead old connection.
! 777: *
! 778: * A connection needs an easy handle when closing down. We support this passed
! 779: * in separately since the connection to get closed here is often already
! 780: * disassociated from an easy handle.
! 781: *
! 782: * This function MUST NOT reset state in the Curl_easy struct if that
! 783: * isn't strictly bound to the life-time of *this* particular connection.
! 784: *
! 785: */
! 786:
! 787: CURLcode Curl_disconnect(struct Curl_easy *data,
! 788: struct connectdata *conn, bool dead_connection)
! 789: {
! 790: if(!conn)
! 791: return CURLE_OK; /* this is closed and fine already */
! 792:
! 793: if(!data) {
! 794: DEBUGF(infof(data, "DISCONNECT without easy handle, ignoring\n"));
! 795: return CURLE_OK;
! 796: }
! 797:
! 798: /*
! 799: * If this connection isn't marked to force-close, leave it open if there
! 800: * are other users of it
! 801: */
! 802: if(CONN_INUSE(conn) && !dead_connection) {
! 803: DEBUGF(infof(data, "Curl_disconnect when inuse: %zu\n", CONN_INUSE(conn)));
! 804: return CURLE_OK;
! 805: }
! 806:
! 807: if(conn->dns_entry != NULL) {
! 808: Curl_resolv_unlock(data, conn->dns_entry);
! 809: conn->dns_entry = NULL;
! 810: }
! 811:
! 812: Curl_hostcache_prune(data); /* kill old DNS cache entries */
! 813:
! 814: #if !defined(CURL_DISABLE_HTTP) && defined(USE_NTLM)
! 815: /* Cleanup NTLM connection-related data */
! 816: Curl_http_auth_cleanup_ntlm(conn);
! 817: #endif
! 818: #if !defined(CURL_DISABLE_HTTP) && defined(USE_SPNEGO)
! 819: /* Cleanup NEGOTIATE connection-related data */
! 820: Curl_http_auth_cleanup_negotiate(conn);
! 821: #endif
! 822:
! 823: /* the protocol specific disconnect handler and conn_shutdown need a transfer
! 824: for the connection! */
! 825: conn->data = data;
! 826:
! 827: if(conn->bits.connect_only)
! 828: /* treat the connection as dead in CONNECT_ONLY situations */
! 829: dead_connection = TRUE;
! 830:
! 831: if(conn->handler->disconnect)
! 832: /* This is set if protocol-specific cleanups should be made */
! 833: conn->handler->disconnect(conn, dead_connection);
! 834:
! 835: conn_shutdown(conn);
! 836: conn_free(conn);
! 837: return CURLE_OK;
! 838: }
! 839:
! 840: /*
! 841: * This function should return TRUE if the socket is to be assumed to
! 842: * be dead. Most commonly this happens when the server has closed the
! 843: * connection due to inactivity.
! 844: */
! 845: static bool SocketIsDead(curl_socket_t sock)
! 846: {
! 847: int sval;
! 848: bool ret_val = TRUE;
! 849:
! 850: sval = SOCKET_READABLE(sock, 0);
! 851: if(sval == 0)
! 852: /* timeout */
! 853: ret_val = FALSE;
! 854:
! 855: return ret_val;
! 856: }
! 857:
! 858: /*
! 859: * IsMultiplexingPossible()
! 860: *
! 861: * Return a bitmask with the available multiplexing options for the given
! 862: * requested connection.
! 863: */
! 864: static int IsMultiplexingPossible(const struct Curl_easy *handle,
! 865: const struct connectdata *conn)
! 866: {
! 867: int avail = 0;
! 868:
! 869: /* If a HTTP protocol and multiplexing is enabled */
! 870: if((conn->handler->protocol & PROTO_FAMILY_HTTP) &&
! 871: (!conn->bits.protoconnstart || !conn->bits.close)) {
! 872:
! 873: if(Curl_multiplex_wanted(handle->multi) &&
! 874: (handle->set.httpversion >= CURL_HTTP_VERSION_2))
! 875: /* allows HTTP/2 */
! 876: avail |= CURLPIPE_MULTIPLEX;
! 877: }
! 878: return avail;
! 879: }
! 880:
! 881: #ifndef CURL_DISABLE_PROXY
! 882: static bool
! 883: proxy_info_matches(const struct proxy_info* data,
! 884: const struct proxy_info* needle)
! 885: {
! 886: if((data->proxytype == needle->proxytype) &&
! 887: (data->port == needle->port) &&
! 888: Curl_safe_strcasecompare(data->host.name, needle->host.name))
! 889: return TRUE;
! 890:
! 891: return FALSE;
! 892: }
! 893:
! 894: static bool
! 895: socks_proxy_info_matches(const struct proxy_info* data,
! 896: const struct proxy_info* needle)
! 897: {
! 898: if(!proxy_info_matches(data, needle))
! 899: return FALSE;
! 900:
! 901: /* the user information is case-sensitive
! 902: or at least it is not defined as case-insensitive
! 903: see https://tools.ietf.org/html/rfc3986#section-3.2.1 */
! 904: if((data->user == NULL) != (needle->user == NULL))
! 905: return FALSE;
! 906: /* curl_strequal does a case insentive comparison, so do not use it here! */
! 907: if(data->user &&
! 908: needle->user &&
! 909: strcmp(data->user, needle->user) != 0)
! 910: return FALSE;
! 911: if((data->passwd == NULL) != (needle->passwd == NULL))
! 912: return FALSE;
! 913: /* curl_strequal does a case insentive comparison, so do not use it here! */
! 914: if(data->passwd &&
! 915: needle->passwd &&
! 916: strcmp(data->passwd, needle->passwd) != 0)
! 917: return FALSE;
! 918: return TRUE;
! 919: }
! 920: #else
! 921: /* disabled, won't get called */
! 922: #define proxy_info_matches(x,y) FALSE
! 923: #define socks_proxy_info_matches(x,y) FALSE
! 924: #endif
! 925:
! 926: /* A connection has to have been idle for a shorter time than 'maxage_conn' to
! 927: be subject for reuse. The success rate is just too low after this. */
! 928:
! 929: static bool conn_maxage(struct Curl_easy *data,
! 930: struct connectdata *conn,
! 931: struct curltime now)
! 932: {
! 933: if(!conn->data) {
! 934: timediff_t idletime = Curl_timediff(now, conn->lastused);
! 935: idletime /= 1000; /* integer seconds is fine */
! 936:
! 937: if(idletime > data->set.maxage_conn) {
! 938: infof(data, "Too old connection (%ld seconds), disconnect it\n",
! 939: idletime);
! 940: return TRUE;
! 941: }
! 942: }
! 943: return FALSE;
! 944: }
! 945:
! 946: /*
! 947: * This function checks if the given connection is dead and extracts it from
! 948: * the connection cache if so.
! 949: *
! 950: * When this is called as a Curl_conncache_foreach() callback, the connection
! 951: * cache lock is held!
! 952: *
! 953: * Returns TRUE if the connection was dead and extracted.
! 954: */
! 955: static bool extract_if_dead(struct connectdata *conn,
! 956: struct Curl_easy *data)
! 957: {
! 958: if(!CONN_INUSE(conn) && !conn->data) {
! 959: /* The check for a dead socket makes sense only if the connection isn't in
! 960: use */
! 961: bool dead;
! 962: struct curltime now = Curl_now();
! 963: if(conn_maxage(data, conn, now)) {
! 964: dead = TRUE;
! 965: }
! 966: else if(conn->handler->connection_check) {
! 967: /* The protocol has a special method for checking the state of the
! 968: connection. Use it to check if the connection is dead. */
! 969: unsigned int state;
! 970: struct Curl_easy *olddata = conn->data;
! 971: conn->data = data; /* use this transfer for now */
! 972: state = conn->handler->connection_check(conn, CONNCHECK_ISDEAD);
! 973: conn->data = olddata;
! 974: dead = (state & CONNRESULT_DEAD);
! 975: }
! 976: else {
! 977: /* Use the general method for determining the death of a connection */
! 978: dead = SocketIsDead(conn->sock[FIRSTSOCKET]);
! 979: }
! 980:
! 981: if(dead) {
! 982: infof(data, "Connection %ld seems to be dead!\n", conn->connection_id);
! 983: Curl_conncache_remove_conn(data, conn, FALSE);
! 984: return TRUE;
! 985: }
! 986: }
! 987: return FALSE;
! 988: }
! 989:
! 990: struct prunedead {
! 991: struct Curl_easy *data;
! 992: struct connectdata *extracted;
! 993: };
! 994:
! 995: /*
! 996: * Wrapper to use extract_if_dead() function in Curl_conncache_foreach()
! 997: *
! 998: */
! 999: static int call_extract_if_dead(struct connectdata *conn, void *param)
! 1000: {
! 1001: struct prunedead *p = (struct prunedead *)param;
! 1002: if(extract_if_dead(conn, p->data)) {
! 1003: /* stop the iteration here, pass back the connection that was extracted */
! 1004: p->extracted = conn;
! 1005: return 1;
! 1006: }
! 1007: return 0; /* continue iteration */
! 1008: }
! 1009:
! 1010: /*
! 1011: * This function scans the connection cache for half-open/dead connections,
! 1012: * closes and removes them.
! 1013: * The cleanup is done at most once per second.
! 1014: */
! 1015: static void prune_dead_connections(struct Curl_easy *data)
! 1016: {
! 1017: struct curltime now = Curl_now();
! 1018: timediff_t elapsed =
! 1019: Curl_timediff(now, data->state.conn_cache->last_cleanup);
! 1020:
! 1021: if(elapsed >= 1000L) {
! 1022: struct prunedead prune;
! 1023: prune.data = data;
! 1024: prune.extracted = NULL;
! 1025: while(Curl_conncache_foreach(data, data->state.conn_cache, &prune,
! 1026: call_extract_if_dead)) {
! 1027: /* disconnect it */
! 1028: (void)Curl_disconnect(data, prune.extracted, /* dead_connection */TRUE);
! 1029: }
! 1030: data->state.conn_cache->last_cleanup = now;
! 1031: }
! 1032: }
! 1033:
! 1034: /*
! 1035: * Given one filled in connection struct (named needle), this function should
! 1036: * detect if there already is one that has all the significant details
! 1037: * exactly the same and thus should be used instead.
! 1038: *
! 1039: * If there is a match, this function returns TRUE - and has marked the
! 1040: * connection as 'in-use'. It must later be called with ConnectionDone() to
! 1041: * return back to 'idle' (unused) state.
! 1042: *
! 1043: * The force_reuse flag is set if the connection must be used.
! 1044: */
! 1045: static bool
! 1046: ConnectionExists(struct Curl_easy *data,
! 1047: struct connectdata *needle,
! 1048: struct connectdata **usethis,
! 1049: bool *force_reuse,
! 1050: bool *waitpipe)
! 1051: {
! 1052: struct connectdata *check;
! 1053: struct connectdata *chosen = 0;
! 1054: bool foundPendingCandidate = FALSE;
! 1055: bool canmultiplex = IsMultiplexingPossible(data, needle);
! 1056: struct connectbundle *bundle;
! 1057: const char *hostbundle;
! 1058:
! 1059: #ifdef USE_NTLM
! 1060: bool wantNTLMhttp = ((data->state.authhost.want &
! 1061: (CURLAUTH_NTLM | CURLAUTH_NTLM_WB)) &&
! 1062: (needle->handler->protocol & PROTO_FAMILY_HTTP));
! 1063: bool wantProxyNTLMhttp = (needle->bits.proxy_user_passwd &&
! 1064: ((data->state.authproxy.want &
! 1065: (CURLAUTH_NTLM | CURLAUTH_NTLM_WB)) &&
! 1066: (needle->handler->protocol & PROTO_FAMILY_HTTP)));
! 1067: #endif
! 1068:
! 1069: *force_reuse = FALSE;
! 1070: *waitpipe = FALSE;
! 1071:
! 1072: /* Look up the bundle with all the connections to this particular host.
! 1073: Locks the connection cache, beware of early returns! */
! 1074: bundle = Curl_conncache_find_bundle(needle, data->state.conn_cache,
! 1075: &hostbundle);
! 1076: if(bundle) {
! 1077: /* Max pipe length is zero (unlimited) for multiplexed connections */
! 1078: struct curl_llist_element *curr;
! 1079:
! 1080: infof(data, "Found bundle for host %s: %p [%s]\n",
! 1081: hostbundle, (void *)bundle, (bundle->multiuse == BUNDLE_MULTIPLEX ?
! 1082: "can multiplex" : "serially"));
! 1083:
! 1084: /* We can't multiplex if we don't know anything about the server */
! 1085: if(canmultiplex) {
! 1086: if(bundle->multiuse == BUNDLE_UNKNOWN) {
! 1087: if(data->set.pipewait) {
! 1088: infof(data, "Server doesn't support multiplex yet, wait\n");
! 1089: *waitpipe = TRUE;
! 1090: Curl_conncache_unlock(data);
! 1091: return FALSE; /* no re-use */
! 1092: }
! 1093:
! 1094: infof(data, "Server doesn't support multiplex (yet)\n");
! 1095: canmultiplex = FALSE;
! 1096: }
! 1097: if((bundle->multiuse == BUNDLE_MULTIPLEX) &&
! 1098: !Curl_multiplex_wanted(data->multi)) {
! 1099: infof(data, "Could multiplex, but not asked to!\n");
! 1100: canmultiplex = FALSE;
! 1101: }
! 1102: if(bundle->multiuse == BUNDLE_NO_MULTIUSE) {
! 1103: infof(data, "Can not multiplex, even if we wanted to!\n");
! 1104: canmultiplex = FALSE;
! 1105: }
! 1106: }
! 1107:
! 1108: curr = bundle->conn_list.head;
! 1109: while(curr) {
! 1110: bool match = FALSE;
! 1111: size_t multiplexed = 0;
! 1112:
! 1113: /*
! 1114: * Note that if we use a HTTP proxy in normal mode (no tunneling), we
! 1115: * check connections to that proxy and not to the actual remote server.
! 1116: */
! 1117: check = curr->ptr;
! 1118: curr = curr->next;
! 1119:
! 1120: if(check->bits.connect_only || check->bits.close)
! 1121: /* connect-only or to-be-closed connections will not be reused */
! 1122: continue;
! 1123:
! 1124: if(bundle->multiuse == BUNDLE_MULTIPLEX)
! 1125: multiplexed = CONN_INUSE(check);
! 1126:
! 1127: if(canmultiplex) {
! 1128: ;
! 1129: }
! 1130: else {
! 1131: if(multiplexed) {
! 1132: /* can only happen within multi handles, and means that another easy
! 1133: handle is using this connection */
! 1134: continue;
! 1135: }
! 1136:
! 1137: if(Curl_resolver_asynch()) {
! 1138: /* ip_addr_str[0] is NUL only if the resolving of the name hasn't
! 1139: completed yet and until then we don't re-use this connection */
! 1140: if(!check->ip_addr_str[0]) {
! 1141: infof(data,
! 1142: "Connection #%ld is still name resolving, can't reuse\n",
! 1143: check->connection_id);
! 1144: continue;
! 1145: }
! 1146: }
! 1147:
! 1148: if(check->sock[FIRSTSOCKET] == CURL_SOCKET_BAD) {
! 1149: foundPendingCandidate = TRUE;
! 1150: /* Don't pick a connection that hasn't connected yet */
! 1151: infof(data, "Connection #%ld isn't open enough, can't reuse\n",
! 1152: check->connection_id);
! 1153: continue;
! 1154: }
! 1155: }
! 1156:
! 1157: #ifdef USE_UNIX_SOCKETS
! 1158: if(needle->unix_domain_socket) {
! 1159: if(!check->unix_domain_socket)
! 1160: continue;
! 1161: if(strcmp(needle->unix_domain_socket, check->unix_domain_socket))
! 1162: continue;
! 1163: if(needle->abstract_unix_socket != check->abstract_unix_socket)
! 1164: continue;
! 1165: }
! 1166: else if(check->unix_domain_socket)
! 1167: continue;
! 1168: #endif
! 1169:
! 1170: if((needle->handler->flags&PROTOPT_SSL) !=
! 1171: (check->handler->flags&PROTOPT_SSL))
! 1172: /* don't do mixed SSL and non-SSL connections */
! 1173: if(get_protocol_family(check->handler->protocol) !=
! 1174: needle->handler->protocol || !check->tls_upgraded)
! 1175: /* except protocols that have been upgraded via TLS */
! 1176: continue;
! 1177:
! 1178: if(needle->bits.httpproxy != check->bits.httpproxy ||
! 1179: needle->bits.socksproxy != check->bits.socksproxy)
! 1180: continue;
! 1181:
! 1182: if(needle->bits.socksproxy &&
! 1183: !socks_proxy_info_matches(&needle->socks_proxy,
! 1184: &check->socks_proxy))
! 1185: continue;
! 1186:
! 1187: if(needle->bits.conn_to_host != check->bits.conn_to_host)
! 1188: /* don't mix connections that use the "connect to host" feature and
! 1189: * connections that don't use this feature */
! 1190: continue;
! 1191:
! 1192: if(needle->bits.conn_to_port != check->bits.conn_to_port)
! 1193: /* don't mix connections that use the "connect to port" feature and
! 1194: * connections that don't use this feature */
! 1195: continue;
! 1196:
! 1197: if(needle->bits.httpproxy) {
! 1198: if(!proxy_info_matches(&needle->http_proxy, &check->http_proxy))
! 1199: continue;
! 1200:
! 1201: if(needle->bits.tunnel_proxy != check->bits.tunnel_proxy)
! 1202: continue;
! 1203:
! 1204: if(needle->http_proxy.proxytype == CURLPROXY_HTTPS) {
! 1205: /* use https proxy */
! 1206: if(needle->handler->flags&PROTOPT_SSL) {
! 1207: /* use double layer ssl */
! 1208: if(!Curl_ssl_config_matches(&needle->proxy_ssl_config,
! 1209: &check->proxy_ssl_config))
! 1210: continue;
! 1211: if(check->proxy_ssl[FIRSTSOCKET].state != ssl_connection_complete)
! 1212: continue;
! 1213: }
! 1214: else {
! 1215: if(!Curl_ssl_config_matches(&needle->ssl_config,
! 1216: &check->ssl_config))
! 1217: continue;
! 1218: if(check->ssl[FIRSTSOCKET].state != ssl_connection_complete)
! 1219: continue;
! 1220: }
! 1221: }
! 1222: }
! 1223:
! 1224: DEBUGASSERT(!check->data || GOOD_EASY_HANDLE(check->data));
! 1225:
! 1226: if(!canmultiplex && check->data)
! 1227: /* this request can't be multiplexed but the checked connection is
! 1228: already in use so we skip it */
! 1229: continue;
! 1230:
! 1231: if(check->data && (check->data->multi != needle->data->multi))
! 1232: /* this could be subject for multiplex use, but only if they belong to
! 1233: * the same multi handle */
! 1234: continue;
! 1235:
! 1236: if(needle->localdev || needle->localport) {
! 1237: /* If we are bound to a specific local end (IP+port), we must not
! 1238: re-use a random other one, although if we didn't ask for a
! 1239: particular one we can reuse one that was bound.
! 1240:
! 1241: This comparison is a bit rough and too strict. Since the input
! 1242: parameters can be specified in numerous ways and still end up the
! 1243: same it would take a lot of processing to make it really accurate.
! 1244: Instead, this matching will assume that re-uses of bound connections
! 1245: will most likely also re-use the exact same binding parameters and
! 1246: missing out a few edge cases shouldn't hurt anyone very much.
! 1247: */
! 1248: if((check->localport != needle->localport) ||
! 1249: (check->localportrange != needle->localportrange) ||
! 1250: (needle->localdev &&
! 1251: (!check->localdev || strcmp(check->localdev, needle->localdev))))
! 1252: continue;
! 1253: }
! 1254:
! 1255: if(!(needle->handler->flags & PROTOPT_CREDSPERREQUEST)) {
! 1256: /* This protocol requires credentials per connection,
! 1257: so verify that we're using the same name and password as well */
! 1258: if(strcmp(needle->user, check->user) ||
! 1259: strcmp(needle->passwd, check->passwd)) {
! 1260: /* one of them was different */
! 1261: continue;
! 1262: }
! 1263: }
! 1264:
! 1265: if(!needle->bits.httpproxy || (needle->handler->flags&PROTOPT_SSL) ||
! 1266: needle->bits.tunnel_proxy) {
! 1267: /* The requested connection does not use a HTTP proxy or it uses SSL or
! 1268: it is a non-SSL protocol tunneled or it is a non-SSL protocol which
! 1269: is allowed to be upgraded via TLS */
! 1270:
! 1271: if((strcasecompare(needle->handler->scheme, check->handler->scheme) ||
! 1272: (get_protocol_family(check->handler->protocol) ==
! 1273: needle->handler->protocol && check->tls_upgraded)) &&
! 1274: (!needle->bits.conn_to_host || strcasecompare(
! 1275: needle->conn_to_host.name, check->conn_to_host.name)) &&
! 1276: (!needle->bits.conn_to_port ||
! 1277: needle->conn_to_port == check->conn_to_port) &&
! 1278: strcasecompare(needle->host.name, check->host.name) &&
! 1279: needle->remote_port == check->remote_port) {
! 1280: /* The schemes match or the protocol family is the same and the
! 1281: previous connection was TLS upgraded, and the hostname and host
! 1282: port match */
! 1283: if(needle->handler->flags & PROTOPT_SSL) {
! 1284: /* This is a SSL connection so verify that we're using the same
! 1285: SSL options as well */
! 1286: if(!Curl_ssl_config_matches(&needle->ssl_config,
! 1287: &check->ssl_config)) {
! 1288: DEBUGF(infof(data,
! 1289: "Connection #%ld has different SSL parameters, "
! 1290: "can't reuse\n",
! 1291: check->connection_id));
! 1292: continue;
! 1293: }
! 1294: if(check->ssl[FIRSTSOCKET].state != ssl_connection_complete) {
! 1295: foundPendingCandidate = TRUE;
! 1296: DEBUGF(infof(data,
! 1297: "Connection #%ld has not started SSL connect, "
! 1298: "can't reuse\n",
! 1299: check->connection_id));
! 1300: continue;
! 1301: }
! 1302: }
! 1303: match = TRUE;
! 1304: }
! 1305: }
! 1306: else {
! 1307: /* The requested connection is using the same HTTP proxy in normal
! 1308: mode (no tunneling) */
! 1309: match = TRUE;
! 1310: }
! 1311:
! 1312: if(match) {
! 1313: #if defined(USE_NTLM)
! 1314: /* If we are looking for an HTTP+NTLM connection, check if this is
! 1315: already authenticating with the right credentials. If not, keep
! 1316: looking so that we can reuse NTLM connections if
! 1317: possible. (Especially we must not reuse the same connection if
! 1318: partway through a handshake!) */
! 1319: if(wantNTLMhttp) {
! 1320: if(strcmp(needle->user, check->user) ||
! 1321: strcmp(needle->passwd, check->passwd)) {
! 1322:
! 1323: /* we prefer a credential match, but this is at least a connection
! 1324: that can be reused and "upgraded" to NTLM */
! 1325: if(check->http_ntlm_state == NTLMSTATE_NONE)
! 1326: chosen = check;
! 1327: continue;
! 1328: }
! 1329: }
! 1330: else if(check->http_ntlm_state != NTLMSTATE_NONE) {
! 1331: /* Connection is using NTLM auth but we don't want NTLM */
! 1332: continue;
! 1333: }
! 1334:
! 1335: /* Same for Proxy NTLM authentication */
! 1336: if(wantProxyNTLMhttp) {
! 1337: /* Both check->http_proxy.user and check->http_proxy.passwd can be
! 1338: * NULL */
! 1339: if(!check->http_proxy.user || !check->http_proxy.passwd)
! 1340: continue;
! 1341:
! 1342: if(strcmp(needle->http_proxy.user, check->http_proxy.user) ||
! 1343: strcmp(needle->http_proxy.passwd, check->http_proxy.passwd))
! 1344: continue;
! 1345: }
! 1346: else if(check->proxy_ntlm_state != NTLMSTATE_NONE) {
! 1347: /* Proxy connection is using NTLM auth but we don't want NTLM */
! 1348: continue;
! 1349: }
! 1350:
! 1351: if(wantNTLMhttp || wantProxyNTLMhttp) {
! 1352: /* Credentials are already checked, we can use this connection */
! 1353: chosen = check;
! 1354:
! 1355: if((wantNTLMhttp &&
! 1356: (check->http_ntlm_state != NTLMSTATE_NONE)) ||
! 1357: (wantProxyNTLMhttp &&
! 1358: (check->proxy_ntlm_state != NTLMSTATE_NONE))) {
! 1359: /* We must use this connection, no other */
! 1360: *force_reuse = TRUE;
! 1361: break;
! 1362: }
! 1363:
! 1364: /* Continue look up for a better connection */
! 1365: continue;
! 1366: }
! 1367: #endif
! 1368: if(canmultiplex) {
! 1369: /* We can multiplex if we want to. Let's continue looking for
! 1370: the optimal connection to use. */
! 1371:
! 1372: if(!multiplexed) {
! 1373: /* We have the optimal connection. Let's stop looking. */
! 1374: chosen = check;
! 1375: break;
! 1376: }
! 1377:
! 1378: #ifdef USE_NGHTTP2
! 1379: /* If multiplexed, make sure we don't go over concurrency limit */
! 1380: if(check->bits.multiplex) {
! 1381: /* Multiplexed connections can only be HTTP/2 for now */
! 1382: struct http_conn *httpc = &check->proto.httpc;
! 1383: if(multiplexed >= httpc->settings.max_concurrent_streams) {
! 1384: infof(data, "MAX_CONCURRENT_STREAMS reached, skip (%zu)\n",
! 1385: multiplexed);
! 1386: continue;
! 1387: }
! 1388: else if(multiplexed >=
! 1389: Curl_multi_max_concurrent_streams(needle->data->multi)) {
! 1390: infof(data, "client side MAX_CONCURRENT_STREAMS reached"
! 1391: ", skip (%zu)\n",
! 1392: multiplexed);
! 1393: continue;
! 1394: }
! 1395: }
! 1396: #endif
! 1397: /* When not multiplexed, we have a match here! */
! 1398: chosen = check;
! 1399: infof(data, "Multiplexed connection found!\n");
! 1400: break;
! 1401: }
! 1402: else {
! 1403: /* We have found a connection. Let's stop searching. */
! 1404: chosen = check;
! 1405: break;
! 1406: }
! 1407: }
! 1408: }
! 1409: }
! 1410:
! 1411: if(chosen) {
! 1412: /* mark it as used before releasing the lock */
! 1413: chosen->data = data; /* own it! */
! 1414: Curl_conncache_unlock(data);
! 1415: *usethis = chosen;
! 1416: return TRUE; /* yes, we found one to use! */
! 1417: }
! 1418: Curl_conncache_unlock(data);
! 1419:
! 1420: if(foundPendingCandidate && data->set.pipewait) {
! 1421: infof(data,
! 1422: "Found pending candidate for reuse and CURLOPT_PIPEWAIT is set\n");
! 1423: *waitpipe = TRUE;
! 1424: }
! 1425:
! 1426: return FALSE; /* no matching connecting exists */
! 1427: }
! 1428:
! 1429: /*
! 1430: * verboseconnect() displays verbose information after a connect
! 1431: */
! 1432: #ifndef CURL_DISABLE_VERBOSE_STRINGS
! 1433: void Curl_verboseconnect(struct connectdata *conn)
! 1434: {
! 1435: if(conn->data->set.verbose)
! 1436: infof(conn->data, "Connected to %s (%s) port %ld (#%ld)\n",
! 1437: conn->bits.socksproxy ? conn->socks_proxy.host.dispname :
! 1438: conn->bits.httpproxy ? conn->http_proxy.host.dispname :
! 1439: conn->bits.conn_to_host ? conn->conn_to_host.dispname :
! 1440: conn->host.dispname,
! 1441: conn->ip_addr_str, conn->port, conn->connection_id);
! 1442: }
! 1443: #endif
! 1444:
! 1445: /*
! 1446: * Helpers for IDNA conversions.
! 1447: */
! 1448: bool Curl_is_ASCII_name(const char *hostname)
! 1449: {
! 1450: /* get an UNSIGNED local version of the pointer */
! 1451: const unsigned char *ch = (const unsigned char *)hostname;
! 1452:
! 1453: if(!hostname) /* bad input, consider it ASCII! */
! 1454: return TRUE;
! 1455:
! 1456: while(*ch) {
! 1457: if(*ch++ & 0x80)
! 1458: return FALSE;
! 1459: }
! 1460: return TRUE;
! 1461: }
! 1462:
! 1463: /*
! 1464: * Strip single trailing dot in the hostname,
! 1465: * primarily for SNI and http host header.
! 1466: */
! 1467: static void strip_trailing_dot(struct hostname *host)
! 1468: {
! 1469: size_t len;
! 1470: if(!host || !host->name)
! 1471: return;
! 1472: len = strlen(host->name);
! 1473: if(len && (host->name[len-1] == '.'))
! 1474: host->name[len-1] = 0;
! 1475: }
! 1476:
! 1477: /*
! 1478: * Perform any necessary IDN conversion of hostname
! 1479: */
! 1480: CURLcode Curl_idnconvert_hostname(struct connectdata *conn,
! 1481: struct hostname *host)
! 1482: {
! 1483: struct Curl_easy *data = conn->data;
! 1484:
! 1485: #ifndef USE_LIBIDN2
! 1486: (void)data;
! 1487: (void)conn;
! 1488: #elif defined(CURL_DISABLE_VERBOSE_STRINGS)
! 1489: (void)conn;
! 1490: #endif
! 1491:
! 1492: /* set the name we use to display the host name */
! 1493: host->dispname = host->name;
! 1494:
! 1495: /* Check name for non-ASCII and convert hostname to ACE form if we can */
! 1496: if(!Curl_is_ASCII_name(host->name)) {
! 1497: #ifdef USE_LIBIDN2
! 1498: if(idn2_check_version(IDN2_VERSION)) {
! 1499: char *ace_hostname = NULL;
! 1500: #if IDN2_VERSION_NUMBER >= 0x00140000
! 1501: /* IDN2_NFC_INPUT: Normalize input string using normalization form C.
! 1502: IDN2_NONTRANSITIONAL: Perform Unicode TR46 non-transitional
! 1503: processing. */
! 1504: int flags = IDN2_NFC_INPUT | IDN2_NONTRANSITIONAL;
! 1505: #else
! 1506: int flags = IDN2_NFC_INPUT;
! 1507: #endif
! 1508: int rc = idn2_lookup_ul((const char *)host->name, &ace_hostname, flags);
! 1509: if(rc == IDN2_OK) {
! 1510: host->encalloc = (char *)ace_hostname;
! 1511: /* change the name pointer to point to the encoded hostname */
! 1512: host->name = host->encalloc;
! 1513: }
! 1514: else {
! 1515: failf(data, "Failed to convert %s to ACE; %s\n", host->name,
! 1516: idn2_strerror(rc));
! 1517: return CURLE_URL_MALFORMAT;
! 1518: }
! 1519: }
! 1520: #elif defined(USE_WIN32_IDN)
! 1521: char *ace_hostname = NULL;
! 1522:
! 1523: if(curl_win32_idn_to_ascii(host->name, &ace_hostname)) {
! 1524: host->encalloc = ace_hostname;
! 1525: /* change the name pointer to point to the encoded hostname */
! 1526: host->name = host->encalloc;
! 1527: }
! 1528: else {
! 1529: char buffer[STRERROR_LEN];
! 1530: failf(data, "Failed to convert %s to ACE; %s\n", host->name,
! 1531: Curl_winapi_strerror(GetLastError(), buffer, sizeof(buffer)));
! 1532: return CURLE_URL_MALFORMAT;
! 1533: }
! 1534: #else
! 1535: infof(data, "IDN support not present, can't parse Unicode domains\n");
! 1536: #endif
! 1537: }
! 1538: return CURLE_OK;
! 1539: }
! 1540:
! 1541: /*
! 1542: * Frees data allocated by idnconvert_hostname()
! 1543: */
! 1544: void Curl_free_idnconverted_hostname(struct hostname *host)
! 1545: {
! 1546: #if defined(USE_LIBIDN2)
! 1547: if(host->encalloc) {
! 1548: idn2_free(host->encalloc); /* must be freed with idn2_free() since this was
! 1549: allocated by libidn */
! 1550: host->encalloc = NULL;
! 1551: }
! 1552: #elif defined(USE_WIN32_IDN)
! 1553: free(host->encalloc); /* must be freed with free() since this was
! 1554: allocated by curl_win32_idn_to_ascii */
! 1555: host->encalloc = NULL;
! 1556: #else
! 1557: (void)host;
! 1558: #endif
! 1559: }
! 1560:
! 1561: /*
! 1562: * Allocate and initialize a new connectdata object.
! 1563: */
! 1564: static struct connectdata *allocate_conn(struct Curl_easy *data)
! 1565: {
! 1566: struct connectdata *conn = calloc(1, sizeof(struct connectdata));
! 1567: if(!conn)
! 1568: return NULL;
! 1569:
! 1570: #ifdef USE_SSL
! 1571: /* The SSL backend-specific data (ssl_backend_data) objects are allocated as
! 1572: a separate array to ensure suitable alignment.
! 1573: Note that these backend pointers can be swapped by vtls (eg ssl backend
! 1574: data becomes proxy backend data). */
! 1575: {
! 1576: size_t sslsize = Curl_ssl->sizeof_ssl_backend_data;
! 1577: char *ssl = calloc(4, sslsize);
! 1578: if(!ssl) {
! 1579: free(conn);
! 1580: return NULL;
! 1581: }
! 1582: conn->ssl_extra = ssl;
! 1583: conn->ssl[0].backend = (void *)ssl;
! 1584: conn->ssl[1].backend = (void *)(ssl + sslsize);
! 1585: conn->proxy_ssl[0].backend = (void *)(ssl + 2 * sslsize);
! 1586: conn->proxy_ssl[1].backend = (void *)(ssl + 3 * sslsize);
! 1587: }
! 1588: #endif
! 1589:
! 1590: conn->handler = &Curl_handler_dummy; /* Be sure we have a handler defined
! 1591: already from start to avoid NULL
! 1592: situations and checks */
! 1593:
! 1594: /* and we setup a few fields in case we end up actually using this struct */
! 1595:
! 1596: conn->sock[FIRSTSOCKET] = CURL_SOCKET_BAD; /* no file descriptor */
! 1597: conn->sock[SECONDARYSOCKET] = CURL_SOCKET_BAD; /* no file descriptor */
! 1598: conn->tempsock[0] = CURL_SOCKET_BAD; /* no file descriptor */
! 1599: conn->tempsock[1] = CURL_SOCKET_BAD; /* no file descriptor */
! 1600: conn->connection_id = -1; /* no ID */
! 1601: conn->port = -1; /* unknown at this point */
! 1602: conn->remote_port = -1; /* unknown at this point */
! 1603: #if defined(USE_RECV_BEFORE_SEND_WORKAROUND) && defined(DEBUGBUILD)
! 1604: conn->postponed[0].bindsock = CURL_SOCKET_BAD; /* no file descriptor */
! 1605: conn->postponed[1].bindsock = CURL_SOCKET_BAD; /* no file descriptor */
! 1606: #endif /* USE_RECV_BEFORE_SEND_WORKAROUND && DEBUGBUILD */
! 1607:
! 1608: /* Default protocol-independent behavior doesn't support persistent
! 1609: connections, so we set this to force-close. Protocols that support
! 1610: this need to set this to FALSE in their "curl_do" functions. */
! 1611: connclose(conn, "Default to force-close");
! 1612:
! 1613: /* Store creation time to help future close decision making */
! 1614: conn->created = Curl_now();
! 1615:
! 1616: /* Store current time to give a baseline to keepalive connection times. */
! 1617: conn->keepalive = Curl_now();
! 1618:
! 1619: /* Store off the configured connection upkeep time. */
! 1620: conn->upkeep_interval_ms = data->set.upkeep_interval_ms;
! 1621:
! 1622: conn->data = data; /* Setup the association between this connection
! 1623: and the Curl_easy */
! 1624:
! 1625: conn->http_proxy.proxytype = data->set.proxytype;
! 1626: conn->socks_proxy.proxytype = CURLPROXY_SOCKS4;
! 1627:
! 1628: #if !defined(CURL_DISABLE_PROXY)
! 1629: /* note that these two proxy bits are now just on what looks to be
! 1630: requested, they may be altered down the road */
! 1631: conn->bits.proxy = (data->set.str[STRING_PROXY] &&
! 1632: *data->set.str[STRING_PROXY]) ? TRUE : FALSE;
! 1633: conn->bits.httpproxy = (conn->bits.proxy &&
! 1634: (conn->http_proxy.proxytype == CURLPROXY_HTTP ||
! 1635: conn->http_proxy.proxytype == CURLPROXY_HTTP_1_0 ||
! 1636: conn->http_proxy.proxytype == CURLPROXY_HTTPS)) ?
! 1637: TRUE : FALSE;
! 1638: conn->bits.socksproxy = (conn->bits.proxy &&
! 1639: !conn->bits.httpproxy) ? TRUE : FALSE;
! 1640:
! 1641: if(data->set.str[STRING_PRE_PROXY] && *data->set.str[STRING_PRE_PROXY]) {
! 1642: conn->bits.proxy = TRUE;
! 1643: conn->bits.socksproxy = TRUE;
! 1644: }
! 1645:
! 1646: conn->bits.proxy_user_passwd =
! 1647: (data->set.str[STRING_PROXYUSERNAME]) ? TRUE : FALSE;
! 1648: conn->bits.tunnel_proxy = data->set.tunnel_thru_httpproxy;
! 1649: #endif /* CURL_DISABLE_PROXY */
! 1650:
! 1651: conn->bits.user_passwd = (data->set.str[STRING_USERNAME]) ? TRUE : FALSE;
! 1652: #ifndef CURL_DISABLE_FTP
! 1653: conn->bits.ftp_use_epsv = data->set.ftp_use_epsv;
! 1654: conn->bits.ftp_use_eprt = data->set.ftp_use_eprt;
! 1655: #endif
! 1656: conn->ssl_config.verifystatus = data->set.ssl.primary.verifystatus;
! 1657: conn->ssl_config.verifypeer = data->set.ssl.primary.verifypeer;
! 1658: conn->ssl_config.verifyhost = data->set.ssl.primary.verifyhost;
! 1659: conn->proxy_ssl_config.verifystatus =
! 1660: data->set.proxy_ssl.primary.verifystatus;
! 1661: conn->proxy_ssl_config.verifypeer = data->set.proxy_ssl.primary.verifypeer;
! 1662: conn->proxy_ssl_config.verifyhost = data->set.proxy_ssl.primary.verifyhost;
! 1663: conn->ip_version = data->set.ipver;
! 1664: conn->bits.connect_only = data->set.connect_only;
! 1665: conn->transport = TRNSPRT_TCP; /* most of them are TCP streams */
! 1666:
! 1667: #if !defined(CURL_DISABLE_HTTP) && defined(USE_NTLM) && \
! 1668: defined(NTLM_WB_ENABLED)
! 1669: conn->ntlm.ntlm_auth_hlpr_socket = CURL_SOCKET_BAD;
! 1670: conn->proxyntlm.ntlm_auth_hlpr_socket = CURL_SOCKET_BAD;
! 1671: #endif
! 1672:
! 1673: /* Initialize the easy handle list */
! 1674: Curl_llist_init(&conn->easyq, NULL);
! 1675:
! 1676: #ifdef HAVE_GSSAPI
! 1677: conn->data_prot = PROT_CLEAR;
! 1678: #endif
! 1679:
! 1680: /* Store the local bind parameters that will be used for this connection */
! 1681: if(data->set.str[STRING_DEVICE]) {
! 1682: conn->localdev = strdup(data->set.str[STRING_DEVICE]);
! 1683: if(!conn->localdev)
! 1684: goto error;
! 1685: }
! 1686: conn->localportrange = data->set.localportrange;
! 1687: conn->localport = data->set.localport;
! 1688:
! 1689: /* the close socket stuff needs to be copied to the connection struct as
! 1690: it may live on without (this specific) Curl_easy */
! 1691: conn->fclosesocket = data->set.fclosesocket;
! 1692: conn->closesocket_client = data->set.closesocket_client;
! 1693: conn->lastused = Curl_now(); /* used now */
! 1694:
! 1695: return conn;
! 1696: error:
! 1697:
! 1698: Curl_llist_destroy(&conn->easyq, NULL);
! 1699: free(conn->localdev);
! 1700: #ifdef USE_SSL
! 1701: free(conn->ssl_extra);
! 1702: #endif
! 1703: free(conn);
! 1704: return NULL;
! 1705: }
! 1706:
! 1707: /* returns the handler if the given scheme is built-in */
! 1708: const struct Curl_handler *Curl_builtin_scheme(const char *scheme)
! 1709: {
! 1710: const struct Curl_handler * const *pp;
! 1711: const struct Curl_handler *p;
! 1712: /* Scan protocol handler table and match against 'scheme'. The handler may
! 1713: be changed later when the protocol specific setup function is called. */
! 1714: for(pp = protocols; (p = *pp) != NULL; pp++)
! 1715: if(strcasecompare(p->scheme, scheme))
! 1716: /* Protocol found in table. Check if allowed */
! 1717: return p;
! 1718: return NULL; /* not found */
! 1719: }
! 1720:
! 1721:
! 1722: static CURLcode findprotocol(struct Curl_easy *data,
! 1723: struct connectdata *conn,
! 1724: const char *protostr)
! 1725: {
! 1726: const struct Curl_handler *p = Curl_builtin_scheme(protostr);
! 1727:
! 1728: if(p && /* Protocol found in table. Check if allowed */
! 1729: (data->set.allowed_protocols & p->protocol)) {
! 1730:
! 1731: /* it is allowed for "normal" request, now do an extra check if this is
! 1732: the result of a redirect */
! 1733: if(data->state.this_is_a_follow &&
! 1734: !(data->set.redir_protocols & p->protocol))
! 1735: /* nope, get out */
! 1736: ;
! 1737: else {
! 1738: /* Perform setup complement if some. */
! 1739: conn->handler = conn->given = p;
! 1740:
! 1741: /* 'port' and 'remote_port' are set in setup_connection_internals() */
! 1742: return CURLE_OK;
! 1743: }
! 1744: }
! 1745:
! 1746: /* The protocol was not found in the table, but we don't have to assign it
! 1747: to anything since it is already assigned to a dummy-struct in the
! 1748: create_conn() function when the connectdata struct is allocated. */
! 1749: failf(data, "Protocol \"%s\" not supported or disabled in " LIBCURL_NAME,
! 1750: protostr);
! 1751:
! 1752: return CURLE_UNSUPPORTED_PROTOCOL;
! 1753: }
! 1754:
! 1755:
! 1756: CURLcode Curl_uc_to_curlcode(CURLUcode uc)
! 1757: {
! 1758: switch(uc) {
! 1759: default:
! 1760: return CURLE_URL_MALFORMAT;
! 1761: case CURLUE_UNSUPPORTED_SCHEME:
! 1762: return CURLE_UNSUPPORTED_PROTOCOL;
! 1763: case CURLUE_OUT_OF_MEMORY:
! 1764: return CURLE_OUT_OF_MEMORY;
! 1765: case CURLUE_USER_NOT_ALLOWED:
! 1766: return CURLE_LOGIN_DENIED;
! 1767: }
! 1768: }
! 1769:
! 1770: /*
! 1771: * If the URL was set with an IPv6 numerical address with a zone id part, set
! 1772: * the scope_id based on that!
! 1773: */
! 1774:
! 1775: static void zonefrom_url(CURLU *uh, struct connectdata *conn)
! 1776: {
! 1777: char *zoneid;
! 1778: CURLUcode uc;
! 1779:
! 1780: uc = curl_url_get(uh, CURLUPART_ZONEID, &zoneid, 0);
! 1781:
! 1782: if(!uc && zoneid) {
! 1783: char *endp;
! 1784: unsigned long scope = strtoul(zoneid, &endp, 10);
! 1785: if(!*endp && (scope < UINT_MAX))
! 1786: /* A plain number, use it directly as a scope id. */
! 1787: conn->scope_id = (unsigned int)scope;
! 1788: #if defined(HAVE_IF_NAMETOINDEX)
! 1789: else {
! 1790: #elif defined(WIN32)
! 1791: else if(Curl_if_nametoindex) {
! 1792: #endif
! 1793:
! 1794: #if defined(HAVE_IF_NAMETOINDEX) || defined(WIN32)
! 1795: /* Zone identifier is not numeric */
! 1796: unsigned int scopeidx = 0;
! 1797: #if defined(WIN32)
! 1798: scopeidx = Curl_if_nametoindex(zoneid);
! 1799: #else
! 1800: scopeidx = if_nametoindex(zoneid);
! 1801: #endif
! 1802: if(!scopeidx)
! 1803: infof(conn->data, "Invalid zoneid: %s; %s\n", zoneid,
! 1804: strerror(errno));
! 1805: else
! 1806: conn->scope_id = scopeidx;
! 1807: }
! 1808: #endif /* HAVE_IF_NAMETOINDEX || WIN32 */
! 1809:
! 1810: free(zoneid);
! 1811: }
! 1812: }
! 1813:
! 1814: /*
! 1815: * Parse URL and fill in the relevant members of the connection struct.
! 1816: */
! 1817: static CURLcode parseurlandfillconn(struct Curl_easy *data,
! 1818: struct connectdata *conn)
! 1819: {
! 1820: CURLcode result;
! 1821: CURLU *uh;
! 1822: CURLUcode uc;
! 1823: char *hostname;
! 1824:
! 1825: up_free(data); /* cleanup previous leftovers first */
! 1826:
! 1827: /* parse the URL */
! 1828: if(data->set.uh) {
! 1829: uh = data->state.uh = curl_url_dup(data->set.uh);
! 1830: }
! 1831: else {
! 1832: uh = data->state.uh = curl_url();
! 1833: }
! 1834:
! 1835: if(!uh)
! 1836: return CURLE_OUT_OF_MEMORY;
! 1837:
! 1838: if(data->set.str[STRING_DEFAULT_PROTOCOL] &&
! 1839: !Curl_is_absolute_url(data->change.url, NULL, MAX_SCHEME_LEN)) {
! 1840: char *url;
! 1841: if(data->change.url_alloc)
! 1842: free(data->change.url);
! 1843: url = aprintf("%s://%s", data->set.str[STRING_DEFAULT_PROTOCOL],
! 1844: data->change.url);
! 1845: if(!url)
! 1846: return CURLE_OUT_OF_MEMORY;
! 1847: data->change.url = url;
! 1848: data->change.url_alloc = TRUE;
! 1849: }
! 1850:
! 1851: if(!data->set.uh) {
! 1852: char *newurl;
! 1853: uc = curl_url_set(uh, CURLUPART_URL, data->change.url,
! 1854: CURLU_GUESS_SCHEME |
! 1855: CURLU_NON_SUPPORT_SCHEME |
! 1856: (data->set.disallow_username_in_url ?
! 1857: CURLU_DISALLOW_USER : 0) |
! 1858: (data->set.path_as_is ? CURLU_PATH_AS_IS : 0));
! 1859: if(uc) {
! 1860: DEBUGF(infof(data, "curl_url_set rejected %s\n", data->change.url));
! 1861: return Curl_uc_to_curlcode(uc);
! 1862: }
! 1863:
! 1864: /* after it was parsed, get the generated normalized version */
! 1865: uc = curl_url_get(uh, CURLUPART_URL, &newurl, 0);
! 1866: if(uc)
! 1867: return Curl_uc_to_curlcode(uc);
! 1868: if(data->change.url_alloc)
! 1869: free(data->change.url);
! 1870: data->change.url = newurl;
! 1871: data->change.url_alloc = TRUE;
! 1872: }
! 1873:
! 1874: uc = curl_url_get(uh, CURLUPART_SCHEME, &data->state.up.scheme, 0);
! 1875: if(uc)
! 1876: return Curl_uc_to_curlcode(uc);
! 1877:
! 1878: result = findprotocol(data, conn, data->state.up.scheme);
! 1879: if(result)
! 1880: return result;
! 1881:
! 1882: uc = curl_url_get(uh, CURLUPART_USER, &data->state.up.user,
! 1883: CURLU_URLDECODE);
! 1884: if(!uc) {
! 1885: conn->user = strdup(data->state.up.user);
! 1886: if(!conn->user)
! 1887: return CURLE_OUT_OF_MEMORY;
! 1888: conn->bits.user_passwd = TRUE;
! 1889: }
! 1890: else if(uc != CURLUE_NO_USER)
! 1891: return Curl_uc_to_curlcode(uc);
! 1892:
! 1893: uc = curl_url_get(uh, CURLUPART_PASSWORD, &data->state.up.password,
! 1894: CURLU_URLDECODE);
! 1895: if(!uc) {
! 1896: conn->passwd = strdup(data->state.up.password);
! 1897: if(!conn->passwd)
! 1898: return CURLE_OUT_OF_MEMORY;
! 1899: conn->bits.user_passwd = TRUE;
! 1900: }
! 1901: else if(uc != CURLUE_NO_PASSWORD)
! 1902: return Curl_uc_to_curlcode(uc);
! 1903:
! 1904: uc = curl_url_get(uh, CURLUPART_OPTIONS, &data->state.up.options,
! 1905: CURLU_URLDECODE);
! 1906: if(!uc) {
! 1907: conn->options = strdup(data->state.up.options);
! 1908: if(!conn->options)
! 1909: return CURLE_OUT_OF_MEMORY;
! 1910: }
! 1911: else if(uc != CURLUE_NO_OPTIONS)
! 1912: return Curl_uc_to_curlcode(uc);
! 1913:
! 1914: uc = curl_url_get(uh, CURLUPART_HOST, &data->state.up.hostname, 0);
! 1915: if(uc) {
! 1916: if(!strcasecompare("file", data->state.up.scheme))
! 1917: return CURLE_OUT_OF_MEMORY;
! 1918: }
! 1919:
! 1920: uc = curl_url_get(uh, CURLUPART_PATH, &data->state.up.path, 0);
! 1921: if(uc)
! 1922: return Curl_uc_to_curlcode(uc);
! 1923:
! 1924: uc = curl_url_get(uh, CURLUPART_PORT, &data->state.up.port,
! 1925: CURLU_DEFAULT_PORT);
! 1926: if(uc) {
! 1927: if(!strcasecompare("file", data->state.up.scheme))
! 1928: return CURLE_OUT_OF_MEMORY;
! 1929: }
! 1930: else {
! 1931: unsigned long port = strtoul(data->state.up.port, NULL, 10);
! 1932: conn->port = conn->remote_port = curlx_ultous(port);
! 1933: }
! 1934:
! 1935: (void)curl_url_get(uh, CURLUPART_QUERY, &data->state.up.query, 0);
! 1936:
! 1937: hostname = data->state.up.hostname;
! 1938: if(hostname && hostname[0] == '[') {
! 1939: /* This looks like an IPv6 address literal. See if there is an address
! 1940: scope. */
! 1941: size_t hlen;
! 1942: conn->bits.ipv6_ip = TRUE;
! 1943: /* cut off the brackets! */
! 1944: hostname++;
! 1945: hlen = strlen(hostname);
! 1946: hostname[hlen - 1] = 0;
! 1947:
! 1948: zonefrom_url(uh, conn);
! 1949: }
! 1950:
! 1951: /* make sure the connect struct gets its own copy of the host name */
! 1952: conn->host.rawalloc = strdup(hostname ? hostname : "");
! 1953: if(!conn->host.rawalloc)
! 1954: return CURLE_OUT_OF_MEMORY;
! 1955: conn->host.name = conn->host.rawalloc;
! 1956:
! 1957: if(data->set.scope_id)
! 1958: /* Override any scope that was set above. */
! 1959: conn->scope_id = data->set.scope_id;
! 1960:
! 1961: return CURLE_OK;
! 1962: }
! 1963:
! 1964:
! 1965: /*
! 1966: * If we're doing a resumed transfer, we need to setup our stuff
! 1967: * properly.
! 1968: */
! 1969: static CURLcode setup_range(struct Curl_easy *data)
! 1970: {
! 1971: struct UrlState *s = &data->state;
! 1972: s->resume_from = data->set.set_resume_from;
! 1973: if(s->resume_from || data->set.str[STRING_SET_RANGE]) {
! 1974: if(s->rangestringalloc)
! 1975: free(s->range);
! 1976:
! 1977: if(s->resume_from)
! 1978: s->range = aprintf("%" CURL_FORMAT_CURL_OFF_T "-", s->resume_from);
! 1979: else
! 1980: s->range = strdup(data->set.str[STRING_SET_RANGE]);
! 1981:
! 1982: s->rangestringalloc = (s->range) ? TRUE : FALSE;
! 1983:
! 1984: if(!s->range)
! 1985: return CURLE_OUT_OF_MEMORY;
! 1986:
! 1987: /* tell ourselves to fetch this range */
! 1988: s->use_range = TRUE; /* enable range download */
! 1989: }
! 1990: else
! 1991: s->use_range = FALSE; /* disable range download */
! 1992:
! 1993: return CURLE_OK;
! 1994: }
! 1995:
! 1996:
! 1997: /*
! 1998: * setup_connection_internals() -
! 1999: *
! 2000: * Setup connection internals specific to the requested protocol in the
! 2001: * Curl_easy. This is inited and setup before the connection is made but
! 2002: * is about the particular protocol that is to be used.
! 2003: *
! 2004: * This MUST get called after proxy magic has been figured out.
! 2005: */
! 2006: static CURLcode setup_connection_internals(struct connectdata *conn)
! 2007: {
! 2008: const struct Curl_handler * p;
! 2009: CURLcode result;
! 2010:
! 2011: /* Perform setup complement if some. */
! 2012: p = conn->handler;
! 2013:
! 2014: if(p->setup_connection) {
! 2015: result = (*p->setup_connection)(conn);
! 2016:
! 2017: if(result)
! 2018: return result;
! 2019:
! 2020: p = conn->handler; /* May have changed. */
! 2021: }
! 2022:
! 2023: if(conn->port < 0)
! 2024: /* we check for -1 here since if proxy was detected already, this
! 2025: was very likely already set to the proxy port */
! 2026: conn->port = p->defport;
! 2027:
! 2028: return CURLE_OK;
! 2029: }
! 2030:
! 2031: /*
! 2032: * Curl_free_request_state() should free temp data that was allocated in the
! 2033: * Curl_easy for this single request.
! 2034: */
! 2035:
! 2036: void Curl_free_request_state(struct Curl_easy *data)
! 2037: {
! 2038: Curl_safefree(data->req.protop);
! 2039: Curl_safefree(data->req.newurl);
! 2040:
! 2041: #ifndef CURL_DISABLE_DOH
! 2042: Curl_close(&data->req.doh.probe[0].easy);
! 2043: Curl_close(&data->req.doh.probe[1].easy);
! 2044: #endif
! 2045: }
! 2046:
! 2047:
! 2048: #ifndef CURL_DISABLE_PROXY
! 2049: /****************************************************************
! 2050: * Checks if the host is in the noproxy list. returns true if it matches
! 2051: * and therefore the proxy should NOT be used.
! 2052: ****************************************************************/
! 2053: static bool check_noproxy(const char *name, const char *no_proxy)
! 2054: {
! 2055: /* no_proxy=domain1.dom,host.domain2.dom
! 2056: * (a comma-separated list of hosts which should
! 2057: * not be proxied, or an asterisk to override
! 2058: * all proxy variables)
! 2059: */
! 2060: if(no_proxy && no_proxy[0]) {
! 2061: size_t tok_start;
! 2062: size_t tok_end;
! 2063: const char *separator = ", ";
! 2064: size_t no_proxy_len;
! 2065: size_t namelen;
! 2066: char *endptr;
! 2067: if(strcasecompare("*", no_proxy)) {
! 2068: return TRUE;
! 2069: }
! 2070:
! 2071: /* NO_PROXY was specified and it wasn't just an asterisk */
! 2072:
! 2073: no_proxy_len = strlen(no_proxy);
! 2074: if(name[0] == '[') {
! 2075: /* IPv6 numerical address */
! 2076: endptr = strchr(name, ']');
! 2077: if(!endptr)
! 2078: return FALSE;
! 2079: name++;
! 2080: namelen = endptr - name;
! 2081: }
! 2082: else
! 2083: namelen = strlen(name);
! 2084:
! 2085: for(tok_start = 0; tok_start < no_proxy_len; tok_start = tok_end + 1) {
! 2086: while(tok_start < no_proxy_len &&
! 2087: strchr(separator, no_proxy[tok_start]) != NULL) {
! 2088: /* Look for the beginning of the token. */
! 2089: ++tok_start;
! 2090: }
! 2091:
! 2092: if(tok_start == no_proxy_len)
! 2093: break; /* It was all trailing separator chars, no more tokens. */
! 2094:
! 2095: for(tok_end = tok_start; tok_end < no_proxy_len &&
! 2096: strchr(separator, no_proxy[tok_end]) == NULL; ++tok_end)
! 2097: /* Look for the end of the token. */
! 2098: ;
! 2099:
! 2100: /* To match previous behaviour, where it was necessary to specify
! 2101: * ".local.com" to prevent matching "notlocal.com", we will leave
! 2102: * the '.' off.
! 2103: */
! 2104: if(no_proxy[tok_start] == '.')
! 2105: ++tok_start;
! 2106:
! 2107: if((tok_end - tok_start) <= namelen) {
! 2108: /* Match the last part of the name to the domain we are checking. */
! 2109: const char *checkn = name + namelen - (tok_end - tok_start);
! 2110: if(strncasecompare(no_proxy + tok_start, checkn,
! 2111: tok_end - tok_start)) {
! 2112: if((tok_end - tok_start) == namelen || *(checkn - 1) == '.') {
! 2113: /* We either have an exact match, or the previous character is a .
! 2114: * so it is within the same domain, so no proxy for this host.
! 2115: */
! 2116: return TRUE;
! 2117: }
! 2118: }
! 2119: } /* if((tok_end - tok_start) <= namelen) */
! 2120: } /* for(tok_start = 0; tok_start < no_proxy_len;
! 2121: tok_start = tok_end + 1) */
! 2122: } /* NO_PROXY was specified and it wasn't just an asterisk */
! 2123:
! 2124: return FALSE;
! 2125: }
! 2126:
! 2127: #ifndef CURL_DISABLE_HTTP
! 2128: /****************************************************************
! 2129: * Detect what (if any) proxy to use. Remember that this selects a host
! 2130: * name and is not limited to HTTP proxies only.
! 2131: * The returned pointer must be freed by the caller (unless NULL)
! 2132: ****************************************************************/
! 2133: static char *detect_proxy(struct connectdata *conn)
! 2134: {
! 2135: char *proxy = NULL;
! 2136:
! 2137: /* If proxy was not specified, we check for default proxy environment
! 2138: * variables, to enable i.e Lynx compliance:
! 2139: *
! 2140: * http_proxy=http://some.server.dom:port/
! 2141: * https_proxy=http://some.server.dom:port/
! 2142: * ftp_proxy=http://some.server.dom:port/
! 2143: * no_proxy=domain1.dom,host.domain2.dom
! 2144: * (a comma-separated list of hosts which should
! 2145: * not be proxied, or an asterisk to override
! 2146: * all proxy variables)
! 2147: * all_proxy=http://some.server.dom:port/
! 2148: * (seems to exist for the CERN www lib. Probably
! 2149: * the first to check for.)
! 2150: *
! 2151: * For compatibility, the all-uppercase versions of these variables are
! 2152: * checked if the lowercase versions don't exist.
! 2153: */
! 2154: char proxy_env[128];
! 2155: const char *protop = conn->handler->scheme;
! 2156: char *envp = proxy_env;
! 2157: char *prox;
! 2158:
! 2159: /* Now, build <protocol>_proxy and check for such a one to use */
! 2160: while(*protop)
! 2161: *envp++ = (char)tolower((int)*protop++);
! 2162:
! 2163: /* append _proxy */
! 2164: strcpy(envp, "_proxy");
! 2165:
! 2166: /* read the protocol proxy: */
! 2167: prox = curl_getenv(proxy_env);
! 2168:
! 2169: /*
! 2170: * We don't try the uppercase version of HTTP_PROXY because of
! 2171: * security reasons:
! 2172: *
! 2173: * When curl is used in a webserver application
! 2174: * environment (cgi or php), this environment variable can
! 2175: * be controlled by the web server user by setting the
! 2176: * http header 'Proxy:' to some value.
! 2177: *
! 2178: * This can cause 'internal' http/ftp requests to be
! 2179: * arbitrarily redirected by any external attacker.
! 2180: */
! 2181: if(!prox && !strcasecompare("http_proxy", proxy_env)) {
! 2182: /* There was no lowercase variable, try the uppercase version: */
! 2183: Curl_strntoupper(proxy_env, proxy_env, sizeof(proxy_env));
! 2184: prox = curl_getenv(proxy_env);
! 2185: }
! 2186:
! 2187: envp = proxy_env;
! 2188: if(prox) {
! 2189: proxy = prox; /* use this */
! 2190: }
! 2191: else {
! 2192: envp = (char *)"all_proxy";
! 2193: proxy = curl_getenv(envp); /* default proxy to use */
! 2194: if(!proxy) {
! 2195: envp = (char *)"ALL_PROXY";
! 2196: proxy = curl_getenv(envp);
! 2197: }
! 2198: }
! 2199: if(proxy)
! 2200: infof(conn->data, "Uses proxy env variable %s == '%s'\n", envp, proxy);
! 2201:
! 2202: return proxy;
! 2203: }
! 2204: #endif /* CURL_DISABLE_HTTP */
! 2205:
! 2206: /*
! 2207: * If this is supposed to use a proxy, we need to figure out the proxy
! 2208: * host name, so that we can re-use an existing connection
! 2209: * that may exist registered to the same proxy host.
! 2210: */
! 2211: static CURLcode parse_proxy(struct Curl_easy *data,
! 2212: struct connectdata *conn, char *proxy,
! 2213: curl_proxytype proxytype)
! 2214: {
! 2215: char *portptr = NULL;
! 2216: long port = -1;
! 2217: char *proxyuser = NULL;
! 2218: char *proxypasswd = NULL;
! 2219: char *host;
! 2220: bool sockstype;
! 2221: CURLUcode uc;
! 2222: struct proxy_info *proxyinfo;
! 2223: CURLU *uhp = curl_url();
! 2224: CURLcode result = CURLE_OK;
! 2225: char *scheme = NULL;
! 2226:
! 2227: /* When parsing the proxy, allowing non-supported schemes since we have
! 2228: these made up ones for proxies. Guess scheme for URLs without it. */
! 2229: uc = curl_url_set(uhp, CURLUPART_URL, proxy,
! 2230: CURLU_NON_SUPPORT_SCHEME|CURLU_GUESS_SCHEME);
! 2231: if(!uc) {
! 2232: /* parsed okay as a URL */
! 2233: uc = curl_url_get(uhp, CURLUPART_SCHEME, &scheme, 0);
! 2234: if(uc) {
! 2235: result = CURLE_OUT_OF_MEMORY;
! 2236: goto error;
! 2237: }
! 2238:
! 2239: if(strcasecompare("https", scheme))
! 2240: proxytype = CURLPROXY_HTTPS;
! 2241: else if(strcasecompare("socks5h", scheme))
! 2242: proxytype = CURLPROXY_SOCKS5_HOSTNAME;
! 2243: else if(strcasecompare("socks5", scheme))
! 2244: proxytype = CURLPROXY_SOCKS5;
! 2245: else if(strcasecompare("socks4a", scheme))
! 2246: proxytype = CURLPROXY_SOCKS4A;
! 2247: else if(strcasecompare("socks4", scheme) ||
! 2248: strcasecompare("socks", scheme))
! 2249: proxytype = CURLPROXY_SOCKS4;
! 2250: else if(strcasecompare("http", scheme))
! 2251: ; /* leave it as HTTP or HTTP/1.0 */
! 2252: else {
! 2253: /* Any other xxx:// reject! */
! 2254: failf(data, "Unsupported proxy scheme for \'%s\'", proxy);
! 2255: result = CURLE_COULDNT_CONNECT;
! 2256: goto error;
! 2257: }
! 2258: }
! 2259: else {
! 2260: failf(data, "Unsupported proxy syntax in \'%s\'", proxy);
! 2261: result = CURLE_COULDNT_RESOLVE_PROXY;
! 2262: goto error;
! 2263: }
! 2264:
! 2265: #ifdef USE_SSL
! 2266: if(!(Curl_ssl->supports & SSLSUPP_HTTPS_PROXY))
! 2267: #endif
! 2268: if(proxytype == CURLPROXY_HTTPS) {
! 2269: failf(data, "Unsupported proxy \'%s\', libcurl is built without the "
! 2270: "HTTPS-proxy support.", proxy);
! 2271: result = CURLE_NOT_BUILT_IN;
! 2272: goto error;
! 2273: }
! 2274:
! 2275: sockstype =
! 2276: proxytype == CURLPROXY_SOCKS5_HOSTNAME ||
! 2277: proxytype == CURLPROXY_SOCKS5 ||
! 2278: proxytype == CURLPROXY_SOCKS4A ||
! 2279: proxytype == CURLPROXY_SOCKS4;
! 2280:
! 2281: proxyinfo = sockstype ? &conn->socks_proxy : &conn->http_proxy;
! 2282: proxyinfo->proxytype = proxytype;
! 2283:
! 2284: /* Is there a username and password given in this proxy url? */
! 2285: curl_url_get(uhp, CURLUPART_USER, &proxyuser, CURLU_URLDECODE);
! 2286: curl_url_get(uhp, CURLUPART_PASSWORD, &proxypasswd, CURLU_URLDECODE);
! 2287: if(proxyuser || proxypasswd) {
! 2288: Curl_safefree(proxyinfo->user);
! 2289: proxyinfo->user = proxyuser;
! 2290: Curl_safefree(proxyinfo->passwd);
! 2291: if(!proxypasswd) {
! 2292: proxypasswd = strdup("");
! 2293: if(!proxypasswd) {
! 2294: result = CURLE_OUT_OF_MEMORY;
! 2295: goto error;
! 2296: }
! 2297: }
! 2298: proxyinfo->passwd = proxypasswd;
! 2299: conn->bits.proxy_user_passwd = TRUE; /* enable it */
! 2300: }
! 2301:
! 2302: curl_url_get(uhp, CURLUPART_PORT, &portptr, 0);
! 2303:
! 2304: if(portptr) {
! 2305: port = strtol(portptr, NULL, 10);
! 2306: free(portptr);
! 2307: }
! 2308: else {
! 2309: if(data->set.proxyport)
! 2310: /* None given in the proxy string, then get the default one if it is
! 2311: given */
! 2312: port = data->set.proxyport;
! 2313: else {
! 2314: if(proxytype == CURLPROXY_HTTPS)
! 2315: port = CURL_DEFAULT_HTTPS_PROXY_PORT;
! 2316: else
! 2317: port = CURL_DEFAULT_PROXY_PORT;
! 2318: }
! 2319: }
! 2320: if(port >= 0) {
! 2321: proxyinfo->port = port;
! 2322: if(conn->port < 0 || sockstype || !conn->socks_proxy.host.rawalloc)
! 2323: conn->port = port;
! 2324: }
! 2325:
! 2326: /* now, clone the proxy host name */
! 2327: uc = curl_url_get(uhp, CURLUPART_HOST, &host, CURLU_URLDECODE);
! 2328: if(uc) {
! 2329: result = CURLE_OUT_OF_MEMORY;
! 2330: goto error;
! 2331: }
! 2332: Curl_safefree(proxyinfo->host.rawalloc);
! 2333: proxyinfo->host.rawalloc = host;
! 2334: if(host[0] == '[') {
! 2335: /* this is a numerical IPv6, strip off the brackets */
! 2336: size_t len = strlen(host);
! 2337: host[len-1] = 0; /* clear the trailing bracket */
! 2338: host++;
! 2339: zonefrom_url(uhp, conn);
! 2340: }
! 2341: proxyinfo->host.name = host;
! 2342:
! 2343: error:
! 2344: free(scheme);
! 2345: curl_url_cleanup(uhp);
! 2346: return result;
! 2347: }
! 2348:
! 2349: /*
! 2350: * Extract the user and password from the authentication string
! 2351: */
! 2352: static CURLcode parse_proxy_auth(struct Curl_easy *data,
! 2353: struct connectdata *conn)
! 2354: {
! 2355: char proxyuser[MAX_CURL_USER_LENGTH]="";
! 2356: char proxypasswd[MAX_CURL_PASSWORD_LENGTH]="";
! 2357: CURLcode result;
! 2358:
! 2359: if(data->set.str[STRING_PROXYUSERNAME] != NULL) {
! 2360: strncpy(proxyuser, data->set.str[STRING_PROXYUSERNAME],
! 2361: MAX_CURL_USER_LENGTH);
! 2362: proxyuser[MAX_CURL_USER_LENGTH-1] = '\0'; /*To be on safe side*/
! 2363: }
! 2364: if(data->set.str[STRING_PROXYPASSWORD] != NULL) {
! 2365: strncpy(proxypasswd, data->set.str[STRING_PROXYPASSWORD],
! 2366: MAX_CURL_PASSWORD_LENGTH);
! 2367: proxypasswd[MAX_CURL_PASSWORD_LENGTH-1] = '\0'; /*To be on safe side*/
! 2368: }
! 2369:
! 2370: result = Curl_urldecode(data, proxyuser, 0, &conn->http_proxy.user, NULL,
! 2371: FALSE);
! 2372: if(!result)
! 2373: result = Curl_urldecode(data, proxypasswd, 0, &conn->http_proxy.passwd,
! 2374: NULL, FALSE);
! 2375: return result;
! 2376: }
! 2377:
! 2378: /* create_conn helper to parse and init proxy values. to be called after unix
! 2379: socket init but before any proxy vars are evaluated. */
! 2380: static CURLcode create_conn_helper_init_proxy(struct connectdata *conn)
! 2381: {
! 2382: char *proxy = NULL;
! 2383: char *socksproxy = NULL;
! 2384: char *no_proxy = NULL;
! 2385: CURLcode result = CURLE_OK;
! 2386: struct Curl_easy *data = conn->data;
! 2387:
! 2388: /*************************************************************
! 2389: * Extract the user and password from the authentication string
! 2390: *************************************************************/
! 2391: if(conn->bits.proxy_user_passwd) {
! 2392: result = parse_proxy_auth(data, conn);
! 2393: if(result)
! 2394: goto out;
! 2395: }
! 2396:
! 2397: /*************************************************************
! 2398: * Detect what (if any) proxy to use
! 2399: *************************************************************/
! 2400: if(data->set.str[STRING_PROXY]) {
! 2401: proxy = strdup(data->set.str[STRING_PROXY]);
! 2402: /* if global proxy is set, this is it */
! 2403: if(NULL == proxy) {
! 2404: failf(data, "memory shortage");
! 2405: result = CURLE_OUT_OF_MEMORY;
! 2406: goto out;
! 2407: }
! 2408: }
! 2409:
! 2410: if(data->set.str[STRING_PRE_PROXY]) {
! 2411: socksproxy = strdup(data->set.str[STRING_PRE_PROXY]);
! 2412: /* if global socks proxy is set, this is it */
! 2413: if(NULL == socksproxy) {
! 2414: failf(data, "memory shortage");
! 2415: result = CURLE_OUT_OF_MEMORY;
! 2416: goto out;
! 2417: }
! 2418: }
! 2419:
! 2420: if(!data->set.str[STRING_NOPROXY]) {
! 2421: const char *p = "no_proxy";
! 2422: no_proxy = curl_getenv(p);
! 2423: if(!no_proxy) {
! 2424: p = "NO_PROXY";
! 2425: no_proxy = curl_getenv(p);
! 2426: }
! 2427: if(no_proxy) {
! 2428: infof(conn->data, "Uses proxy env variable %s == '%s'\n", p, no_proxy);
! 2429: }
! 2430: }
! 2431:
! 2432: if(check_noproxy(conn->host.name, data->set.str[STRING_NOPROXY] ?
! 2433: data->set.str[STRING_NOPROXY] : no_proxy)) {
! 2434: Curl_safefree(proxy);
! 2435: Curl_safefree(socksproxy);
! 2436: }
! 2437: #ifndef CURL_DISABLE_HTTP
! 2438: else if(!proxy && !socksproxy)
! 2439: /* if the host is not in the noproxy list, detect proxy. */
! 2440: proxy = detect_proxy(conn);
! 2441: #endif /* CURL_DISABLE_HTTP */
! 2442:
! 2443: Curl_safefree(no_proxy);
! 2444:
! 2445: #ifdef USE_UNIX_SOCKETS
! 2446: /* For the time being do not mix proxy and unix domain sockets. See #1274 */
! 2447: if(proxy && conn->unix_domain_socket) {
! 2448: free(proxy);
! 2449: proxy = NULL;
! 2450: }
! 2451: #endif
! 2452:
! 2453: if(proxy && (!*proxy || (conn->handler->flags & PROTOPT_NONETWORK))) {
! 2454: free(proxy); /* Don't bother with an empty proxy string or if the
! 2455: protocol doesn't work with network */
! 2456: proxy = NULL;
! 2457: }
! 2458: if(socksproxy && (!*socksproxy ||
! 2459: (conn->handler->flags & PROTOPT_NONETWORK))) {
! 2460: free(socksproxy); /* Don't bother with an empty socks proxy string or if
! 2461: the protocol doesn't work with network */
! 2462: socksproxy = NULL;
! 2463: }
! 2464:
! 2465: /***********************************************************************
! 2466: * If this is supposed to use a proxy, we need to figure out the proxy host
! 2467: * name, proxy type and port number, so that we can re-use an existing
! 2468: * connection that may exist registered to the same proxy host.
! 2469: ***********************************************************************/
! 2470: if(proxy || socksproxy) {
! 2471: if(proxy) {
! 2472: result = parse_proxy(data, conn, proxy, conn->http_proxy.proxytype);
! 2473: Curl_safefree(proxy); /* parse_proxy copies the proxy string */
! 2474: if(result)
! 2475: goto out;
! 2476: }
! 2477:
! 2478: if(socksproxy) {
! 2479: result = parse_proxy(data, conn, socksproxy,
! 2480: conn->socks_proxy.proxytype);
! 2481: /* parse_proxy copies the socks proxy string */
! 2482: Curl_safefree(socksproxy);
! 2483: if(result)
! 2484: goto out;
! 2485: }
! 2486:
! 2487: if(conn->http_proxy.host.rawalloc) {
! 2488: #ifdef CURL_DISABLE_HTTP
! 2489: /* asking for a HTTP proxy is a bit funny when HTTP is disabled... */
! 2490: result = CURLE_UNSUPPORTED_PROTOCOL;
! 2491: goto out;
! 2492: #else
! 2493: /* force this connection's protocol to become HTTP if compatible */
! 2494: if(!(conn->handler->protocol & PROTO_FAMILY_HTTP)) {
! 2495: if((conn->handler->flags & PROTOPT_PROXY_AS_HTTP) &&
! 2496: !conn->bits.tunnel_proxy)
! 2497: conn->handler = &Curl_handler_http;
! 2498: else
! 2499: /* if not converting to HTTP over the proxy, enforce tunneling */
! 2500: conn->bits.tunnel_proxy = TRUE;
! 2501: }
! 2502: conn->bits.httpproxy = TRUE;
! 2503: #endif
! 2504: }
! 2505: else {
! 2506: conn->bits.httpproxy = FALSE; /* not a HTTP proxy */
! 2507: conn->bits.tunnel_proxy = FALSE; /* no tunneling if not HTTP */
! 2508: }
! 2509:
! 2510: if(conn->socks_proxy.host.rawalloc) {
! 2511: if(!conn->http_proxy.host.rawalloc) {
! 2512: /* once a socks proxy */
! 2513: if(!conn->socks_proxy.user) {
! 2514: conn->socks_proxy.user = conn->http_proxy.user;
! 2515: conn->http_proxy.user = NULL;
! 2516: Curl_safefree(conn->socks_proxy.passwd);
! 2517: conn->socks_proxy.passwd = conn->http_proxy.passwd;
! 2518: conn->http_proxy.passwd = NULL;
! 2519: }
! 2520: }
! 2521: conn->bits.socksproxy = TRUE;
! 2522: }
! 2523: else
! 2524: conn->bits.socksproxy = FALSE; /* not a socks proxy */
! 2525: }
! 2526: else {
! 2527: conn->bits.socksproxy = FALSE;
! 2528: conn->bits.httpproxy = FALSE;
! 2529: }
! 2530: conn->bits.proxy = conn->bits.httpproxy || conn->bits.socksproxy;
! 2531:
! 2532: if(!conn->bits.proxy) {
! 2533: /* we aren't using the proxy after all... */
! 2534: conn->bits.proxy = FALSE;
! 2535: conn->bits.httpproxy = FALSE;
! 2536: conn->bits.socksproxy = FALSE;
! 2537: conn->bits.proxy_user_passwd = FALSE;
! 2538: conn->bits.tunnel_proxy = FALSE;
! 2539: }
! 2540:
! 2541: out:
! 2542:
! 2543: free(socksproxy);
! 2544: free(proxy);
! 2545: return result;
! 2546: }
! 2547: #endif /* CURL_DISABLE_PROXY */
! 2548:
! 2549: /*
! 2550: * Curl_parse_login_details()
! 2551: *
! 2552: * This is used to parse a login string for user name, password and options in
! 2553: * the following formats:
! 2554: *
! 2555: * user
! 2556: * user:password
! 2557: * user:password;options
! 2558: * user;options
! 2559: * user;options:password
! 2560: * :password
! 2561: * :password;options
! 2562: * ;options
! 2563: * ;options:password
! 2564: *
! 2565: * Parameters:
! 2566: *
! 2567: * login [in] - The login string.
! 2568: * len [in] - The length of the login string.
! 2569: * userp [in/out] - The address where a pointer to newly allocated memory
! 2570: * holding the user will be stored upon completion.
! 2571: * passwdp [in/out] - The address where a pointer to newly allocated memory
! 2572: * holding the password will be stored upon completion.
! 2573: * optionsp [in/out] - The address where a pointer to newly allocated memory
! 2574: * holding the options will be stored upon completion.
! 2575: *
! 2576: * Returns CURLE_OK on success.
! 2577: */
! 2578: CURLcode Curl_parse_login_details(const char *login, const size_t len,
! 2579: char **userp, char **passwdp,
! 2580: char **optionsp)
! 2581: {
! 2582: CURLcode result = CURLE_OK;
! 2583: char *ubuf = NULL;
! 2584: char *pbuf = NULL;
! 2585: char *obuf = NULL;
! 2586: const char *psep = NULL;
! 2587: const char *osep = NULL;
! 2588: size_t ulen;
! 2589: size_t plen;
! 2590: size_t olen;
! 2591:
! 2592: /* Attempt to find the password separator */
! 2593: if(passwdp) {
! 2594: psep = strchr(login, ':');
! 2595:
! 2596: /* Within the constraint of the login string */
! 2597: if(psep >= login + len)
! 2598: psep = NULL;
! 2599: }
! 2600:
! 2601: /* Attempt to find the options separator */
! 2602: if(optionsp) {
! 2603: osep = strchr(login, ';');
! 2604:
! 2605: /* Within the constraint of the login string */
! 2606: if(osep >= login + len)
! 2607: osep = NULL;
! 2608: }
! 2609:
! 2610: /* Calculate the portion lengths */
! 2611: ulen = (psep ?
! 2612: (size_t)(osep && psep > osep ? osep - login : psep - login) :
! 2613: (osep ? (size_t)(osep - login) : len));
! 2614: plen = (psep ?
! 2615: (osep && osep > psep ? (size_t)(osep - psep) :
! 2616: (size_t)(login + len - psep)) - 1 : 0);
! 2617: olen = (osep ?
! 2618: (psep && psep > osep ? (size_t)(psep - osep) :
! 2619: (size_t)(login + len - osep)) - 1 : 0);
! 2620:
! 2621: /* Allocate the user portion buffer */
! 2622: if(userp && ulen) {
! 2623: ubuf = malloc(ulen + 1);
! 2624: if(!ubuf)
! 2625: result = CURLE_OUT_OF_MEMORY;
! 2626: }
! 2627:
! 2628: /* Allocate the password portion buffer */
! 2629: if(!result && passwdp && plen) {
! 2630: pbuf = malloc(plen + 1);
! 2631: if(!pbuf) {
! 2632: free(ubuf);
! 2633: result = CURLE_OUT_OF_MEMORY;
! 2634: }
! 2635: }
! 2636:
! 2637: /* Allocate the options portion buffer */
! 2638: if(!result && optionsp && olen) {
! 2639: obuf = malloc(olen + 1);
! 2640: if(!obuf) {
! 2641: free(pbuf);
! 2642: free(ubuf);
! 2643: result = CURLE_OUT_OF_MEMORY;
! 2644: }
! 2645: }
! 2646:
! 2647: if(!result) {
! 2648: /* Store the user portion if necessary */
! 2649: if(ubuf) {
! 2650: memcpy(ubuf, login, ulen);
! 2651: ubuf[ulen] = '\0';
! 2652: Curl_safefree(*userp);
! 2653: *userp = ubuf;
! 2654: }
! 2655:
! 2656: /* Store the password portion if necessary */
! 2657: if(pbuf) {
! 2658: memcpy(pbuf, psep + 1, plen);
! 2659: pbuf[plen] = '\0';
! 2660: Curl_safefree(*passwdp);
! 2661: *passwdp = pbuf;
! 2662: }
! 2663:
! 2664: /* Store the options portion if necessary */
! 2665: if(obuf) {
! 2666: memcpy(obuf, osep + 1, olen);
! 2667: obuf[olen] = '\0';
! 2668: Curl_safefree(*optionsp);
! 2669: *optionsp = obuf;
! 2670: }
! 2671: }
! 2672:
! 2673: return result;
! 2674: }
! 2675:
! 2676: /*************************************************************
! 2677: * Figure out the remote port number and fix it in the URL
! 2678: *
! 2679: * No matter if we use a proxy or not, we have to figure out the remote
! 2680: * port number of various reasons.
! 2681: *
! 2682: * The port number embedded in the URL is replaced, if necessary.
! 2683: *************************************************************/
! 2684: static CURLcode parse_remote_port(struct Curl_easy *data,
! 2685: struct connectdata *conn)
! 2686: {
! 2687:
! 2688: if(data->set.use_port && data->state.allow_port) {
! 2689: /* if set, we use this instead of the port possibly given in the URL */
! 2690: char portbuf[16];
! 2691: CURLUcode uc;
! 2692: conn->remote_port = (unsigned short)data->set.use_port;
! 2693: msnprintf(portbuf, sizeof(portbuf), "%d", conn->remote_port);
! 2694: uc = curl_url_set(data->state.uh, CURLUPART_PORT, portbuf, 0);
! 2695: if(uc)
! 2696: return CURLE_OUT_OF_MEMORY;
! 2697: }
! 2698:
! 2699: return CURLE_OK;
! 2700: }
! 2701:
! 2702: /*
! 2703: * Override the login details from the URL with that in the CURLOPT_USERPWD
! 2704: * option or a .netrc file, if applicable.
! 2705: */
! 2706: static CURLcode override_login(struct Curl_easy *data,
! 2707: struct connectdata *conn,
! 2708: char **userp, char **passwdp, char **optionsp)
! 2709: {
! 2710: bool user_changed = FALSE;
! 2711: bool passwd_changed = FALSE;
! 2712: CURLUcode uc;
! 2713:
! 2714: if(data->set.use_netrc == CURL_NETRC_REQUIRED && conn->bits.user_passwd) {
! 2715: /* ignore user+password in the URL */
! 2716: if(*userp) {
! 2717: Curl_safefree(*userp);
! 2718: user_changed = TRUE;
! 2719: }
! 2720: if(*passwdp) {
! 2721: Curl_safefree(*passwdp);
! 2722: passwd_changed = TRUE;
! 2723: }
! 2724: conn->bits.user_passwd = FALSE; /* disable user+password */
! 2725: }
! 2726:
! 2727: if(data->set.str[STRING_USERNAME]) {
! 2728: free(*userp);
! 2729: *userp = strdup(data->set.str[STRING_USERNAME]);
! 2730: if(!*userp)
! 2731: return CURLE_OUT_OF_MEMORY;
! 2732: conn->bits.user_passwd = TRUE; /* enable user+password */
! 2733: user_changed = TRUE;
! 2734: }
! 2735:
! 2736: if(data->set.str[STRING_PASSWORD]) {
! 2737: free(*passwdp);
! 2738: *passwdp = strdup(data->set.str[STRING_PASSWORD]);
! 2739: if(!*passwdp)
! 2740: return CURLE_OUT_OF_MEMORY;
! 2741: conn->bits.user_passwd = TRUE; /* enable user+password */
! 2742: passwd_changed = TRUE;
! 2743: }
! 2744:
! 2745: if(data->set.str[STRING_OPTIONS]) {
! 2746: free(*optionsp);
! 2747: *optionsp = strdup(data->set.str[STRING_OPTIONS]);
! 2748: if(!*optionsp)
! 2749: return CURLE_OUT_OF_MEMORY;
! 2750: }
! 2751:
! 2752: conn->bits.netrc = FALSE;
! 2753: if(data->set.use_netrc != CURL_NETRC_IGNORED &&
! 2754: (!*userp || !**userp || !*passwdp || !**passwdp)) {
! 2755: bool netrc_user_changed = FALSE;
! 2756: bool netrc_passwd_changed = FALSE;
! 2757: int ret;
! 2758:
! 2759: ret = Curl_parsenetrc(conn->host.name,
! 2760: userp, passwdp,
! 2761: &netrc_user_changed, &netrc_passwd_changed,
! 2762: data->set.str[STRING_NETRC_FILE]);
! 2763: if(ret > 0) {
! 2764: infof(data, "Couldn't find host %s in the .netrc file; using defaults\n",
! 2765: conn->host.name);
! 2766: }
! 2767: else if(ret < 0) {
! 2768: return CURLE_OUT_OF_MEMORY;
! 2769: }
! 2770: else {
! 2771: /* set bits.netrc TRUE to remember that we got the name from a .netrc
! 2772: file, so that it is safe to use even if we followed a Location: to a
! 2773: different host or similar. */
! 2774: conn->bits.netrc = TRUE;
! 2775: conn->bits.user_passwd = TRUE; /* enable user+password */
! 2776:
! 2777: if(netrc_user_changed) {
! 2778: user_changed = TRUE;
! 2779: }
! 2780: if(netrc_passwd_changed) {
! 2781: passwd_changed = TRUE;
! 2782: }
! 2783: }
! 2784: }
! 2785:
! 2786: /* for updated strings, we update them in the URL */
! 2787: if(user_changed) {
! 2788: uc = curl_url_set(data->state.uh, CURLUPART_USER, *userp, 0);
! 2789: if(uc)
! 2790: return Curl_uc_to_curlcode(uc);
! 2791: }
! 2792: if(passwd_changed) {
! 2793: uc = curl_url_set(data->state.uh, CURLUPART_PASSWORD, *passwdp, 0);
! 2794: if(uc)
! 2795: return Curl_uc_to_curlcode(uc);
! 2796: }
! 2797: return CURLE_OK;
! 2798: }
! 2799:
! 2800: /*
! 2801: * Set the login details so they're available in the connection
! 2802: */
! 2803: static CURLcode set_login(struct connectdata *conn)
! 2804: {
! 2805: CURLcode result = CURLE_OK;
! 2806: const char *setuser = CURL_DEFAULT_USER;
! 2807: const char *setpasswd = CURL_DEFAULT_PASSWORD;
! 2808:
! 2809: /* If our protocol needs a password and we have none, use the defaults */
! 2810: if((conn->handler->flags & PROTOPT_NEEDSPWD) && !conn->bits.user_passwd)
! 2811: ;
! 2812: else {
! 2813: setuser = "";
! 2814: setpasswd = "";
! 2815: }
! 2816: /* Store the default user */
! 2817: if(!conn->user) {
! 2818: conn->user = strdup(setuser);
! 2819: if(!conn->user)
! 2820: return CURLE_OUT_OF_MEMORY;
! 2821: }
! 2822:
! 2823: /* Store the default password */
! 2824: if(!conn->passwd) {
! 2825: conn->passwd = strdup(setpasswd);
! 2826: if(!conn->passwd)
! 2827: result = CURLE_OUT_OF_MEMORY;
! 2828: }
! 2829:
! 2830: return result;
! 2831: }
! 2832:
! 2833: /*
! 2834: * Parses a "host:port" string to connect to.
! 2835: * The hostname and the port may be empty; in this case, NULL is returned for
! 2836: * the hostname and -1 for the port.
! 2837: */
! 2838: static CURLcode parse_connect_to_host_port(struct Curl_easy *data,
! 2839: const char *host,
! 2840: char **hostname_result,
! 2841: int *port_result)
! 2842: {
! 2843: char *host_dup;
! 2844: char *hostptr;
! 2845: char *host_portno;
! 2846: char *portptr;
! 2847: int port = -1;
! 2848:
! 2849: #if defined(CURL_DISABLE_VERBOSE_STRINGS)
! 2850: (void) data;
! 2851: #endif
! 2852:
! 2853: *hostname_result = NULL;
! 2854: *port_result = -1;
! 2855:
! 2856: if(!host || !*host)
! 2857: return CURLE_OK;
! 2858:
! 2859: host_dup = strdup(host);
! 2860: if(!host_dup)
! 2861: return CURLE_OUT_OF_MEMORY;
! 2862:
! 2863: hostptr = host_dup;
! 2864:
! 2865: /* start scanning for port number at this point */
! 2866: portptr = hostptr;
! 2867:
! 2868: /* detect and extract RFC6874-style IPv6-addresses */
! 2869: if(*hostptr == '[') {
! 2870: #ifdef ENABLE_IPV6
! 2871: char *ptr = ++hostptr; /* advance beyond the initial bracket */
! 2872: while(*ptr && (ISXDIGIT(*ptr) || (*ptr == ':') || (*ptr == '.')))
! 2873: ptr++;
! 2874: if(*ptr == '%') {
! 2875: /* There might be a zone identifier */
! 2876: if(strncmp("%25", ptr, 3))
! 2877: infof(data, "Please URL encode %% as %%25, see RFC 6874.\n");
! 2878: ptr++;
! 2879: /* Allow unreserved characters as defined in RFC 3986 */
! 2880: while(*ptr && (ISALPHA(*ptr) || ISXDIGIT(*ptr) || (*ptr == '-') ||
! 2881: (*ptr == '.') || (*ptr == '_') || (*ptr == '~')))
! 2882: ptr++;
! 2883: }
! 2884: if(*ptr == ']')
! 2885: /* yeps, it ended nicely with a bracket as well */
! 2886: *ptr++ = '\0';
! 2887: else
! 2888: infof(data, "Invalid IPv6 address format\n");
! 2889: portptr = ptr;
! 2890: /* Note that if this didn't end with a bracket, we still advanced the
! 2891: * hostptr first, but I can't see anything wrong with that as no host
! 2892: * name nor a numeric can legally start with a bracket.
! 2893: */
! 2894: #else
! 2895: failf(data, "Use of IPv6 in *_CONNECT_TO without IPv6 support built-in!");
! 2896: free(host_dup);
! 2897: return CURLE_NOT_BUILT_IN;
! 2898: #endif
! 2899: }
! 2900:
! 2901: /* Get port number off server.com:1080 */
! 2902: host_portno = strchr(portptr, ':');
! 2903: if(host_portno) {
! 2904: char *endp = NULL;
! 2905: *host_portno = '\0'; /* cut off number from host name */
! 2906: host_portno++;
! 2907: if(*host_portno) {
! 2908: long portparse = strtol(host_portno, &endp, 10);
! 2909: if((endp && *endp) || (portparse < 0) || (portparse > 65535)) {
! 2910: infof(data, "No valid port number in connect to host string (%s)\n",
! 2911: host_portno);
! 2912: hostptr = NULL;
! 2913: port = -1;
! 2914: }
! 2915: else
! 2916: port = (int)portparse; /* we know it will fit */
! 2917: }
! 2918: }
! 2919:
! 2920: /* now, clone the cleaned host name */
! 2921: if(hostptr) {
! 2922: *hostname_result = strdup(hostptr);
! 2923: if(!*hostname_result) {
! 2924: free(host_dup);
! 2925: return CURLE_OUT_OF_MEMORY;
! 2926: }
! 2927: }
! 2928:
! 2929: *port_result = port;
! 2930:
! 2931: free(host_dup);
! 2932: return CURLE_OK;
! 2933: }
! 2934:
! 2935: /*
! 2936: * Parses one "connect to" string in the form:
! 2937: * "HOST:PORT:CONNECT-TO-HOST:CONNECT-TO-PORT".
! 2938: */
! 2939: static CURLcode parse_connect_to_string(struct Curl_easy *data,
! 2940: struct connectdata *conn,
! 2941: const char *conn_to_host,
! 2942: char **host_result,
! 2943: int *port_result)
! 2944: {
! 2945: CURLcode result = CURLE_OK;
! 2946: const char *ptr = conn_to_host;
! 2947: int host_match = FALSE;
! 2948: int port_match = FALSE;
! 2949:
! 2950: *host_result = NULL;
! 2951: *port_result = -1;
! 2952:
! 2953: if(*ptr == ':') {
! 2954: /* an empty hostname always matches */
! 2955: host_match = TRUE;
! 2956: ptr++;
! 2957: }
! 2958: else {
! 2959: /* check whether the URL's hostname matches */
! 2960: size_t hostname_to_match_len;
! 2961: char *hostname_to_match = aprintf("%s%s%s",
! 2962: conn->bits.ipv6_ip ? "[" : "",
! 2963: conn->host.name,
! 2964: conn->bits.ipv6_ip ? "]" : "");
! 2965: if(!hostname_to_match)
! 2966: return CURLE_OUT_OF_MEMORY;
! 2967: hostname_to_match_len = strlen(hostname_to_match);
! 2968: host_match = strncasecompare(ptr, hostname_to_match,
! 2969: hostname_to_match_len);
! 2970: free(hostname_to_match);
! 2971: ptr += hostname_to_match_len;
! 2972:
! 2973: host_match = host_match && *ptr == ':';
! 2974: ptr++;
! 2975: }
! 2976:
! 2977: if(host_match) {
! 2978: if(*ptr == ':') {
! 2979: /* an empty port always matches */
! 2980: port_match = TRUE;
! 2981: ptr++;
! 2982: }
! 2983: else {
! 2984: /* check whether the URL's port matches */
! 2985: char *ptr_next = strchr(ptr, ':');
! 2986: if(ptr_next) {
! 2987: char *endp = NULL;
! 2988: long port_to_match = strtol(ptr, &endp, 10);
! 2989: if((endp == ptr_next) && (port_to_match == conn->remote_port)) {
! 2990: port_match = TRUE;
! 2991: ptr = ptr_next + 1;
! 2992: }
! 2993: }
! 2994: }
! 2995: }
! 2996:
! 2997: if(host_match && port_match) {
! 2998: /* parse the hostname and port to connect to */
! 2999: result = parse_connect_to_host_port(data, ptr, host_result, port_result);
! 3000: }
! 3001:
! 3002: return result;
! 3003: }
! 3004:
! 3005: /*
! 3006: * Processes all strings in the "connect to" slist, and uses the "connect
! 3007: * to host" and "connect to port" of the first string that matches.
! 3008: */
! 3009: static CURLcode parse_connect_to_slist(struct Curl_easy *data,
! 3010: struct connectdata *conn,
! 3011: struct curl_slist *conn_to_host)
! 3012: {
! 3013: CURLcode result = CURLE_OK;
! 3014: char *host = NULL;
! 3015: int port = -1;
! 3016:
! 3017: while(conn_to_host && !host && port == -1) {
! 3018: result = parse_connect_to_string(data, conn, conn_to_host->data,
! 3019: &host, &port);
! 3020: if(result)
! 3021: return result;
! 3022:
! 3023: if(host && *host) {
! 3024: conn->conn_to_host.rawalloc = host;
! 3025: conn->conn_to_host.name = host;
! 3026: conn->bits.conn_to_host = TRUE;
! 3027:
! 3028: infof(data, "Connecting to hostname: %s\n", host);
! 3029: }
! 3030: else {
! 3031: /* no "connect to host" */
! 3032: conn->bits.conn_to_host = FALSE;
! 3033: Curl_safefree(host);
! 3034: }
! 3035:
! 3036: if(port >= 0) {
! 3037: conn->conn_to_port = port;
! 3038: conn->bits.conn_to_port = TRUE;
! 3039: infof(data, "Connecting to port: %d\n", port);
! 3040: }
! 3041: else {
! 3042: /* no "connect to port" */
! 3043: conn->bits.conn_to_port = FALSE;
! 3044: port = -1;
! 3045: }
! 3046:
! 3047: conn_to_host = conn_to_host->next;
! 3048: }
! 3049:
! 3050: #ifdef USE_ALTSVC
! 3051: if(data->asi && !host && (port == -1) &&
! 3052: ((conn->handler->protocol == CURLPROTO_HTTPS) ||
! 3053: #ifdef CURLDEBUG
! 3054: /* allow debug builds to circumvent the HTTPS restriction */
! 3055: getenv("CURL_ALTSVC_HTTP")
! 3056: #else
! 3057: 0
! 3058: #endif
! 3059: )) {
! 3060: /* no connect_to match, try alt-svc! */
! 3061: enum alpnid srcalpnid;
! 3062: bool hit;
! 3063: struct altsvc *as;
! 3064: const int allowed_versions = ( ALPN_h1
! 3065: #ifdef USE_NGHTTP2
! 3066: | ALPN_h2
! 3067: #endif
! 3068: #ifdef ENABLE_QUIC
! 3069: | ALPN_h3
! 3070: #endif
! 3071: ) & data->asi->flags;
! 3072:
! 3073: host = conn->host.rawalloc;
! 3074: #ifdef USE_NGHTTP2
! 3075: /* with h2 support, check that first */
! 3076: srcalpnid = ALPN_h2;
! 3077: hit = Curl_altsvc_lookup(data->asi,
! 3078: srcalpnid, host, conn->remote_port, /* from */
! 3079: &as /* to */,
! 3080: allowed_versions);
! 3081: if(!hit)
! 3082: #endif
! 3083: {
! 3084: srcalpnid = ALPN_h1;
! 3085: hit = Curl_altsvc_lookup(data->asi,
! 3086: srcalpnid, host, conn->remote_port, /* from */
! 3087: &as /* to */,
! 3088: allowed_versions);
! 3089: }
! 3090: if(hit) {
! 3091: char *hostd = strdup((char *)as->dst.host);
! 3092: if(!hostd)
! 3093: return CURLE_OUT_OF_MEMORY;
! 3094: conn->conn_to_host.rawalloc = hostd;
! 3095: conn->conn_to_host.name = hostd;
! 3096: conn->bits.conn_to_host = TRUE;
! 3097: conn->conn_to_port = as->dst.port;
! 3098: conn->bits.conn_to_port = TRUE;
! 3099: conn->bits.altused = TRUE;
! 3100: infof(data, "Alt-svc connecting from [%s]%s:%d to [%s]%s:%d\n",
! 3101: Curl_alpnid2str(srcalpnid), host, conn->remote_port,
! 3102: Curl_alpnid2str(as->dst.alpnid), hostd, as->dst.port);
! 3103: if(srcalpnid != as->dst.alpnid) {
! 3104: /* protocol version switch */
! 3105: switch(as->dst.alpnid) {
! 3106: case ALPN_h1:
! 3107: conn->httpversion = 11;
! 3108: break;
! 3109: case ALPN_h2:
! 3110: conn->httpversion = 20;
! 3111: break;
! 3112: case ALPN_h3:
! 3113: conn->transport = TRNSPRT_QUIC;
! 3114: conn->httpversion = 30;
! 3115: break;
! 3116: default: /* shouldn't be possible */
! 3117: break;
! 3118: }
! 3119: }
! 3120: }
! 3121: }
! 3122: #endif
! 3123:
! 3124: return result;
! 3125: }
! 3126:
! 3127: /*************************************************************
! 3128: * Resolve the address of the server or proxy
! 3129: *************************************************************/
! 3130: static CURLcode resolve_server(struct Curl_easy *data,
! 3131: struct connectdata *conn,
! 3132: bool *async)
! 3133: {
! 3134: CURLcode result = CURLE_OK;
! 3135: timediff_t timeout_ms = Curl_timeleft(data, NULL, TRUE);
! 3136:
! 3137: DEBUGASSERT(conn);
! 3138: DEBUGASSERT(data);
! 3139: /*************************************************************
! 3140: * Resolve the name of the server or proxy
! 3141: *************************************************************/
! 3142: if(conn->bits.reuse)
! 3143: /* We're reusing the connection - no need to resolve anything, and
! 3144: idnconvert_hostname() was called already in create_conn() for the re-use
! 3145: case. */
! 3146: *async = FALSE;
! 3147:
! 3148: else {
! 3149: /* this is a fresh connect */
! 3150: int rc;
! 3151: struct Curl_dns_entry *hostaddr;
! 3152:
! 3153: #ifdef USE_UNIX_SOCKETS
! 3154: if(conn->unix_domain_socket) {
! 3155: /* Unix domain sockets are local. The host gets ignored, just use the
! 3156: * specified domain socket address. Do not cache "DNS entries". There is
! 3157: * no DNS involved and we already have the filesystem path available */
! 3158: const char *path = conn->unix_domain_socket;
! 3159:
! 3160: hostaddr = calloc(1, sizeof(struct Curl_dns_entry));
! 3161: if(!hostaddr)
! 3162: result = CURLE_OUT_OF_MEMORY;
! 3163: else {
! 3164: bool longpath = FALSE;
! 3165: hostaddr->addr = Curl_unix2addr(path, &longpath,
! 3166: conn->abstract_unix_socket);
! 3167: if(hostaddr->addr)
! 3168: hostaddr->inuse++;
! 3169: else {
! 3170: /* Long paths are not supported for now */
! 3171: if(longpath) {
! 3172: failf(data, "Unix socket path too long: '%s'", path);
! 3173: result = CURLE_COULDNT_RESOLVE_HOST;
! 3174: }
! 3175: else
! 3176: result = CURLE_OUT_OF_MEMORY;
! 3177: free(hostaddr);
! 3178: hostaddr = NULL;
! 3179: }
! 3180: }
! 3181: }
! 3182: else
! 3183: #endif
! 3184: if(!conn->bits.proxy) {
! 3185: struct hostname *connhost;
! 3186: if(conn->bits.conn_to_host)
! 3187: connhost = &conn->conn_to_host;
! 3188: else
! 3189: connhost = &conn->host;
! 3190:
! 3191: /* If not connecting via a proxy, extract the port from the URL, if it is
! 3192: * there, thus overriding any defaults that might have been set above. */
! 3193: if(conn->bits.conn_to_port)
! 3194: conn->port = conn->conn_to_port;
! 3195: else
! 3196: conn->port = conn->remote_port;
! 3197:
! 3198: /* Resolve target host right on */
! 3199: conn->hostname_resolve = strdup(connhost->name);
! 3200: if(!conn->hostname_resolve)
! 3201: return CURLE_OUT_OF_MEMORY;
! 3202: rc = Curl_resolv_timeout(conn, conn->hostname_resolve, (int)conn->port,
! 3203: &hostaddr, timeout_ms);
! 3204: if(rc == CURLRESOLV_PENDING)
! 3205: *async = TRUE;
! 3206:
! 3207: else if(rc == CURLRESOLV_TIMEDOUT)
! 3208: result = CURLE_OPERATION_TIMEDOUT;
! 3209:
! 3210: else if(!hostaddr) {
! 3211: failf(data, "Couldn't resolve host '%s'", connhost->dispname);
! 3212: result = CURLE_COULDNT_RESOLVE_HOST;
! 3213: /* don't return yet, we need to clean up the timeout first */
! 3214: }
! 3215: }
! 3216: else {
! 3217: /* This is a proxy that hasn't been resolved yet. */
! 3218:
! 3219: struct hostname * const host = conn->bits.socksproxy ?
! 3220: &conn->socks_proxy.host : &conn->http_proxy.host;
! 3221:
! 3222: /* resolve proxy */
! 3223: conn->hostname_resolve = strdup(host->name);
! 3224: if(!conn->hostname_resolve)
! 3225: return CURLE_OUT_OF_MEMORY;
! 3226: rc = Curl_resolv_timeout(conn, conn->hostname_resolve, (int)conn->port,
! 3227: &hostaddr, timeout_ms);
! 3228:
! 3229: if(rc == CURLRESOLV_PENDING)
! 3230: *async = TRUE;
! 3231:
! 3232: else if(rc == CURLRESOLV_TIMEDOUT)
! 3233: result = CURLE_OPERATION_TIMEDOUT;
! 3234:
! 3235: else if(!hostaddr) {
! 3236: failf(data, "Couldn't resolve proxy '%s'", host->dispname);
! 3237: result = CURLE_COULDNT_RESOLVE_PROXY;
! 3238: /* don't return yet, we need to clean up the timeout first */
! 3239: }
! 3240: }
! 3241: DEBUGASSERT(conn->dns_entry == NULL);
! 3242: conn->dns_entry = hostaddr;
! 3243: }
! 3244:
! 3245: return result;
! 3246: }
! 3247:
! 3248: /*
! 3249: * Cleanup the connection just allocated before we can move along and use the
! 3250: * previously existing one. All relevant data is copied over and old_conn is
! 3251: * ready for freeing once this function returns.
! 3252: */
! 3253: static void reuse_conn(struct connectdata *old_conn,
! 3254: struct connectdata *conn)
! 3255: {
! 3256: Curl_free_idnconverted_hostname(&old_conn->http_proxy.host);
! 3257: Curl_free_idnconverted_hostname(&old_conn->socks_proxy.host);
! 3258:
! 3259: free(old_conn->http_proxy.host.rawalloc);
! 3260: free(old_conn->socks_proxy.host.rawalloc);
! 3261:
! 3262: /* free the SSL config struct from this connection struct as this was
! 3263: allocated in vain and is targeted for destruction */
! 3264: Curl_free_primary_ssl_config(&old_conn->ssl_config);
! 3265: Curl_free_primary_ssl_config(&old_conn->proxy_ssl_config);
! 3266:
! 3267: conn->data = old_conn->data;
! 3268:
! 3269: /* get the user+password information from the old_conn struct since it may
! 3270: * be new for this request even when we re-use an existing connection */
! 3271: conn->bits.user_passwd = old_conn->bits.user_passwd;
! 3272: if(conn->bits.user_passwd) {
! 3273: /* use the new user name and password though */
! 3274: Curl_safefree(conn->user);
! 3275: Curl_safefree(conn->passwd);
! 3276: conn->user = old_conn->user;
! 3277: conn->passwd = old_conn->passwd;
! 3278: old_conn->user = NULL;
! 3279: old_conn->passwd = NULL;
! 3280: }
! 3281:
! 3282: conn->bits.proxy_user_passwd = old_conn->bits.proxy_user_passwd;
! 3283: if(conn->bits.proxy_user_passwd) {
! 3284: /* use the new proxy user name and proxy password though */
! 3285: Curl_safefree(conn->http_proxy.user);
! 3286: Curl_safefree(conn->socks_proxy.user);
! 3287: Curl_safefree(conn->http_proxy.passwd);
! 3288: Curl_safefree(conn->socks_proxy.passwd);
! 3289: conn->http_proxy.user = old_conn->http_proxy.user;
! 3290: conn->socks_proxy.user = old_conn->socks_proxy.user;
! 3291: conn->http_proxy.passwd = old_conn->http_proxy.passwd;
! 3292: conn->socks_proxy.passwd = old_conn->socks_proxy.passwd;
! 3293: old_conn->http_proxy.user = NULL;
! 3294: old_conn->socks_proxy.user = NULL;
! 3295: old_conn->http_proxy.passwd = NULL;
! 3296: old_conn->socks_proxy.passwd = NULL;
! 3297: }
! 3298:
! 3299: /* host can change, when doing keepalive with a proxy or if the case is
! 3300: different this time etc */
! 3301: Curl_free_idnconverted_hostname(&conn->host);
! 3302: Curl_free_idnconverted_hostname(&conn->conn_to_host);
! 3303: Curl_safefree(conn->host.rawalloc);
! 3304: Curl_safefree(conn->conn_to_host.rawalloc);
! 3305: conn->host = old_conn->host;
! 3306: conn->conn_to_host = old_conn->conn_to_host;
! 3307: conn->conn_to_port = old_conn->conn_to_port;
! 3308: conn->remote_port = old_conn->remote_port;
! 3309: Curl_safefree(conn->hostname_resolve);
! 3310:
! 3311: conn->hostname_resolve = old_conn->hostname_resolve;
! 3312: old_conn->hostname_resolve = NULL;
! 3313:
! 3314: /* persist connection info in session handle */
! 3315: Curl_persistconninfo(conn);
! 3316:
! 3317: conn_reset_all_postponed_data(old_conn); /* free buffers */
! 3318:
! 3319: /* re-use init */
! 3320: conn->bits.reuse = TRUE; /* yes, we're re-using here */
! 3321:
! 3322: Curl_safefree(old_conn->user);
! 3323: Curl_safefree(old_conn->passwd);
! 3324: Curl_safefree(old_conn->options);
! 3325: Curl_safefree(old_conn->http_proxy.user);
! 3326: Curl_safefree(old_conn->socks_proxy.user);
! 3327: Curl_safefree(old_conn->http_proxy.passwd);
! 3328: Curl_safefree(old_conn->socks_proxy.passwd);
! 3329: Curl_safefree(old_conn->localdev);
! 3330: Curl_llist_destroy(&old_conn->easyq, NULL);
! 3331:
! 3332: #ifdef USE_UNIX_SOCKETS
! 3333: Curl_safefree(old_conn->unix_domain_socket);
! 3334: #endif
! 3335: }
! 3336:
! 3337: /**
! 3338: * create_conn() sets up a new connectdata struct, or re-uses an already
! 3339: * existing one, and resolves host name.
! 3340: *
! 3341: * if this function returns CURLE_OK and *async is set to TRUE, the resolve
! 3342: * response will be coming asynchronously. If *async is FALSE, the name is
! 3343: * already resolved.
! 3344: *
! 3345: * @param data The sessionhandle pointer
! 3346: * @param in_connect is set to the next connection data pointer
! 3347: * @param async is set TRUE when an async DNS resolution is pending
! 3348: * @see Curl_setup_conn()
! 3349: *
! 3350: * *NOTE* this function assigns the conn->data pointer!
! 3351: */
! 3352:
! 3353: static CURLcode create_conn(struct Curl_easy *data,
! 3354: struct connectdata **in_connect,
! 3355: bool *async)
! 3356: {
! 3357: CURLcode result = CURLE_OK;
! 3358: struct connectdata *conn;
! 3359: struct connectdata *conn_temp = NULL;
! 3360: bool reuse;
! 3361: bool connections_available = TRUE;
! 3362: bool force_reuse = FALSE;
! 3363: bool waitpipe = FALSE;
! 3364: size_t max_host_connections = Curl_multi_max_host_connections(data->multi);
! 3365: size_t max_total_connections = Curl_multi_max_total_connections(data->multi);
! 3366:
! 3367: *async = FALSE;
! 3368: *in_connect = NULL;
! 3369:
! 3370: /*************************************************************
! 3371: * Check input data
! 3372: *************************************************************/
! 3373: if(!data->change.url) {
! 3374: result = CURLE_URL_MALFORMAT;
! 3375: goto out;
! 3376: }
! 3377:
! 3378: /* First, split up the current URL in parts so that we can use the
! 3379: parts for checking against the already present connections. In order
! 3380: to not have to modify everything at once, we allocate a temporary
! 3381: connection data struct and fill in for comparison purposes. */
! 3382: conn = allocate_conn(data);
! 3383:
! 3384: if(!conn) {
! 3385: result = CURLE_OUT_OF_MEMORY;
! 3386: goto out;
! 3387: }
! 3388:
! 3389: /* We must set the return variable as soon as possible, so that our
! 3390: parent can cleanup any possible allocs we may have done before
! 3391: any failure */
! 3392: *in_connect = conn;
! 3393:
! 3394: result = parseurlandfillconn(data, conn);
! 3395: if(result)
! 3396: goto out;
! 3397:
! 3398: if(data->set.str[STRING_SASL_AUTHZID]) {
! 3399: conn->sasl_authzid = strdup(data->set.str[STRING_SASL_AUTHZID]);
! 3400: if(!conn->sasl_authzid) {
! 3401: result = CURLE_OUT_OF_MEMORY;
! 3402: goto out;
! 3403: }
! 3404: }
! 3405:
! 3406: #ifdef USE_UNIX_SOCKETS
! 3407: if(data->set.str[STRING_UNIX_SOCKET_PATH]) {
! 3408: conn->unix_domain_socket = strdup(data->set.str[STRING_UNIX_SOCKET_PATH]);
! 3409: if(conn->unix_domain_socket == NULL) {
! 3410: result = CURLE_OUT_OF_MEMORY;
! 3411: goto out;
! 3412: }
! 3413: conn->abstract_unix_socket = data->set.abstract_unix_socket;
! 3414: }
! 3415: #endif
! 3416:
! 3417: /* After the unix socket init but before the proxy vars are used, parse and
! 3418: initialize the proxy vars */
! 3419: #ifndef CURL_DISABLE_PROXY
! 3420: result = create_conn_helper_init_proxy(conn);
! 3421: if(result)
! 3422: goto out;
! 3423: #endif
! 3424:
! 3425: /*************************************************************
! 3426: * If the protocol is using SSL and HTTP proxy is used, we set
! 3427: * the tunnel_proxy bit.
! 3428: *************************************************************/
! 3429: if((conn->given->flags&PROTOPT_SSL) && conn->bits.httpproxy)
! 3430: conn->bits.tunnel_proxy = TRUE;
! 3431:
! 3432: /*************************************************************
! 3433: * Figure out the remote port number and fix it in the URL
! 3434: *************************************************************/
! 3435: result = parse_remote_port(data, conn);
! 3436: if(result)
! 3437: goto out;
! 3438:
! 3439: /* Check for overridden login details and set them accordingly so they
! 3440: they are known when protocol->setup_connection is called! */
! 3441: result = override_login(data, conn, &conn->user, &conn->passwd,
! 3442: &conn->options);
! 3443: if(result)
! 3444: goto out;
! 3445:
! 3446: result = set_login(conn); /* default credentials */
! 3447: if(result)
! 3448: goto out;
! 3449:
! 3450: /*************************************************************
! 3451: * Process the "connect to" linked list of hostname/port mappings.
! 3452: * Do this after the remote port number has been fixed in the URL.
! 3453: *************************************************************/
! 3454: result = parse_connect_to_slist(data, conn, data->set.connect_to);
! 3455: if(result)
! 3456: goto out;
! 3457:
! 3458: /*************************************************************
! 3459: * IDN-convert the hostnames
! 3460: *************************************************************/
! 3461: result = Curl_idnconvert_hostname(conn, &conn->host);
! 3462: if(result)
! 3463: goto out;
! 3464: if(conn->bits.conn_to_host) {
! 3465: result = Curl_idnconvert_hostname(conn, &conn->conn_to_host);
! 3466: if(result)
! 3467: goto out;
! 3468: }
! 3469: if(conn->bits.httpproxy) {
! 3470: result = Curl_idnconvert_hostname(conn, &conn->http_proxy.host);
! 3471: if(result)
! 3472: goto out;
! 3473: }
! 3474: if(conn->bits.socksproxy) {
! 3475: result = Curl_idnconvert_hostname(conn, &conn->socks_proxy.host);
! 3476: if(result)
! 3477: goto out;
! 3478: }
! 3479:
! 3480: /*************************************************************
! 3481: * Check whether the host and the "connect to host" are equal.
! 3482: * Do this after the hostnames have been IDN-converted.
! 3483: *************************************************************/
! 3484: if(conn->bits.conn_to_host &&
! 3485: strcasecompare(conn->conn_to_host.name, conn->host.name)) {
! 3486: conn->bits.conn_to_host = FALSE;
! 3487: }
! 3488:
! 3489: /*************************************************************
! 3490: * Check whether the port and the "connect to port" are equal.
! 3491: * Do this after the remote port number has been fixed in the URL.
! 3492: *************************************************************/
! 3493: if(conn->bits.conn_to_port && conn->conn_to_port == conn->remote_port) {
! 3494: conn->bits.conn_to_port = FALSE;
! 3495: }
! 3496:
! 3497: /*************************************************************
! 3498: * If the "connect to" feature is used with an HTTP proxy,
! 3499: * we set the tunnel_proxy bit.
! 3500: *************************************************************/
! 3501: if((conn->bits.conn_to_host || conn->bits.conn_to_port) &&
! 3502: conn->bits.httpproxy)
! 3503: conn->bits.tunnel_proxy = TRUE;
! 3504:
! 3505: /*************************************************************
! 3506: * Setup internals depending on protocol. Needs to be done after
! 3507: * we figured out what/if proxy to use.
! 3508: *************************************************************/
! 3509: result = setup_connection_internals(conn);
! 3510: if(result)
! 3511: goto out;
! 3512:
! 3513: conn->recv[FIRSTSOCKET] = Curl_recv_plain;
! 3514: conn->send[FIRSTSOCKET] = Curl_send_plain;
! 3515: conn->recv[SECONDARYSOCKET] = Curl_recv_plain;
! 3516: conn->send[SECONDARYSOCKET] = Curl_send_plain;
! 3517:
! 3518: conn->bits.tcp_fastopen = data->set.tcp_fastopen;
! 3519:
! 3520: /***********************************************************************
! 3521: * file: is a special case in that it doesn't need a network connection
! 3522: ***********************************************************************/
! 3523: #ifndef CURL_DISABLE_FILE
! 3524: if(conn->handler->flags & PROTOPT_NONETWORK) {
! 3525: bool done;
! 3526: /* this is supposed to be the connect function so we better at least check
! 3527: that the file is present here! */
! 3528: DEBUGASSERT(conn->handler->connect_it);
! 3529: Curl_persistconninfo(conn);
! 3530: result = conn->handler->connect_it(conn, &done);
! 3531:
! 3532: /* Setup a "faked" transfer that'll do nothing */
! 3533: if(!result) {
! 3534: conn->bits.tcpconnect[FIRSTSOCKET] = TRUE; /* we are "connected */
! 3535:
! 3536: result = Curl_conncache_add_conn(data->state.conn_cache, conn);
! 3537: if(result)
! 3538: goto out;
! 3539:
! 3540: /*
! 3541: * Setup whatever necessary for a resumed transfer
! 3542: */
! 3543: result = setup_range(data);
! 3544: if(result) {
! 3545: DEBUGASSERT(conn->handler->done);
! 3546: /* we ignore the return code for the protocol-specific DONE */
! 3547: (void)conn->handler->done(conn, result, FALSE);
! 3548: goto out;
! 3549: }
! 3550: Curl_attach_connnection(data, conn);
! 3551: Curl_setup_transfer(data, -1, -1, FALSE, -1);
! 3552: }
! 3553:
! 3554: /* since we skip do_init() */
! 3555: Curl_init_do(data, conn);
! 3556:
! 3557: goto out;
! 3558: }
! 3559: #endif
! 3560:
! 3561: /* Get a cloned copy of the SSL config situation stored in the
! 3562: connection struct. But to get this going nicely, we must first make
! 3563: sure that the strings in the master copy are pointing to the correct
! 3564: strings in the session handle strings array!
! 3565:
! 3566: Keep in mind that the pointers in the master copy are pointing to strings
! 3567: that will be freed as part of the Curl_easy struct, but all cloned
! 3568: copies will be separately allocated.
! 3569: */
! 3570: data->set.ssl.primary.CApath = data->set.str[STRING_SSL_CAPATH_ORIG];
! 3571: data->set.proxy_ssl.primary.CApath = data->set.str[STRING_SSL_CAPATH_PROXY];
! 3572: data->set.ssl.primary.CAfile = data->set.str[STRING_SSL_CAFILE_ORIG];
! 3573: data->set.proxy_ssl.primary.CAfile = data->set.str[STRING_SSL_CAFILE_PROXY];
! 3574: data->set.ssl.primary.random_file = data->set.str[STRING_SSL_RANDOM_FILE];
! 3575: data->set.proxy_ssl.primary.random_file =
! 3576: data->set.str[STRING_SSL_RANDOM_FILE];
! 3577: data->set.ssl.primary.egdsocket = data->set.str[STRING_SSL_EGDSOCKET];
! 3578: data->set.proxy_ssl.primary.egdsocket = data->set.str[STRING_SSL_EGDSOCKET];
! 3579: data->set.ssl.primary.cipher_list =
! 3580: data->set.str[STRING_SSL_CIPHER_LIST_ORIG];
! 3581: data->set.proxy_ssl.primary.cipher_list =
! 3582: data->set.str[STRING_SSL_CIPHER_LIST_PROXY];
! 3583: data->set.ssl.primary.cipher_list13 =
! 3584: data->set.str[STRING_SSL_CIPHER13_LIST_ORIG];
! 3585: data->set.proxy_ssl.primary.cipher_list13 =
! 3586: data->set.str[STRING_SSL_CIPHER13_LIST_PROXY];
! 3587: data->set.ssl.primary.pinned_key =
! 3588: data->set.str[STRING_SSL_PINNEDPUBLICKEY_ORIG];
! 3589: data->set.proxy_ssl.primary.pinned_key =
! 3590: data->set.str[STRING_SSL_PINNEDPUBLICKEY_PROXY];
! 3591:
! 3592: data->set.ssl.CRLfile = data->set.str[STRING_SSL_CRLFILE_ORIG];
! 3593: data->set.proxy_ssl.CRLfile = data->set.str[STRING_SSL_CRLFILE_PROXY];
! 3594: data->set.ssl.issuercert = data->set.str[STRING_SSL_ISSUERCERT_ORIG];
! 3595: data->set.proxy_ssl.issuercert = data->set.str[STRING_SSL_ISSUERCERT_PROXY];
! 3596: data->set.ssl.cert = data->set.str[STRING_CERT_ORIG];
! 3597: data->set.proxy_ssl.cert = data->set.str[STRING_CERT_PROXY];
! 3598: data->set.ssl.cert_type = data->set.str[STRING_CERT_TYPE_ORIG];
! 3599: data->set.proxy_ssl.cert_type = data->set.str[STRING_CERT_TYPE_PROXY];
! 3600: data->set.ssl.key = data->set.str[STRING_KEY_ORIG];
! 3601: data->set.proxy_ssl.key = data->set.str[STRING_KEY_PROXY];
! 3602: data->set.ssl.key_type = data->set.str[STRING_KEY_TYPE_ORIG];
! 3603: data->set.proxy_ssl.key_type = data->set.str[STRING_KEY_TYPE_PROXY];
! 3604: data->set.ssl.key_passwd = data->set.str[STRING_KEY_PASSWD_ORIG];
! 3605: data->set.proxy_ssl.key_passwd = data->set.str[STRING_KEY_PASSWD_PROXY];
! 3606: data->set.ssl.primary.clientcert = data->set.str[STRING_CERT_ORIG];
! 3607: data->set.proxy_ssl.primary.clientcert = data->set.str[STRING_CERT_PROXY];
! 3608: #ifdef USE_TLS_SRP
! 3609: data->set.ssl.username = data->set.str[STRING_TLSAUTH_USERNAME_ORIG];
! 3610: data->set.proxy_ssl.username = data->set.str[STRING_TLSAUTH_USERNAME_PROXY];
! 3611: data->set.ssl.password = data->set.str[STRING_TLSAUTH_PASSWORD_ORIG];
! 3612: data->set.proxy_ssl.password = data->set.str[STRING_TLSAUTH_PASSWORD_PROXY];
! 3613: #endif
! 3614:
! 3615: if(!Curl_clone_primary_ssl_config(&data->set.ssl.primary,
! 3616: &conn->ssl_config)) {
! 3617: result = CURLE_OUT_OF_MEMORY;
! 3618: goto out;
! 3619: }
! 3620:
! 3621: if(!Curl_clone_primary_ssl_config(&data->set.proxy_ssl.primary,
! 3622: &conn->proxy_ssl_config)) {
! 3623: result = CURLE_OUT_OF_MEMORY;
! 3624: goto out;
! 3625: }
! 3626:
! 3627: prune_dead_connections(data);
! 3628:
! 3629: /*************************************************************
! 3630: * Check the current list of connections to see if we can
! 3631: * re-use an already existing one or if we have to create a
! 3632: * new one.
! 3633: *************************************************************/
! 3634:
! 3635: DEBUGASSERT(conn->user);
! 3636: DEBUGASSERT(conn->passwd);
! 3637:
! 3638: /* reuse_fresh is TRUE if we are told to use a new connection by force, but
! 3639: we only acknowledge this option if this is not a re-used connection
! 3640: already (which happens due to follow-location or during a HTTP
! 3641: authentication phase). CONNECT_ONLY transfers also refuse reuse. */
! 3642: if((data->set.reuse_fresh && !data->state.this_is_a_follow) ||
! 3643: data->set.connect_only)
! 3644: reuse = FALSE;
! 3645: else
! 3646: reuse = ConnectionExists(data, conn, &conn_temp, &force_reuse, &waitpipe);
! 3647:
! 3648: if(reuse) {
! 3649: /*
! 3650: * We already have a connection for this, we got the former connection
! 3651: * in the conn_temp variable and thus we need to cleanup the one we
! 3652: * just allocated before we can move along and use the previously
! 3653: * existing one.
! 3654: */
! 3655: reuse_conn(conn, conn_temp);
! 3656: #ifdef USE_SSL
! 3657: free(conn->ssl_extra);
! 3658: #endif
! 3659: free(conn); /* we don't need this anymore */
! 3660: conn = conn_temp;
! 3661: *in_connect = conn;
! 3662:
! 3663: infof(data, "Re-using existing connection! (#%ld) with %s %s\n",
! 3664: conn->connection_id,
! 3665: conn->bits.proxy?"proxy":"host",
! 3666: conn->socks_proxy.host.name ? conn->socks_proxy.host.dispname :
! 3667: conn->http_proxy.host.name ? conn->http_proxy.host.dispname :
! 3668: conn->host.dispname);
! 3669: }
! 3670: else {
! 3671: /* We have decided that we want a new connection. However, we may not
! 3672: be able to do that if we have reached the limit of how many
! 3673: connections we are allowed to open. */
! 3674:
! 3675: if(conn->handler->flags & PROTOPT_ALPN_NPN) {
! 3676: /* The protocol wants it, so set the bits if enabled in the easy handle
! 3677: (default) */
! 3678: if(data->set.ssl_enable_alpn)
! 3679: conn->bits.tls_enable_alpn = TRUE;
! 3680: if(data->set.ssl_enable_npn)
! 3681: conn->bits.tls_enable_npn = TRUE;
! 3682: }
! 3683:
! 3684: if(waitpipe)
! 3685: /* There is a connection that *might* become usable for multiplexing
! 3686: "soon", and we wait for that */
! 3687: connections_available = FALSE;
! 3688: else {
! 3689: /* this gets a lock on the conncache */
! 3690: const char *bundlehost;
! 3691: struct connectbundle *bundle =
! 3692: Curl_conncache_find_bundle(conn, data->state.conn_cache, &bundlehost);
! 3693:
! 3694: if(max_host_connections > 0 && bundle &&
! 3695: (bundle->num_connections >= max_host_connections)) {
! 3696: struct connectdata *conn_candidate;
! 3697:
! 3698: /* The bundle is full. Extract the oldest connection. */
! 3699: conn_candidate = Curl_conncache_extract_bundle(data, bundle);
! 3700: Curl_conncache_unlock(data);
! 3701:
! 3702: if(conn_candidate)
! 3703: (void)Curl_disconnect(data, conn_candidate,
! 3704: /* dead_connection */ FALSE);
! 3705: else {
! 3706: infof(data, "No more connections allowed to host %s: %zu\n",
! 3707: bundlehost, max_host_connections);
! 3708: connections_available = FALSE;
! 3709: }
! 3710: }
! 3711: else
! 3712: Curl_conncache_unlock(data);
! 3713:
! 3714: }
! 3715:
! 3716: if(connections_available &&
! 3717: (max_total_connections > 0) &&
! 3718: (Curl_conncache_size(data) >= max_total_connections)) {
! 3719: struct connectdata *conn_candidate;
! 3720:
! 3721: /* The cache is full. Let's see if we can kill a connection. */
! 3722: conn_candidate = Curl_conncache_extract_oldest(data);
! 3723: if(conn_candidate)
! 3724: (void)Curl_disconnect(data, conn_candidate,
! 3725: /* dead_connection */ FALSE);
! 3726: else {
! 3727: infof(data, "No connections available in cache\n");
! 3728: connections_available = FALSE;
! 3729: }
! 3730: }
! 3731:
! 3732: if(!connections_available) {
! 3733: infof(data, "No connections available.\n");
! 3734:
! 3735: conn_free(conn);
! 3736: *in_connect = NULL;
! 3737:
! 3738: result = CURLE_NO_CONNECTION_AVAILABLE;
! 3739: goto out;
! 3740: }
! 3741: else {
! 3742: /*
! 3743: * This is a brand new connection, so let's store it in the connection
! 3744: * cache of ours!
! 3745: */
! 3746: result = Curl_conncache_add_conn(data->state.conn_cache, conn);
! 3747: if(result)
! 3748: goto out;
! 3749: }
! 3750:
! 3751: #if defined(USE_NTLM)
! 3752: /* If NTLM is requested in a part of this connection, make sure we don't
! 3753: assume the state is fine as this is a fresh connection and NTLM is
! 3754: connection based. */
! 3755: if((data->state.authhost.picked & (CURLAUTH_NTLM | CURLAUTH_NTLM_WB)) &&
! 3756: data->state.authhost.done) {
! 3757: infof(data, "NTLM picked AND auth done set, clear picked!\n");
! 3758: data->state.authhost.picked = CURLAUTH_NONE;
! 3759: data->state.authhost.done = FALSE;
! 3760: }
! 3761:
! 3762: if((data->state.authproxy.picked & (CURLAUTH_NTLM | CURLAUTH_NTLM_WB)) &&
! 3763: data->state.authproxy.done) {
! 3764: infof(data, "NTLM-proxy picked AND auth done set, clear picked!\n");
! 3765: data->state.authproxy.picked = CURLAUTH_NONE;
! 3766: data->state.authproxy.done = FALSE;
! 3767: }
! 3768: #endif
! 3769: }
! 3770:
! 3771: /* Setup and init stuff before DO starts, in preparing for the transfer. */
! 3772: Curl_init_do(data, conn);
! 3773:
! 3774: /*
! 3775: * Setup whatever necessary for a resumed transfer
! 3776: */
! 3777: result = setup_range(data);
! 3778: if(result)
! 3779: goto out;
! 3780:
! 3781: /* Continue connectdata initialization here. */
! 3782:
! 3783: /*
! 3784: * Inherit the proper values from the urldata struct AFTER we have arranged
! 3785: * the persistent connection stuff
! 3786: */
! 3787: conn->seek_func = data->set.seek_func;
! 3788: conn->seek_client = data->set.seek_client;
! 3789:
! 3790: /*************************************************************
! 3791: * Resolve the address of the server or proxy
! 3792: *************************************************************/
! 3793: result = resolve_server(data, conn, async);
! 3794:
! 3795: /* Strip trailing dots. resolve_server copied the name. */
! 3796: strip_trailing_dot(&conn->host);
! 3797: if(conn->bits.httpproxy)
! 3798: strip_trailing_dot(&conn->http_proxy.host);
! 3799: if(conn->bits.socksproxy)
! 3800: strip_trailing_dot(&conn->socks_proxy.host);
! 3801: if(conn->bits.conn_to_host)
! 3802: strip_trailing_dot(&conn->conn_to_host);
! 3803:
! 3804: out:
! 3805: return result;
! 3806: }
! 3807:
! 3808: /* Curl_setup_conn() is called after the name resolve initiated in
! 3809: * create_conn() is all done.
! 3810: *
! 3811: * Curl_setup_conn() also handles reused connections
! 3812: *
! 3813: * conn->data MUST already have been setup fine (in create_conn)
! 3814: */
! 3815:
! 3816: CURLcode Curl_setup_conn(struct connectdata *conn,
! 3817: bool *protocol_done)
! 3818: {
! 3819: CURLcode result = CURLE_OK;
! 3820: struct Curl_easy *data = conn->data;
! 3821:
! 3822: Curl_pgrsTime(data, TIMER_NAMELOOKUP);
! 3823:
! 3824: if(conn->handler->flags & PROTOPT_NONETWORK) {
! 3825: /* nothing to setup when not using a network */
! 3826: *protocol_done = TRUE;
! 3827: return result;
! 3828: }
! 3829: *protocol_done = FALSE; /* default to not done */
! 3830:
! 3831: /* set proxy_connect_closed to false unconditionally already here since it
! 3832: is used strictly to provide extra information to a parent function in the
! 3833: case of proxy CONNECT failures and we must make sure we don't have it
! 3834: lingering set from a previous invoke */
! 3835: conn->bits.proxy_connect_closed = FALSE;
! 3836:
! 3837: /*
! 3838: * Set user-agent. Used for HTTP, but since we can attempt to tunnel
! 3839: * basically anything through a http proxy we can't limit this based on
! 3840: * protocol.
! 3841: */
! 3842: if(data->set.str[STRING_USERAGENT]) {
! 3843: Curl_safefree(conn->allocptr.uagent);
! 3844: conn->allocptr.uagent =
! 3845: aprintf("User-Agent: %s\r\n", data->set.str[STRING_USERAGENT]);
! 3846: if(!conn->allocptr.uagent)
! 3847: return CURLE_OUT_OF_MEMORY;
! 3848: }
! 3849:
! 3850: data->req.headerbytecount = 0;
! 3851:
! 3852: #ifdef CURL_DO_LINEEND_CONV
! 3853: data->state.crlf_conversions = 0; /* reset CRLF conversion counter */
! 3854: #endif /* CURL_DO_LINEEND_CONV */
! 3855:
! 3856: /* set start time here for timeout purposes in the connect procedure, it
! 3857: is later set again for the progress meter purpose */
! 3858: conn->now = Curl_now();
! 3859:
! 3860: if(CURL_SOCKET_BAD == conn->sock[FIRSTSOCKET]) {
! 3861: conn->bits.tcpconnect[FIRSTSOCKET] = FALSE;
! 3862: result = Curl_connecthost(conn, conn->dns_entry);
! 3863: if(result)
! 3864: return result;
! 3865: }
! 3866: else {
! 3867: Curl_pgrsTime(data, TIMER_CONNECT); /* we're connected already */
! 3868: if(conn->ssl[FIRSTSOCKET].use ||
! 3869: (conn->handler->protocol & PROTO_FAMILY_SSH))
! 3870: Curl_pgrsTime(data, TIMER_APPCONNECT); /* we're connected already */
! 3871: conn->bits.tcpconnect[FIRSTSOCKET] = TRUE;
! 3872: *protocol_done = TRUE;
! 3873: Curl_updateconninfo(conn, conn->sock[FIRSTSOCKET]);
! 3874: Curl_verboseconnect(conn);
! 3875: }
! 3876:
! 3877: conn->now = Curl_now(); /* time this *after* the connect is done, we set
! 3878: this here perhaps a second time */
! 3879: return result;
! 3880: }
! 3881:
! 3882: CURLcode Curl_connect(struct Curl_easy *data,
! 3883: bool *asyncp,
! 3884: bool *protocol_done)
! 3885: {
! 3886: CURLcode result;
! 3887: struct connectdata *conn;
! 3888:
! 3889: *asyncp = FALSE; /* assume synchronous resolves by default */
! 3890:
! 3891: /* init the single-transfer specific data */
! 3892: Curl_free_request_state(data);
! 3893: memset(&data->req, 0, sizeof(struct SingleRequest));
! 3894: data->req.maxdownload = -1;
! 3895:
! 3896: /* call the stuff that needs to be called */
! 3897: result = create_conn(data, &conn, asyncp);
! 3898:
! 3899: if(!result) {
! 3900: if(CONN_INUSE(conn))
! 3901: /* multiplexed */
! 3902: *protocol_done = TRUE;
! 3903: else if(!*asyncp) {
! 3904: /* DNS resolution is done: that's either because this is a reused
! 3905: connection, in which case DNS was unnecessary, or because DNS
! 3906: really did finish already (synch resolver/fast async resolve) */
! 3907: result = Curl_setup_conn(conn, protocol_done);
! 3908: }
! 3909: }
! 3910:
! 3911: if(result == CURLE_NO_CONNECTION_AVAILABLE) {
! 3912: return result;
! 3913: }
! 3914: else if(result && conn) {
! 3915: /* We're not allowed to return failure with memory left allocated in the
! 3916: connectdata struct, free those here */
! 3917: Curl_disconnect(data, conn, TRUE);
! 3918: }
! 3919: else if(!result && !data->conn)
! 3920: /* FILE: transfers already have the connection attached */
! 3921: Curl_attach_connnection(data, conn);
! 3922:
! 3923: return result;
! 3924: }
! 3925:
! 3926: /*
! 3927: * Curl_init_do() inits the readwrite session. This is inited each time (in
! 3928: * the DO function before the protocol-specific DO functions are invoked) for
! 3929: * a transfer, sometimes multiple times on the same Curl_easy. Make sure
! 3930: * nothing in here depends on stuff that are setup dynamically for the
! 3931: * transfer.
! 3932: *
! 3933: * Allow this function to get called with 'conn' set to NULL.
! 3934: */
! 3935:
! 3936: CURLcode Curl_init_do(struct Curl_easy *data, struct connectdata *conn)
! 3937: {
! 3938: struct SingleRequest *k = &data->req;
! 3939:
! 3940: if(conn) {
! 3941: conn->bits.do_more = FALSE; /* by default there's no curl_do_more() to
! 3942: use */
! 3943: /* if the protocol used doesn't support wildcards, switch it off */
! 3944: if(data->state.wildcardmatch &&
! 3945: !(conn->handler->flags & PROTOPT_WILDCARD))
! 3946: data->state.wildcardmatch = FALSE;
! 3947: }
! 3948:
! 3949: data->state.done = FALSE; /* *_done() is not called yet */
! 3950: data->state.expect100header = FALSE;
! 3951:
! 3952:
! 3953: if(data->set.opt_no_body)
! 3954: /* in HTTP lingo, no body means using the HEAD request... */
! 3955: data->set.httpreq = HTTPREQ_HEAD;
! 3956: else if(HTTPREQ_HEAD == data->set.httpreq)
! 3957: /* ... but if unset there really is no perfect method that is the
! 3958: "opposite" of HEAD but in reality most people probably think GET
! 3959: then. The important thing is that we can't let it remain HEAD if the
! 3960: opt_no_body is set FALSE since then we'll behave wrong when getting
! 3961: HTTP. */
! 3962: data->set.httpreq = HTTPREQ_GET;
! 3963:
! 3964: k->start = Curl_now(); /* start time */
! 3965: k->now = k->start; /* current time is now */
! 3966: k->header = TRUE; /* assume header */
! 3967:
! 3968: k->bytecount = 0;
! 3969:
! 3970: k->buf = data->state.buffer;
! 3971: k->hbufp = data->state.headerbuff;
! 3972: k->ignorebody = FALSE;
! 3973:
! 3974: Curl_speedinit(data);
! 3975:
! 3976: Curl_pgrsSetUploadCounter(data, 0);
! 3977: Curl_pgrsSetDownloadCounter(data, 0);
! 3978:
! 3979: return CURLE_OK;
! 3980: }
! 3981:
! 3982: /*
! 3983: * get_protocol_family()
! 3984: *
! 3985: * This is used to return the protocol family for a given protocol.
! 3986: *
! 3987: * Parameters:
! 3988: *
! 3989: * protocol [in] - A single bit protocol identifier such as HTTP or HTTPS.
! 3990: *
! 3991: * Returns the family as a single bit protocol identifier.
! 3992: */
! 3993:
! 3994: static unsigned int get_protocol_family(unsigned int protocol)
! 3995: {
! 3996: unsigned int family;
! 3997:
! 3998: switch(protocol) {
! 3999: case CURLPROTO_HTTP:
! 4000: case CURLPROTO_HTTPS:
! 4001: family = CURLPROTO_HTTP;
! 4002: break;
! 4003:
! 4004: case CURLPROTO_FTP:
! 4005: case CURLPROTO_FTPS:
! 4006: family = CURLPROTO_FTP;
! 4007: break;
! 4008:
! 4009: case CURLPROTO_SCP:
! 4010: family = CURLPROTO_SCP;
! 4011: break;
! 4012:
! 4013: case CURLPROTO_SFTP:
! 4014: family = CURLPROTO_SFTP;
! 4015: break;
! 4016:
! 4017: case CURLPROTO_TELNET:
! 4018: family = CURLPROTO_TELNET;
! 4019: break;
! 4020:
! 4021: case CURLPROTO_LDAP:
! 4022: case CURLPROTO_LDAPS:
! 4023: family = CURLPROTO_LDAP;
! 4024: break;
! 4025:
! 4026: case CURLPROTO_DICT:
! 4027: family = CURLPROTO_DICT;
! 4028: break;
! 4029:
! 4030: case CURLPROTO_FILE:
! 4031: family = CURLPROTO_FILE;
! 4032: break;
! 4033:
! 4034: case CURLPROTO_TFTP:
! 4035: family = CURLPROTO_TFTP;
! 4036: break;
! 4037:
! 4038: case CURLPROTO_IMAP:
! 4039: case CURLPROTO_IMAPS:
! 4040: family = CURLPROTO_IMAP;
! 4041: break;
! 4042:
! 4043: case CURLPROTO_POP3:
! 4044: case CURLPROTO_POP3S:
! 4045: family = CURLPROTO_POP3;
! 4046: break;
! 4047:
! 4048: case CURLPROTO_SMTP:
! 4049: case CURLPROTO_SMTPS:
! 4050: family = CURLPROTO_SMTP;
! 4051: break;
! 4052:
! 4053: case CURLPROTO_RTSP:
! 4054: family = CURLPROTO_RTSP;
! 4055: break;
! 4056:
! 4057: case CURLPROTO_RTMP:
! 4058: case CURLPROTO_RTMPS:
! 4059: family = CURLPROTO_RTMP;
! 4060: break;
! 4061:
! 4062: case CURLPROTO_RTMPT:
! 4063: case CURLPROTO_RTMPTS:
! 4064: family = CURLPROTO_RTMPT;
! 4065: break;
! 4066:
! 4067: case CURLPROTO_RTMPE:
! 4068: family = CURLPROTO_RTMPE;
! 4069: break;
! 4070:
! 4071: case CURLPROTO_RTMPTE:
! 4072: family = CURLPROTO_RTMPTE;
! 4073: break;
! 4074:
! 4075: case CURLPROTO_GOPHER:
! 4076: family = CURLPROTO_GOPHER;
! 4077: break;
! 4078:
! 4079: case CURLPROTO_SMB:
! 4080: case CURLPROTO_SMBS:
! 4081: family = CURLPROTO_SMB;
! 4082: break;
! 4083:
! 4084: default:
! 4085: family = 0;
! 4086: break;
! 4087: }
! 4088:
! 4089: return family;
! 4090: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to url.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / curl / lib