_   _ ____  _
                              ___| | | |  _ \| |
                             / __| | | | |_) | |
                            | (__| |_| |  _ <| |___
                             \___|\___/|_| \_\_____|

                                  Changelog

Version 7.65.0 (22 May 2019)

Daniel Stenberg (22 May 2019)
- RELEASE-NOTES: 7.65.0 release

- THANKS: from the 7.65.0 release-notes

- url: convert the zone id from a IPv6 URL to correct scope id
  
  Reported-by: GitYuanQu on github
  Fixes #3902
  Closes #3914

- configure: detect getsockname and getpeername on windows too
  
  Made detection macros for these two functions in the same style as other
  functions possibly in winsock in the hope this will work better to
  detect these functions when cross-compiling for Windows.
  
  Follow-up to e91e4816123
  
  Fixes #3913
  Closes #3915

Marcel Raad (21 May 2019)
- examples: remove unused variables
  
  Fixes Codacy/CppCheck warnings.
  
  Closes

Daniel Gustafsson (21 May 2019)
- udpateconninfo: mark variable unused
  
  When compiling without getpeername() or getsockname(), the sockfd
  paramter to Curl_udpateconninfo() became unused after commit e91e481612
  added ifdef guards.
  
  Closes #3910
  Fixes https://curl.haxx.se/dev/log.cgi?id=20190520172441-32196
  Reviewed-by: Marcel Raad, Daniel Stenberg

- ftp: move ftp_ccc in under featureflag
  
  Commit e91e48161235272ff485ff32bd048c53af731f43 moved ftp_ccc in under
  the FTP featureflag in the UserDefined struct, but vtls callsites were
  still using it unprotected.
  
  Closes #3912
  Fixes: https://curl.haxx.se/dev/log.cgi?id=20190520044705-29865
  Reviewed-by: Daniel Stenberg, Marcel Raad

Daniel Stenberg (20 May 2019)
- curl: report error for "--no-" on non-boolean options
  
  Reported-by: Olen Andoni
  Fixes #3906
  Closes #3907

- [Guy Poizat brought this change]

  mbedtls: enable use of EC keys
  
  Closes #3892

- lib1560: add tests for parsing URL with too long scheme
  
  Ref: #3905

- [Omar Ramadan brought this change]

  urlapi: increase supported scheme length to 40 bytes
  
  The longest currently registered URI scheme at IANA is 36 bytes long.
  
  Closes #3905
  Closes #3900

Marcel Raad (20 May 2019)
- lib: reduce variable scopes
  
  Fixes Codacy/CppCheck warnings.
  
  Closes https://github.com/curl/curl/pull/3872

- tool_formparse: remove redundant assignment
  
  Just initialize word_begin with the correct value.
  
  Closes https://github.com/curl/curl/pull/3873

- ssh: move variable declaration to where it's used
  
  This way, we need only one call to free.
  
  Closes https://github.com/curl/curl/pull/3873

- ssh-libssh: remove unused variable
  
  sock was only used to be assigned to fd_read.
  
  Closes https://github.com/curl/curl/pull/3873

Daniel Stenberg (20 May 2019)
- test332: verify the blksize fix

- tftp: use the current blksize for recvfrom()
  
  bug: https://curl.haxx.se/docs/CVE-2019-5436.html
  Reported-by: l00p3r on hackerone
  CVE-2019-5436

Daniel Gustafsson (19 May 2019)
- version: make ssl_version buffer match for multi_ssl
  
  When running a multi TLS backend build the version string needs more
  buffer space. Make the internal ssl_buffer stack buffer match the one
  in Curl_multissl_version() to allow for the longer string. For single
  TLS backend builds there is no use in extended to buffer. This is a
  fallout from #3863 which fixes up the multi_ssl string generation to
  avoid a buffer overflow when the buffer is too small.
  
  Closes #3875
  Reviewed-by: Daniel Stenberg <daniel@haxx.se>

Steve Holme (18 May 2019)
- http_ntlm_wb: Handle auth for only a single request
  
  Currently when the server responds with 401 on NTLM authenticated
  connection (re-used) we consider it to have failed.  However this is
  legitimate and may happen when for example IIS is set configured to
  'authPersistSingleRequest' or when the request goes thru a proxy (with
  'via' header).
  
  Implemented by imploying an additional state once a connection is
  re-used to indicate that if we receive 401 we need to restart
  authentication.
  
  Missed in fe6049f0.

- http_ntlm_wb: Cleanup handshake after clean NTLM failure
  
  Missed in 50b87c4e.

- http_ntlm_wb: Return the correct error on receiving an empty auth message
  
  Missed in fe20826b as it wasn't implemented in http.c in b4d6db83.
  
  Closes #3894

Daniel Stenberg (18 May 2019)
- curl: make code work with protocol-disabled libcurl
  
  Closes #3844

- libcurl: #ifdef away more code for disabled features/protocols

- progress: CURL_DISABLE_PROGRESS_METER

- hostip: CURL_DISABLE_SHUFFLE_DNS

- netrc: CURL_DISABLE_NETRC

Viktor Szakats (16 May 2019)
- docs: Markdown and misc improvements [ci skip]
  
  Approved-by: Daniel Stenberg
  Closes #3896

- docs/RELEASE-PROCEDURE: link to live iCalendar [ci skip]
  
  Ref: https://github.com/curl/curl/commit/0af41b40b2c7bd379b2251cbe7cd618e21fa0ea1#commitcomment-33563135
  Approved-by: Daniel Stenberg
  Closes #3895

Daniel Stenberg (16 May 2019)
- travis: add an osx http-only build
  
  Closes #3887

- cleanup: remove FIXME and TODO comments
  
  They serve very little purpose and mostly just add noise. Most of them
  have been around for a very long time. I read them all before removing
  or rephrasing them.
  
  Ref: #3876
  Closes #3883

- curl: don't set FTP options for FTP-disabled builds
  
  ... since libcurl has started to be totally unaware of options for
  disabled protocols they now return error.
  
  Bug: https://github.com/curl/curl/commit/c9c5304dd4747cbe75d2f24be85920d572fcb5b8#commitcomment-33533937
  
  Reported-by: Marcel Raad
  Closes #3886

Steve Holme (16 May 2019)
- http_ntlm_wb: Move the type-2 message processing into a dedicated function
  
  This brings the code inline with the other HTTP authentication mechanisms.
  
  Closes #3890

Daniel Stenberg (15 May 2019)
- RELEASE-NOTES: synced

- docs/RELEASE-PROCEDURE: updated coming releases dates [ci skip]

- CURLOPT_READFUNCTION.3: see also CURLOPT_UPLOAD_BUFFERSIZE [ci skip]
  
  Reported-by: Roy Bellingan
  Bug: #3885

- parse_proxy: use the URL parser API
  
  As we treat a given proxy as a URL we should use the unified URL parser
  to extract the parts out of it.
  
  Closes #3878

Steve Holme (15 May 2019)
- http_negotiate: Move the Negotiate state out of the negotiatedata structure
  
  Given that this member variable is not used by the SASL based protocols
  there is no need to have it here.
  
  Closes #3882

- http_ntlm: Move the NTLM state out of the ntlmdata structure
  
  Given that this member variable is not used by the SASL based protocols
  there is no need to have it here.

- url: Move the negotiate state type into a dedicated enum

- url: Remove duplicate clean up of the winbind variables in conn_shutdown()
  
  Given that Curl_disconnect() calls Curl_http_auth_cleanup_ntlm() prior
  to calling conn_shutdown() and it in turn performs this, there is no
  need to perform the same action in conn_shutdown().
  
  Closes #3881

Daniel Stenberg (14 May 2019)
- urlapi: require a non-zero host name length when parsing URL
  
  Updated test 1560 to verify.
  
  Closes #3880

- configure: error out if OpenSSL wasn't detected when asked for
  
  If --with-ssl is used and configure still couldn't enable SSL this
  creates an error instead of just silently ignoring the fact.
  
  Suggested-by: Isaiah Norton
  Fixes #3824
  Closes #3830

Daniel Gustafsson (14 May 2019)
- imap: Fix typo in comment

Steve Holme (14 May 2019)
- url: Remove unnecessary initialisation from allocate_conn()
  
  No need to set variables to zero as calloc() does this for us.
  
  Closes #3879

Daniel Stenberg (14 May 2019)
- CURLOPT_CAINFO.3: with Schannel, you want Windows 8 or later [ci skip]
  
  Clues-provided-by: Jay Satiro
  Clues-provided-by: Jeroen Ooms
  Fixes #3711
  Closes #3874

Daniel Gustafsson (13 May 2019)
- vtls: fix potential ssl_buffer stack overflow
  
  In Curl_multissl_version() it was possible to overflow the passed in
  buffer if the generated version string exceeded the size of the buffer.
  Fix by inverting the logic, and also make sure to not exceed the local
  buffer during the string generation.
  
  Closes #3863
  Reported-by: nevv on HackerOne/curl
  Reviewed-by: Jay Satiro
  Reviewed-by: Daniel Stenberg

Daniel Stenberg (13 May 2019)
- RELEASE-NOTES: synced

- appveyor: also build "/ci" branches like travis

- pingpong: disable more when no pingpong enabled

- proxy: acknowledge DISABLE_PROXY more

- parsedate: CURL_DISABLE_PARSEDATE

- sasl: only enable if there's a protocol enabled using it

- mime: acknowledge CURL_DISABLE_MIME

- wildcard: disable from build when FTP isn't present

- http: CURL_DISABLE_HTTP_AUTH

- base64: build conditionally if there are users

- doh: CURL_DISABLE_DOH

Steve Holme (12 May 2019)
- auth: Rename the various authentication clean up functions
  
  For consistency and to a avoid confusion.
  
  Closes #3869

Daniel Stenberg (12 May 2019)
- [Jay Satiro brought this change]

  docs/INSTALL: fix broken link [ci skip]
  
  Reported-by: Joombalaya on github
  Fixes #3818

Marcel Raad (12 May 2019)
- easy: fix another "clarify calculation precedence" warning
  
  I missed this one in commit 6b3dde7fe62ea5a557fd1fd323fac2bcd0c2e9be.

- build: fix "clarify calculation precedence" warnings
  
  Codacy/CppCheck warns about this. Consistently use parentheses as we
  already do in some places to silence the warning.
  
  Closes https://github.com/curl/curl/pull/3866

- cmake: restore C89 compatibility of CurlTests.c
  
  I broke it in d1b5cf830bfe169745721b21245d2217d2c2453e and
  97de97daefc2ed084c91eff34af2426f2e55e134.
  
  Reported-by: Viktor Szakats
  Ref: https://github.com/curl/curl/commit/97de97daefc2ed084c91eff34af2426f2e55e134#commitcomment-33499044
  Closes https://github.com/curl/curl/pull/3868

Steve Holme (11 May 2019)
- http_ntlm: Corrected the name of the include guard
  
  Missed in f0bdd72c.
  
  Closes #3867

- http_digest: Don't expose functions when HTTP and Crypto Auth are disabled
  
  Closes #3861

- http_negotiate: Don't expose functions when HTTP is disabled

Daniel Stenberg (11 May 2019)
- SECURITY-PROCESS: fix links [ci skip]

Marcel Raad (11 May 2019)
- CMake: suppress unused variable warnings
  
  I missed these in commit d1b5cf830bfe169745721b21245d2217d2c2453e.

Daniel Stenberg (11 May 2019)
- doh: disable DOH for the cases it doesn't work
  
  Due to limitations in Curl_resolver_wait_resolv(), it doesn't work for
  DOH resolves. This fix disables DOH for those.
  
  Limitation added to KNOWN_BUGS.
  
  Fixes #3850
  Closes #3857

Jay Satiro (11 May 2019)
- checksrc.bat: Ignore snprintf warnings in docs/examples
  
  .. because we allow snprintf use in docs/examples.
  
  Closes https://github.com/curl/curl/pull/3862

Steve Holme (10 May 2019)
- vauth: Fix incorrect function description for Curl_auth_user_contains_domain()
  
  ...and misalignment of these comments. From a78c61a4.
  
  Closes #3860

Jay Satiro (10 May 2019)
- Revert "multi: support verbose conncache closure handle"
  
  This reverts commit b0972bc.
  
  - No longer show verbose output for the conncache closure handle.
  
  The offending commit was added so that the conncache closure handle
  would inherit verbose mode from the user's easy handle. (Note there is
  no way for the user to set options for the closure handle which is why
  that was necessary.) Other debug settings such as the debug function
  were not also inherited since we determined that could lead to crashes
  if the user's per-handle private data was used on an unexpected handle.
  
  The reporter here says he has a debug function to capture the verbose
  output, and does not expect or want any output to stderr; however
  because the conncache closure handle does not inherit the debug function
  the verbose output for that handle does go to stderr.
  
  There are other plausible scenarios as well such as the user redirects
  stderr on their handle, which is also not inherited since it could lead
  to crashes when used on an unexpected handle.
  
  Short of allowing the user to set options for the conncache closure
  handle I don't think there's much we can safely do except no longer
  inherit the verbose setting.
  
  Bug: https://curl.haxx.se/mail/lib-2019-05/0021.html
  Reported-by: Kristoffer Gleditsch
  
  Ref: https://github.com/curl/curl/pull/3598
  Ref: https://github.com/curl/curl/pull/3618
  
  Closes https://github.com/curl/curl/pull/3856

Steve Holme (10 May 2019)
- ntlm: Fix misaligned function comments for Curl_auth_ntlm_cleanup()
  
  From 6012fa5a.
  
  Closes #3858

Daniel Stenberg (9 May 2019)
- BUG-BOUNTY: minor formatting fixes [ci skip]

- RELEASE-NOTES: synced

- BUG-BOUNTY.md: add the Dropbox "bonus" extra payout ability [ci skip]
  
  Closes #3839

Kamil Dudka (9 May 2019)
- http_negotiate: do not treat failure of gss_init_sec_context() as fatal
  
  Fixes #3726
  Closes #3849

- spnego_gssapi: fix return code on gss_init_sec_context() failure
  
  Fixes #3726
  Closes #3849

Steve Holme (9 May 2019)
- gen_resp_file.bat: Removed unnecessary @ from all but the first command
  
  There is need to use @ on every command once echo has been turned off.
  
  Closes #3854

Jay Satiro (8 May 2019)
- http: Ignore HTTP/2 prior knowledge setting for HTTP proxies
  
  - Do not switch to HTTP/2 for an HTTP proxy that is not tunnelling to
    the destination host.
  
  We already do something similar for HTTPS proxies by not sending h2. [1]
  
  Prior to this change setting CURL_HTTP_VERSION_2_PRIOR_KNOWLEDGE would
  incorrectly use HTTP/2 to talk to the proxy, which is not something we
  support (yet?). Also it's debatable whether or not that setting should
  apply to HTTP/2 proxies.
  
  [1]: https://github.com/curl/curl/commit/17c5d05
  
  Bug: https://github.com/curl/curl/issues/3570
  Bug: https://github.com/curl/curl/issues/3832
  
  Closes https://github.com/curl/curl/pull/3853

Marcel Raad (8 May 2019)
- travis: update mesalink build to xenial
  
  Closes https://github.com/curl/curl/pull/3842

Daniel Stenberg (8 May 2019)
- [Ricky Leverence brought this change]

  OpenSSL: Report -fips in version if OpenSSL is built with FIPS
  
  Older versions of OpenSSL report FIPS availabilty via an OPENSSL_FIPS
  define. It uses this define to determine whether to publish -fips at
  the end of the version displayed. Applications that utilize the version
  reported by OpenSSL will see a mismatch if they compare it to what curl
  reports, as curl is not modifying the version in the same way. This
  change simply adds a check to see if OPENSSL_FIPS is defined, and will
  alter the reported version to match what OpenSSL itself provides. This
  only appears to be applicable in versions of OpenSSL <1.1.1
  
  Closes #3771

Kamil Dudka (7 May 2019)
- [Frank Gevaerts brought this change]

  nss: allow fifos and character devices for certificates.
  
  Currently you can do things like --cert <(cat ./cert.crt) with (at least) the
  openssl backend, but that doesn't work for nss because is_file rejects fifos.
  
  I don't actually know if this is sufficient, nss might do things internally
  (like seeking back) that make this not work, so actual testing is needed.
  
  Closes #3807

Daniel Gustafsson (6 May 2019)
- test2100: Fix typos in test description

Daniel Stenberg (6 May 2019)
- ssh: define USE_SSH if SSH is enabled (any backend)
  
  Closes #3846

Steve Holme (5 May 2019)
- winbuild: Add our standard copyright header to the winbuild batch files

- makedebug: Fix ERRORLEVEL detection after running where.exe
  
  Closes #3838

Daniel Stenberg (5 May 2019)
- urlapi: add CURLUPART_ZONEID to set and get
  
  The zoneid can be used with IPv6 numerical addresses.
  
  Updated test 1560 to verify.
  
  Closes #3834

- [Taiyu Len brought this change]

  WRITEFUNCTION: add missing set_in_callback around callback
  
  Closes #3837

- RELEASE-NOTES: synced

- CURLMOPT_TIMERFUNCTION.3: warn about the recursive risk [ci skip]
  
  Reported-by: Ricardo Gomes
  
  Bug: #3537
  Closes #3836

- CURLOPT_CHUNK_BGN_FUNCTION.3: document the struct and time value
  
  The time field in the curl_fileinfo struct will always be zero. No code
  was ever implemented to actually convert the date string to a time_t.
  
  Fixes #3829
  Closes #3835

- OS400/ccsidcurl.c: code style fixes

- OS400/ccsidcurl: replace use of Curl_vsetopt
  
  (and make the code style comply)
  
  Fixes #3833

- urlapi: strip off scope id from numerical IPv6 addresses
  
  ... to make the host name "usable". Store the scope id and put it back
  when extracting a URL out of it.
  
  Also makes curl_url_set() syntax check CURLUPART_HOST.
  
  Fixes #3817
  Closes #3822

- RELEASE-NOTES: synced

- multiif.h: remove unused protos
  
  ... for functions related to pipelining. Those functions were removed in
  2f44e94efb3df.
  
  Closes #3828

- [Yiming Jing brought this change]

  travis: mesalink: temporarily disable test 3001
  
  ... due to SHA-1 signatures in test certs

- [Yiming Jing brought this change]

  travis: upgrade the MesaLink TLS backend to v1.0.0
  
  Closes #3823
  Closes #3776

- ConnectionExists: improve non-multiplexing use case
  
  - better log output
  
  - make sure multiplex is enabled for it to be used

- multi: provide Curl_multiuse_state to update information
  
  As soon as a TLS backend gets ALPN conformation about the specific HTTP
  version it can now set the multiplex situation for the "bundle" and
  trigger moving potentially queued up transfers to the CONNECT state.

- process_pending_handles: mark queued transfers as previously pending
  
  With transfers being queued up, we only move one at a a time back to the
  CONNECT state but now we mark moved transfers so that when a moved
  transfer is confirmed "successful" (it connected) it will trigger the
  move of another pending transfer. Previously, it would otherwise wait
  until the transfer was done before doing this. This makes queued up
  pending transfers get processed (much) faster.

- http: mark bundle as not for multiuse on < HTTP/2 response
  
  Fixes #3813
  Closes #3815

Daniel Gustafsson (1 May 2019)
- cookie: Guard against possible NULL ptr deref
  
  In case the name pointer isn't set (due to memory pressure most likely)
  we need to skip the prefix matching and reject with a badcookie to avoid
  a possible NULL pointer dereference.
  
  Closes #3820 #3821
  Reported-by: Jonathan Moerman
  Reviewed-by: Daniel Stenberg <daniel@haxx.se>

Patrick Monnerat (30 Apr 2019)
- os400: Add CURLOPT_MAXAGE_CONN to ILE/RPG bindings

Kamil Dudka (29 Apr 2019)
- nss: provide more specific error messages on failed init
  
  Closes #3808

Daniel Stenberg (29 Apr 2019)
- [Reed Loden brought this change]

  docs: minor polish to the bug bounty / security docs
  
  Closes #3811

- CURL_MAX_INPUT_LENGTH: largest acceptable string input size
  
  This limits all accepted input strings passed to libcurl to be less than
  CURL_MAX_INPUT_LENGTH (8000000) bytes, for these API calls:
  curl_easy_setopt() and curl_url_set().
  
  The 8000000 number is arbitrary picked and is meant to detect mistakes
  or abuse, not to limit actual practical use cases. By limiting the
  acceptable string lengths we also reduce the risk of integer overflows
  all over.
  
  NOTE: This does not apply to `CURLOPT_POSTFIELDS`.
  
  Test 1559 verifies.
  
  Closes #3805

- [Tseng Jun brought this change]

  curlver.h: use parenthesis in CURL_VERSION_BITS macro
  
  Closes #3809

Marcel Raad (27 Apr 2019)
- [Simon Warta brought this change]

  cmake: rename CMAKE_USE_DARWINSSL to CMAKE_USE_SECTRANSP
  
  Closes https://github.com/curl/curl/pull/3769

Steve Holme (23 Apr 2019)
- ntlm: Missed pre-processor || (or) during rebase for cd15acd0

- ntlm: Support the NT response in the type-3 when OpenSSL doesn't include MD4
  
  Just like we do for mbed TLS, use our local implementation of MD4 when
  OpenSSL doesn't support it. This allows a type-3 message to include the
  NT response.

Daniel Gustafsson (23 Apr 2019)
- INTERNALS: fix misindentation of ToC item
  
  Kerberos was incorrectly indented as a subsection under FTP, which is
  incorrect as they are both top level sections. A fix for this was first
  attempted in commit fef38a0898322f285401c5ff2f5e7c90dbf3be63 but that
  was a few paddles short of being complete.

- [Aron Bergman brought this change]

  INTERNALS: Add structs to ToC
  
  Add the subsections under "Structs in libcurl" to the table of contents.
  
  Reviewed-by: Daniel Stenberg <daniel@haxx.se>
  Reviewed-by: Daniel Gustafsson <daniel@yesql.se>

- [Aron Bergman brought this change]

  INTERNALS: Add code highlighting
  
  Make all struct members under the Curl_handler section
  print in monospace font.
  
  Closes #3801
  Reviewed-by: Daniel Stenberg <daniel@haxx.se>
  Reviewed-by: Daniel Gustafsson <daniel@yesql.se>

Daniel Stenberg (22 Apr 2019)
- docs/BUG-BOUNTY: bug bounty time [skip ci]
  
  Introducing the curl bug bounty program on hackerone. We now recommend
  filing security issues directly in the hackerone ticket system which
  only is readable to curl security team members.
  
  Assisted-by: Daniel Gustafsson
  
  Closes #3488

Steve Holme (22 Apr 2019)
- sasl: Don't send authcid as authzid for the PLAIN mechanism as per RFC 4616
  
  RFC 4616 specifies the authzid is optional in the client authentication
  message and that the server will derive the authorisation identity
  (authzid) from the authentication identity (authcid) when not specified
  by the client.

Jay Satiro (22 Apr 2019)
- [Gisle Vanem brought this change]

  memdebug: fix variable name
  
  Follow-up to 76b6348 which renamed logfile as curl_dbg_logfile.
  
  Ref: https://github.com/curl/curl/commit/76b6348#r33259088

Steve Holme (21 Apr 2019)
- vauth/cleartext: Don't send the authzid if it is empty
  
  Follow up to 762a292f.

Daniel Stenberg (21 Apr 2019)
- test 196,197,198: add 'retry' keyword [skip ci]

- RELEASE-NOTES: synced

- CURLOPT_MAXAGE_CONN: set the maximum allowed age for conn reuse
  
  ... and disconnect too old ones instead of trying to reuse.
  
  Default max age is set to 118 seconds.
  
  Ref: #3722
  Closes #3782

Daniel Gustafsson (20 Apr 2019)
- [Po-Chuan Hsieh brought this change]

  altsvc: Fix building with cookies disables
  
  ALTSVC requires Curl_get_line which is defined in lib/cookie.c inside a #if
  check of HTTP and COOKIES. That makes Curl_get_line undefined if COOKIES is
  disabled. Fix by splitting out the function into a separate file which can
  be included where needed.
  
  Closes #3717
  Reviewed-by: Daniel Gustafsson <daniel@yesql.se>
  Reviewed-by: Marcel Raad <Marcel.Raad@teamviewer.com>

Daniel Stenberg (20 Apr 2019)
- test1002: correct the name [skip ci]

- test660: verify CONNECT_ONLY with IMAP
  
  which basically just makes sure LOGOUT is *not* issued on disconnect

- Curl_disconnect: treat all CONNECT_ONLY connections as "dead"
  
  Since the connection has been used by the "outside" we don't know the
  state of it anymore and curl should not use it anymore.
  
  Bug: https://curl.haxx.se/mail/lib-2019-04/0052.html
  
  Closes #3795

- multi: fix the statenames (follow-up fix from 2f44e94efb3df8e)
  
  The list of names must be in sync with the defined states in the header
  file!

Steve Holme (16 Apr 2019)
- openvms: Remove pre-processors for Windows as VMS cannot support them

- openvms: Remove pre-processor for SecureTransport as VMS cannot support it
  
  Fixes #3768
  Closes #3785

Jay Satiro (16 Apr 2019)
- TODO: Add issue link to an existing entry

Daniel Stenberg (16 Apr 2019)
- RELEASE-NOTES: synced

Jay Satiro (16 Apr 2019)
- tool_help: Warn if curl and libcurl versions do not match
  
  .. because functionality may be affected if the versions differ.
  
  This commit implements TODO 18.7 "warning if curl version is not in sync
  with libcurl version".
  
  Ref: https://github.com/curl/curl/blob/curl-7_64_1/docs/TODO#L1028-L1033
  
  Closes https://github.com/curl/curl/pull/3774

Steve Holme (16 Apr 2019)
- md5: Update the function signature following d84da52d

- md5: Forgot to update the code alignment in d84da52d

- md5: Return CURLcode from the internally accessible functions
  
  Following 28f826b3 to return CURLE_OK instead of numeric 0.

Daniel Gustafsson (15 Apr 2019)
- tests: Run global cleanup at end of tests
  
  Make sure to run curl_global_cleanup() when shutting down the test
  suite to release any resources allocated in the SSL setup. This is
  clearly visible when running tests with PolarSSL where the thread
  lock calloc() memory which isn't released when not running cleanup.
  Below is an excerpt from the autobuild logs:
  
    ==12368== 96 bytes in 1 blocks are possibly lost in loss record 1 of 2
    ==12368== at 0x4837B65: calloc (vg_replace_malloc.c:752)
    ==12368== by 0x11A76E: curl_dbg_calloc (memdebug.c:205)
    ==12368== by 0x145CDF: Curl_polarsslthreadlock_thread_setup
                           (polarssl_threadlock.c:54)
    ==12368== by 0x145B37: Curl_polarssl_init (polarssl.c:865)
    ==12368== by 0x14129D: Curl_ssl_init (vtls.c:171)
    ==12368== by 0x118B4C: global_init (easy.c:158)
    ==12368== by 0x118BF5: curl_global_init (easy.c:221)
    ==12368== by 0x118D0B: curl_easy_init (easy.c:299)
    ==12368== by 0x114E96: test (lib1906.c:32)
    ==12368== by 0x115495: main (first.c:174)
  
  Closes #3783
  Reviewed-by: Marcel Raad <Marcel.Raad@teamviewer.com>
  Reviewed-by: Daniel Stenberg <daniel@haxx.se>

Marcel Raad (15 Apr 2019)
- travis: use mbedtls from Xenial
  
  No need to build it from source anymore.
  
  Closes https://github.com/curl/curl/pull/3779

- travis: use libpsl from Xenial
  
  This makes building libpsl and libidn2 from source unnecessary and
  removes the need for the autopoint and libunistring-dev packages.
  
  Closes https://github.com/curl/curl/pull/3779

Daniel Stenberg (15 Apr 2019)
- runtests: start socksd like other servers
  
  ... without a $srcdir prefix. Triggered by the failures in several
  autobuilds.
  
  Closes #3781

Daniel Gustafsson (14 Apr 2019)
- socksd: Fix typos
  
  Reviewed-by: Daniel Stenberg <daniel@haxx.se>

- socksd: Properly decorate static variables
  
  Mark global variables static to avoid compiler warning in Clang when
  using -Wmissing-variable-declarations.
  
  Closes #3778
  Reviewed-by: Daniel Stenberg <daniel@haxx.se>

Steve Holme (14 Apr 2019)
- md(4|5): Fixed indentation oddities with the importation of replacement code
  
  The indentation from 211d5329 and 57d6d253 was a little strange as
  parts didn't align correctly, uses 4 spaces rather than 2. Checked
  the indentation of the original source so it aligns, albeit, using
  curl style.

- md5: Code style to return CURLE_OK rather than numeric 0

- md5: Corrected code style for some pointer arguments

Marcel Raad (13 Apr 2019)
- travis: update some builds to xenial
  
  Xenial comes with more up-to-date software versions and more available
  packages, some of which we currently build from source. Unfortunately,
  some builds would fail with Xenial because of assertion failures in
  Valgrind when using OpenSSL, so leave these at Trusty.
  
  Closes https://github.com/curl/curl/pull/3777

Daniel Stenberg (13 Apr 2019)
- test: make tests and test scripts use socksd for SOCKS
  
  Make all SOCKS tests use socksd instead of ssh.

- socksd: new SOCKS 4+5 server for tests
  
  Closes #3752

- singleipconnect: show port in the verbose "Trying ..." message
  
  To aid debugging better.

- [tmilburn brought this change]

  CURLOPT_ADDRESS_SCOPE: fix range check and more
  
  Commit 9081014 fixed most of the confusing issues between scope id and
  scope however 844896d added bad limits checking assuming that the scope
  is being set and not the scope id.
  
  I have fixed the documentation so it all refers to scope ids.
  
  In addition Curl_if2ip refered to the scope id as remote_scope_id which
  is incorrect, so I renamed it to local_scope_id.
  
  Adjusted-by: Daniel Stenberg
  
  Closes #3655
  Closes #3765
  Fixes #3713

- urlapi: stricter CURLUPART_PORT parsing
  
  Only allow well formed decimal numbers in the input.
  
  Document that the number MUST be between 1 and 65535.
  
  Add tests to test 1560 to verify the above.
  
  Ref: https://github.com/curl/curl/issues/3753
  Closes #3762

Jay Satiro (13 Apr 2019)
- [Jan Ehrhardt brought this change]

  winbuild: Support MultiSSL builds
  
  - Remove the lines in winbuild/Makefile.vc that generate an error with
    multiple SSL backends.
  
  - Add /DCURL_WITH_MULTI_SSL in winbuild/MakefileBuild.vc if multiple SSL
    backends are set.
  
  Closes https://github.com/curl/curl/pull/3772

Daniel Stenberg (12 Apr 2019)
- travis: remove mesalink builds (temporarily?)
  
  Since the mesalink build started to fail on travis, even though we build
  a fixed release version, we disable it to prevent it from blocking
  progress.
  
  Closes #3767

- openssl: mark connection for close on TLS close_notify
  
  Without this, detecting and avoid reusing a closed TLS connection
  (without a previous GOAWAY) when doing HTTP/2 is tricky.
  
  Reported-by: Tom van der Woerdt
  Fixes #3750
  Closes #3763

- RELEASE-NOTES: synced

Steve Holme (11 Apr 2019)
- vauth/cleartext: Update the PLAIN login function signature to match RFC 4616
  
  Functionally this doesn't change anything as we still use the username
  for both the authorisation identity and the authentication identity.
  
  Closes #3757

Daniel Stenberg (11 Apr 2019)
- test1906: verify CURLOPT_CURLU + CURLOPT_PORT usage
  
  Based-on-code-by: Poul T Lomholt

- url: always clone the CUROPT_CURLU handle
  
  Since a few code paths actually update that data.
  
  Fixes #3753
  Closes #3761
  
  Reported-by: Poul T Lomholt

- CURLOPT_DNS_USE_GLOBAL_CACHE: remove
  
  Remove the code too. The functionality has been disabled in code since
  7.62.0. Setting this option will from now on simply be ignored and have
  no function.
  
  Closes #3654

Marcel Raad (11 Apr 2019)
- travis: install libgnutls28-dev only for --with-gnutls build
  
  Reduces the time needed for the other jobs a little.
  
  Closes https://github.com/curl/curl/pull/3721

- travis: install libnss3-dev only for --with-nss build
  
  Reduces the time needed for the other jobs a little.
  
  Closes https://github.com/curl/curl/pull/3721

- travis: install libssh2-dev only for --with-libssh2 build
  
  Reduces the time needed for the other jobs a little.
  
  Closes https://github.com/curl/curl/pull/3721

- travis: install libssh-dev only for --with-libssh build
  
  Reduces the time needed for the other jobs a little.
  
  Closes https://github.com/curl/curl/pull/3721

- travis: install krb5-user only for --with-gssapi build
  
  Reduces the time needed for the other jobs a little.
  
  Closes https://github.com/curl/curl/pull/3721

- travis: install lcov only for the coverage job
  
  Reduces the time needed for the other jobs a little.
  
  Closes https://github.com/curl/curl/pull/3721

- travis: install clang only when needed
  
  This reduces the GCC job runtimes a little and it's needed to
  selectively update clang builds to xenial.
  
  Closes https://github.com/curl/curl/pull/3721

- AppVeyor: enable testing for WinSSL build
  
  Closes https://github.com/curl/curl/pull/3725

- build: fix Codacy/CppCheck warnings
  
  - remove unused variables
  - declare conditionally used variables conditionally
  - suppress unused variable warnings in the CMake tests
  - remove dead variable stores
  - consistently use WIN32 macro to detect Windows
  
  Closes https://github.com/curl/curl/pull/3739

- polarssl_threadlock: remove conditionally unused code
  
  Make functions no-ops if neither both USE_THREADS_POSIX and
  HAVE_PTHREAD_H nor both USE_THREADS_WIN32 and HAVE_PROCESS_H are
  defined. Previously, if only one of them was defined, there was either
  code compiled that did nothing useful or the wrong header included for
  the functions used.
  
  Also, move POLARSSL_MUTEX_T define to implementation file as it's not
  used externally.
  
  Closes https://github.com/curl/curl/pull/3739

- lib557: initialize variables
  
  These variables are only conditionally initialized.
  
  Closes https://github.com/curl/curl/pull/3739

- lib509: add missing include for strdup
  
  Closes https://github.com/curl/curl/pull/3739

- README.md: fix no-consecutive-blank-lines Codacy warning
  
  Consistently use one blank line between blocks.
  
  Closes https://github.com/curl/curl/pull/3739

- tests/server/util: fix Windows Unicode build
  
  Always use the ANSI version of FormatMessage as we don't have the
  curl_multibyte gear available here.
  
  Closes https://github.com/curl/curl/pull/3758

Daniel Stenberg (11 Apr 2019)
- curl_easy_getinfo.3: fix minor formatting mistake

Daniel Gustafsson (11 Apr 2019)
- xattr: skip unittest on unsupported platforms
  
  The stripcredentials unittest fails to compile on platforms without
  xattr support, for example the Solaris member in the buildfarm which
  fails with the following:
  
    CC unit1621-unit1621.o
    CC ../libtest/unit1621-first.o
    CCLD unit1621
    Undefined first referenced
    symbol in file
    stripcredentials unit1621-unit1621.o
    goto problem 2
    ld: fatal: symbol referencing errors. No output written to .libs/unit1621
    collect2: error: ld returned 1 exit status
    gmake[2]: *** [Makefile:996: unit1621] Error 1
  
  Fix by excluding the test on such platforms by using the reverse
  logic from where stripcredentials() is defined.
  
  Closes #3759
  Reviewed-by: Daniel Stenberg <daniel@haxx.se>

Steve Holme (11 Apr 2019)
- emailL Added reference to RFC8314 for implicit TLS

- README: Schannel, stop calling it "winssl"
  
  Stick to "Schannel" everywhere - follow up to 180501cb.

Jakub Zakrzewski (10 Apr 2019)
- cmake: clear CMAKE_REQUIRED_LIBRARIES after each use
  
  This fixes GSSAPI builds with the libraries in a non-standard location.
  The testing for recv() were failing because it failed to link
  the Kerberos libraries, which are not needed for this or subsequent
  tests.
  
  fixes #3743
  closes #3744

- cmake: avoid linking executable for some tests with cmake 3.6+
  
  With CMAKE_TRY_COMPILE_TARGET_TYPE set to STATIC_LIBRARY, the try_compile()
  (which is used by check_c_source_compiles()) will build static library
  instead of executable. This avoids linking additional libraries in and thus
  speeds up those checks a little.
  
  This commit also avoids #3743 (GSSAPI build errors) on itself with cmake
  3.6 or above. That issue was fixed separately for all versions.
  
  Ref: #3744

- cmake: minor cleanup
  
  - Remove nneeded include_regular_expression.
    It was setting what is already a default.
  
  - Remove duplicated include.
  
  - Don't check for pre-3.0.0 CMake version.
    We already require at least 3.0.0, so it's just clutter.
  
  Ref: #3744

Steve Holme (8 Apr 2019)
- build-openssl.bat: Fixed support for OpenSSL v1.1.0+

- build-openssl.bat: Perfer the use of if statements rather than goto (where possible)

- build-openssl.bat: Perform the install for each build type directly after the build

- build-openssl.bat: Split the install of static and shared build types

- build-openssl.bat: Split the building of static and shared build types

- build-openssl.bat: Move the installation into a separate function

- build-openssl.bat: Move the build step into a separate function

- build-openssl.bat: Move the OpenSSL configuration into a separate function

- build-openssl.bat: Fixed the BUILD_CONFIG variable not being initialised
  
  Should the parent environment set this variable then the build might
  not be performed as the user intended.

Daniel Stenberg (8 Apr 2019)
- socks: fix error message

- config.d: clarify that initial : and = might need quoting [skip ci]
  
  Fixes #3738
  Closes #3749

- RELEASE-NOTES: synced
  
  bumped to 7.65.0 for next release

- socks5: user name and passwords must be shorter than 256
  
  bytes... since the protocol needs to store the length in a single byte field.
  
  Reported-by: XmiliaH on github
  Fixes #3737
  Closes #3740

- [Jakub Zakrzewski brought this change]

  test: urlapi: urlencode characters above 0x7f correctly

- [Jakub Zakrzewski brought this change]

  urlapi: urlencode characters above 0x7f correctly
  
  fixes #3741
  Closes #3742

- [Even Rouault brought this change]

  multi_runsingle(): fix use-after-free
  
  Fixes #3745
  Closes #3746
  
  The following snippet
  ```
  
  int main()
  {
      CURL* hCurlHandle = curl_easy_init();
      curl_easy_setopt(hCurlHandle, CURLOPT_URL, "http://example.com");
      curl_easy_setopt(hCurlHandle, CURLOPT_PROXY, "1");
      curl_easy_perform(hCurlHandle);
      curl_easy_cleanup(hCurlHandle);
      return 0;
  }
  ```
  triggers the following Valgrind warning
  
  ```
  ==4125== Invalid read of size 8
  ==4125==    at 0x4E7D1EE: Curl_llist_remove (llist.c:97)
  ==4125==    by 0x4E7EF5C: detach_connnection (multi.c:798)
  ==4125==    by 0x4E80545: multi_runsingle (multi.c:1451)
  ==4125==    by 0x4E8197C: curl_multi_perform (multi.c:2072)
  ==4125==    by 0x4E766A0: easy_transfer (easy.c:625)
  ==4125==    by 0x4E76915: easy_perform (easy.c:719)
  ==4125==    by 0x4E7697C: curl_easy_perform (easy.c:738)
  ==4125==    by 0x4008BE: main (in /home/even/curl/test)
  ==4125==  Address 0x9b3d1d0 is 1,120 bytes inside a block of size 1,600 free'd
  ==4125==    at 0x4C2ECF0: free (vg_replace_malloc.c:530)
  ==4125==    by 0x4E62C36: conn_free (url.c:756)
  ==4125==    by 0x4E62D34: Curl_disconnect (url.c:818)
  ==4125==    by 0x4E48DF9: Curl_once_resolved (hostip.c:1097)
  ==4125==    by 0x4E8052D: multi_runsingle (multi.c:1446)
  ==4125==    by 0x4E8197C: curl_multi_perform (multi.c:2072)
  ==4125==    by 0x4E766A0: easy_transfer (easy.c:625)
  ==4125==    by 0x4E76915: easy_perform (easy.c:719)
  ==4125==    by 0x4E7697C: curl_easy_perform (easy.c:738)
  ==4125==    by 0x4008BE: main (in /home/even/curl/test)
  ==4125==  Block was alloc'd at
  ==4125==    at 0x4C2F988: calloc (vg_replace_malloc.c:711)
  ==4125==    by 0x4E6438E: allocate_conn (url.c:1654)
  ==4125==    by 0x4E685B4: create_conn (url.c:3496)
  ==4125==    by 0x4E6968F: Curl_connect (url.c:4023)
  ==4125==    by 0x4E802E7: multi_runsingle (multi.c:1368)
  ==4125==    by 0x4E8197C: curl_multi_perform (multi.c:2072)
  ==4125==    by 0x4E766A0: easy_transfer (easy.c:625)
  ==4125==    by 0x4E76915: easy_perform (easy.c:719)
  ==4125==    by 0x4E7697C: curl_easy_perform (easy.c:738)
  ==4125==    by 0x4008BE: main (in /home/even/curl/test)
  ```
  
  This has been bisected to commit 2f44e94
  
  Fixes https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=14109
  Credit to OSS Fuzz

- pipelining: removed
  
  As previously planned and documented in DEPRECATE.md, all pipelining
  code is removed.
  
  Closes #3651

- [cclauss brought this change]

  tests: make Impacket (SMB server) Python 3 compatible
  
  Closes #3731
  Fixes #3289

Marcel Raad (6 Apr 2019)
- [Simon Warta brought this change]

  cmake: set SSL_BACKENDS
  
  This groups all SSL backends into the feature "SSL" and sets the
  SSL_BACKENDS analogue to configure.ac
  
  Closes https://github.com/curl/curl/pull/3736

- [Simon Warta brought this change]

  cmake: don't run SORT on empty list
  
  In case of an empty list, SORTing leads to the cmake error "list
  sub-command SORT requires list to be present."
  
  Closes https://github.com/curl/curl/pull/3736

Daniel Gustafsson (5 Apr 2019)
- [Eli Schwartz brought this change]

  configure: fix default location for fish completions
  
  Fish defines a vendor completions directory for completions that are not
  installed as part of the fish project itself, and the vendor completions
  are preferred if they exist. This prevents trying to overwrite the
  builtin curl.fish completion (or creating file conflicts in distro
  packaging).
  
  Prefer the pkg-config defined location exported by fish, if it can be
  found, and fall back to the correct directory defined by most systems.
  
  Closes #3723
  Reviewed-by: Daniel Gustafsson

Marcel Raad (5 Apr 2019)
- ftplistparser: fix LGTM alert "Empty block without comment"
  
  Removing the block is consistent with line 954/957.
  
  Closes https://github.com/curl/curl/pull/3732

- transfer: fix LGTM alert "Comparison is always true"
  
  Just remove the redundant condition, which also makes it clear that
  k->buf is always 0-terminated if this break is not hit.
  
  Closes https://github.com/curl/curl/pull/3732

Jay Satiro (4 Apr 2019)
- [Rikard Falkeborn brought this change]

  smtp: fix compiler warning
  
  - Fix clang string-plus-int warning.
  
  Clang 8 warns about adding a string to an int does not append to the
  string. Indeed it doesn't, but that was not the intention either. Use
  array indexing as suggested to silence the warning. There should be no
  functional changes.
  
  (In other words clang warns about "foo"+2 but not &"foo"[2] so use the
  latter.)
  
  smtp.c:1221:29: warning: adding 'int' to a string does not append to the
  string [-Wstring-plus-int]
        eob = strdup(SMTP_EOB + 2);
              ~~~~~~~~~~~~~~~~^~~~
  
  Closes https://github.com/curl/curl/pull/3729

Marcel Raad (4 Apr 2019)
- VS projects: use Unicode for VC10+
  
  All Windows APIs have been natively UTF-16 since Windows 2000 and the
  non-Unicode variants are just wrappers around them. Only Windows 9x
  doesn't understand Unicode without the UnicoWS DLL. As later Visual
  Studio versions cannot target Windows 9x anyway, using the ANSI API
  doesn't really have any benefit there.
  
  This avoids issues like KNOWN_BUGS 6.5.
  
  Ref: https://github.com/curl/curl/issues/2120
  Closes https://github.com/curl/curl/pull/3720

Daniel Gustafsson (3 Apr 2019)
- RELEASE-NOTES: synced
  
  Bump the version in progress to 7.64.2, if we merge any "change"
  before the cut-off date we can update the version.

- [Tim Rühsen brought this change]

  documentation: Fix several typos
  
  Closes #3724
  Reviewed-by: Jakub Zakrzewski
  Reviewed-by: Daniel Gustafsson

Jay Satiro (2 Apr 2019)
- [Mert Yazıcıoğlu brought this change]

  vauth/oauth2: Fix OAUTHBEARER token generation
  
  OAUTHBEARER tokens were incorrectly generated in a format similar to
  XOAUTH2 tokens. These changes make OAUTHBEARER tokens conform to the
  RFC7628.
  
  Fixes: #2487
  Reported-by: Paolo Mossino
  
  Closes https://github.com/curl/curl/pull/3377

Marcel Raad (2 Apr 2019)
- tool_cb_wrt: fix bad-function-cast warning
  
  Commit f5bc578f4cdfdc6c708211dfc2962a0e9d79352d reintroduced the
  warning fixed in commit 2f5f31bb57d68b54e03bffcd9648aece1fe564f8.
  Extend fhnd's scope and reuse that variable instead of calling
  _get_osfhandle a second time to fix the warning again.
  
  Closes https://github.com/curl/curl/pull/3718

- VC15 project: remove MinimalRebuild
  
  Already done in commit d5cfefd0ea8e331b884186bff484210fad36e345 for the
  library project, but I forgot the tool project template. Now also
  removed for that.

Dan Fandrich (1 Apr 2019)
- cirrus: Customize the disabled tests per FreeBSD version
  
  Try to run as many test cases as possible on each OS version.
  12.0 passes 13 more tests than the older versions, so we might as well
  run them.

Daniel Stenberg (1 Apr 2019)
- tool_help: include <strings.h> for strcasecmp
  
  Reported-by: Wyatt O'Day
  Fixes #3715
  Closes #3716

Daniel Gustafsson (31 Mar 2019)
- scripts: fix typos

Dan Fandrich (28 Mar 2019)
- travis: allow builds on branches named "ci"
  
  This allows a way to test changes other than through PRs.

Daniel Stenberg (27 Mar 2019)
- [Brad Spencer brought this change]

  resolve: apply Happy Eyeballs philosophy to parallel c-ares queries
  
  Closes #3699

- multi: improved HTTP_1_1_REQUIRED handling
  
  Make sure to downgrade to 1.1 even when we get this HTTP/2 stream error
  on first flight.
  
  Reported-by: niner on github
  Fixes #3696
  Closes #3707

- [Leonardo Taccari brought this change]

  configure: avoid unportable `==' test(1) operator
  
  Closes #3709

Version 7.64.1 (27 Mar 2019)

Daniel Stenberg (27 Mar 2019)
- RELEASE: 7.64.1

- Revert "ntlm: remove USE_WIN32_CRYPTO check to get USE_NTLM2SESSION set"

  Closes https://github.com/curl/curl/pull/2808

Daniel Stenberg (29 Jul 2018)
- test1157: follow-up to 35ecffb9
  
  Ignore the user-agent line.
  Pointed-out-by: Marcel Raad

typedef void (*func_type)();

int main()
{
#ifndef inet_ntoa_r
  func_type func;
  func = (func_type)inet_ntoa_r;
  (void)func;
#endif
  return 0;
}
#endif
#ifdef HAVE_INET_NTOA_R_DECL_REENTRANT
#define _REENTRANT
#include <arpa/inet.h>

typedef void (*func_type)();

int main()
{
#ifndef inet_ntoa_r
  func_type func;
  func = (func_type)&inet_ntoa_r;
  (void)func;
#endif
  return 0;
}
#endif
#ifdef HAVE_GETADDRINFO
#include <netdb.h>
#include <sys/types.h>

  return arg1 + arg2;
}

int
main() {
  int res3 = c99_vmacro3(1, 2, 3);
  int res2 = c99_vmacro2(1, 2);
  (void)res3;
  (void)res2;
  return 0;
}
#endif
#ifdef HAVE_VARIADIC_MACROS_GCC
#define gcc_vmacro3(first, args...) fun3(first, args)
#define gcc_vmacro2(first, args...) fun2(first, args)

  return arg1 + arg2;
}

int
main() {
  int res3 = gcc_vmacro3(1, 2, 3);
  int res2 = gcc_vmacro2(1, 2);
  (void)res3;
  (void)res2;
  return 0;
}
#endif

    set(CMAKE_REQUIRED_LIBRARIES ws2_32)
  endif()
else()
  add_header_include(HAVE_SYS_TYPES_H "sys/types.h")
  add_header_include(HAVE_SYS_SOCKET_H "sys/socket.h")
endif()

set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)

check_c_source_compiles("${_source_epilogue}
int main(void) {
    recv(0, 0, 0, 0);
    return 0;
}" curl_cv_recv)
if(curl_cv_recv)
  if(NOT DEFINED curl_cv_func_recv_args OR "${curl_cv_func_recv_args}" STREQUAL "unknown")

  struct timeval ts;
  ts.tv_sec  = 0;
  ts.tv_usec = 0;
  (void)ts;
  return 0;
}" HAVE_STRUCT_TIMEVAL)

set(HAVE_SIG_ATOMIC_T 1)
set(CMAKE_REQUIRED_FLAGS)
if(HAVE_SIGNAL_H)
  set(CMAKE_REQUIRED_FLAGS "-DHAVE_SIGNAL_H")
  set(CMAKE_EXTRA_INCLUDE_FILES "signal.h")
endif()
check_type_size("sig_atomic_t" SIZEOF_SIG_ATOMIC_T)
if(HAVE_SIZEOF_SIG_ATOMIC_T)
  check_c_source_compiles("
    #ifdef HAVE_SIGNAL_H
    #  include <signal.h>
    #endif
    int main(void) {
      static volatile sig_atomic_t dummy = 0;
      (void)dummy;
      return 0;
    }" HAVE_SIG_ATOMIC_T_NOT_VOLATILE)
  if(NOT HAVE_SIG_ATOMIC_T_NOT_VOLATILE)
    set(HAVE_SIG_ATOMIC_T_VOLATILE 1)
  endif()
endif()

if(HAVE_WINDOWS_H)
  set(CMAKE_EXTRA_INCLUDE_FILES winsock2.h)
else()
  set(CMAKE_EXTRA_INCLUDE_FILES)
  if(HAVE_SYS_SOCKET_H)
    set(CMAKE_EXTRA_INCLUDE_FILES sys/socket.h)
  endif()
endif()

check_type_size("struct sockaddr_storage" SIZEOF_STRUCT_SOCKADDR_STORAGE)
if(HAVE_SIZEOF_STRUCT_SOCKADDR_STORAGE)
  set(HAVE_STRUCT_SOCKADDR_STORAGE 1)
endif()

unset(CMAKE_TRY_COMPILE_TARGET_TYPE)

if(NOT DEFINED CMAKE_TOOLCHAIN_FILE)
  # if not cross-compilation...
  include(CheckCSourceRuns)
  set(CMAKE_REQUIRED_FLAGS "")
  if(HAVE_SYS_POLL_H)
    set(CMAKE_REQUIRED_FLAGS "-DHAVE_SYS_POLL_H")
  elseif(HAVE_POLL_H)

            return 1;
          }
        }
        return 0;
    }" HAVE_POLL_FINE)
endif()

string(REGEX MATCH "#define LIBCURL_VERSION \"[^\"]*"
  CURL_VERSION ${CURL_VERSION_H_CONTENTS})
string(REGEX REPLACE "[^\"]+\"" "" CURL_VERSION ${CURL_VERSION})
string(REGEX MATCH "#define LIBCURL_VERSION_NUM 0x[0-9a-fA-F]+"
  CURL_VERSION_NUM ${CURL_VERSION_H_CONTENTS})
string(REGEX REPLACE "[^0]+0x" "" CURL_VERSION_NUM ${CURL_VERSION_NUM})



# Setup package meta-data
# SET(PACKAGE "curl")
message(STATUS "curl version=[${CURL_VERSION}]")
# SET(PACKAGE_TARNAME "curl")
# SET(PACKAGE_NAME "curl")
# SET(PACKAGE_VERSION "-")

      endif()
    endforeach()
  endif()
endif()

if(ENABLE_DEBUG)
  # DEBUGBUILD will be defined only for Debug builds

  set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS $<$<CONFIG:Debug>:DEBUGBUILD>)



  set(ENABLE_CURLDEBUG ON)
endif()

if(ENABLE_CURLDEBUG)
  set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS CURLDEBUG)
endif()

include(CheckFunctionExists)
include(CheckIncludeFile)
include(CheckIncludeFiles)
include(CheckLibraryExists)
include(CheckSymbolExists)
include(CheckTypeSize)
include(CheckCSourceCompiles)


# On windows preload settings
if(WIN32)
  set(CMAKE_REQUIRED_DEFINITIONS "${CMAKE_REQUIRED_DEFINITIONS} -D_WINSOCKAPI_=")
  include(${CMAKE_CURRENT_SOURCE_DIR}/CMake/Platforms/WindowsCache.cmake)
endif()

  list(APPEND CURL_LIBS "advapi32")
endif()

# check SSL libraries
# TODO support GNUTLS, NSS, POLARSSL, CYASSL

if(APPLE)
  option(CMAKE_USE_SECTRANSP "enable Apple OS native SSL/TLS" OFF)
endif()
if(WIN32)
  option(CMAKE_USE_WINSSL "enable Windows native SSL/TLS" OFF)
  cmake_dependent_option(CURL_WINDOWS_SSPI "Use windows libraries to allow NTLM authentication without openssl" ON
    CMAKE_USE_WINSSL OFF)
endif()
option(CMAKE_USE_MBEDTLS "Enable mbedTLS for SSL/TLS" OFF)

set(openssl_default ON)
if(WIN32 OR CMAKE_USE_SECTRANSP OR CMAKE_USE_WINSSL OR CMAKE_USE_MBEDTLS)
  set(openssl_default OFF)
endif()
option(CMAKE_USE_OPENSSL "Use OpenSSL code. Experimental" ${openssl_default})

count_true(enabled_ssl_options_count
  CMAKE_USE_WINSSL
  CMAKE_USE_SECTRANSP
  CMAKE_USE_OPENSSL
  CMAKE_USE_MBEDTLS
)
if(enabled_ssl_options_count GREATER "1")
  set(CURL_WITH_MULTI_SSL ON)
endif()

if(CMAKE_USE_WINSSL)
  set(SSL_ENABLED ON)
  set(USE_SCHANNEL ON) # Windows native SSL/TLS support
  set(USE_WINDOWS_SSPI ON) # CMAKE_USE_WINSSL implies CURL_WINDOWS_SSPI
  list(APPEND CURL_LIBS "crypt32")
endif()
if(CURL_WINDOWS_SSPI)
  set(USE_WINDOWS_SSPI ON)
  set(CMAKE_REQUIRED_DEFINITIONS "${CMAKE_REQUIRED_DEFINITIONS} -DSECURITY_WIN32")
endif()

if(CMAKE_USE_DARWINSSL)
  message(FATAL_ERROR "The cmake option CMAKE_USE_DARWINSSL was renamed to CMAKE_USE_SECTRANSP.")
endif()

if(CMAKE_USE_SECTRANSP)
  find_library(COREFOUNDATION_FRAMEWORK "CoreFoundation")
  if(NOT COREFOUNDATION_FRAMEWORK)
      message(FATAL_ERROR "CoreFoundation framework not found")
  endif()

  find_library(SECURITY_FRAMEWORK "Security")
  if(NOT SECURITY_FRAMEWORK)
     message(FATAL_ERROR "Security framework not found")
  endif()

  set(SSL_ENABLED ON)
  set(USE_SECTRANSP ON)
  list(APPEND CURL_LIBS "${COREFOUNDATION_FRAMEWORK}" "${SECURITY_FRAMEWORK}")
endif()

if(CMAKE_USE_OPENSSL)
  find_package(OpenSSL REQUIRED)
  set(SSL_ENABLED ON)
  set(USE_OPENSSL ON)

      )
      set(CMAKE_REQUIRED_DEFINITIONS "${CMAKE_REQUIRED_DEFINITIONS} -DLDAP_DEPRECATED=1")
      list(APPEND CMAKE_REQUIRED_LIBRARIES ${CMAKE_LDAP_LIB})
      if(HAVE_LIBLBER)
        list(APPEND CMAKE_REQUIRED_LIBRARIES ${CMAKE_LBER_LIB})
      endif()
      check_c_source_compiles("${_SRC_STRING}" NOT_NEED_LBER_H)
      unset(CMAKE_REQUIRED_LIBRARIES)

      if(NOT_NEED_LBER_H)
        set(NEED_LBER_H OFF)
      else()
        set(CURL_TEST_DEFINES "${CURL_TEST_DEFINES} -DNEED_LBER_H")
      endif()
    endif()

    set(CMAKE_EXTRA_INCLUDE_FILES "libssh2.h")
    check_function_exists(libssh2_version           HAVE_LIBSSH2_VERSION)
    check_function_exists(libssh2_init              HAVE_LIBSSH2_INIT)
    check_function_exists(libssh2_exit              HAVE_LIBSSH2_EXIT)
    check_function_exists(libssh2_scp_send64        HAVE_LIBSSH2_SCP_SEND64)
    check_function_exists(libssh2_session_handshake HAVE_LIBSSH2_SESSION_HANDSHAKE)
    set(CMAKE_EXTRA_INCLUDE_FILES "")
    unset(CMAKE_REQUIRED_LIBRARIES)
  endif()
endif()

option(CMAKE_USE_GSSAPI "Use GSSAPI implementation (right now only Heimdal is supported with CMake build)" OFF)
mark_as_advanced(CMAKE_USE_GSSAPI)

if(CMAKE_USE_GSSAPI)

      set(CMAKE_REQUIRED_FLAGS "${_COMPILER_FLAGS_STR} ${_LINKER_FLAGS_STR}")
      set(CMAKE_REQUIRED_LIBRARIES ${GSS_LIBRARIES})
      check_symbol_exists("GSS_C_NT_HOSTBASED_SERVICE" ${_INCLUDE_LIST} HAVE_GSS_C_NT_HOSTBASED_SERVICE)
      if(NOT HAVE_GSS_C_NT_HOSTBASED_SERVICE)
        set(HAVE_OLD_GSSMIT ON)
      endif()
      unset(CMAKE_REQUIRED_LIBRARIES)

    endif()

    include_directories(${GSS_INCLUDE_DIR})
    link_directories(${GSS_LINK_DIRECTORIES})
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${GSS_COMPILER_FLAGS}")
    set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${GSS_LINKER_FLAGS}")

check_symbol_exists(fork           "${CURL_INCLUDES}" HAVE_FORK)
check_symbol_exists(getaddrinfo    "${CURL_INCLUDES}" HAVE_GETADDRINFO)
check_symbol_exists(freeaddrinfo   "${CURL_INCLUDES}" HAVE_FREEADDRINFO)
check_symbol_exists(freeifaddrs    "${CURL_INCLUDES}" HAVE_FREEIFADDRS)
check_symbol_exists(pipe           "${CURL_INCLUDES}" HAVE_PIPE)
check_symbol_exists(ftruncate      "${CURL_INCLUDES}" HAVE_FTRUNCATE)
check_symbol_exists(getprotobyname "${CURL_INCLUDES}" HAVE_GETPROTOBYNAME)
check_symbol_exists(getpeername    "${CURL_INCLUDES}" HAVE_GETPEERNAME)
check_symbol_exists(getsockname    "${CURL_INCLUDES}" HAVE_GETSOCKNAME)
check_symbol_exists(getrlimit      "${CURL_INCLUDES}" HAVE_GETRLIMIT)
check_symbol_exists(setlocale      "${CURL_INCLUDES}" HAVE_SETLOCALE)
check_symbol_exists(setmode        "${CURL_INCLUDES}" HAVE_SETMODE)
check_symbol_exists(setrlimit      "${CURL_INCLUDES}" HAVE_SETRLIMIT)
check_symbol_exists(fcntl          "${CURL_INCLUDES}" HAVE_FCNTL)
check_symbol_exists(ioctl          "${CURL_INCLUDES}" HAVE_IOCTL)
check_symbol_exists(setsockopt     "${CURL_INCLUDES}" HAVE_SETSOCKOPT)

  if(${ARGN})
    set(_items ${_items} "${label}" PARENT_SCOPE)
  endif()
endfunction()

# Clear list and try to detect available features
set(_items)
_add_if("SSL"           SSL_ENABLED)



_add_if("IPv6"          ENABLE_IPV6)
_add_if("unix-sockets"  USE_UNIX_SOCKETS)
_add_if("libz"          HAVE_LIBZ)
_add_if("AsynchDNS"     USE_ARES OR USE_THREADS_POSIX OR USE_THREADS_WIN32)
_add_if("IDN"           HAVE_LIBIDN2)
_add_if("Largefile"     (CURL_SIZEOF_CURL_OFF_T GREATER 4) AND
                        ((SIZEOF_OFF_T GREATER 4) OR USE_WIN32_LARGE_FILES))
# TODO SSP1 (WinSSL) check is missing
_add_if("SSPI"          USE_WINDOWS_SSPI)
_add_if("GSS-API"       HAVE_GSSAPI)
# TODO SSP1 missing for SPNEGO
_add_if("SPNEGO"        NOT CURL_DISABLE_CRYPTO_AUTH AND
                        (HAVE_GSSAPI OR USE_WINDOWS_SSPI))
_add_if("Kerberos"      NOT CURL_DISABLE_CRYPTO_AUTH AND
                        (HAVE_GSSAPI OR USE_WINDOWS_SSPI))
# NTLM support requires crypto function adaptions from various SSL libs
# TODO alternative SSL libs tests for SSP1, GNUTLS, NSS
if(NOT CURL_DISABLE_CRYPTO_AUTH AND (USE_OPENSSL OR USE_WINDOWS_SSPI OR USE_SECTRANSP OR USE_MBEDTLS))
  _add_if("NTLM"        1)
  # TODO missing option (autoconf: --enable-ntlm-wb)
  _add_if("NTLM_WB"     NOT CURL_DISABLE_HTTP AND NTLM_WB_ENABLED)
endif()
# TODO missing option (--enable-tls-srp), depends on GNUTLS_SRP/OPENSSL_SRP
_add_if("TLS-SRP"       USE_TLS_SRP)
# TODO option --with-nghttp2 tests for nghttp2 lib and nghttp2/nghttp2.h header

_add_if("IMAPS"         NOT CURL_DISABLE_IMAP AND SSL_ENABLED)
_add_if("SMTP"          NOT CURL_DISABLE_SMTP)
_add_if("SMTPS"         NOT CURL_DISABLE_SMTP AND SSL_ENABLED)
_add_if("SCP"           USE_LIBSSH2)
_add_if("SFTP"          USE_LIBSSH2)
_add_if("RTSP"          NOT CURL_DISABLE_RTSP)
_add_if("RTMP"          USE_LIBRTMP)
if(_items)
  list(SORT _items)
endif()
string(REPLACE ";" " " SUPPORT_PROTOCOLS "${_items}")
message(STATUS "Enabled protocols: ${SUPPORT_PROTOCOLS}")

# Clear list and collect SSL backends
set(_items)
_add_if("WinSSL"           SSL_ENABLED AND USE_WINDOWS_SSPI)
_add_if("OpenSSL"          SSL_ENABLED AND USE_OPENSSL)
_add_if("Secure Transport" SSL_ENABLED AND USE_SECTRANSP)
_add_if("mbedTLS"          SSL_ENABLED AND USE_MBEDTLS)
if(_items)
  list(SORT _items)
endif()
string(REPLACE ";" " " SSL_BACKENDS "${_items}")
message(STATUS "Enabled SSL backends: ${SSL_BACKENDS}")

# curl-config needs the following options to be set.
set(CC                      "${CMAKE_C_COMPILER}")
# TODO probably put a -D... options here?
set(CONFIGURE_OPTIONS       "")
# TODO when to set "-DCURL_STATICLIB" for CPPFLAG_CURL_STATICLIB?
set(CPPFLAG_CURL_STATICLIB  "")
set(CURLVERSION             "${CURL_VERSION}")

  inet_ntop.c parsedate.c select.c tftp.c splay.c strdup.c socks.c      \
  ssh.c ssh-libssh.c curl_addrinfo.c socks_gssapi.c socks_sspi.c        \
  curl_sspi.c slist.c nonblock.c curl_memrchr.c imap.c pop3.c smtp.c    \
  pingpong.c rtsp.c curl_threads.c warnless.c hmac.c curl_rtmp.c        \
  openldap.c curl_gethostname.c gopher.c idn_win32.c                    \
  http_proxy.c non-ascii.c asyn-ares.c asyn-thread.c curl_gssapi.c      \
  http_ntlm.c curl_ntlm_wb.c curl_ntlm_core.c curl_sasl.c rand.c        \
  curl_multibyte.c hostcheck.c conncache.c dotdot.c                     \
  x509asn1.c http2.c smb.c curl_endian.c curl_des.c system_win32.c      \
  mime.c sha256.c setopt.c curl_path.c curl_ctype.c curl_range.c psl.c  \
  doh.c urlapi.c curl_get_line.c altsvc.c

LIB_HFILES = arpa_telnet.h netrc.h file.h timeval.h hostip.h progress.h \
  formdata.h cookie.h http.h sendf.h ftp.h url.h dict.h if2ip.h         \
  speedcheck.h urldata.h curl_ldap.h escape.h telnet.h getinfo.h        \
  strcase.h curl_sec.h memdebug.h http_chunks.h curl_fnmatch.h          \
  wildcard.h fileinfo.h ftplistparser.h strtok.h connect.h llist.h      \
  hash.h content_encoding.h share.h curl_md4.h curl_md5.h http_digest.h \
  http_negotiate.h inet_pton.h amigaos.h strtoofft.h strerror.h         \
  inet_ntop.h curlx.h curl_memory.h curl_setup.h transfer.h select.h    \
  easyif.h multiif.h parsedate.h tftp.h sockaddr.h splay.h strdup.h     \
  socks.h ssh.h curl_base64.h curl_addrinfo.h curl_sspi.h      \
  slist.h nonblock.h curl_memrchr.h imap.h pop3.h smtp.h pingpong.h     \
  rtsp.h curl_threads.h warnless.h curl_hmac.h curl_rtmp.h              \
  curl_gethostname.h gopher.h http_proxy.h non-ascii.h asyn.h           \
  http_ntlm.h curl_gssapi.h curl_ntlm_wb.h curl_ntlm_core.h             \
  curl_sasl.h curl_multibyte.h hostcheck.h conncache.h                  \
  curl_setup_once.h multihandle.h setup-vms.h dotdot.h                  \
  x509asn1.h http2.h sigpipe.h smb.h curl_endian.h curl_des.h           \
  curl_printf.h system_win32.h rand.h mime.h curl_sha256.h setopt.h     \
  curl_path.h curl_ctype.h curl_range.h psl.h doh.h urlapi-int.h        \
  curl_get_line.h altsvc.h

LIB_RCFILES = libcurl.rc
CSOURCES = $(LIB_CFILES) $(LIB_VAUTH_CFILES) $(LIB_VTLS_CFILES)
HHEADERS = $(LIB_HFILES) $(LIB_VAUTH_HFILES) $(LIB_VTLS_HFILES)

# libcurl has sources that provide functions named curlx_* that aren't part of
# the official API, but we re-use the code here to avoid duplication.

  To download the very latest source off the GIT server do this:

    git clone https://github.com/curl/curl.git

  (you'll get a directory named curl created, filled with the source code)

SECURITY PROBLEMS

  Report suspected security problems via our HackerOne page and not in public!

    https://hackerone.com/curl

NOTICE

  Curl contains pieces of source code that is Copyright (c) 1998, 1999
  Kungliga Tekniska Högskolan. This notice is included here to comply with the
  distribution terms.

curl and libcurl 7.65.0

 Public curl releases:         181
 Command line options:         221
 curl_easy_setopt() options:   268
 Public functions in libcurl:  80
 Contributors:                 1929

This release includes the following changes:

 o CURLOPT_DNS_USE_GLOBAL_CACHE: removed [25]
 o CURLOPT_MAXAGE_CONN: set the maximum allowed age for conn reuse [37]
 o pipelining: removed [10]

This release includes the following bugfixes:

 o CVE-2019-5435: Integer overflows in curl_url_set [87]
 o CVE-2019-5436: tftp: use the current blksize for recvfrom() [82]
 o --config: clarify that initial : and = might need quoting [17]
 o AppVeyor: enable testing for WinSSL build [23]
 o CURLMOPT_TIMERFUNCTION.3: warn about the recursive risk [52]


 o CURLOPT_ADDRESS_SCOPE: fix range check and more [32]
 o CURLOPT_CAINFO.3: with Schannel, you want Windows 8 or later [75]
 o CURLOPT_CHUNK_BGN_FUNCTION.3: document the struct and time value [51]
 o CURLOPT_READFUNCTION.3: see also CURLOPT_UPLOAD_BUFFERSIZE [71]
 o CURL_MAX_INPUT_LENGTH: largest acceptable string input size [44]
 o Curl_disconnect: treat all CONNECT_ONLY connections as "dead" [39]
 o INTERNALS: Add code highlighting [47]
 o OS400/ccsidcurl: replace use of Curl_vsetopt [50]
 o OpenSSL: Report -fips in version if OpenSSL is built with FIPS [55]
 o README.md: fix no-consecutive-blank-lines Codacy warning [22]
 o VC15 project: remove MinimalRebuild

 o VS projects: use Unicode for VC10+ [16]
 o WRITEFUNCTION: add missing set_in_callback around callback [60]
 o altsvc: Fix building with cookies disabled [38]
 o auth: Rename the various authentication clean up functions [61]
 o base64: build conditionally if there are users
 o build-openssl.bat: Fixed support for OpenSSL v1.1.0+

 o build: fix "clarify calculation precedence" warnings [63]
 o checksrc.bat: ignore snprintf warnings in docs/examples [67]
 o cirrus: Customize the disabled tests per FreeBSD version
 o cleanup: remove FIXME and TODO comments [81]
 o cmake: avoid linking executable for some tests with cmake 3.6+ [18]
 o cmake: clear CMAKE_REQUIRED_LIBRARIES after each use [19]
 o cmake: rename CMAKE_USE_DARWINSSL to CMAKE_USE_SECTRANSP [46]
 o cmake: set SSL_BACKENDS [12]
 o configure: avoid unportable `==' test(1) operator [1]
 o configure: error out if OpenSSL wasn't detected when asked for [74]
 o configure: fix default location for fish completions [13]
 o cookie: Guard against possible NULL ptr deref [42]

 o curl: make code work with protocol-disabled libcurl [78]
 o curl: report error for "--no-" on non-boolean options [86]
 o curl_easy_getinfo.3: fix minor formatting mistake
 o curlver.h: use parenthesis in CURL_VERSION_BITS macro [45]
 o docs/BUG-BOUNTY: bug bounty time [48]
 o docs/INSTALL: fix broken link [62]
 o docs/RELEASE-PROCEDURE: link to live iCalendar [79]
 o documentation: Fix several typos [7]
 o doh: acknowledge CURL_DISABLE_DOH
 o doh: disable DOH for the cases it doesn't work [66]





 o examples: remove unused variables [88]




 o ftplistparser: fix LGTM alert "Empty block without comment" [14]
 o hostip: acknowledge CURL_DISABLE_SHUFFLE_DNS [78]
 o http: Ignore HTTP/2 prior knowledge setting for HTTP proxies [54]
 o http: acknowledge CURL_DISABLE_HTTP_AUTH
 o http: mark bundle as not for multiuse on < HTTP/2 response [41]
 o http_digest: Don't expose functions when HTTP and Crypto Auth are disabled [65]
 o http_negotiate: do not treat failure of gss_init_sec_context() as fatal [53]
 o http_ntlm: Corrected the name of the include guard [64]
 o http_ntlm_wb: Handle auth for only a single request [77]
 o http_ntlm_wb: Return the correct error on receiving an empty auth message [77]
 o lib509: add missing include for strdup [22]
 o lib557: initialize variables [22]
 o makedebug: Fix ERRORLEVEL detection after running where.exe [58]
 o mbedtls: enable use of EC keys [85]
 o mime: acknowledge CURL_DISABLE_MIME
 o multi: improved HTTP_1_1_REQUIRED handling [2]
 o netrc: acknowledge CURL_DISABLE_NETRC [78]
 o nss: allow fifos and character devices for certificates [56]
 o nss: provide more specific error messages on failed init [43]

 o ntlm: Fix misaligned function comments for Curl_auth_ntlm_cleanup [70]

 o ntlm: Support the NT response in the type-3 when OpenSSL doesn't include MD4
 o openssl: mark connection for close on TLS close_notify [36]
 o openvms: Remove pre-processor for SecureTransport [40]
 o openvms: Remove pre-processors for Windows [40]
 o parse_proxy: use the URL parser API [72]
 o parsedate: disabled on CURL_DISABLE_PARSEDATE
 o pingpong: disable more when no pingpong protocols are enabled
 o polarssl_threadlock: remove conditionally unused code [22]
 o progress: acknowledge CURL_DISABLE_PROGRESS_METER [78]
 o proxy: acknowledge DISABLE_PROXY more
 o resolve: apply Happy Eyeballs philosophy to parallel c-ares queries [3]
 o revert "multi: support verbose conncache closure handle" [69]






 o sasl: Don't send authcid as authzid for the PLAIN mechanism as per RFC 4616
 o sasl: only enable if there's a protocol enabled using it

 o scripts: fix typos
 o singleipconnect: show port in the verbose "Trying ..." message
 o smtp: fix compiler warning [15]
 o socks5: user name and passwords must be shorter than 256 [8]
 o socks: fix error message
 o socksd: new SOCKS 4+5 server for tests [31]
 o spnego_gssapi: fix return code on gss_init_sec_context() failure [53]
 o ssh-libssh: remove unused variable [83]
 o ssh: define USE_SSH if SSH is enabled (any backend) [57]

 o ssh: move variable declaration to where it's used [83]
 o test1002: correct the name
 o test2100: Fix typos in test description
 o tests/server/util: fix Windows Unicode build [21]
 o tests: Run global cleanup at end of tests [29]
 o tests: make Impacket (SMB server) Python 3 compatible [11]
 o tool_cb_wrt: fix bad-function-cast warning [5]
 o tool_formparse: remove redundant assignment [83]
 o tool_help: Warn if curl and libcurl versions do not match [28]
 o tool_help: include <strings.h> for strcasecmp [4]
 o transfer: fix LGTM alert "Comparison is always true" [14]
 o travis: add an osx http-only build [80]
 o travis: allow builds on branches named "ci"
 o travis: install dependencies only when needed [24]
 o travis: update some builds do Xenial [30]
 o travis: updated mesalink builds [35]
 o url: always clone the CUROPT_CURLU handle [26]
 o url: convert the zone id from a IPv6 URL to correct scope id [89]
 o urlapi: add CURLUPART_ZONEID to set and get [59]
 o urlapi: increase supported scheme length to 40 bytes [84]
 o urlapi: require a non-zero host name length when parsing URL [73]
 o urlapi: stricter CURLUPART_PORT parsing [33]
 o urlapi: strip off zone id from numerical IPv6 addresses [49]
 o urlapi: urlencode characters above 0x7f correctly [9]
 o vauth/cleartext: update the PLAIN login to match RFC 4616 [27]
 o vauth/oauth2: Fix OAUTHBEARER token generation [6]
 o vauth: Fix incorrect function description for Curl_auth_user_contains_domain [68]

 o vtls: fix potential ssl_buffer stack overflow [76]
 o wildcard: disable from build when FTP isn't present
 o winbuild: Support MultiSSL builds [34]
 o xattr: skip unittest on unsupported platforms [20]

This release includes the following known bugs:

 o see docs/KNOWN_BUGS (https://curl.haxx.se/docs/knownbugs.html)

This release would not have looked like this without help, code, reports and
advice from friends like these:



  Aron Bergman, Brad Spencer, cclauss on github, Dan Fandrich,
  Daniel Gustafsson, Daniel Stenberg, Eli Schwartz, Even Rouault,
  Frank Gevaerts, Gisle Vanem, GitYuanQu on github, Guy Poizat, Isaiah Norton,
  Jakub Zakrzewski, Jan Ehrhardt, Jeroen Ooms, Jonathan Cardoso Machado,
  Jonathan Moerman, Joombalaya on github, Kamil Dudka, Kristoffer Gleditsch,
  l00p3r on hackerone, Leonardo Taccari, Marcel Raad, Mert Yazıcıoğlu,
  nevv on HackerOne/curl, niner on github, Olen Andoni, Omar Ramadan,
  Paolo Mossino, Patrick Monnerat, Po-Chuan Hsieh, Poul T Lomholt, Ray Satiro,

  Reed Loden, Ricardo Gomes, Ricky Leverence, Rikard Falkeborn, Roy Bellingan,
  Simon Warta, Steve Holme, Taiyu Len, Tim Rühsen, Tom van der Woerdt,
  Tseng Jun, Viktor Szakats, Wenchao Li, Wyatt O'Day, XmiliaH on github,
  Yiming Jing,
  (50 contributors)

        Thanks! (and sorry if I forgot to mention someone)

References to bug reports and discussions on issues:

 [1] = https://curl.haxx.se/bug/?i=3709
 [2] = https://curl.haxx.se/bug/?i=3707
 [3] = https://curl.haxx.se/bug/?i=3699
 [4] = https://curl.haxx.se/bug/?i=3715
 [5] = https://curl.haxx.se/bug/?i=3718
 [6] = https://curl.haxx.se/bug/?i=2487
 [7] = https://curl.haxx.se/bug/?i=3724
 [8] = https://curl.haxx.se/bug/?i=3737
 [9] = https://curl.haxx.se/bug/?i=3741
 [10] = https://curl.haxx.se/bug/?i=3651
 [11] = https://curl.haxx.se/bug/?i=3731
 [12] = https://curl.haxx.se/bug/?i=3736
 [13] = https://curl.haxx.se/bug/?i=3723
 [14] = https://curl.haxx.se/bug/?i=3732
 [15] = https://curl.haxx.se/bug/?i=3729
 [16] = https://curl.haxx.se/bug/?i=3720
 [17] = https://curl.haxx.se/bug/?i=3738
 [18] = https://curl.haxx.se/bug/?i=3744
 [19] = https://curl.haxx.se/bug/?i=3743
 [20] = https://curl.haxx.se/bug/?i=3759
 [21] = https://curl.haxx.se/bug/?i=3758
 [22] = https://curl.haxx.se/bug/?i=3739
 [23] = https://curl.haxx.se/bug/?i=3725
 [24] = https://curl.haxx.se/bug/?i=3721
 [25] = https://curl.haxx.se/bug/?i=3654
 [26] = https://curl.haxx.se/bug/?i=3753
 [27] = https://curl.haxx.se/bug/?i=3757
 [28] = https://curl.haxx.se/bug/?i=3774
 [29] = https://curl.haxx.se/bug/?i=3783
 [30] = https://curl.haxx.se/bug/?i=3777
 [31] = https://curl.haxx.se/bug/?i=3752
 [32] = https://curl.haxx.se/bug/?i=3713
 [33] = https://curl.haxx.se/bug/?i=3762
 [34] = https://curl.haxx.se/bug/?i=3772
 [35] = https://curl.haxx.se/bug/?i=3823
 [36] = https://curl.haxx.se/bug/?i=3750
 [37] = https://curl.haxx.se/bug/?i=3782
 [38] = https://curl.haxx.se/bug/?i=3717
 [39] = https://curl.haxx.se/mail/lib-2019-04/0052.html
 [40] = https://curl.haxx.se/bug/?i=3768
 [41] = https://curl.haxx.se/bug/?i=3813
 [42] = https://curl.haxx.se/bug/?i=3820
 [43] = https://curl.haxx.se/bug/?i=3808
 [44] = https://curl.haxx.se/bug/?i=3805
 [45] = https://curl.haxx.se/bug/?i=3809
 [46] = https://curl.haxx.se/bug/?i=3769
 [47] = https://curl.haxx.se/bug/?i=3801
 [48] = https://curl.haxx.se/bug/?i=3488
 [49] = https://curl.haxx.se/bug/?i=3817
 [50] = https://curl.haxx.se/bug/?i=3833
 [51] = https://curl.haxx.se/bug/?i=3829
 [52] = https://curl.haxx.se/bug/?i=3537
 [53] = https://curl.haxx.se/bug/?i=3726
 [54] = https://curl.haxx.se/bug/?i=3570
 [55] = https://curl.haxx.se/bug/?i=3771
 [56] = https://curl.haxx.se/bug/?i=3807
 [57] = https://curl.haxx.se/bug/?i=3846
 [58] = https://curl.haxx.se/bug/?i=3838
 [59] = https://curl.haxx.se/bug/?i=3834
 [60] = https://curl.haxx.se/bug/?i=3837
 [61] = https://curl.haxx.se/bug/?i=3869
 [62] = https://curl.haxx.se/bug/?i=3818
 [63] = https://curl.haxx.se/bug/?i=3866
 [64] = https://curl.haxx.se/bug/?i=3867
 [65] = https://curl.haxx.se/bug/?i=3861
 [66] = https://curl.haxx.se/bug/?i=3850
 [67] = https://curl.haxx.se/bug/?i=3862
 [68] = https://curl.haxx.se/bug/?i=3860
 [69] = https://curl.haxx.se/bug/?i=3856
 [70] = https://curl.haxx.se/bug/?i=3858
 [71] = https://curl.haxx.se/bug/?i=3885
 [72] = https://curl.haxx.se/bug/?i=3878
 [73] = https://curl.haxx.se/bug/?i=3880
 [74] = https://curl.haxx.se/bug/?i=3824
 [75] = https://curl.haxx.se/bug/?i=3711
 [76] = https://curl.haxx.se/bug/?i=3863
 [77] = https://curl.haxx.se/bug/?i=3894
 [78] = https://curl.haxx.se/bug/?i=3844
 [79] = https://curl.haxx.se/bug/?i=3895
 [80] = https://curl.haxx.se/bug/?i=3887
 [81] = https://curl.haxx.se/bug/?i=3876
 [82] = https://curl.haxx.se/docs/CVE-2019-5436.html
 [83] = https://curl.haxx.se/bug/?i=3873
 [84] = https://curl.haxx.se/bug/?i=3905
 [85] = https://curl.haxx.se/bug/?i=3892
 [86] = https://curl.haxx.se/bug/?i=3906
 [87] = https://curl.haxx.se/docs/CVE-2019-5435.html
 [88] = https://curl.haxx.se/bug/?i=3908
 [89] = https://curl.haxx.se/bug/?i=3902

if test "${with_amissl+set}" = set; then :
  withval=$with_amissl; OPT_AMISSL=$withval
fi


{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to enable Amiga native SSL/TLS (AmiSSL)" >&5
$as_echo_n "checking whether to enable Amiga native SSL/TLS (AmiSSL)... " >&6; }
if test "$HAVE_PROTO_BSDSOCKET_H" = "1"; then
  if test -z "$ssl_backends" -o "x$OPT_AMISSL" != xno; then
    ssl_msg=
    if test "x$OPT_AMISSL" != "xno"; then
      { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
      ssl_msg="AmiSSL"
      test amissl != "$DEFAULT_SSL_BACKEND" || VALID_DEFAULT_SSL_BACKEND=yes

  fi

    check_for_ca_bundle=1
  fi

  test -z "$ssl_msg" || ssl_backends="${ssl_backends:+$ssl_backends, }$ssl_msg"
fi

if test X"$OPT_SSL" != Xoff &&
  test X"$OPT_SSL" != Xno &&
  test "$OPENSSL_ENABLED" != "1"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: OPT_SSL: $OPT_SSL" >&5
$as_echo "$as_me: OPT_SSL: $OPT_SSL" >&6;}
  { $as_echo "$as_me:${as_lineno-$LINENO}: OPENSSL_ENABLED: $OPENSSL_ENABLED" >&5
$as_echo "$as_me: OPENSSL_ENABLED: $OPENSSL_ENABLED" >&6;}
  as_fn_error $? "--with-ssl was given but OpenSSL could not be detected" "$LINENO" 5
fi


if test X"$OPENSSL_ENABLED" = X"1"; then

# Check whether --with-egd-socket was given.
if test "${with_egd_socket+set}" = set; then :
  withval=$with_egd_socket;  EGD_SOCKET="$withval"

  withval=$with_fish_functions_dir; OPT_FISH_FPATH=$withval
fi

case "$OPT_FISH_FPATH" in
  no)
        ;;
  default|yes)

    if test -n "$PKG_CONFIG"; then
      PKGCONFIG="$PKG_CONFIG"
    else
      if test -n "$ac_tool_prefix"; then
  # Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args.
set dummy ${ac_tool_prefix}pkg-config; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_path_PKGCONFIG+:} false; then :
  $as_echo_n "(cached) " >&6
else
  case $PKGCONFIG in
  [\\/]* | ?:[\\/]*)
  ac_cv_path_PKGCONFIG="$PKGCONFIG" # Let the user override the test with a path.
  ;;
  *)
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
as_dummy="$PATH:/usr/bin:/usr/local/bin"
for as_dir in $as_dummy
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_path_PKGCONFIG="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  ;;
esac
fi
PKGCONFIG=$ac_cv_path_PKGCONFIG
if test -n "$PKGCONFIG"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKGCONFIG" >&5
$as_echo "$PKGCONFIG" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi


fi
if test -z "$ac_cv_path_PKGCONFIG"; then
  ac_pt_PKGCONFIG=$PKGCONFIG
  # Extract the first word of "pkg-config", so it can be a program name with args.
set dummy pkg-config; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_path_ac_pt_PKGCONFIG+:} false; then :
  $as_echo_n "(cached) " >&6
else
  case $ac_pt_PKGCONFIG in
  [\\/]* | ?:[\\/]*)
  ac_cv_path_ac_pt_PKGCONFIG="$ac_pt_PKGCONFIG" # Let the user override the test with a path.
  ;;
  *)
  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
as_dummy="$PATH:/usr/bin:/usr/local/bin"
for as_dir in $as_dummy
do
  IFS=$as_save_IFS
  test -z "$as_dir" && as_dir=.
    for ac_exec_ext in '' $ac_executable_extensions; do
  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    ac_cv_path_ac_pt_PKGCONFIG="$as_dir/$ac_word$ac_exec_ext"
    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    break 2
  fi
done
  done
IFS=$as_save_IFS

  ;;
esac
fi
ac_pt_PKGCONFIG=$ac_cv_path_ac_pt_PKGCONFIG
if test -n "$ac_pt_PKGCONFIG"; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_pt_PKGCONFIG" >&5
$as_echo "$ac_pt_PKGCONFIG" >&6; }
else
  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi

  if test "x$ac_pt_PKGCONFIG" = x; then
    PKGCONFIG="no"
  else
    case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
    PKGCONFIG=$ac_pt_PKGCONFIG
  fi
else
  PKGCONFIG="$ac_cv_path_PKGCONFIG"
fi

    fi

    if test "x$PKGCONFIG" != "xno"; then
      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fish options with pkg-config" >&5
$as_echo_n "checking for fish options with pkg-config... " >&6; }
            itexists=`
    if test -n ""; then
      PKG_CONFIG_LIBDIR=""
      export PKG_CONFIG_LIBDIR
    fi
         $PKGCONFIG --exists fish >/dev/null 2>&1 && echo 1`

      if test -z "$itexists"; then
                        PKGCONFIG="no"
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
      else
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: found" >&5
$as_echo "found" >&6; }
      fi
    fi

    if test "$PKGCONFIG" != "no" ; then
      FISH_FUNCTIONS_DIR="$($PKGCONFIG --variable completionsdir fish)"
    else
      FISH_FUNCTIONS_DIR="$datarootdir/fish/vendor_completions.d"
    fi

    ;;
  *)
        FISH_FUNCTIONS_DIR="$withval"

    ;;
esac

    curl_cv_func_gethostname="yes"
  else
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
    curl_cv_func_gethostname="no"
  fi


          #
  tst_links_getpeername="unknown"
  tst_proto_getpeername="unknown"
  tst_compi_getpeername="unknown"
  tst_allow_getpeername="unknown"
  #
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if getpeername can be linked" >&5
$as_echo_n "checking if getpeername can be linked... " >&6; }
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */


      $curl_includes_winsock2
      $curl_includes_bsdsocket
      $curl_includes_sys_socket

int main (void)
{

      if(0 != getpeername(0, (void *)0, (void *)0))
        return 1;

 ;
 return 0;
}

_ACEOF
if ac_fn_c_try_link "$LINENO"; then :

    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
    tst_links_getpeername="yes"

else

    { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
    tst_links_getpeername="no"

fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
  #
  if test "$tst_links_getpeername" = "yes"; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if getpeername is prototyped" >&5
$as_echo_n "checking if getpeername is prototyped... " >&6; }
    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

      $curl_includes_winsock2
      $curl_includes_bsdsocket
      $curl_includes_sys_socket

_ACEOF
if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
  $EGREP "getpeername" >/dev/null 2>&1; then :

      { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
      tst_proto_getpeername="yes"

else

      { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
      tst_proto_getpeername="no"

fi
rm -f conftest*

  fi
  #
  if test "$tst_proto_getpeername" = "yes"; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if getpeername is compilable" >&5
$as_echo_n "checking if getpeername is compilable... " >&6; }
    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */


        $curl_includes_winsock2
        $curl_includes_bsdsocket
        $curl_includes_sys_socket

int main (void)
{

        if(0 != getpeername(0, (void *)0, (void *)0))
          return 1;

 ;
 return 0;
}

_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :

      { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
      tst_compi_getpeername="yes"

else

      { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
      tst_compi_getpeername="no"

fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  fi
  #
  if test "$tst_compi_getpeername" = "yes"; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if getpeername usage allowed" >&5
$as_echo_n "checking if getpeername usage allowed... " >&6; }
    if test "x$curl_disallow_getpeername" != "xyes"; then
      { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
      tst_allow_getpeername="yes"
    else
      { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
      tst_allow_getpeername="no"
    fi
  fi
  #
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if getpeername might be used" >&5
$as_echo_n "checking if getpeername might be used... " >&6; }
  if test "$tst_links_getpeername" = "yes" &&
     test "$tst_proto_getpeername" = "yes" &&
     test "$tst_compi_getpeername" = "yes" &&
     test "$tst_allow_getpeername" = "yes"; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }

cat >>confdefs.h <<_ACEOF
#define HAVE_GETPEERNAME 1
_ACEOF

    curl_cv_func_getpeername="yes"
  else
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
    curl_cv_func_getpeername="no"
  fi


          #
  tst_links_getsockname="unknown"
  tst_proto_getsockname="unknown"
  tst_compi_getsockname="unknown"
  tst_allow_getsockname="unknown"
  #
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if getsockname can be linked" >&5
$as_echo_n "checking if getsockname can be linked... " >&6; }
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */


      $curl_includes_winsock2
      $curl_includes_bsdsocket
      $curl_includes_sys_socket

int main (void)
{

      if(0 != getsockname(0, (void *)0, (void *)0))
        return 1;

 ;
 return 0;
}

_ACEOF
if ac_fn_c_try_link "$LINENO"; then :

    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
    tst_links_getsockname="yes"

else

    { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
    tst_links_getsockname="no"

fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
  #
  if test "$tst_links_getsockname" = "yes"; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if getsockname is prototyped" >&5
$as_echo_n "checking if getsockname is prototyped... " >&6; }
    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

      $curl_includes_winsock2
      $curl_includes_bsdsocket
      $curl_includes_sys_socket

_ACEOF
if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
  $EGREP "getsockname" >/dev/null 2>&1; then :

      { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
      tst_proto_getsockname="yes"

else

      { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
      tst_proto_getsockname="no"

fi
rm -f conftest*

  fi
  #
  if test "$tst_proto_getsockname" = "yes"; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if getsockname is compilable" >&5
$as_echo_n "checking if getsockname is compilable... " >&6; }
    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */


        $curl_includes_winsock2
        $curl_includes_bsdsocket
        $curl_includes_sys_socket

int main (void)
{

        if(0 != getsockname(0, (void *)0, (void *)0))
          return 1;

 ;
 return 0;
}

_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :

      { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
      tst_compi_getsockname="yes"

else

      { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
      tst_compi_getsockname="no"

fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
  fi
  #
  if test "$tst_compi_getsockname" = "yes"; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if getsockname usage allowed" >&5
$as_echo_n "checking if getsockname usage allowed... " >&6; }
    if test "x$curl_disallow_getsockname" != "xyes"; then
      { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
      tst_allow_getsockname="yes"
    else
      { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
      tst_allow_getsockname="no"
    fi
  fi
  #
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if getsockname might be used" >&5
$as_echo_n "checking if getsockname might be used... " >&6; }
  if test "$tst_links_getsockname" = "yes" &&
     test "$tst_proto_getsockname" = "yes" &&
     test "$tst_compi_getsockname" = "yes" &&
     test "$tst_allow_getsockname" = "yes"; then
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }

cat >>confdefs.h <<_ACEOF
#define HAVE_GETSOCKNAME 1
_ACEOF

    curl_cv_func_getsockname="yes"
  else
    { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
    curl_cv_func_getsockname="no"
  fi


      #
  tst_links_getifaddrs="unknown"
  tst_proto_getifaddrs="unknown"
  tst_compi_getifaddrs="unknown"
  tst_works_getifaddrs="unknown"
  tst_allow_getifaddrs="unknown"

OPT_AMISSL=no
AC_ARG_WITH(amissl,dnl
AC_HELP_STRING([--with-amissl],[enable Amiga native SSL/TLS (AmiSSL)])
AC_HELP_STRING([--without-amissl], [disable Amiga native SSL/TLS (AmiSSL)]),
  OPT_AMISSL=$withval)

AC_MSG_CHECKING([whether to enable Amiga native SSL/TLS (AmiSSL)])
if test "$HAVE_PROTO_BSDSOCKET_H" = "1"; then
  if test -z "$ssl_backends" -o "x$OPT_AMISSL" != xno; then
    ssl_msg=
    if test "x$OPT_AMISSL" != "xno"; then
      AC_MSG_RESULT(yes)
      ssl_msg="AmiSSL"
      test amissl != "$DEFAULT_SSL_BACKEND" || VALID_DEFAULT_SSL_BACKEND=yes
      AMISSL_ENABLED=1

    fi
    CURL_CHECK_OPENSSL_API
    check_for_ca_bundle=1
  fi

  test -z "$ssl_msg" || ssl_backends="${ssl_backends:+$ssl_backends, }$ssl_msg"
fi

if test X"$OPT_SSL" != Xoff &&
  test X"$OPT_SSL" != Xno &&
  test "$OPENSSL_ENABLED" != "1"; then
  AC_MSG_NOTICE([OPT_SSL: $OPT_SSL])
  AC_MSG_NOTICE([OPENSSL_ENABLED: $OPENSSL_ENABLED])
  AC_MSG_ERROR([--with-ssl was given but OpenSSL could not be detected])
fi

dnl **********************************************************************
dnl Check for the random seed preferences
dnl **********************************************************************

if test X"$OPENSSL_ENABLED" = X"1"; then
  AC_ARG_WITH(egd-socket,

  [OPT_FISH_FPATH=$withval])
case "$OPT_FISH_FPATH" in
  no)
    dnl --without-fish-functions-dir option used
    ;;
  default|yes)
    dnl --with-fish-functions-dir option used without path
    CURL_CHECK_PKGCONFIG(fish)
    if test "$PKGCONFIG" != "no" ; then
      FISH_FUNCTIONS_DIR="$($PKGCONFIG --variable completionsdir fish)"
    else
      FISH_FUNCTIONS_DIR="$datarootdir/fish/vendor_completions.d"
    fi
    AC_SUBST(FISH_FUNCTIONS_DIR)
    ;;
  *)
    dnl --with-fish-functions-dir option used with path
    FISH_FUNCTIONS_DIR="$withval"
    AC_SUBST(FISH_FUNCTIONS_DIR)
    ;;

CURL_CHECK_FUNC_GETADDRINFO
CURL_CHECK_FUNC_GAI_STRERROR
CURL_CHECK_FUNC_GETHOSTBYADDR
CURL_CHECK_FUNC_GETHOSTBYADDR_R
CURL_CHECK_FUNC_GETHOSTBYNAME
CURL_CHECK_FUNC_GETHOSTBYNAME_R
CURL_CHECK_FUNC_GETHOSTNAME
CURL_CHECK_FUNC_GETPEERNAME
CURL_CHECK_FUNC_GETSOCKNAME
CURL_CHECK_FUNC_GETIFADDRS
CURL_CHECK_FUNC_GETSERVBYPORT_R
CURL_CHECK_FUNC_GMTIME_R
CURL_CHECK_FUNC_INET_NTOA_R
CURL_CHECK_FUNC_INET_NTOP
CURL_CHECK_FUNC_INET_PTON
CURL_CHECK_FUNC_IOCTL

# The curl bug bounty

The curl project runs a bug bounty program in association with
[HackerOne](https://www.hackerone.com) and the [Internet Bug
Bounty](https://internetbugbounty.org).

# How does it work?

Start out by posting your suspected security vulnerability directly to [curl's
HackerOne program](https://hackerone.com/curl).

After you have reported a security issue, it has been deemed credible, and a
patch and advisory has been made public, you may be eligible for a bounty from
this program.

See all details at [https://hackerone.com/curl](https://hackerone.com/curl)

This bounty is relying on funds from sponsors. If you use curl professionally,
consider help funding this! See
[https://opencollective.com/curl](https://opencollective.com/curl) for
details.

# What are the reward amounts?

The curl projects offer monetary compensation for reported and published
security vulnerabilities. The amount of money that is rewarded depends on how
serious the flaw is determined to be.

We offer reward money *up to* a certain amount per severity. The curl security
team determines the severity of each reported flaw on a case by case basis and
the exact amount rewarded to the reporter is then decided.

Check out the current award amounts at [https://hackerone.com/curl](https://hackerone.com/curl)

# Who is eligible for a reward?

Everyone and anyone who reports a security problem in a released curl version
that hasn't already been reported can ask for a bounty.

Vulnerabilities in features that are off by default and documented as
experimental are not eligible for a reward.

The vulnerability has to be fixed and publicly announced (by the curl project)
before a bug bounty will be considered.

Bounties need to be requested within twelve months from the publication of the
vulnerability.

The vulnerabilities must not have been made public before February 1st, 2019.
We do not retroactively pay for old, already known, or published security
problems.

# Product vulnerabilities only

This bug bounty only concerns the curl and libcurl products and thus their
respective source codes - when running on existing hardware. It does not
include documentation, websites, or other infrastructure.

The curl security team will be the sole arbiter if a reported flaw can be
subject to a bounty or not.

# How are vulnerabilities graded?

The grading of each reported vulnerability that makes a reward claim will be
performed by the curl security team. The grading will be based on the CVSS
(Common Vulnerability Scoring System) 3.0.

# How are reward amounts determined?

The curl security team first gives the vulnerability a score, as mentioned
above, and based on that level we set an amount depending on the specifics of
the individual case. Other sponsors of the program might also get involved and
can raise the amounts depending on the particular issue.

# What happens if the bounty fund is drained?

The bounty fund depends on sponsors. If we pay out more bounties than we add,
the fund will eventually drain. If that end up happening, we will simply not
be able to pay out as high bounties as we would like and hope that we can
convince new sponsors to help us top up the fund again.

# Regarding taxes, etc. on the bounties

In the event that the individual receiving a curl bug bounty needs to pay
taxes on the reward money, the responsibility lies with the receiver. The
curl project or its security team never actually receive any of this money,
hold the money, or pay out the money.

## Bonus levels

In cooperation with [Dropbox](https://www.dropbox.com) the curl bug bounty can
offer the highest levels of rewards if the issue covers one of the interest
areas of theirs - and only if the bug is graded *high* or *critical*. A
non-exhaustive list of vulnerabilities Dropbox is interested in are:

 - RCE
 - URL parsing vulnerabilities with demonstrable security impact

Dropbox would generally hand out rewards for critical vulnerabilities ranging
from 12k-32k USD where RCE is on the upper end of the spectrum.

URL parsing vulnerabilities with demonstrable security impact might include
incorrectly determining the authority of a URL when a special character is
inserted into the path of the URL (as a hypothetical). This type of
vulnerability would likely yield 6k-12k unless further impact could be
demonstrated.

  If you find a bug or problem in curl or libcurl that you think has a
  security impact, for example a bug that can put users in danger or make them
  vulnerable if the bug becomes public knowledge, then please report that bug
  using our security development process.

  Security related bugs or bugs that are suspected to have a security impact,
  should be reported on the curl security tracker at HackerOne:

        https://hackerone.com/curl

  This ensures that the report reaches the curl security team so that they
  first can be deal with the report away from the public to minimize the harm
  and impact it will have on existing users out there who might be using the
  vulnerable versions.

  The curl project's process for handling security related issues is
  documented here:

        https://curl.haxx.se/dev/secprocess.html

1.4 What to report

`ecdhe_rsa_chacha20_poly1305_sha_256`
`ecdhe_ecdsa_chacha20_poly1305_sha_256`
`dhe_rsa_chacha20_poly1305_sha_256`

## GSKit

Ciphers are internally defined as
[numeric codes](https://www.ibm.com/support/knowledgecenter/ssw_ibm_i_73/apis/gsk_attribute_set_buffer.htm),
but libcurl maps them to the following case-insensitive names.

### SSL2 cipher suites (insecure: disabled by default)

`rc2-md5`
`rc4-md5`
`exp-rc2-md5`

`ECDHE-PSK-NULL-SHA256`,
`ECDHE-PSK-AES128-CBC-SHA256`,
`PSK-CHACHA20-POLY1305`,
`ECDHE-PSK-CHACHA20-POLY1305`,
`DHE-PSK-CHACHA20-POLY1305`,
`EDH-RSA-DES-CBC3-SHA`,

## Schannel

Schannel allows the enabling and disabling of encryption algorithms, but not
specific ciphersuites. They are
[defined](https://docs.microsoft.com/windows/desktop/SecCrypto/alg-id) by
Microsoft.

`CALG_MD2`,
`CALG_MD4`,
`CALG_MD5`,
`CALG_SHA`,
`CALG_SHA1`,
`CALG_MAC`,

# curl C code style

Source code that has a common style is easier to read than code that uses
different styles in different places. It helps making the code feel like one
single code base. Easy-to-read is a very important property of code and helps
making it easier to review when new things are added and it helps debugging
code when developers are trying to figure out why things go wrong. A unified
style is more important than individual contributors having their own personal
tastes satisfied.

Our C code has a few style rules. Most of them are verified and upheld by the
`lib/checksrc.pl` script. Invoked with `make checksrc` or even by default by
the build system when built after `./configure --enable-debug` has been used.

It is normally not a problem for anyone to follow the guidelines, as you just
need to copy the style already used in the source code and there are no
particularly unusual rules in our set of rules.

We also work hard on writing code that are warning-free on all the major
platforms and in general on as many platforms as possible. Code that obviously

                 (int)clipamount));

## Platform dependent code

Use **#ifdef HAVE_FEATURE** to do conditional code. We avoid checking for
particular operating systems or hardware in the #ifdef lines. The HAVE_FEATURE
shall be generated by the configure script for unix-like systems and they are
hard-coded in the `config-[system].h` files for the others.

We also encourage use of macros/functions that possibly are empty or defined
to constants when libcurl is built without that feature, to make the code
seamless. Like this example where the **magic()** function works differently
depending on a build-time conditional:

    #ifdef HAVE_MAGIC

# Items to be removed from future curl releases

If any of these deprecated features is a cause for concern for you, please
email the curl-library mailing list as soon as possible and explain to us why
this is a problem for you and how your use case can't be satisfied properly
using a work around.





























































## HTTP/0.9

Supporting this is non-obvious and might even come as a surprise to some
users. Potentially even being a security risk in some cases.

### State

If you insist on forcing a build without SSL support, even though you may
have OpenSSL installed in your system, you can run configure like this:

   ./configure --without-ssl

If you have OpenSSL installed, but with the libraries in one place and the
header files somewhere else, you have to set the `LDFLAGS` and `CPPFLAGS`
environment variables prior to running configure.  Something like this should
work:

    CPPFLAGS="-I/path/to/ssl/include" LDFLAGS="-L/path/to/ssl/lib" ./configure

If you have shared SSL libs installed in a directory where your run-time
linker doesn't find them (which usually causes configure failures), you can

 discouraged, and intermixing CRTs in the same app is something to avoid at
 any cost.

 Reading and comprehending Microsoft Knowledge Base articles KB94248 and
 KB140584 is a must for any Windows developer. Especially important is full
 understanding if you are not going to follow the advice given above.

 - [How To Use the C Run-Time](https://support.microsoft.com/help/94248/how-to-use-the-c-run-time)
 - [Run-Time Library Compiler Options](https://docs.microsoft.com/cpp/build/reference/md-mt-ld-use-run-time-library)
 - [Potential Errors Passing CRT Objects Across DLL Boundaries](https://docs.microsoft.com/cpp/c-runtime-library/potential-errors-passing-crt-objects-across-dll-boundaries)

If your app is misbehaving in some strange way, or it is suffering from
memory corruption, before asking for further help, please try first to
rebuild every single library your app uses as well as your app using the
debug multithreaded dynamic C runtime.

 If you get linkage errors read section 5.7 of the FAQ document.

 - `mingw32-make mingw32-zlib` to build with Zlib support;
 - `mingw32-make mingw32-ssl-zlib` to build with SSL and Zlib enabled;
 - `mingw32-make mingw32-ssh2-ssl-zlib` to build with SSH2, SSL, Zlib;
 - `mingw32-make mingw32-ssh2-ssl-sspi-zlib` to build with SSH2, SSL, Zlib
   and SSPI support.

If you have any problems linking libraries or finding header files, be sure
to verify that the provided `Makefile.m32` files use the proper paths, and
adjust as necessary. It is also possible to override these paths with
environment variables, for example:

    set ZLIB_PATH=c:\zlib-1.2.8
    set OPENSSL_PATH=c:\openssl-1.0.2c
    set LIBSSH2_PATH=c:\libssh2-1.6.0

    set USE_LDAP_NOVELL=1

If you want to enable LDAPS support then set LDAPS=1.

## Cygwin

Almost identical to the unix installation. Run the configure script in the
curl source tree root with `sh configure`. Make sure you have the `sh`
executable in `/bin/` or you'll see the configure fail toward the end.

Run `make`

## Disabling Specific Protocols in Windows builds

The configure utility, unfortunately, is not available for the Windows
environment, therefore, you cannot use the various disable-protocol options of

 - `CURL_DISABLE_HTTP`     disables HTTP
 - `CURL_DISABLE_IMAP`     disables IMAP
 - `CURL_DISABLE_POP3`     disables POP3
 - `CURL_DISABLE_SMTP`     disables SMTP

If you want to set any of these defines you have the following options:

 - Modify `lib/config-win32.h`
 - Modify `lib/curl_setup.h`
 - Modify `winbuild/Makefile.vc`
 - Modify the "Preprocessor Definitions" in the libcurl project

Note: The pre-processor settings can be found using the Visual Studio IDE
under "Project -> Settings -> C/C++ -> General" in VC6 and "Project ->
Properties -> Configuration Properties -> C/C++ -> Preprocessor" in later
versions.

## Using BSD-style lwIP instead of Winsock TCP/IP stack in Win32 builds

In order to compile libcurl and curl using BSD-style lwIP TCP/IP stack it is
necessary to make definition of preprocessor symbol `USE_LWIPSOCK` visible to
libcurl and curl compilation processes. To set this definition you have the
following alternatives:

 - Modify `lib/config-win32.h` and `src/config-win32.h`
 - Modify `winbuild/Makefile.vc`
 - Modify the "Preprocessor Definitions" in the libcurl project

Note: The pre-processor settings can be found using the Visual Studio IDE
under "Project -> Settings -> C/C++ -> General" in VC6 and "Project ->
Properties -> Configuration Properties -> C/C++ -> Preprocessor" in later
versions.

When building an application that uses the static libcurl library on Windows,
you must add `-DCURL_STATICLIB` to your `CFLAGS`.  Otherwise the linker will
look for dynamic import symbols.

## Legacy Windows and SSL

Schannel (from Windows SSPI), is the native SSL library in Windows. However,
Schannel in Windows <= XP is unable to connect to servers that
no longer support the legacy handshakes and algorithms used by those
versions. If you will be using curl in one of those earlier versions of
Windows you should choose another SSL backend such as OpenSSL.

# Apple iOS and macOS

On modern Apple operating systems, curl can be built to use Apple's SSL/TLS
implementation, Secure Transport, instead of OpenSSL. To build with Secure
Transport for SSL/TLS, use the configure option `--with-darwinssl`. (It is not
necessary to use the option `--without-ssl`.) This feature requires iOS 5.0 or
later, or OS X 10.5 ("Leopard") or later.

When Secure Transport is in use, the curl options `--cacert` and `--capath`
and their libcurl equivalents, will be ignored, because Secure Transport uses
the certificates stored in the Keychain to evaluate whether or not to trust
the server. This, of course, includes the root certificates that ship with the
OS. The `--cert` and `--engine` options, and their libcurl equivalents, are
currently unimplemented in curl with Secure Transport.

For macOS users: In OS X 10.8 ("Mountain Lion"), Apple made a major overhaul
to the Secure Transport API that, among other things, added support for the
newer TLS 1.1 and 1.2 protocols. To get curl to support TLS 1.1 and 1.2, you
must build curl on Mountain Lion or later, or by using the equivalent SDK. If
you set the `MACOSX_DEPLOYMENT_TARGET` environmental variable to an earlier
version of macOS prior to building curl, then curl will use the new Secure
Transport API on Mountain Lion and later, and fall back on the older API when
the same curl binary is executed on older cats. For example, running these
commands in curl's directory in the shell will build the code such that it
will run on cats as old as OS X 10.6 ("Snow Leopard") (using bash):

    export MACOSX_DEPLOYMENT_TARGET="10.6"
    ./configure --with-darwinssl
    make

# Cross compile

Download and unpack the curl package.

`cd` to the new directory. (e.g. `cd curl-7.12.3`)

Set environment variables to point to the cross-compile toolchain and call
configure with any options you need.  Be sure and specify the `--host` and
`--build` parameters at configuration time.  The following script is an
example of cross-compiling for the IBM 405GP PowerPC processor using the
toolchain from MonteVista for Hardhat Linux.

    ./configure --host=ARCH-OS

# REDUCING SIZE

There are a number of configure options that can be used to reduce the size of
libcurl for embedded applications where binary size is an important factor.
First, be sure to set the `CFLAGS` variable when configuring with any relevant
compiler optimization flags to reduce the size of the binary.  For gcc, this
would mean at minimum the -Os option, and potentially the `-march=X`,
`-mdynamic-no-pic` and `-flto` options as well, e.g.

    ./configure CFLAGS='-Os' LDFLAGS='-Wl,-Bsymbolic'...

Note that newer compilers often produce smaller code than older versions

 - `--without-libidn` (disables support for the libidn DNS library)
 - `--without-librtmp` (disables support for RTMP)
 - `--without-ssl` (disables support for SSL/TLS)
 - `--without-zlib` (disables support for on-the-fly decompression)

The GNU compiler and linker have a number of options that can reduce the
size of the libcurl dynamic libraries on some platforms even further.
Specify them by providing appropriate `CFLAGS` and `LDFLAGS` variables on
the configure command-line, e.g.

    CFLAGS="-Os -ffunction-sections -fdata-sections
            -fno-unwind-tables -fno-asynchronous-unwind-tables -flto"
    LDFLAGS="-Wl,-s -Wl,-Bsymbolic -Wl,--gc-sections"

Be sure also to strip debugging symbols from your binaries after compiling
using 'strip' (or the appropriate variant if cross-compiling).  If space is

You may find that statically linking libcurl to your application will result
in a lower total size than dynamically linking.

Note that the curl test harness can detect the use of some, but not all, of
the `--disable` statements suggested above. Use will cause tests relying on
those features to fail.  The test harness can be manually forced to skip the
relevant tests by specifying certain key words on the `runtests.pl` command
line.  Following is a list of appropriate key words:

 - `--disable-cookies`          !cookies
 - `--disable-manual`           !--manual
 - `--disable-proxy`            !HTTP\ proxy !proxytunnel !SOCKS4 !SOCKS5

# PORTS

   - [`Curl_connect`](#Curl_connect)
   - [`multi_do`](#multi_do)
   - [`Curl_readwrite`](#Curl_readwrite)
   - [`multi_done`](#multi_done)
   - [`Curl_disconnect`](#Curl_disconnect)
 - [HTTP(S)](#http)
 - [FTP](#ftp)
 - [Kerberos](#kerberos)
 - [TELNET](#telnet)
 - [FILE](#file)
 - [SMB](#smb)
 - [LDAP](#ldap)
 - [E-mail](#email)
 - [General](#general)
 - [Persistent Connections](#persistent)
 - [multi interface/non-blocking](#multi)
 - [SSL libraries](#ssl)
 - [Library Symbols](#symbols)
 - [Return Codes and Informationals](#returncodes)
 - [AP/ABI](#abi)
 - [Client](#client)
 - [Memory Debugging](#memorydebug)
 - [Test Suite](#test)
 - [Asynchronous name resolves](#asyncdns)
   - [c-ares](#cares)
 - [`curl_off_t`](#curl_off_t)
 - [curlx](#curlx)
 - [Content Encoding](#contentencoding)
 - [`hostip.c` explained](#hostip)
 - [Track Down Memory Leaks](#memoryleak)
 - [`multi_socket`](#multi_socket)
 - [Structs in libcurl](#structs)
   - [Curl_easy](#Curl_easy)
   - [connectdata](#connectdata)
   - [Curl_multi](#Curl_multi)
   - [Curl_handler](#Curl_handler)
   - [conncache](#conncache)
   - [Curl_share](#Curl_share)
   - [CookieInfo](#CookieInfo)

<a name="intro"></a>
Intro
=====

 This project is split in two. The library and the client. The client part
 uses the library, but the library is designed to allow other applications to

 Tagging shall be used extensively, and by the time we release new archives we
 should tag the sources with a name similar to the released version number.

<a name="Portability"></a>
Portability
===========

 We write curl and libcurl to compile with C89 compilers.  On 32-bit and up
 machines. Most of libcurl assumes more or less POSIX compliance but that's
 not a requirement.

 We write libcurl to build and work with lots of third party tools, and we
 want it to remain functional and buildable with these and later versions
 (older versions may still work but is not what we work hard to maintain):

 - GNU Libtool  1.4.2
 - GNU Autoconf 2.57
 - GNU Automake 1.7
 - GNU M4       1.4
 - perl         5.004
 - roffit       0.5
 - groff        ? (any version that supports `groff -Tps -man [in] [out]`)
 - ps2pdf (gs)  ?

<a name="winvsunix"></a>
Windows vs Unix
===============

 There are a few differences in how to program curl the Unix way compared to
 the Windows way. Perhaps the four most notable details are:

 1. Different function names for socket operations.

   In curl, this is solved with defines and macros, so that the source looks
   the same in all places except for the header file that defines them. The
   macros in use are `sclose()`, `sread()` and `swrite()`.

 2. Windows requires a couple of init calls for the socket stuff.

   That's taken care of by the `curl_global_init()` call, but if other libs
   also do it etc there might be reasons for applications to alter that
   behaviour.

 (See [Structs in libcurl](#structs) for the separate section describing all
 major internal structs and their purposes.)

 There are plenty of entry points to the library, namely each publicly defined
 function that libcurl offers to applications. All of those functions are
 rather small and easy-to-follow. All the ones prefixed with `curl_easy` are
 put in the `lib/easy.c` file.

 `curl_global_init()` and `curl_global_cleanup()` should be called by the
 application to initialize and clean up global stuff in the library. As of
 today, it can handle the global SSL initing if SSL is enabled and it can init
 the socket layer on windows machines. libcurl itself has no "global" scope.

 All printf()-style functions use the supplied clones in `lib/mprintf.c`. This
 makes sure we stay absolutely platform independent.

 [ `curl_easy_init()`][2] allocates an internal struct and makes some
 initializations.  The returned handle does not reveal internals. This is the
 `Curl_easy` struct which works as an "anchor" struct for all `curl_easy`
 functions. All connections performed will get connect-specific data allocated
 that should be used for things related to particular connections/requests.

 [`curl_easy_setopt()`][1] takes three arguments, where the option stuff must
 be passed in pairs: the parameter-ID and the parameter-value. The list of
 options is documented in the man page. This function mainly sets things in
 the `Curl_easy` struct.

 `curl_easy_perform()` is just a wrapper function that makes use of the multi
 API.  It basically calls `curl_multi_init()`, `curl_multi_add_handle()`,
 `curl_multi_wait()`, and `curl_multi_perform()` until the transfer is done
 and then returns.

 Some of the most important key functions in `url.c` are called from
 `multi.c` when certain key steps are to be made in the transfer operation.

<a name="Curl_connect"></a>
Curl_connect()
--------------

   Analyzes the URL, it separates the different components and connects to the
   remote host. This may involve using a proxy and/or using SSL. The
   `Curl_resolv()` function in `lib/hostip.c` is used for looking up host
   names (it does then use the proper underlying method, which may vary
   between platforms and builds).

   When `Curl_connect` is done, we are connected to the remote site. Then it
   is time to tell the server to get a document/file. `Curl_do()` arranges
   this.

   This function makes sure there's an allocated and initiated `connectdata`
   struct that is used for this particular connection only (although there may
   be several requests performed on the same connect). A bunch of things are
   inited/inherited from the `Curl_easy` struct.

<a name="multi_do"></a>
multi_do()
---------

   `multi_do()` makes sure the proper protocol-specific function is called.
   The functions are named after the protocols they handle.

   The protocol-specific functions of course deal with protocol-specific
   negotiations and setup. They have access to the `Curl_sendf()` (from
   `lib/sendf.c`) function to send printf-style formatted data to the remote
   host and when they're ready to make the actual file transfer they call the
   `Curl_setup_transfer()` function (in `lib/transfer.c`) to setup the
   transfer and returns.

   If this DO function fails and the connection is being re-used, libcurl will
   then close this connection, setup a new connection and re-issue the DO
   request on that. This is because there is no way to be perfectly sure that
   we have discovered a dead connection before the DO function and thus we
   might wrongly be re-using a connection that was closed by the remote peer.

<a name="Curl_readwrite"></a>
Curl_readwrite()
----------------

   Called during the transfer of the actual protocol payload.

   During transfer, the progress functions in `lib/progress.c` are called at
   frequent intervals (or at the user's choice, a specified callback might get
   called). The speedcheck functions in `lib/speedcheck.c` are also used to
   verify that the transfer is as fast as required.

<a name="multi_done"></a>
multi_done()
-----------

   Called after a transfer is done. This function takes care of everything

   connection.

<a name="http"></a>
HTTP(S)
=======

 HTTP offers a lot and is the protocol in curl that uses the most lines of
 code. There is a special file `lib/formdata.c` that offers all the
 multipart post functions.

 base64-functions for user+password stuff (and more) is in `lib/base64.c`
 and all functions for parsing and sending cookies are found in
 `lib/cookie.c`.

 HTTPS uses in almost every case the same procedure as HTTP, with only two
 exceptions: the connect procedure is different and the function used to read
 or write from the socket is different, although the latter fact is hidden in
 the source by the use of `Curl_read()` for reading and `Curl_write()` for
 writing data to the remote server.

 servers.

<a name="ftp"></a>
FTP
===

 The `Curl_if2ip()` function can be used for getting the IP number of a
 specified network interface, and it resides in `lib/if2ip.c`.

 `Curl_ftpsendf()` is used for sending FTP commands to the remote server. It
 was made a separate function to prevent us programmers from forgetting that
 they must be CRLF terminated. They must also be sent in one single `write()`
 to make firewalls and similar happy.

<a name="kerberos"></a>
Kerberos
========

 Kerberos support is mainly in `lib/krb5.c` and `lib/security.c` but also
 `curl_sasl_sspi.c` and `curl_sasl_gssapi.c` for the email protocols and
 `socks_gssapi.c` and `socks_sspi.c` for SOCKS5 proxy specifics.

<a name="telnet"></a>
TELNET
======

 Telnet is implemented in `lib/telnet.c`.

<a name="file"></a>
FILE
====

 The `file://` protocol is dealt with in `lib/file.c`.

<a name="smb"></a>
SMB
===

 The `smb://` protocol is dealt with in `lib/smb.c`.

<a name="ldap"></a>
LDAP
====

 Everything LDAP is in `lib/ldap.c` and `lib/openldap.c`.

<a name="email"></a>
E-mail
======

 The e-mail related source code is in `lib/imap.c`, `lib/pop3.c` and
 `lib/smtp.c`.

<a name="general"></a>
General
=======

 URL encoding and decoding, called escaping and unescaping in the source code,
 is found in `lib/escape.c`.

 While transferring data in `Transfer()` a few functions might get used.
 `curl_getdate()` in `lib/parsedate.c` is for HTTP date comparisons (and
 more).

 `lib/getenv.c` offers `curl_getenv()` which is for reading environment
 variables in a neat platform independent way. That's used in the client, but
 also in `lib/url.c` when checking the proxy environment variables. Note that
 contrary to the normal unix `getenv()`, this returns an allocated buffer that
 must be `free()`ed after use.

 `lib/netrc.c` holds the `.netrc` parser.

 `lib/timeval.c` features replacement functions for systems that don't have
 `gettimeofday()` and a few support functions for timeval conversions.

 A function named `curl_version()` that returns the full curl version string
 is found in `lib/version.c`.

<a name="persistent"></a>
Persistent Connections
======================

 The persistent connection support in libcurl requires some considerations on
 how to do things inside of the library.

 - The `Curl_easy` struct returned in the [`curl_easy_init()`][2] call
   must never hold connection-oriented data. It is meant to hold the root data
   as well as all the options etc that the library-user may choose.

 - The `Curl_easy` struct holds the "connection cache" (an array of
   pointers to `connectdata` structs).

 - This enables the 'curl handle' to be reused on subsequent transfers.

 - When libcurl is told to perform a transfer, it first checks for an already
   existing connection in the cache that we can use. Otherwise it creates a
   new one and adds that to the cache. If the cache is full already when a new
   connection is added, it will first close the oldest unused one.

 Originally libcurl supported SSLeay for SSL/TLS transports, but that was then
 extended to its successor OpenSSL but has since also been extended to several
 other SSL/TLS libraries and we expect and hope to further extend the support
 in future libcurl versions.

 To deal with this internally in the best way possible, we have a generic SSL
 function API as provided by the `vtls/vtls.[ch]` system, and they are the only
 SSL functions we must use from within libcurl. vtls is then crafted to use
 the appropriate lower-level function calls to whatever SSL library that is in
 use. For example `vtls/openssl.[ch]` for the OpenSSL library.

<a name="symbols"></a>
Library Symbols
===============

 All symbols used internally in libcurl must use a `Curl_` prefix if they're
 used in more than a single file. Single-file symbols must be made static.
 Public ("exported") symbols must use a `curl_` prefix. (There are exceptions,
 but they are to be changed to follow this pattern in future versions.) Public
 API functions are marked with `CURL_EXTERN` in the public header files so
 that all others can be hidden on platforms where this is possible.

<a name="returncodes"></a>
Return Codes and Informationals
===============================

 I've made things simple. Almost every function in libcurl returns a CURLcode,
 that must be `CURLE_OK` if everything is OK or otherwise a suitable error
 code as the `curl/curl.h` include file defines. The very spot that detects an
 error must use the `Curl_failf()` function to set the human-readable error
 description.

 In aiding the user to understand what's happening and to debug curl usage, we
 must supply a fair number of informational messages by using the
 `Curl_infof()` function. Those messages are only displayed when the user
 explicitly asks for them. They are best used when revealing information that

 that makes it easier to keep a solid API/ABI over time. See docs/libcurl/ABI
 for our promise to users.

<a name="client"></a>
Client
======

 `main()` resides in `src/tool_main.c`.

 `src/tool_hugehelp.c` is automatically generated by the `mkhelp.pl` perl
 script to display the complete "manual" and the `src/tool_urlglob.c` file
 holds the functions used for the URL-"globbing" support. Globbing in the
 sense that the `{}` and `[]` expansion stuff is there.

 The client mostly sets up its `config` struct properly, then
 it calls the `curl_easy_*()` functions of the library and when it gets back
 control after the `curl_easy_perform()` it cleans up the library, checks
 status and exits.

 When the operation is done, the `ourWriteOut()` function in `src/writeout.c`
 may be called to report about the operation. That function is using the
 `curl_easy_getinfo()` function to extract useful information from the curl
 session.

 It may loop and do all this several times if many URLs were specified on the
 command line or config file.

<a name="memorydebug"></a>
Memory Debugging
================

 The file `lib/memdebug.c` contains debug-versions of a few functions.
 Functions such as `malloc()`, `free()`, `fopen()`, `fclose()`, etc that
 somehow deal with resources that might give us problems if we "leak" them.
 The functions in the memdebug system do nothing fancy, they do their normal
 function and then log information about what they just did. The logged data
 can then be analyzed after a complete session,

 `memanalyze.pl` is the perl script present in `tests/` that analyzes a log
 file generated by the memory tracking system. It detects if resources are
 allocated but never freed and other kinds of errors related to resource
 management.

 Internally, definition of preprocessor symbol `DEBUGBUILD` restricts code
 which is only compiled for debug enabled builds. And symbol `CURLDEBUG` is
 used to differentiate code which is _only_ used for memory
 tracking/debugging.

 Use `-DCURLDEBUG` when compiling to enable memory debugging, this is also
 switched on by running configure with `--enable-curldebug`. Use
 `-DDEBUGBUILD` when compiling to enable a debug build or run configure with
 `--enable-debug`.

 `curl --version` will list 'Debug' feature for debug enabled builds, and
 will list 'TrackMemory' feature for curl debug memory tracking capable
 builds. These features are independent and can be controlled when running
 the configure script. When `--enable-debug` is given both features will be
 enabled, unless some restriction prevents memory tracking from being used.

<a name="test"></a>
Test Suite
==========

 The test suite is placed in its own subdirectory directly off the root in the
 curl archive tree, and it contains a bunch of scripts and a lot of test case
 data.

 The main test script is `runtests.pl` that will invoke test servers like
 `httpserver.pl` and `ftpserver.pl` before all the test cases are performed.
 The test suite currently only runs on Unix-like platforms.

 You'll find a description of the test suite in the `tests/README` file, and
 the test case data files in the `tests/FILEFORMAT` file.

 The test suite automatically detects if curl was built with the memory
 debugging enabled, and if it was, it will detect memory leaks, too.

<a name="asyncdns"></a>
Asynchronous name resolves
==========================

### c-ares on win32

 First I compiled c-ares. I changed the default C runtime library to be the
 single-threaded rather than the multi-threaded (this seems to be required to
 prevent linking errors later on). Then I simply build the areslib project
 (the other projects adig/ahost seem to fail under MSVC).

 Next was libcurl. I opened `lib/config-win32.h` and I added a:
 `#define USE_ARES 1`

 Next thing I did was I added the path for the ares includes to the include
 path, and the libares.lib to the libraries.

 Lastly, I also changed libcurl to be single-threaded rather than
 multi-threaded, again this was to prevent some duplicate symbol errors. I'm
 not sure why I needed to change everything to single-threaded, but when I
 didn't I got redefinition errors for several CRT functions (`malloc()`,
 `stricmp()`, etc.)

<a name="curl_off_t"></a>
`curl_off_t`
==========

 `curl_off_t` is a data type provided by the external libcurl include
 headers. It is the type meant to be used for the [`curl_easy_setopt()`][1]
 options that end with LARGE. The type is 64-bit large on most modern
 platforms.

<a name="curlx"></a>
curlx
=====

 The libcurl source code offers a few functions by source only. They are not
 part of the official libcurl API, but the source files might be useful for
 others so apps can optionally compile/build with these sources to gain
 additional functions.

 We provide them through a single header file for easy access for apps:
 `curlx.h`

`curlx_strtoofft()`
-------------------
   A macro that converts a string containing a number to a `curl_off_t` number.
   This might use the `curlx_strtoll()` function which is provided as source
   code in strtoofft.c. Note that the function is only provided if no
   `strtoll()` (or equivalent) function exist on your platform. If `curl_off_t`
   is only a 32-bit number on your platform, this macro uses `strtol()`.

Future
------

 Several functions will be removed from the public `curl_` name space in a
 future libcurl release. They will then only become available as `curlx_`
 functions instead. To make the transition easier, we already today provide

================

## About content encodings

 [HTTP/1.1][4] specifies that a client may request that a server encode its
 response. This is usually used to compress a response using one (or more)
 encodings from a set of commonly available compression techniques. These
 schemes include `deflate` (the zlib algorithm), `gzip`, `br` (brotli) and
 `compress`. A client requests that the server perform an encoding by including
 an `Accept-Encoding` header in the request document. The value of the header
 should be one of the recognized tokens `deflate`, ... (there's a way to
 register new schemes/tokens, see sec 3.5 of the spec). A server MAY honor
 the client's encoding request. When a response is encoded, the server
 includes a `Content-Encoding` header in the response. The value of the
 `Content-Encoding` header indicates which encodings were used to encode the
 data, in the order in which they were applied.

 It's also possible for a client to attach priorities to different schemes so
 that the server knows which it prefers. See sec 14.3 of RFC 2616 for more
 information on the `Accept-Encoding` header. See sec
 [3.1.2.2 of RFC 7231][15] for more information on the `Content-Encoding`
 header.

## Supported content encodings

 The `deflate`, `gzip` and `br` content encodings are supported by libcurl.
 Both regular and chunked transfers work fine.  The zlib library is required
 for the `deflate` and `gzip` encodings, while the brotli decoding library is
 for the `br` encoding.

## The libcurl interface

 To cause libcurl to request a content encoding use:

  [`curl_easy_setopt`][1](curl, [`CURLOPT_ACCEPT_ENCODING`][5], string)

 where string is the intended value of the `Accept-Encoding` header.

 Currently, libcurl does support multiple encodings but only
 understands how to process responses that use the `deflate`, `gzip` and/or
 `br` content encodings, so the only values for [`CURLOPT_ACCEPT_ENCODING`][5]
 that will work (besides `identity`, which does nothing) are `deflate`,
 `gzip` and `br`. If a response is encoded using the `compress` or methods,
 libcurl will return an error indicating that the response could
 not be decoded.  If `<string>` is NULL no `Accept-Encoding` header is
 generated. If `<string>` is a zero-length string, then an `Accept-Encoding`
 header containing all supported encodings will be generated.

 The [`CURLOPT_ACCEPT_ENCODING`][5] must be set to any non-NULL value for
 content to be automatically decoded.  If it is not set and the server still
 sends encoded content (despite not having been asked), the data is returned
 in its raw form and the `Content-Encoding` type is not checked.

## The curl interface

 Use the [`--compressed`][6] option with curl to cause it to ask servers to
 compress responses using any format supported by curl.

<a name="hostip"></a>
`hostip.c` explained
====================

 The main compile-time defines to keep in mind when reading the `host*.c`
 source file are these:

## `CURLRES_IPV6`

 this host has `getaddrinfo()` and family, and thus we use that. The host may
 not be able to resolve IPv6, but we don't really have to take that into
 account. Hosts that aren't IPv6-enabled have `CURLRES_IPV4` defined.

## `CURLRES_ARES`

 is defined if libcurl is built to use c-ares for asynchronous name
 resolves. This can be Windows or \*nix.

## `CURLRES_THREADED`

 is defined if libcurl is built to use threading for asynchronous name
 resolves. The name resolve will be done in a new thread, and the supported
 asynch API will be the same as for ares-builds. This is the default under
 (native) Windows.

 If any of the two previous are defined, `CURLRES_ASYNCH` is defined too. If
 libcurl is not built to use an asynchronous resolver, `CURLRES_SYNCH` is
 defined.

## `host*.c` sources

 The `host*.c` sources files are split up like this:

 - `hostip.c`      - method-independent resolver functions and utility functions
 - `hostasyn.c`    - functions for asynchronous name resolves
 - `hostsyn.c`     - functions for synchronous name resolves
 - `asyn-ares.c`   - functions for asynchronous name resolves using c-ares
 - `asyn-thread.c` - functions for asynchronous name resolves using threads
 - `hostip4.c`     - IPv4 specific functions
 - `hostip6.c`     - IPv6 specific functions

 The `hostip.h` is the single united header file for all this. It defines the
 `CURLRES_*` defines based on the `config*.h` and `curl_setup.h` defines.

<a name="memoryleak"></a>
Track Down Memory Leaks
=======================

## Single-threaded

  Please note that this memory leak system is not adjusted to work in more
  than one thread. If you want/need to use it in a multi-threaded app. Please
  adjust accordingly.


## Build

  Rebuild libcurl with `-DCURLDEBUG` (usually, rerunning configure with
  `--enable-debug` fixes this). `make clean` first, then `make` so that all
  files are actually rebuilt properly. It will also make sense to build
  libcurl with the debug option (usually `-g` to the compiler) so that
  debugging it will be easier if you actually do find a leak in the library.

  This will create a library that has memory debugging enabled.

## Modify Your Application

  Add a line in your application code:

  Run your program as usual. Watch the specified memory trace file grow.

  Make your program exit and use the proper libcurl cleanup functions etc. So
  that all non-leaks are returned/freed properly.

## Analyze the Flow

  Use the `tests/memanalyze.pl` perl script to analyze the dump file:

    tests/memanalyze.pl dump

  This now outputs a report on what resources that were allocated but never
  freed etc. This report is very fine for posting to the list!

  If this doesn't produce any output, no leak was detected in libcurl. Then
  the leak is mostly likely to be in your code.

<a name="multi_socket"></a>
`multi_socket`
==============

 Implementation of the `curl_multi_socket` API

 The main ideas of this API are simply:

 1. The application can use whatever event system it likes as it gets info
    from libcurl about what file descriptors libcurl waits for what action
    on. (The previous API returns `fd_sets` which is very
    `select()`-centric).

 2. When the application discovers action on a single socket, it calls
    libcurl and informs that there was action on this particular socket and
    libcurl can then act on that socket/transfer only and not care about
    any other transfers. (The previous API always had to scan through all
    the existing transfers.)

 The idea is that [`curl_multi_socket_action()`][7] calls a given callback
 with information about what socket to wait for what action on, and the
 callback only gets called if the status of that socket has changed.

 We also added a timer callback that makes libcurl call the application when
 the timeout value changes, and you set that with [`curl_multi_setopt()`][9]
 and the [`CURLMOPT_TIMERFUNCTION`][10] option. To get this to work,
 Internally, there's an added struct to each easy handle in which we store
 an "expire time" (if any). The structs are then "splay sorted" so that we
 can add and remove times from the linked list and yet somewhat swiftly
 figure out both how long there is until the next nearest timer expires
 and which timer (handle) we should take care of now. Of course, the upside
 of all this is that we get a [`curl_multi_timeout()`][8] that should also
 work with old-style applications that use [`curl_multi_perform()`][11].

 We created an internal "socket to easy handles" hash table that given
 a socket (file descriptor) returns the easy handle that waits for action on
 that socket.  This hash is made using the already existing hash code
 (previously only used for the DNS cache).

 To make libcurl able to report plain sockets in the socket callback, we had
 to re-organize the internals of the [`curl_multi_fdset()`][12] etc so that
 the conversion from sockets to `fd_sets` for that function is only done in
 the last step before the data is returned. I also had to extend c-ares to
 get a function that can return plain sockets, as that library too returned
 only `fd_sets` and that is no longer good enough. The changes done to c-ares
 are available in c-ares 1.3.1 and later.

<a name="structs"></a>
Structs in libcurl
==================

This section should cover 7.32.0 pretty accurately, but will make sense even
for older and later versions as things don't change drastically that often.

<a name="Curl_easy"></a>
## Curl_easy

  The `Curl_easy` struct is the one returned to the outside in the external API
  as a `CURL *`. This is usually known as an easy handle in API documentations
  and examples.

  Information and state that is related to the actual connection is in the
  `connectdata` struct. When a transfer is about to be made, libcurl will
  either create a new connection or re-use an existing one. The particular
  connectdata that is used by this handle is pointed out by
  `Curl_easy->easy_conn`.

  Data and information that regard this particular single transfer is put in
  the `SingleRequest` sub-struct.

  When the `Curl_easy` struct is added to a multi handle, as it must be in
  order to do any transfer, the `->multi` member will point to the `Curl_multi`
  struct it belongs to. The `->prev` and `->next` members will then be used by
  the multi code to keep a linked list of `Curl_easy` structs that are added to
  that same multi handle. libcurl always uses multi so `->multi` *will* point
  to a `Curl_multi` when a transfer is in progress.

  `->mstate` is the multi state of this particular `Curl_easy`. When
  `multi_runsingle()` is called, it will act on this handle according to which
  state it is in. The mstate is also what tells which sockets to return for a
  specific `Curl_easy` when [`curl_multi_fdset()`][12] is called etc.

  The libcurl source code generally use the name `data` for the variable that
  points to the `Curl_easy`.

  When doing multiplexed HTTP/2 transfers, each `Curl_easy` is associated with
  an individual stream, sharing the same connectdata struct. Multiplexing
  makes it even more important to keep things associated with the right thing!

<a name="connectdata"></a>
## connectdata

  A general idea in libcurl is to keep connections around in a connection
  "cache" after they have been used in case they will be used again and then
  re-use an existing one instead of creating a new as it creates a significant
  performance boost.

  Each `connectdata` identifies a single physical connection to a server. If
  the connection can't be kept alive, the connection will be closed after use
  and then this struct can be removed from the cache and freed.

  Thus, the same `Curl_easy` can be used multiple times and each time select
  another `connectdata` struct to use for the connection. Keep this in mind,
  as it is then important to consider if options or choices are based on the
  connection or the `Curl_easy`.

  Functions in libcurl will assume that `connectdata->data` points to the
  `Curl_easy` that uses this connection (for the moment).

  As a special complexity, some protocols supported by libcurl require a
  special disconnect procedure that is more than just shutting down the
  socket. It can involve sending one or more commands to the server before
  doing so. Since connections are kept in the connection cache after use, the
  original `Curl_easy` may no longer be around when the time comes to shut down
  a particular connection. For this purpose, libcurl holds a special dummy
  `closure_handle` `Curl_easy` in the `Curl_multi` struct to use when needed.

  FTP uses two TCP connections for a typical transfer but it keeps both in
  this single struct and thus can be considered a single connection for most
  internal concerns.

  The libcurl source code generally use the name `conn` for the variable that
  points to the connectdata.

<a name="Curl_multi"></a>
## Curl_multi

  Internally, the easy interface is implemented as a wrapper around multi
  interface functions. This makes everything multi interface.

  `Curl_multi` is the multi handle struct exposed as `CURLM *` in external
  APIs.

  This struct holds a list of `Curl_easy` structs that have been added to this
  handle with [`curl_multi_add_handle()`][13]. The start of the list is
  `->easyp` and `->num_easy` is a counter of added `Curl_easy`s.

  `->msglist` is a linked list of messages to send back when

  `->sockhash` is a hash table to allow fast lookups of socket descriptor for
  which `Curl_easy` uses that descriptor. This is necessary for the
  `multi_socket` API.

  `->conn_cache` points to the connection cache. It keeps track of all
  connections that are kept after use. The cache has a maximum size.

  `->closure_handle` is described in the `connectdata` section.

  The libcurl source code generally use the name `multi` for the variable that
  points to the `Curl_multi` struct.

<a name="Curl_handler"></a>
## Curl_handler

  Each unique protocol that is supported by libcurl needs to provide at least
  one `Curl_handler` struct. It defines what the protocol is called and what
  functions the main code should call to deal with protocol specific issues.
  In general, there's a source file named `[protocol].c` in which there's a
  `struct Curl_handler Curl_handler_[protocol]` declared. In `url.c` there's
  then the main array with all individual `Curl_handler` structs pointed to
  from a single array which is scanned through when a URL is given to libcurl
  to work with.

  `->scheme` is the URL scheme name, usually spelled out in uppercase. That's
  "HTTP" or "FTP" etc. SSL versions of the protocol need their own
  `Curl_handler` setup so HTTPS separate from HTTP.

  `->setup_connection` is called to allow the protocol code to allocate
  protocol specific data that then gets associated with that `Curl_easy` for
  the rest of this transfer. It gets freed again at the end of the transfer.
  It will be called before the `connectdata` for the transfer has been
  selected/created. Most protocols will allocate its private
  `struct [PROTOCOL]` here and assign `Curl_easy->req.protop` to point to it.

  `->connect_it` allows a protocol to do some specific actions after the TCP
  connect is done, that can still be considered part of the connection phase.

  Some protocols will alter the `connectdata->recv[]` and
  `connectdata->send[]` function pointers in this function.

  `->done` gets called when the transfer is complete and DONE. That's after the
  main data has been transferred.

  `->do_more` gets called during the `DO_MORE` state. The FTP protocol uses
  this state when setting up the second connection.

  `->proto_getsock`
  `->doing_getsock`
  `->domore_getsock`
  `->perform_getsock`
  Functions that return socket information. Which socket(s) to wait for which
  action(s) during the particular multi state.

  `->disconnect` is called immediately before the TCP connection is shutdown.

  `->readwrite` gets called during transfer to allow the protocol to do extra
  reads/writes

  `->defport` is the default report TCP or UDP port this protocol uses

  `->protocol` is one or more bits in the `CURLPROTO_*` set. The SSL versions
  have their "base" protocol set and then the SSL variation. Like
  "HTTP|HTTPS".

  `->flags` is a bitmask with additional information about the protocol that will
  make it get treated differently by the generic engine:

  - `PROTOPT_SSL` - will make it connect and negotiate SSL

  - `PROTOPT_DUAL` - this protocol uses two connections

  - `PROTOPT_CLOSEACTION` - this protocol has actions to do before closing the
    connection. This flag is no longer used by code, yet still set for a bunch
    of protocol handlers.

  - `PROTOPT_DIRLOCK` - "direction lock". The SSH protocols set this bit to
    limit which "direction" of socket actions that the main engine will
    concern itself with.

  - `PROTOPT_NONETWORK` - a protocol that doesn't use network (read `file:`)

  - `PROTOPT_NEEDSPWD` - this protocol needs a password and will use a default
    one unless one is provided

  - `PROTOPT_NOURLQUERY` - this protocol can't handle a query part on the URL
    (?foo=bar)

<a name="conncache"></a>
## conncache

  Is a hash table with connections for later re-use. Each `Curl_easy` has a
  pointer to its connection cache. Each multi handle sets up a connection
  cache that all added `Curl_easy`s share by default.

<a name="Curl_share"></a>
## Curl_share

  The libcurl share API allocates a `Curl_share` struct, exposed to the
  external API as `CURLSH *`.

  The idea is that the struct can have a set of its own versions of caches and
  pools and then by providing this struct in the `CURLOPT_SHARE` option, those
  specific `Curl_easy`s will use the caches/pools that this share handle
  holds.

  Then individual `Curl_easy` structs can be made to share specific things
  that they otherwise wouldn't, such as cookies.

  The `Curl_share` struct can currently hold cookies, DNS cache and the SSL
  session cache.

<a name="CookieInfo"></a>
## CookieInfo

  This is the main cookie struct. It holds all known cookies and related
  information. Each `Curl_easy` has its own private `CookieInfo` even when
  they are added to a multi handle. They can be made to share cookies by using
  the share API.


[1]: https://curl.haxx.se/libcurl/c/curl_easy_setopt.html
[2]: https://curl.haxx.se/libcurl/c/curl_easy_init.html
[3]: https://c-ares.haxx.se/

 1.1 CURLFORM_CONTENTLEN in an array
 1.2 Disabling HTTP Pipelining
 1.3 STARTTRANSFER time is wrong for HTTP POSTs
 1.4 multipart formposts file name encoding
 1.5 Expect-100 meets 417
 1.6 Unnecessary close when 401 received waiting for 100
 1.7 Deflate error after all content was received
 1.8 DoH isn't used for all name resolves when enabled
 1.9 HTTP/2 frames while in the connection pool kill reuse
 1.10 Strips trailing dot from host name
 1.11 CURLOPT_SEEKFUNCTION not called with CURLFORM_STREAM

 2. TLS
 2.1 CURLINFO_SSL_VERIFYRESULT has limited support
 2.2 DER in keychain

 4.1 -J and -O with %-encoded file names
 4.2 -J with -C - fails
 4.3 --retry and transfer timeouts
 4.4 --upload-file . hang if delay in STDIN
 4.5 Improve --data-urlencode space encoding

 5. Build and portability issues

 5.2 curl-config --libs contains private details
 5.3 curl compiled on OSX 10.13 failed to run on OSX 10.10
 5.4 Cannot compile against a static build of OpenLDAP
 5.5 can't handle Unicode arguments in Windows
 5.6 cmake support gaps
 5.7 Visual Studio project gaps
 5.8 configure finding libs in wrong directory

 waiting for the the 100-continue response.
 https://curl.haxx.se/mail/lib-2008-08/0462.html

1.7 Deflate error after all content was received

 There's a situation where we can get an error in a HTTP response that is
 compressed, when that error is detected after all the actual body contents
 have been received and delivered to the application. This is tricky, but is
 ultimately a broken server.

 See https://github.com/curl/curl/issues/2719

1.8 DoH isn't used for all name resolves when enabled

 Even if DoH is specified to be used, there are some name resolves that are
 done without it. This should be fixed. When the internal function
 `Curl_resolver_wait_resolv()` is called, it doesn't use DoH to complete the
 resolve as it otherwise should.

 See https://github.com/curl/curl/pull/3857 and
 https://github.com/curl/curl/pull/3850

1.9 HTTP/2 frames while in the connection pool kill reuse

 If the server sends HTTP/2 frames (like for example an HTTP/2 PING frame) to
 curl while the connection is held in curl's connection pool, the socket will
 be found readable when considered for reuse and that makes curl think it is
 dead and then it will be closed and a new connection gets created instead.

 ASCII space characters in --data-urlencode are currently encoded as %20
 rather than +, which RFC 1866 says should be used.

 See https://github.com/curl/curl/issues/3229

5. Build and portability issues







5.2 curl-config --libs contains private details

 "curl-config --libs" will include details set in LDFLAGS when configure is
 run that might be needed only for building libcurl. Further, curl-config
 --cflags suffers from the same effects with CFLAGS/CPPFLAGS.

5.3 curl compiled on OSX 10.13 failed to run on OSX 10.10

CLEANFILES = $(GENHTMLPAGES) $(PDFPAGES) $(MANDISTPAGES) curl.1

EXTRA_DIST =                                    \
 $(noinst_man_MANS)                             \
 ALTSVC.md                                      \
 BINDINGS.md                                    \
 BUG-BOUNTY.md                                  \
 BUGS                                           \
 CHECKSRC.md                                    \
 CIPHERS.md                                     \
 CMakeLists.txt                                 \
 CODE_OF_CONDUCT.md                             \
 CODE_STYLE.md                                  \
 CONTRIBUTE.md                                  \

SUBDIRS = . cmdline-opts
DIST_SUBDIRS = $(SUBDIRS) examples libcurl
CLEANFILES = $(GENHTMLPAGES) $(PDFPAGES) $(MANDISTPAGES) curl.1
EXTRA_DIST = \
 $(noinst_man_MANS)                             \
 ALTSVC.md                                      \
 BINDINGS.md                                    \
 BUG-BOUNTY.md                                  \
 BUGS                                           \
 CHECKSRC.md                                    \
 CIPHERS.md                                     \
 CMakeLists.txt                                 \
 CODE_OF_CONDUCT.md                             \
 CODE_STYLE.md                                  \
 CONTRIBUTE.md                                  \

- tag the git repo in this style: `git tag -a curl-7_34_0`. -a annotates the
  tag and we use underscores instead of dots in the version number. Make sure
  the tag is GPG signed (using -s).

- run "./maketgz 7.34.0" to build the release tarballs. It is important that
  you run this on a machine with the correct set of autotools etc installed
  as this is what then will be shipped and used by most users on \*nix like
  systems.

- push the git commits and the new tag

- gpg sign the 4 tarballs as maketgz suggests

- upload the 8 resulting files to the primary download directory

Coming dates
------------

Based on the description above, here are some planned release dates (at the
time of this writing):


- May 22, 2019
- July 17, 2019
- September 11, 2019
- November 6, 2019
- January 8, 2020 (moved)
- February 27, 2020
- April 22, 2020
- June 17, 2020

The above (and more) curl-related dates are published in
[iCalendar format](https://calendar.google.com/calendar/ical/c9u5d64odop9js55oltfarjk6g%40group.calendar.google.com/public/basic.ics)
as well.

curl security process
=====================

This document describes how security vulnerabilities should be handled in the
curl project.

Publishing Information
----------------------

All known and public curl or libcurl related vulnerabilities are listed on
[the curl web site security page](https://curl.haxx.se/docs/security.html).

Security vulnerabilities **should not** be entered in the project's public bug
tracker.


Vulnerability Handling
----------------------

The typical process for handling a new security vulnerability is as follows.

No information should be made public about a vulnerability until it is
formally announced at the end of this process. That means, for example that a
bug tracker entry must NOT be created to track the issue since that will make
the issue public and it should not be discussed on any of the project's public
mailing lists. Also messages associated with any commits should not make any
reference to the security nature of the commit if done prior to the public
announcement.

- The person discovering the issue, the reporter, reports the vulnerability on
  [https://hackerone.com/curl](https://hackerone.com/curl). Issues filed there
  reach a handful of selected and trusted people.

- Messages that do not relate to the reporting or managing of an undisclosed
  security vulnerability in curl or libcurl are ignored and no further action
  is required.

- A person in the security team responds to the original report to acknowledge
  that a human has seen the report.

- The security team investigates the report and either rejects it or accepts
  it.

- If the report is rejected, the team writes to the reporter to explain why.

- If the report is accepted, the team writes to the reporter to let him/her
  know it is accepted and that they are working on a fix.

- The security team discusses the problem, works out a fix, considers the
  impact of the problem and suggests a release schedule. This discussion
  should involve the reporter as much as possible.

- The release of the information should be "as soon as possible" and is most
  often synchronized with an upcoming release that contains the fix. If the
  reporter, or anyone else involved, thinks the next planned release is too
  far away, then a separate earlier release should be considered.

- Write a security advisory draft about the problem that explains what the
  problem is, its impact, which versions it affects, solutions or workarounds,
  when the release is out and make sure to credit all contributors properly.
  Figure out the CWE (Common Weakness Enumeration) number for the flaw.

- Request a CVE number from
  [HackerOne](https://docs.hackerone.com/programs/cve-requests.html)

- Consider informing
  [distros@openwall](https://oss-security.openwall.org/wiki/mailing-lists/distros)
  to prepare them about the upcoming public security vulnerability
  announcement - attach the advisory draft for information. Note that
  'distros' won't accept an embargo longer than 14 days and they do not care
  for Windows-specific flaws.


- Update the "security advisory" with the CVE number.

- The security team commits the fix in a private branch. The commit message
  should ideally contain the CVE number. This fix is usually also distributed
  to the 'distros' mailing list to allow them to use the fix prior to the
  public announcement.