The %err_detail formating code print wrong error information

The bug added with the r13732 patch.

Fix SSL_get_peer_certificate memory leak

The SSL_get_peer_certificate openSSL function increases the lock for X509
object it returns so X509 object retrieved using this function must be
released with X509_free after use.
This patch uses the Ssl::X509_Pointer TidyPointer to release X509 object
retrieved with the SSL_get_peer_certificate function inside the
Ssl::PeerConnector::handleNegotiateError method

This is a Measurement Factory project

Unexpected SQUID_X509_V_ERR_DOMAIN_MISMATCH errors while accessing sites with valid certificates

A "const char *" pointer retrieved using the SBuf::c_str() method may attached
to an SSL object using the SSL_set_ex_data method as server name used to
validate server certificates. This pointer may become invalid, causing
the SQUID_X509_V_ERR_DOMAIN_MISMATCH errors.

This patch changes the type of the ssl_ex_index_server index used with the
SSL_set_ex_data function to be an SBuf object.

This is a Measurement Factory project

Portability: Add hacks to define C++11 explicit N-bit type limits

Add cstdint and stdint.h to libcompat headers and ensure that type limits
used by Squid are always available. Mostly this involves shuffling
existing hacks into the compat headers but the UINT32_* limits are new.

Revert rev.14029

C++11: retain support for older compilers after rev.14028

Epoll: initialize kdpfd and epoll_event in all cases

CBDATA: use class Lock for reference counting

Ensure class Lock counter remains within bounds

Bug 4231 pt2: comm_open_uds does not provide description for newly opened FD

Thanks to Alex Dowad for identifying the problem.

Bug 4231 pt1: fd_open() not correctly handling empty descriptions

SourceFormat Enforcement

Add Kerberos support for MAC OS X 10.x

Reverted r14022 due to some regressions

Detect and use libc++, needed for clang c++11 support

Negotiate Kerberos authentication request size exceeds output buffer size.

Despite the "must match" comment, MAX_AUTHTOKEN_LEN in
auth/UserRequest.h got out of sync with similar constants in Negotiate helpers.
A 32KB buffer cannot fit some helper requests (e.g., those carrying Privilege
Account Certificate information in the client's Kerberos ticket). Each truncated
request blocks the negotiate helper channel, eventually causing helper queue
overflow and possibly killing Squid.

This patch increases MAX_AUTHTOKEN_LEN in UserRequest.h to 65535 which
is also the maximum used by the negotiate helpers. The patch also adds checks
to avoid sending truncated requests, treating them as helper errors instead.

This is a Measurement Factory project.

Do not increment an iterator invalidated by std::map::erase().

Fix initializer missed in rev.14018

Use std::map instead of hash.h for tracking CBDATA memory

One more step towards removing the custom hash implementation.

This also resolves some crashes introduced by the custom hash bucket
system to the cbdata cachemgr reports and valgrind tracking.

Also removes the HASHED_CBDATA macro in favour of WITH_VALGRIND.

Fix require-proxy-header preventing HTTPS proxying and ssl-bump

When requir-proxy-header was used, the request->flags.interceptTproxy is
wrongly set to 1.

Since request->flags.interceptTproxy is 1, the 200 status code for CONNECT
call is not sent which breaks both HTTPS proxying and SSL-bump.

Fix typo in rev.14015

Bug 4212: ssl_crtd crashes with corrupt database

The fix for Bug 3664 "ssl_crtd fails to build on OpenSolaris/OpenIndiana/Solaris 11"
introduced a regression on BSD and Linux where lockf() implementations appear not to
lock the entire file correctly or as reliably as flock().

Reverting the flock/lockf change for non-Solaris OS.

Release Notes: document ssl::server_name

SourceFormat Enforcement

Support for resuming sessions

This patch adds code in squid to control SslBump behavior when dealing with
"resuming SSL/TLS sessions". Without these changes, SslBump usually terminates
all resuming sessions with an error because such sessions do not include
server certificates, preventing Squid from successfully validating the server
identity.

After these changes, Squid splices resuming sessions. Splicing is the right
because Squid most likely has spliced the original connections that the client
and server are trying to resume now.
Without SslBump, session resumption would just work, and SslBump behaviour
should approach that ideal.

Future projects may add ACL checks for allowing resuming sessions and may
add more complex algorithms, including maintaining an SMP-shared
cache of sessions that may be resumed in the future and evaluating
client/server attempts to resume a session using that cache.

This patch also makes SSL client Hello message parsing more robust and
adds an SSL server Hello message parser.

Also add support for NPN (next protocol negotiation) and ALPN (Application-Layer Protocol Negotiation) tls extensions, required to correctly bump web clients
support these extensions

Technical details
-----------------

In Peek mode, the old Squid code would forward the client Hello message to the
server. If the server tries to resume the previous (spliced) SSL session with
the client, then Squid SSL code gets an ssl/PeerConnector.cc "ccs received
early" error (or similar) because the Squid SSL object expects a server
certificate and does not know anything about the session being resumed.

With this patch, Squid detects session resumption attempts and splices

Session resumption detection
----------------------------

There are two mechanism in SSL/TLS for resuming sessions. The traditional
shared session IDs and the TLS ticket extensions:

* If Squid detects a shared ID in both client and server Hello messages, then
Squid decides whether the session is being resumed by comparing those client
and server shared IDs. If (and only if) the IDs are the same, then Squid
assumes that it is dealing with a resuming session (using session IDs).

* If Squid detects a TLS ticket in the client Hello message and TLS ticket
support in the server Hello message as well as a Change Cipher Spec or a New
TLS Ticket message (following the server Hello message), then (and only then)
Squid assumes that it is dealing with a resuming session (using TLS tickets).

The TLS tickets check is not performed if Squid detects a shared session ID
in both client and server Hello messages.

NPN and ALPN tls extensions
---------------------------

Even if squid has some SSL hello messages parsing code, we are relying to
openSSL for full parsing. The openSSL used in peek and splice mode to  parse
server hello message, check for errors and verify server certificates.
If the openSSL, while parses the server hello message, find an extension enabled
in the server hello message, which is not enabled in its side, fails with an
error ("...parse tlsext...").

OpenSSL supports NPN tls extension and from 1.0.2 release supports also the
ALPN tls extensions. In peek mode we are forwading the client SSL hello message
as is, and if this message include support for NPN or ALPN tls extension is
possible that the SSL server support them and include related extensions
in its response. The openSSL will fail if support for these extensions is
not enabled in its side.

This patch handles the NPN (TLSEXT_TYPE_next_proto_neg) as follows:
Try to select the http/1.1 protocol from the server protocols list. If the
http/1.1 is not supported then the SSL bumping will fail. This is valid
because only http protocol we are supporting in squid.
Splicing is not affected.

Also add support for the ALPN TLS extension. This extension is a replacement
for the NPN extension. The client sends a list of supported protocols. In the
case of stare mode squid now sends only http as supported protocol. In the
case of server-first or client-first bumbing modes, squid does enable this
extension.

The NPN supported by chromium browser the ALPN supported by firefox.
Support for ALPN is added to openSSL 1.0.2 release.
These extensions are used to support SPDY and similar protocols.

This is a Measurement Factory project.

Bug 4226: digest_edirectory_auth: found but cannot be built

SourceFormat Enforcement

Fix server_name ACL  patch (r14008): fixes to allow squid compile when openssl is not enabled

Add server_name ACL matching server name(s) obtained from various sources such as CONNECT request URI, client SNI, and SSL server certificate CN.

During each SslBump step, Squid improves its understanding of a "true server
name", with a bias towards server-provided (and Squid-validated) information.

The server-provided server names are retrieved from the server certificate CN
and Subject Alternate Names. The new server_name ACL matches any of alternate
names and CN. If the CN or an alternate name is a wildcard, then the new ACL
matches any domain that matches the domain with the wildcard.

Other than supporting many sources of server name information (including
sources that may supply Squid with multiple server name variants and
wildcards), the new ACL is similar to dstdomain.

Also added a server_name_regex ACL.

This is a Measurement Factory project.

Fix HttpStateData::readReply to retry read from server in the case of EINPROGRESS, EAGAIN or similar errors

This bug mostly affects SSL bumped connections.
The HttpStateData::readReply will not retry read from server in the case of an
EINPROGRESS or similar comm errors and the connection will hang, until the
timeout handler called.

The Comm::ReadNow method calls ignoreErrno function to test if the comm error
should be ignored and in this case return Comm::INPROGRESS value.
In this case we need to set flags.do_next_read to true to force
HttpStateData::maybeReadVirginBody() method retry read.

This is a Measurement Factory project

Fix: An invalid request->clientConnectionManager object can be used inside Ssl::PeerConnector::handleNegotiateError method

This patch adds the Ssl::ServerBio::bumpMode() method to retrieve the configured
mode from a ServerBio object, and uses this method for checking the bumping
mode inside Ssl::PeerConnector::handleNegotiateError method

This is a Measurement Factory project

httpsEstablish: remove unused code

assertion failed: client_side.h:364: "sslServerBump == srvBump"

After a failed http_access acl check of an HTTP request, tunneled through a
SSL bumped connection, ssl bumping code try to re-setup the connection for a
client-first bumping mode to serve the error crashing squid.

This is a Measurement Factory project

Fix cross-compile issues with SSL_get_certificate()

Explicitly assume 'no' to these hacks when cross-compiling and create
the autoconf.h #define.

Thanks to Cambier Gaëtan for identifying the problem.

Docs: RFC 7238 obsoleted by RFC 7538

Fix to make ECAP build and run after patch r13995

Update SPONSORS entries

digest_edirectory_auth: Fix -lnettle dependency error

Boilerplate: reference Translator copyrights in CREDITS

Cleanup: Place explicit size on ref-count lock counter

This allows us to make explicit calculation of child object sizes in a
portable way despite differences in system 'unsigned' size.

SourceFormat Enforcement

Parser-NG: Convert the ICAP read buffer to an SBuf.

* Remove the double-buffering hack used to comm_read() ICAP responses as
  c-string then convert to MemBuf for parsing.

* Revert the HttpMsg parser API from MemBuf to c-string parameters.
  The internals did not make much use of the MemBuf abilities and it is
  simpler to retrieve c-string values directly from an SBuf than to go
  via a MemBuf conversion.

Merge from trunk rev.13994

Release Notes: update for 4.x

Prep for 3.5.3

Docs: update QUICKSTART and INSTALL

Fix Squid crash while an error page generated

When squid generated an error page which contains the "%m" formating code
but the authentication information is not available squid dies with
segfault.

This is a Measurement Factory project

Fix GNU atomics detection support, enable caching for them

Crypto-NG: Move Ssl::PeerConnectorAnswer to Security::EncryptorAnswer

This class was not actually depending on OpenSSL API symbols and by
abstracting it out we can unify the callback handlers for encrypted and
non-encrypted logic paths for several classes that setup connections.

Revert changes to external_acl.cc in rev.13985

Move Ssl::PeerConnectorAnswer to Security::EncryptorAnswer

This class was not actually depending on OpenSSL API symbols and by
abstracting it out we can unify the callback handlers for encrypted and
non-encrypted logic paths for several classes that setup connections.

SourceFormat Enforcement

Add missing SBufStatsAction changes for registration rework

somehow forgot to add these to previous commit

Rework SBufStatsAction registration to use explicit code path

GCC was not happy about the global level registration "variable" not being used

start workers as root

SMP workers in trunk start without root privileges. This results in startup
failures when workers need to use a privileged port (e.g., 443) or other
root-only features such as TPROXY.

The watch_child function, responsible to watch and start squid workers for
the squid monitor process, called after a enter_suid() call, but the
writePidFile() call, inside the watch_child(), will leave suid mode before exit.

This patch add enter_suid() cals after the writePidFile and removePidFile()
inside the watch_child() function.

This is a Measurement Factory project

Implement lazy buffer reallocation for HTTP server connections

Bug 4206 was caused by early buffers allocated for read I/O being
dropped while waiting for the read to actually take place.

In order to prevent future bugs in the server connection read logics we
implement the same lazy/late grow behaviour as required to fix bug 4206.

Polish rev.13980 debugs

Fix bug 4206 equivalent code in new ICAP logic

Merge from trunk rev.13981

Bug 4206: Regression in expect:100-continue

Cleanup: extend SBuf debugging information

It can be hard determining what simple operations (ie cow(), grow()) are
being done no what SBuf object. Add the SBuf::id to debugs() output on
many more operations.

Bug 4204: ./configure does not abort when required helpers cannot be built

Bug 4213: negotiate_kerberos_auth: freeing non-dynamic memory

Bug 4215: double-free in CBDATA with --enable-debug-cbdata

Cleanup: RebuildState does not need ref-counting

Cleanup: Drop unused CBDATA free_func parameter

C++11: wrap move semantics operators

Allowing older not-quite-C++11 compilers to build for a while longer.

Move is a performance optimization.

Rename 3.HEAD to 4.0.0

Portability: check 64-bit GNU atomic operators are useable

Sometimes (namely 32-bit OpenBSD libstdc++) do not fully implement the
GNU atomic operators for both 32-bit and 64-bit. But Squid makes use of
both types if the compiler deems them required.

We need to check them all before declaring the atomics usable, or not.

 Thanks to Stuart Henderson for identifying the issue.

Tests: extend pre-compiler unit tests to check macro permutations

We are getting come complaints about precompiler issues building with
#if FOO && FOO || FOO boolean constructs using undefined macros.

The particualr form reported so far dies when building the test, so will
be found earlier than these checks are run. This is to ensure its not a
widespread subtle error in other "working" installations.

Merged from trunk rev.13970

Document that on_unsupported_protocol works for bumped tunnels.

Fix uninitialized member of ps_state

 Detected by Coverity Scan. Issue 740575

Abort Host header lookup if line ends without an LF.

 Detected by Coverity Scan. Issue 1270007

Remove useless checks in rev.13951

Being overly paranoid it seems.

 Detected by Coverity Scan. Issue 1273436

Fix uninitialized members in Security::PeerOptions rev.13952

 Detected by Coverity Scan. Issue 1273438

Fix uninitialized members in Http1::ResponseParser

 Detected by Coverity Scan. Issue 1273439

Fix typo added tweaking rev.13962

SourceFormat Enforcement

Portability: only use SSL compression when available

Compression in SSL/TLS is deprecated. LibreSSL, BoringSSL, and some
OpenSSL builds do not contain support for it at all.

Remove SSLv2 support in SSL BIO code

We are not supporting SSLv2 features anymore.

Add missing copyright blurbs from rev.13954

Source Maintenance: update src/acl/Address.h wrapper macro

Cleanup: convert BodyPipe to MEMPROXY_CLASS

BodyPipe is ref-counted. Such classes should not be using CBDATA_CLASS
for smart pointer referencing and memory management. They use RefCount
for smart pointer referencing, MEMPROXY_CLASS for memory management.

Remove needless XXX comment

Merged from trunk rev.13957

Portability: fix compile errors on ICC after rev.13954

"type qualifier on return type is meaningless"

Fix signed/unsigned comparison compile error on 64-bit

SourceFormat Enforcement

Parser-NG: HTTP Response Parser upgrade

1) convert the HTTP server read buffer to an SBuf using the same design
and Comm::Read API implemented previously for the client connections.

The buffer remains default initialized at 16KB per connection but is no
longer absolutely limited to 256KB. Instead it is limited by
configuration options controlling maximum server input sizes on
read_ahead_gap and response message headers.

The Client API has been extended with a new method to estimate size
requirements of an SBuf I/O buffer. Modelled on and deprecating the
existing MemBuf estimator.

The Comm::ReadNow() API is extended to allow limited-size read(2)
operations by setting the CommIoCbParams::size parameter.

The HttpStateData buffer is partially detached from
StoreEntry::delayAwareRead() API due to requirements of the
Comm::ReadNow() API. Instead StoreEntry::bytesWanted() is used directly
to determine read(2) size, and DeferredRead are generated only when
ReadNow() is actually and immediately to be deferred. Theoretically this
means less read operations get deferred in some high load cases.
Practically it means there is no longer an AsyncCall queue plus socket
wait delay between delay_pools promising a read size, doing the
read(2), and accounting for the bytes received - accuracy should be much
improved under load.

This introduces one temporary performance regression converting the SBuf
content to MemBuf for chunked decoder to process.

2) add Http1::ResponseParser class for parsing HTTP response messages.

Modelled on the same design as used for the HTTP RequestParser, and
inheriting from a mutual parent Http1::Parser.

The Parser is Tokeniser based, incremental and 'consumes' bytes out of
the buffer as they are parsed.

The Tokenizer int64 API is updated to handle limited-length scans and
optional +/- symbols.

This Parser class recognises HTTP/1.x and ICY/1 syntax messages. Any
unknown syntax input is assumed to be HTTP "0.9" and it will
gateway/transform the response to HTTP/1.1.
 NOTE: these are all semantic actions performed by the code being
replaced in (3). Only the form and OO scoping has changed.

The mime header block detection operation is generalized into the
Http1::Parser for use by both RequestParser and ResponseParser. The
request_parse_status error code has also been adapted for shared use.

3) integrate the HTTP1::ResponseParser with HttpStateData server
response processing.

This is largely code shuffling. Though I have extended the EOF \r\n hack
such that it enables Squid to parse truncated response headers now.

SourceFormat Enforcement

Merge from trunk rev.13952

Bug 2741 (partial): Initial libsecurity API

The first step(s) towards a generic TLS/SSL security API for Squid.

Creates the basic security/libsecurity.la library and Security::
namespace infrastructure. Symbols provided by this API are always
available instead of conditionally compiled (unlike the ssl/* code for
OpenSSL use).

Merge the TLS/SSL context parameters into a Security::PeerOptions
object instead of maintaining multiple member variables in the
CachePeer and SquidConfig objects.

Squid now provides an error if SSL-specific squid.conf parameters are
used for a Squid without OpenSSL support, instead of silently ignoring
them.

Merged from trunk

Bug 2907: high CPU usage on CONNECT when using delay pools

When delay pools are active on a CONNECT tunnel and the pool is drained
the I/O loop cycles very often transferring 1 byte until the pool is
topped-up at the end of the second.

Instead of looping constantly trying to read 1 byte at a time, add an
asynchronous event to wait for a few I/O cycles or until more bytes can
be read.

To protect against infinite loops of waiting when many tunnels are
competing for the pool allowance we only delay for a limited number of
loops before allowing at least 1 byte through. Also, the amount of time
waited is an odd fraction of 1 second so re-tries naturally spread
across any given second fairly, with connections rotating closer or
further from the time when pool topup happens. That behaviour still
allows some variance in service times, but overall the CPU consumption
and (as a result) total proxy speed appears to be much improved.

NP: Initial production testing shows a 36% RPS speed increase,
    with a 50% reduction in total CPU usage.

SourceFormat Enforcement

Fake CONNECT exceeds concurrent requests limit part2: wrap Openssl related code inside "#if USE_OPENSSL ..."

Fake CONNECT exceeds concurrent requests limit.

Squid closes the SSL client connection with "Failed to start fake CONNECT
request for ssl spliced connection". This happens especially often when
the pipeline_prefetch configuration parameter is set to "0" (i.e., default).

When a transparent SSL connection is peeked and then spliced in step2, we are
generating a fake CONNECT request. The fake CONNECT request is counted as a
new pipelined request and may exceed the configured limit. This patch solves
this problem by raising the limit for that request.

Needs more work to better identify the requests that need a different limit.

This is a Measurement Factory project.

Bug 3805: support shared memory on MacOS X in Mem::IPC::Segment

MacOS X doesn't support the O_TRUNC flag to shm_open; it is redundant anyway
because the shared memory segment is truncated immediately after opening
as per best practices. With this support Squid can now be built and run
under MacOS X.

Candidate for fixing MacOS SHM