run formatter

Fix comment about v23 ciphers

Also add the RFC links

Polishing fixes

 - Replace Handshake::details pointer with an always-available object
 - Replace Security::ProtocolVersion and its "int" representation in TlsDetails
   and NegotiationHistory classes with the existing Anyp::ProtocolVersion
 - Fix TlsDetails::compressMethod. The clients may send a compression methods
   list with a NULL compression method.
   Rename to TlsDetails::compressionSupported.
 - Other minor fixes.

Fixed header guard style.

Fixed lack of heartbeat detection.

Optimization: Spend less CPU and RAM on adjustSSL(). Speed gain: ~5%.

Do not store extension types just to iterate over them in adjustSSL().
Check for extension support while parsing instead. Since the list of
OpenSSL-supported extensions is constant (does not depend on the
connection), we do not need to create and index extension storage once
for each TLS connection; we now do it once per worker lifetime instead.

Use std::unordered_set instead of std::list for ciphers. Most real-world
cipher lists probably contain dozens of 2-byte entries, making std::list
storage a poor choice. Unlike TLS extensions, supported ciphers depend
on the connection so we have to store all of them to check whether each
stored cipher is supported for the SSL connection object created later.
Having an O(1) lookup speeds up that last check a lot compared to the
old linear search across all stored ciphers.

Do fast adjustSSL() checks before the longer cipher loop check.

Acknowledge TLS_EMPTY_RENEGOTIATION_INFO_SCSV pseudo cipher support.

Added TLSEXT_TYPE_signature_algorithms(13) and
TLSEXT_TYPE_next_proto_neg(13172) to the list of TLS extensions
supported by OpenSSL and recognized by Squid. Recognizing these
extensions is necessary for adjustSSL() to work in more real-world
cases.

Also sorted TLSEXT_TYPE_* entries and replaced "#if 0" code with a way
to build Squid to recognize more extensions as OpenSSL's list grows.

Finalized BinaryTokenizer context handling. Polished.

No more funny context fields inside TLS structures. Context is handled
by the parsing code without needlessly storing it long-term.

Hid TLS structures/parsers used exclusively by
Security::HandshakeParser inside security/Handshake.cc to simplify API.

Also skipped unused ServerHello.random (instead of storing it in
TlsDetails::clientRandom) and replaced SQUID_TLS_RANDOM_SIZE macro
with a regular C++ constant.

Stop parsing SSL records after a fatal SSL Alert.

The fatal alert sender should close the connection. Waiting for the next
record is pointless and will obscure the problem when we eventually read
the EOF on the socket.

Separated BinaryTokenizer commits from context debugging. Polished.

Commits are relatively rare events specific to incremental parsing. Most
parsers are not incremental and do not commit/rollback. However, all
parsers need to debug what they parse. Thus, it was wrong to combine
commits with context debugging.

BinaryTokenizer single-context debugging did not support nested contexts
(such as Hello.version.major) and reported wrong FieldGroup sizes for
some parsed structures. The new BinaryTokenizerContext does not have
these problems and is more general (but still needs more polishing
work).

Also polished many field names, comments, debug messages, and some code.

Simplified variable-length vector (our "PStrings") contents extraction.

Earlier code required the caller to first create a PString object and
then extract its .data field to get to the vector contents as an SBuf.
However, that approach just increased code and logging noise because
that SBuf itself (including SBuf.length()) is all the caller may need!

Fixed parsing of server-sent SNI.

The old code could not handle an empty SNI extension that most servers
send. RFC 6066 prose instructs servers to send empty SNI extensions, and
the formal SNI grammar is apparently client-specific. We are not the
only ones being confused by that because there are severs that send
empty ServerNameLists, which are actually prohibited by the grammar.

Fixed SNI parsing. The old code could only handle single-name SNI lists.

... and, hence, failed to parse empty SNI lists with misleading
"needMore" errors.

Be careful with parsed TLS handshake details. They may be missing.

TODO: Convert HandshakeParser::details pointer into an always-available
object?

Removed HandshakeParser::parseError and hid/renamed its parseDone.

The presence of two "persistent" parsing outcomes (done and error) was
confusing to the callers: Which one do I check and when? The adjusted
interface uses exceptions for errors and a false parseHandshake() return
value to signal "need more data". This simplifies the API and untangles
the calling code quite a bit.

Fixed "make distcheck".

Removed unused methods.

Fixed "make check".

Code polishing. No functionality changes.

Do not allocate TlsDetails until throwing isSslv2Record() returns.

If isSslv2Record() throws InsufficientInput, then we must re-parse these
first few bytes later. Nil details triggers that parsing.

Merged two identical methods together. No functionality changes.

Lack of data at EOF is a parsing error, not a "need more" condition.

Branch changes did not distinguish "need more and can expect more" from
"need more but got everything" situations. When one of the inner parsers
that deal with "complete" buffers failed, it would throw
InsufficientInput exception and the higher level parsing code would
interpret that as a sign that more SSL records/fragments are needed,
resulting in stuck transactions instead of parsing errors.

Unlike parsing errors, stuck transactions cannot be bypassed or ignored
so the difference is important.

Fixed "unused variable" compilation error.

Optimization/simplification: Do not parse unused challenge in v2 Handshake.

Also removed pointless commit() and #if-0d code.

Refactored and probably sped up ServerBio reading.

I could not grok the logic of the ServerBio::read*() methods and
saw strange cache.log message sequences like this:

  | bio.cc(121) read: FD 13 read -1 <= 65535
  | bio.cc(126) read: error: 11 ignored: 1
  | bio.cc(139) readAndBuffer: read -1 bytes
  | bio.cc(266) read: Pass 5 bytes to openSSL as read
  | bio.cc(121) read: FD 13 read -1 <= 65535
  | bio.cc(126) read: error: 11 ignored: 1
  | bio.cc(139) readAndBuffer: read -1 bytes
  | bio.cc(266) read: Pass 4 bytes to openSSL as read

Initially, they looked like we were [incorrectly] subtracting -1 from
some buffer length (read -1, pass 5; read -1, pass 4). Now, I believe
they [just] indicated unnecessary network reads. The fixed sequence
looks similar to this (note no network reads):

  | bio.cc(289) giveBuffered: Pass 5 read bytes to openSSL
  | bio.cc(289) giveBuffered: Pass 4 read bytes to openSSL

The refactored ServerBio code starts in "parsing" state (SSL Hello
parsing is the primary ServerBio functionality). Only when that parsing
is over, ServerBio starts feeding OpenSSL with received bytes. This
internal logic allows us to hide parsing from callers and avoid the
confusing public holdRead API.

The "hold write" conditions are not important enough for debug level 1.

... and are already reported at lower levels in ServerBio.

I was getting one of this messages for every(?) transaction in Polygraph
tests.

Fixed SSL server Hello parsing.

We must parse cipher and compression method before extensions.

Also fixed extensions detection to match RFC 5246 algorithm.

Record SSL client and SSL server details (supported TLS version/requested
TLS version) for fast-sni branch

Currently the fast-SNI-peek branch does not parse SSL client hello in
Client-First and Server-First bumping modes. This patch always "peeks" the
SSL client hello message and apply the squid TLS parser for Client-First
and Server-First modes to.

Also this patch moves the code which retrieves SSL server details from
PeekingPeerConnector class to PeerConnector class t retrieve details  for all
SSL server side connections.

fix comment

Cleanup and fixes

- remove uneeded members from classes
- Remove the TlsDetails object from ClientBio
- Enable SSL Server Hello parsing code
- remove uneeded code
- Fix bump client first and bump server first bumping modes

First fast-sni implementation

Squid parses incomming client SSL hello mesage, before create any openSSL
related structures and objects. After acl check at bumping step2.
Actually creating openSSL objects for client side still can be delayed
untill the server side is finishes. The only reason to create openSSL
structures imediatelly after step2 is to use openSSL to check for unsupported
comunications features and settings and fallback to spliceOnError.

Regression:
  Squid does not parses client Hello message in the case of bump-server-first
  and bump-client-first.
  The supported and requested SSL versions (i %ssl::>received_supported_version
  and %ssl::>received_hello_version formating codes ) can not be logged for
  these modes.

The code still needs cleanup.

Improve TLS/SSL parsing code in Handshale.cc and use it inside bio.cc for client
and server messages

  - full implementation for TLS and SSLv2 parsers inside Handshake.cc/h files
  - remove parsing code from bio.cc
  - Store parsed info in new Security::TlsDetails struct and remove the
    Ssl::sslFeatures class
  - improve SSLv2 parsing code.

First implementation for parsing SSLv2/v3 handshake messages and extracing SSL features

required fixes to PeerConnector to work with Ssl::ServerBio fixes

merge new SSL messages parser from lp:fetch-cert branch

Bug 4423: adding stdio: prefix to cache_log directive produces FATAL error

Bug 4459: move ssl_db into /var/cache/squid/

* auto-generates the man(8) page for this helper.

* moves the shared Makefile variables to Common.am

* updates the heper documentation to use the builds actual
  installed paths instead of hard-coding standard paths

Bug 4459: FHS compliance: move netdb.state to /var/cache/squid

Cleanup: de-duplicate HttpRequest CreateFromUrl functions

SourceFormat Enforcement

assertion failed: Write.cc:41: "!ccb->active()"

Bug description:
   - The client side and server side are finished
   - On server side the Ftp::Relay::finalizeDataDownload() is called and
     schedules the Ftp::Server::originDataCompletionCheckpoint
   - On client side the "Ftp::Server::userDataCompletionCheckpoint" is
     called. This is schedules a write to control connection and closes
     data connection.
   - The Ftp::Server::originDataCompletionCheckpoint is called which is
     trying to write to control connection and the assertion triggered.

This bug is an corner case, where the client-side  (FTP::Server) should
wait for the server side (Ftp::Client/Ftp::Relay) to finish its job before
respond to the FTP client. In this bug the existing mechanism, designed
to handle such problems, did not worked correctly and resulted to a double
write response to the client.

This patch try to fix the existing mechanism as follows:

- When Ftp::Server receives a "startWaitingForOrigin" callback, postpones
  writting possible responses to the client and keeps waiting for the
  stopWaitingForOrigin callback

- When the Ftp::Server receives a "stopWaitingForOrigin" callback,
  resumes any postponed response.

- When the Ftp::Client starts working on a DATA-related transaction, calls the
  Ftp::Server::startWaitingForOrigin callback

- When the Ftp::Client finishes its job or when its abort abnormaly, checks
  whether it needs to call Ftp::Server::stopWaitingForOrigin callback.

- Also this patch try to fix the status code returned to the FTP client
  taking in account the status code returned by FTP server. The
  "Ftp::Server::stopWaitingForOrigin" is used to pass the returned status code
  to the client side.

This is a Measurement Factory project

Bug 4458: Squid 4 behaviour change with external ACL arguments

Detect when a child method declaration hides parent's virtual method.

Adding -Woverloaded-virtual exposed one problem in the existing code.

Author: Eduard Bagdasaryan <eduard.bagdasaryan@measurement-factory.com>
Added ACL-driven server_pconn_for_nonretriable squid.conf directive.

This directive provides fine-grained control over persistent connection
reuse when forwarding HTTP requests that Squid cannot retry. It is
useful in environments where opening new connections is very expensive
and race conditions associated with persistent connections are very rare
and/or only cause minor problems.

Trying to avoid "looser throw specifier" error with Wheezy GCC.

AFAICT, the default CbdataParent destructor gets implicit
"noexcept(true)" specifier (because the default destructor does not
throw itself, and CbdataParent has no data members or parents that could
have contributed potentially throwing destructors). The AsyncJob child
uses a lot of things that might throw during destruction (the compiler
cannot tell for sure because we do not use noexcept specifiers). Thus,
the compiler has to use "noexcept(false)" specifier for ~AsyncJob, which
is "looser" that "noexcept(true)" for ~CbdataParent and, hence, violates
the parent interface AsyncJob is implementing/overriding.

I have doubts about the above analysis because many other compilers,
including GCC v5 and clang are happy with the default virtual
CbdataParent destructor. If my analysis is correct, then the rule of
thumb is: Base classes must not use "= default" destructors until all
our implicit destructors become "noexcept".

Improve class declaration consistency a bit. No functionality changes.

Use CBDATA_CHILD() instead of CBDATA_CLASS() to mark overridden methods.

TODO: If this works across the build farm, convert other AsyncJob kids.

Fixed clang -Winconsistent-missing-override warning.

AsyncJob classes can now use C++11 overrides as long as they use the new
CBDATA_CHILD() macro instead of old CBDATA_CLASS().

I have prohibited multiple CBDATA_CHILD() classes on the same
inheritance branch by adding the "final" specifier to toCbdata(). Such
classes feel dangerous because they may have different sizes and it is
not obvious to me whether the cbdata code will call the right size-
specific delete for them. We can easily relax this later if needed.

Bug 7: Update cached entries on 304 responses.

New Store API to update entry metadata and headers on 304s.
Support entry updates in shared memory cache and rock cache_dirs.
No changes to ufs-based cache_dirs: Their entries are still not updated.

* Atomic StoreEntry metadata updating

   StoreEntry metadata (swap_file_sz, timestamps, etc.) is used
   throughout Squid code. Metadata cannot be updated atomically because
   it has many fields, but a partial update to those fields causes
   assertions. Still, we must update metadata when updating HTTP
   headers. Locking the entire entry for a rewrite does not work well
   because concurrent requests will attempt to download a new entry
   copy, defeating the very HTTP 304 optimization we want to support.

   Ipc::StoreMap index now uses an extra level of indirection (the
   StoreMap::fileNos index) which allows StoreMap control which
   anchor/fileno is associated with a given StoreEntry key. The entry
   updating code creates a disassociated (i.e., entry/key-less) anchor,
   writes new metadata and headers using that new anchor, and then
   _atomically_ switches the map to use that new anchor. This allows old
   readers to continue reading using the stale anchor/fileno as if
   nothing happened while a new reader gets the new anchor/fileno.

   Shared memory usage increase: 8 additional bytes per cache entry: 4
   for the extra level of indirection (StoreMapFileNos) plus 4 for
   splicing fresh chain prefix with the stale chain suffix
   (StoreMapAnchor::splicingPoint). However, if the updated headers are
   larger than the stale ones, Squid will allocate shared memory pages
   to accommodate for the increase, leading to shared memory
   fragmentation/waste for small increases.

* Revamped rock index rebuild process

   The index rebuild process had to be completely revamped because
   splicing fresh and stale entry slot chain segments implies tolerating
   multiple entry versions in a single chain and the old code was based
   on the assumption that different slot versions are incompatible. We
   were also uncomfortable with the old cavalier approach to accessing
   two differently indexed layers of information (entry vs. slot) using
   the same set of class fields, making it trivial to accidentally
   access entry data while using slot index.

   During the rewrite of the index rebuilding code, we also discovered a
   way to significantly reduce RAM usage for the index build map (a
   temporary object that is allocated in the beginning and freed at the
   end of the index build process). The savings depend on the cache
   size: A small cache saves about 30% (17 vs 24 bytes per entry/slot)
   while a 1TB cache_dir with 32KB slots (which implies uneven
   entry/slot indexes) saves more than 50% (~370MB vs. ~800MB).

   Adjusted how invalid slots are counted. The code was sometimes
   counting invalid entries and sometimes invalid entry slots. We should
   always count _slots_ now because progress is measured in the number
   of slots scanned, not entries loaded. This accounting change may
   surprise users with much higher "Invalid entries" count in cache.log
   upon startup, but at least the new reports are meaningful.

   This rewrite does not attempt to solve all rock index build problems.
   For example, the code still assumes that StoreEntry metadata fits a
   single slot which is not always true for very small slots.

Documented some of the Packable API problems.

Do not prohibit updating Last-Modified on 304 responses.

RFC 7232 Section 4.1 says sending Last-Modified in 304 might be useful
and RFC 7234 Section 4.3.3 requires updating all non-Warning headers.

Added missing const qualifiers to HTTP message packing methods.

Removed SWAPOUT_WRITING assertion from storeSwapMetaBuild().

I do not see any strong dependency of that code on that state and we
need to be able to build swap metadata when updating a stale entry
(which would not normally be in the SWAPOUT_WRITING state).

The biggest danger is that somebody calls storeSwapMetaBuild() when the
entry metadata is not yet stable. I am not sure we have a way of
detecting that without using something as overly strong as
SWAPOUT_WRITING.

Fix memory leak of lastAclData

Cleanup: improved EUI debugging

Fix memory leak of HttpRequest objects

Cleanup: remove last goto in libsslsquid

Squid crashes on shutdown while cleaning up idle ICAP connections.

The global Adaptation::Icap::TheConfig object is automatically
destroyed when Squid exits. Its destructor destroys Icap::ServiceRep
objects that, in turn, close all open connections in the idle
connections pool. Since this happens after comm_exit has destroyed all
Comm structures associated with those connections, Squid crases.

This is a Measurement Factory project.

Implement sbuf/forward.h and use it

Make use of sbuf/forward.h

Sort sbuf/Makefile.am

add sbuf/forward.h

Rename files in sbuf/ to better adhere  to standards

Merged from trunk

Source maintenance

Rename sbuf/SBufList and sbuf/SBufStream

RFC 7725: Add registry entry for 451 status text

While Squid does not generate these messages automatically we still have
to relay the status line text accurately, and admin may want to use it
for deny_info status.

Bug 4447:FwdState.cc:447 "serverConnection() == conn" assertion, part2

Fix to allow make check  work again.

Bug 4447:FwdState.cc:447 "serverConnection() == conn" assertion

After certain failures, FwdState::retryOrBail() may be called twice,
once from FwdState::unregisterdServerEnd() [called from
HttpStateData::swanSong()] and once from the FwdState's own connection
close handler. This may result in two concurrent connections to the
remote server, followed by an assertion upon a connection closure.

This patch:

 - After HttpStateData failures, instead of closing the squid-to-peer
   connection directly (and, hence, triggering closure handlers), calls
   HttpStateData::closeServer() and mustStop() for a cleaner exit with
   fewer wasteful side effects and better debugging.

 - Creates and remembers a FwdState close handler AsyncCall so that
   comm_remove_close_handler() can cancel an already scheduled callback.
   The conversion to the AsyncCall was necessary because legacy [close
   handler callbacks] cannot be canceled once scheduled.

This is a Measurement Factory project.

Merged from trunk

Rename some files in sbuf/ and apply include paths consistently

SourceFormat Enforcement

Docs: release notes update

Cleanup: separate SBufStats from SBuf.h

Remove most *_DEPENDENCIES clauses from src/Makefile.am, they are not necessary

rename SBufStringConvert.h to StringConvert.h

renamed SBufExceptions to sbuf/Exceptions

renamed SBufDetailedStats.h to sbuf/DetailedStats.h

renamed sbuf/SBufAlgos.h to sbuf/Algorithms.h

Merged from trunk

SourceFormat Enforcement

Refactor SBuf into own library and simplify link time dependencies

Implement audit suggestions

Merged from trunk

avoid unnecessary SBuf copies

Fix include paths in some unit tests

avoid unnecessary SBuf copies

Improve documentation

Shuffle libbase in its proper order, fix formatting, remove some unneeded files

Removed spurious file in libsbuf SOURCES

Remove some _DEPENDENCIES declarations for unit tests

Removed unnecessary stubs from unit tests

Removed unnecessary stubs from unit tests

Bug 4450: wait() related cleanup

Docs: release notes about process manager changes

Bug 3826: Add --foreground option to fix -z process behaviour

Move SBuf<->String conversion to own header.

Remove SBUF_SOURCE from src/Makefile.am

Move SBufDetailedStats to src/sbuf

Bug 3826: SMP compatibility with systemd

** These changes require capabilities changes specific to Squid-4 and
   require systemd 209+

NOTE: 'squid -z' command does not yet support SMP with systemd.

Differences from the Squid-3 tools/systemd/squid.service:

- After=nss-lookup.target, for people running a local DNS server like BIND.
  Since there is no requirement dependency, it is a NOP when no such
  service is running.

- Type=forking and squid without -N in ExecStart: SMP now works.

- PIDFile=/var/run/squid.pid to tell systemd what pid is the main one. This
  is actually optional with Squid 4, because systemd will consider its first
  child as the main pid. But let's be safe. DEFAULT_PID_FILE could be used
  here with proper autoconf/automake magic...

- ExecReload calls kill rather than 'squid -k reconfigure'. systemd already
  knows the main pid.

- KillMode=mixed. The old KillMode=process sends SIGTERM (and SIGKILL after
  TimeoutStopSec) only to main daemon process. 'mixed' OTOH sends SIGTERM
  only to main process, but SIGKILL to all services' cgroup processes after
  timeout. With 'mixed' systemd ensures if daemon shutdown fails it will
  clean up all the remains. 'mixed' requires systemd >= 209.

4.0.7