Cleanup: update several CBDATA classes part 2

Removes several cbdataAlloc/cbdataFree by updating classes to use
CBDATA_CLASS2 macro..

FTP gateway: fix segfault during large file download.

FTP gateway: fix upload freezing for large files.

FTP gateway: upload support.

The patch adds support for FTP upload commands: STOR, APPE and STOU.

Do not broadcast changes if there are no remote readers.

New/future readers should anchor themselves to the cache in order to get the
earlier updates they missed.

Avoid "STORE_DISK_CLIENT == getType()" assertions for ENTRY_ABORTED clients
and no disk cache configured.

StoreEntry::abort() makes entry STORE_OK, which makes
storeClientNoMoreToSend() return false for entries with unknown objectLen(),
triggering a disk read for some of them (when store_client::doCopy() cannot
schedule a memory read). If the entry is not really on disk, we hit an
assertion in store_client::scheduleDiskRead().

Various fixes related to overlapping and collapsed entry caching.

Wrote Transients description, replacing an irrelevant copy-pasted comment.
Maintain proper transient entry locks, distinguishing reading and writing
cases.

Fixed transients synchronization logic. Store::get() must not return
incomplete from-cache entries, except for local or transient ones. Otherwise,
the returned entry will not be updated when its remote writer makes changes.

Marked entries fully loaded from the shared memory cache as STORE_OK.

Avoid caching ENTRY_SPECIAL in the shared memory cache for now. This is not
strictly necessary, I think, but it simplifies shared caching log when
triaging start-test-analyze test cases. The restriction can be removed
when ENTRY_SPECIAL generation code becomes shared cache-aware, for example.

Fixed copy-paste error in Transients::disconnect().

Changed CollapsedForwarding::Broadcast() profile in preparation for excluding
broadcasts for entries without remote readers.

Do not purge entire cache entries just because we have to trim their RAM
footprint. The old code assumed that non-swappable entries may not have any
other stored content (which is no longer correct because they may still reside
in the shared memory cache) so it almost made sense to purge them, but it is
possible for clients to use partial in-RAM data when serving range requests,
so we should not be purging unless there are other reasons to do that. This
may expose client-side bugs if the hit validation code is not checking for RAM
entries being incomplete.

Allow MemObject::trimUnSwappable() to be called when there is nothing to trim.
This used to be a special case in StoreEntry::trimMemory(), but we do not need
it anymore after the above change.

Added transient and shared memory indexes to StoreEntry debugging summaries.

Mark client streams that sent everything as STREAM_COMPLETE.

The old code used STREAM_UNPLANNED_COMPLETE if the completed stream was
associated with a non-persistent connection, which did not make sense to me
and, IIRC, led to store entry aborts even though the entries were not damaged
in any way.

This change may expose other subtle bugs, but none are known at this time.

See also:
  http://www.squid-cache.org/mail-archive/squid-dev/200702/0017.html
  http://www.squid-cache.org/mail-archive/squid-dev/201102/0210.html

Removed StoreEntry::hidden_mem_obj.
Replaced MemObject::url with MemObject::urlXXX() and storeId().

* Replace StoreEntry::hidden_mem_obj hack with explicit MemObject::setUris().
We need MemObject to tie Store::get() results to locked memory cache entries
and such but Store::get() does not know the entry URIs so we had to use fake
"TBD" URIs instead.  The hidden_mem_obj hack was added to minimize chances
that those temporary "TBD" URIs are going to be logged or forwarded.

However, new code uses MemObject cache ties a lot more, and it became too
cumbersome and error prone to always check whether there is a hidden object
holding indexes of locked StoreMap entries. It should be easier to ensure
that true URIs are set after Store::get() instead.

* Provide accessors for MemObject::url (which is actually a store ID these
days) and MemObject::log_url (which is usually the same as the url so we now
do not allocated it when it is the same). These accessors allow us to verify
that the caller is not going to use an undefined URI or Store ID because some
code forgot to set them explicitly.

* Add urlXXX() to mark old callers that appear to assume that MemObject::url
still holds a URI (instead of StoreID). Fixing those callers is outside this
project scope, but this was a good opportunity to identify/mark them because
we needed to hide raw Store ID field name ("url") anyway.

Fix Ip::Address::operator =(sockaddr_storage)

The memcpy() for AF_INET6 is using a length of sizeof(sockaddr_in) instead
of sizeof(sockaddr_in6), so squid was trying to connect to truncatured IPv6
addresses with strange ports.

Various shared memory-based collapsed forwarding improvements and fixes.

Lock transient entries while in use. Transient entry presence is used
used to detect collapsed entry aborts for not-yet-cached entries.

Store current transient locks and memory cache entry state in MemObject. Why
not in StoreEntry like the disk cache does?  To avoid penalizing those Stores
that keep idle StoreEntries in RAM.

Mark collapsing entries specially (in MemObject) so that we can stop updating
(un-tie) local entries that tried to collapse but did not like the collapsed
hit object that they started to get from another worker. When this happens,
the client side creates a new StoreEntry, but without a flag Store cannot tell
whether that entry needs to be kept in sync with the collapsed writer because
both the old entry and the new one have the same key. We may eventually find
a better way to distinguish the two cases.

Do not require MemObjects to be disassociated from various caches during
shutdown because Squid is currently incapable of maintaining Store::Root()
during shutdown.

Support incremental shared memory caching. Maintain and honor the
ENTRY_FWD_HDR_WAIT flag. Maintain shared memory cache reading/writing states.

Better updates of collapsed entries. Detect aborted entries. Do not release
entries that are not yet cached anywhere at the update time.

Polished entry debugging.

Bug 3480 fix.

Added XXXs to mark new problems and old bugs.

The path member can remain private.

Properly reinitialize reused acnhor.start and slice.size.

Since we allowed readers and [appending] writers to share an entry, it is
no longer possible to implement abortIo(). The caller must either close
the reading entry or abort the writing one, depending on the caller's lock.

Do not clear ENTRY_FWD_HDR_WAIT twice. It is cleared by replaceHttpReply().

Marked one spot where newly allocated Store::get*() entries are forgotten and
probably leaking.

Added debugging to allow automated store entry tracking during CF notifications.

Polished "queue overflow" error reporting.

Make !lock.readers and !lock.writers assertions safe.

The lock class used readers level counter to count both attempts to read and
current readers. The attempts part made assertions declaring that there should
be no readers unsafe because even a writing entry may have a reading attempt.
Same for writers counter: A reading entry may have a writing attempt.

We now segragate the attempts level, which is internal information required
for shared lock to work, from counting the number of successful attempts
(i.e., actual readers and writers), which is public information useful for
assertions, stats, etc.

Fixed ipc/Queue notification race leading to stuck, overflowing queues.

The writer calling OneToOneUniQueue::push() must tell readers if it places the
first item into a previously empty queue. We used to determine emptiness prior
to incrementing queue size. That created a window between wasEmpty calculation
and queuing the new item (by incrementing the queue size). During that window,
the readers could pop() all previously queued items (resulting in an empty
queue) but since that happened after wasEmpty was computed to be false, the
writer would not notify them about the new item it just placed, and they will
get stuck, eventually resulting in queue overflow errors.

The fix attempts to increment the queue size and extract the previous size
value atomically.

Redirector helpers related changes

- The redirectStateData handlers requires the HelperReply::Okay helper reply
  result code else will drop the helper reply, but we are always pass to them
  the HelperReply::Unknown reply result code

- The NotePairs are not support "=" operator. This patch replaces a such command
  using the NotePairs::append member, and also adds unimplemented private
  = operator and copy constructor to prevent developers from using it.

Integrate libTrie into squid build process

Merged from trunk

Cleanup: update several CBDATA classes

Removes several cbdataAlloc/cbdataFree by updating classes to use
CBDATA_CLASS2 macro..

Add Master Transaction class

... to store and propigate the shared state used end-to-end through Squid
for logging or server-side component input. This excludes Job and Call
pointers, but does include any 'factual' data regarding the traansaction.

Make sure %<tt includes all [failed] connection attempts.

The old code was using zero n_tries to detect the first connection attempt,
but n_tries is not incremented when we are opening a new connection rather
than reusing an old one. Perhaps n_tries should be updated differently as
well, but this change simply makes %<tt (hier.total_response_time) management
independent from that [complex] counter.

Sending root certificate for validation

This patch modify squid cert validation subsystem to sent to cert validator
helper the complete certificates chain, not only the certificates sent by
web server. This is may not be possible in all cases, for example  in cases
where the root certificate is not stored localy.

Also this patch includes a small optimization, it checks for domain mismatch
error only when the checked (current) certificate is the server certificate.

This is a Measurement Factory project

Deprecate log_icap and log_access configuration directives

The log_icap and log_access are not really needed to control requests logging.
Someone can use acls  with access_log and icap_log configuration directives
for this purpose.
Also currently the requests denied for logging using the log_access access list
will not be accounted for in performance counters.

This patch:
 - removes log_icap and log_access options from configuration file.
 - adds the "stats_collection" access list to control performane counters
   accounting.

This is a Measurement Factory project

SourceLayout: Add anyp/forward.h predefinition

Provide the AnyP:: namespace predefines to reduce dependencies.

Removed useless include compiler flags

Merged from trunk

LibTrie refactro: remove sub-configure invocation

Fix icap_log and log_icap acls checking

The HTTP reply related acls does not check for icap_log

Fix request headers logging for icap_log

The %http::>h does not print the original request headers but the adapted
request headers. Also the %http::>ha does not print adapted headers.

Fix wrong check inside Format::Format::assemble

We are checking for al->request but we are using al->adapted_request. This is
may cause crashes if the al->adapted_request is NULL.

Minor fix for cert validator helper messages parsing

Allow "host=" cert validation message parameter exist anywhere in the message.
Currently supposed to be always the first parameter of the message.

SourceFormat Enforcement

Support forwarding intercepted but not bumped connections to cache_peers.

When talking to a cache_peer (i.e., sending a CONNECT request before tunneling
the transaction), tunnel code is using a clever hack: Squid does not parse
the CONNECT response from peer but blindly forwards it to the client. This
works great and simplifies code a lot, except when the client connection
was intercepted and, hence, the client did not send a CONNECT request and
is not expecting a CONNECT response.

In those situations, we now accumulate, parse, and strip the peer CONNECT
response (or close connection on errors).

The existing tunnel I/O code is too simple to accommodate that task -- it
cannot accumulate read data (its I/O buffers work in lockstep fashion, writing
everything it reads before reading again). Instead of rewriting the entire
tunnel code to use more complex buffers, I added a temporary accumulation
buffer for the CONNECT response. That buffer is not allocated unless it is
needed and does not grow beyond SQUID_TCP_SO_RCVBUF size, just like the
simple buffers.

Bug 3722: Invalid markup in Armenian hy ERR_ONLY_IF_CACHED_MISS

Instruct clang not to treat unused command line arguments as errors

Release Notes: fix typo

Fix detection of concurrent ACLChecklist checks, avoiding !accessList asserts.

Concurrent checks are not supported, but it is possible for the same
ACLChecklist to be used for a sequence of checks, alternating fastCheck(void)
and fastCheck(list) calls. We needed a different/dedicated mechanism to detect
check concurrency (added ACLChecklist::occupied_), and we needed to preserve
(and then restore) pre-set accessList during fastCheck(list) checks.

Simplified MemObject::write() API.

The API required a callback, but the call was always synchronous and the
required callback mechanism could not reliably support an async call anyway.

The method adjusted the buffer offset to become relative to headers rather
than body. While the intent to separate headers from body is noble, none of
the existing caches support that separation, and a different API will be
needed to support it correctly anyway. For now, let's reduce the number of
special cases and offset manipulations.

Support "appending" read/write lock state that can be shared by readers
and writer. Writer promises not to update key metadata (except growing
object size and next pointers) and readers promise to be careful when
reading growing slices.

Support copying of partially cached entries from the shared memory cache to
local RAM. This is required for collapsed shared memory hits to receive new
data during broadcasted updates.

Properly unlock objects in the shared memory cache when their entries are
abandoned by a worker. This was not necessary before because we never locked
memory cache entries for more than a single method call. Now, with partially
cached entries support, the locks may persist much longer.

Properly delete objects from the shared memory cache when they are purged by a
worker. Before this change, locally purged objects may have stayed in the
shared memory cache.

Update disk cache index _after_ the changes are written to disk. Another
worker may be using that index and will expect to find the indexed slices on
disk. Disk queues are not FIFOs across workers.

Made CollapsedForwarding work better in non-SMP mode.

Polished broadcasting code. We need to broadcast entry key because the entry
may not have any other information (it may no longer be cached by the sender,
for example).

Implemented "anchoring" in-transit entries when the writer caches the
corresponding object. This allows the reader's entry object to reflect its
cached status and, hence, be able to ask for cached data during broadcasted
entry updates. Still need to handle the case where the writer does not cache
the object (by aborting collapsed hit).

Kill some old unused & unmaintained code for sending an error response

... on timeout before seeing a request

Ported from 2.7 rev.11516

SourceLayout: shuffle forward.h/cc to FwdState.h/cc

Our convenience libraries are using the filename forward.h for forward
declarations of symbols. This clashes with the old deprecated naming
of src/forward.h at times.

Rename the src/forward.* files to FwdState.* inline with current coding
guidelines and add a source maintenance check to avoid this problem in
future.

Fix configure with --disable-internal-dns compile error

dns.cc: In function variable_list* snmp_netDnsFn(variable_list*,s=nint*):
dns.cc:150:5: error: snmpDebugOid was not declared in this scope

SourceFormat Enforcement

Do not log bogus ERRORs when url_rewrite_access bypasses url_rewriter.

The code uses HelperReply() object as a fake reply when url_rewrite_access
ACLs did not match. That fake reply had Unknown result code, which made Squid
log ERRORs to cache.log. We now use Error result code, just like
store_id_access does.

TODO: Bypass the overheads of creating and processing a fake reply by moving
all post-processing actions and checks into a new dedicated method and calling
that method when url_rewrite_access does not match. Do the same to the StoreID
code.

basic_sasl_auth: Fix helper auto-detection

The helpers update in rev.12782 revealed SASL detection errors in the
use of ./configure script variables. This fixes the SASL library checks
and updates them to use the configure variable naming scheme.

Polished icap_service and ecap_service documentation.

Tying validation errors to certificates

When Squid sends errors to the certificate validation daemon, the daemon cannot
tell which certificate caused which error. This is especially bad because the
validator has to return that same information in the response (the response
format requires the validator to match the error to the certificate).
This patch adjust the validation request format to provide that information
using a set of the following key=value pairs:

    error_name_N=the name of the certificate error number N
    error_cert_N=the ID of the certificate which caused error_name_N

where N is non-negative integer. N values start from zero and increase
sequentially.

This is a Measurement Factory project

Redo r12887 (bug 2066 fix) which introduced several related bugs:

  - fatal() if chroot is given
  - no chdir to / after chroot if coredump_dir is given
  - wrong detection of "none" coredump_dir
  - chdir to uninitialized pathbuf if no chroot is given

This emergency fix helps Squid start better but may need more testing/work.

Fixed r12859 (Boolean ACLs) bugs related to ACL parsing and dumping:

- BoolOps.cc:94: "false" assertion when parsing ssl_bump directive.

- Infinite loop with RAM growth in dump_wordlist when dumping Squid
  configuration for cache manager.

- Segfault on not configured (nil) access lists in dump_acl_access.

SourceFormat Enforcement

Drop Ip::Address(Ip::Address *) constructor entirely

Has been deprecated for a while and appears to no longer be required by
any of the current code. The reference& copy-constructor can easily be
used in its place.

Fix NULL-dereference added in rev.12779

With the change of helper responses from Notes to NotePairs the errNote
in NTLM ERR/NA responses was altered to a potentially NULL char*, and
allowed to be printed in debugs() level 4.

This updated NTLM and Negotiate halpers to print the helper response as
"Result: ..." in identical fashion.

  Detected by Coverity Scan. Issue 1020655.

Bug 2066: squid does not do chdir() after chroot()

The earlier workaround applied only fixed 1 of the 3 places performing
chroot().
 This makes chroot and chdir integral parts of setting up Squids running
directory and alters teh chroot() calls to be mainSetCwnd() calls. Which
fixes several potential problems with core dumps from squid -z or -k
executions ending up in unexpected locations, regardless of whether
chroot() and coredump_dir are configured.

 Detected by Coverity Scan. Issue 740335.

Fix assert unsigned-vs-0 comparison

Nodes::size_type is unsigned and cannot be <0.

 Detected by Coverity Scan. Issue 1026516.

Fix string termination in snmplib

strncpy() does not null-terminate if the source string is larger or equal
to the destination buffer length.

 Detected by Coverity Scan. Issue 1025738.

Fix typo-omission in rev.12882

Fix basic_pam_auth helper detection

The m4_include() for this helpers test script was omitted from rev.12782.
Add that in, and shuffle the PAM-specific configure tests into the helper
required.m4 script.

Polish: update Ip::Address to follow Squid coding guidelines

* lower-case initial word for camelCase method names
* _ suffix for private variables.
* upper-case for static methods
* InitAddrInfo() and FreeAddrInfo() are static, do not use as methods

Not all methods are camelCased due to meaning irregularities and there
are other guidelines not being followed which also need to be fixed.

Merge from trunk

Prepare external_acl_type format codes for libformat upgrade

Add upgrade warnings for the %> and %< header codes which will change
radically in a future version when libformat is integrated.

Also, while we are at it support the other logformat codes which map 1:1
but silently for now and only on parse.

Fix incorrect external_acl_type codes

Documentation describes %USER_CA_CERT_* codes for outputing the CA cert
attributes. However the directive parser and internals were all
referencing it as %CA_CERT_*.

This updates the internals to match documentation, and adds an upgrade
notice for any installations using the old token name.

Add unit-test for char* copy-constructor

Support multicast DNS

Resolve .local domain names using mDNS one-shot queries ahead of regular
recursive DNS qeuries.

* adds the mDNS multicast group IPs as always-present entries in the
  nameservers list.

* filters each request. ".local" lookups are permitted to both the mDNS
  resolvers and the recursive resolvers, other requests are only
  permitted to the regular recursive resolvers.

Cleanup: remove several HTTPMSGLOCK/HTTPMSGUNLOCK

Convert the TunnelStateData and UrnStateData HttpRequest* to Pointer.

Release Notes: initial details for Store-ID and Annotations

Bug 3854: pt3: redo pt2 fix and revert rev.12587

The fix in rev.12857 works for Unix and Linux systems. But BSD based
systems it results in TextException errors via sub-includes from the stub

Fix typo in rev.12859

cbdataReference() is a macro with a design which means it requires usage
in the form of an assignment. ie a = cbdataReference(B); , or as a
parameter in equivalent to a variable.

Not using it in either of those manners results in syntax errors about a
',' from any strict compiler, and many older versions of GCC.

Polish: more debug info from squidclient

Add some missing includes

Cleanup: remove useless includes

Add missing include dlink.h for mem.cc

Cleanup: remove useless includes

Remove useless includes

Remove useless includes

Remove useless includes

Remove useless include

Made some of the Rock collapsing behavior dependent on collapsed_forwarding.

Do not write empty rock I/O buffer to disk.

Added more comments and polished.

Added BaseMultiQueue class, a common base of the old FewToFewBiQueue class and
the new MultiQueue class.

Added MultiQueue, a lockless fixed-capacity bidirectional queue for a limited
number processes. Any process may send data to and receive from any other
process (including itself). Used for collapsed forwarding notifications.

Added CollapsedForwarding class to send and handle received collapsed
forwarding notifications using MultiQueue.

Write partial Rock pages to disk in order to propagate data from the hit
writer to the collapsed hit readers. Send collapsed forwarding notification
after data was written to disk.

Missing code to share locked StoreMap entries, kick collapsed hit readers, and
to disable notifications in no-daemon mode.

Make GCC on CentOS 5.3 happier by removing an unused static function

parse_acl_access was unused when USE_HTTP_VIOLATIONS was not defined.

SourceFormat Enforcement

Make GCC on CentOS 5.3 happier by explicitly #including <sstream>
(used by aclParseAclList() template) in acl/Gadgets.h.

Make GCC on CentOS 5.3 happier by explicitly #including <sstream>
used by aclParseAclList() template.

Cleanup: Removed unused #include.

Cleanup: Removed unused #include.

Improve ACL handling. Support all-of and any-of ACL types.

This commit encapsulated many significant ACL changes, including:

* Expressiveness: Two new boolean ACLs (all-of and any-of) that allow
admins to group ACLs as needed, to express complex conditions more
naturally, with fewer squid.conf lines. Conditions such as "(a or b) and
(c or d)" are easily expressed now. Explicit groups of ACLs of different
types can now be configured, named, and used in any ACL expression.

* Correctness and performance: When a slow ACL (that has suspended
checks to wait for an async lookup) is ready to resume checking, Squid
resumes checking from that ACL, instead of rechecking all ACLs for the
same action (or the same squid.conf directive) again.

* Internals: Store ACL-related configurations as an expression tree,
streamlining the code and clearing the way for future math-style/natural
ACL conditions support. The usual boolean operators (and, or, and not)
form intermediate nodes while good old configurable ACLs become tree
leaves. The new all-of and any-of ACLs use the boolean operators (and
also become intermediate nodes, of course).

Addressed a few code styling XXXs.

Simplified prepNonBlocking() to address an XXX: Moved finished() check to
resumeNonBlockingCheck().

Merged from trunk (r12858).

SourceFormat

Fix build on Intel's compiler suite.

Forcing 64-bit file operations on 64-bit systems exposes
an issue in stdlibc++, which is covered by gcc but not by
icc in non-gcc mode. This patch prevents forcing 64-bit
file operations on systems where long int is 64-bit or more.
It also properly protects a couple of gcc-specific #pragma.

Bug 3854: pt2: link stub_fd with squidclient

AIX and possibly other systems still require fde:: symbols pulled in by
ip/libip. Link the stub since the symbols are actually in dead code.

Bug 3854: pt1: compile errors on AIX

SourceFormat Enforcement

Add IPC kid type for helper child processes

Enable length configuration for pipeline_prefetch queue

Updates the queue length magic numbers (2) by making pipeline_prefetch a
numeric queus length instead of aon/off toggle.

Also, adds configuration file consistency check for pipeline enabled
when client prsistent connections disable.

Merged from trunk (r12852).

Windows: include 'functional' before defining stdlib API wrapper functions

We currently use of #define to replace functions in the stdlib API with
versions which use the Windows API and error reporting.
Some of these result in precompiler replacement of systen internal
symbols. In this case member functions called bind() in templates of
<functional> API get replaced by Squid::bind() symbol.