Merged from parent (trunk r11379, v3.2.0.6+).

Polished shared memory initialization sequence, using RunnersRegistry API.

The master process is now responsible for initializing all shared memory
segments before starting kids. The kids do not create new segments and attach
to the already initialized segments instead. This approach may not scale for
ever, but it avoids more complex initialization synchronization via
Coordinator.

Do not use Strings for globals because current string memory pools do not
support early initialization.

Added RunnersRegistry, an API to register and, later, run a group of actions.

Useful for keeping general initialization management code (e.g., main.cc)
independent from specific initialization code (e.g., Ipc::Mem::Init) during
staged initialization and cleaning.

SourceLayout: namesapce for Auth::User children

Also, shuffle the resulting classes into their own compilation units.

No Logic changes.
Have omitted shuffling or altering two Auth::Basic::User methods handling
the validation short-circuit since these shodul not be part of that class.
Followup patch will move them appropriately.

Check the limit early in hope to catch cases when it becomes zero.
We could support maps with zero limits, but they should not be needed for now.

Increased page size to 32KB so that most typical responses would fit
until we support multi-page caching.

Made cumulative page size limit configurable via cache_mem.

Implemented Ipc::Mem::Limit().

Use size_t for cumulative shared pages limits instead of uint64_t
because cache_mem (Config.memMaxSize) is size_t.

Fixed comment typo.

Fixed shared memory cleanup code -- we were not returning freed pages to Pages.

Added Ipc::StoreMapCleaner API so that map users are notified when the slot is
about to be overwritten or freed. Users need a chance to update their state
(e.g., return the no longer used shared page) before the extra information in
the slot disappears.

Explain why we do not implement Icp::StoreMapCleaner API (yet).

Fixed how storeSwapOutStart() prevents repeated calls on failures.

We used to release the entry to signal that swapout is not possible. That hack
worked for disk caching, but it prevents nearly all memory caching because
released entries cannot be cached in memory.

A polished solution is to explicitly remember whether we made the decision to
allow or reject a swapout. The decision is now stored in MemObject::SwapOut.

Call StoreEntry::checkCachable() from StoreEntry::swapoutPossible(). This
allows us to make the decision sooner in some cases. Needs more work because
some checks in the two functions overlap and "too many files" checks in
checkCachable() should not be there at all.

Added an XXX for the checkCachable() call at the end of swapout. Out of this
project scope.

SourceFormat Enforcement

Fixed storeDirSelectSwapDirRoundRobin iteration for the "no cache_dir" case.

Moved [shared] memory cache stats reporting, addressing an old FIXME.

Added basic stats reporting.

Fixed Ipc::Mem::PageStack::theSize type to be signed.
Otherwise, unsigned zero theSize underflows in pop(), causing an infinite loop.

Polished debugging.

Fixed Ipc::Mem::Segment::reserve().
It was returning the pointer to the end of the reserved area.

Added debugging.

Fixed signed-with-unsigned compiler warnings.

Manager: send User-Agent header from cachemgr.cgi

Uses hard-coded string "cachemgr.cgi/" instead of progname to avoid
complications from alternative names and when running under a browser.

May be elided in transit however teh VERSION sent here will help the
queried proxy respond appropriate to the CGI capabilities as we extend
the types and content of reports coming back from the future releases.

SourceLayout: add missing CredentialState.h

Added initial shared memory cache implementation (MemStore) and integrated it.

Like Rock Store, shared memory cache keeps its own compact index of cached
entries using extended Ipc::StoreMap class (MemStoreMap). Like Rock Store, the
cache also struggles to keep its Root.get() results out of the store_table
except during transit.

There are several XXXs and TODOs that still need to be addressed for a more
polished implementation.

Eventually, the non-shared/local memory cache should also be implemented
using a MemStore-like class, I think. This will allow to clearly isolate
local from shared memory cache code.

SourceFormat Enforcement

Avoid creating unlocked store_table entries when handling rebuild conflicts.

Such StoreEntry objects persist until a hit locks and unlocks them (or the
replacement policy removes them?), creating SMP synchronization problems
because they are treated as in-transit objects even though their store slot
may be gone already.

Added TODOs to avoid creating unlocked store_table entries.

SourceLayout: namespace for Auth::User

No logic changes.

Import SN.png correctly as binary.

Re-fix icons/ FHS compliance

It seems I was working out of an outdated copy of the FHS.
Current standards describe /var/www as deprecated.

Reverting the icons location back to where it started.

SourceLayout: Shuffle InitAuthSchemes() to Auth::Init()

No logic changes.

SourceFormat Enforcement

Bug 3183: Invalid URL accepted with url host part of only '@'.

3.0 results in an ICAP segfault handling these URLs.

Newer releases do not segfault as easily, but still accept the invalid
URL and there may be other unknown side-effects.

Makes the URL parser present ERR_INVALID_URL for this edge case.

SourceLayout: namespace for Auth::Config children

No Logic changes.

Also, no code shuffling which should normally have been done with namespace.
Config children are currently too intwined with UserRequest children and
helper management. Logic changes are required before that can be done.

Portability: allow GnuRegex to use libcompat min()/max()

Portability: aio.h suffers from GCC-specific hacks on Linux 64-bit

64-bit file support on 32-bit systems uses GCC-specific #define to convert
the functions to 64-bit API but omits the struct aiocb passed as paremeter.

GCC seems not to mind, but non-GCC compilers barf on the invalid types.

SourceLayout: namespace for Auth::Config

Also renames symbol Auth::authConfig to Auth::ConfigVector to clarify
that it is a vector<> of Auth::Config objects or children.

No logic changes.

Split Rock-only Rock::DirMap into Rock::DirMap and reusable Ipc pieces
which a shared memory cache implementation can use:

Ipc::StoreMap is responsible for maintaining a collection of lockable slots,
each with readable/writeable/free state and a "waiting to be free" flag. Kids
of this class can add more metadata (in parallel structures using the same
index as primary slots). I tried extending the slots themselves, but that
turned out to be more complex/messy.

Ipc::ReadWriteLock is a basic multiple readers, single writer lock.  Its
earlier implementation inside Rock::DirMap mixed slot locking and slot
state/flags. That simplified the caller code a little, but the current simpler
class is easier to understand and reuse.

Rock::DirMap now just adds Rock::DbCellHeader metadata to Ipc::StoreMap slots.

Simplified mapping API by reducing the number of similar-but-different
methods. For example, instead of putAt, the caller can use an
openForWriting/closeForWriting pair. This helps with moving custom metadata
manipulations outside of the reusable Ipc::StoreMap.

It would be possible to split Ipc::StoreMap further by moving Store-specific
bits outside of its slots. Currently, there is no need for that though.

Added reserve() method to allow nested classes or similar related users of
the same segment to safely bite off pieces of the same shared segment. Still
need to convert the callers.

The reserve() method is useful for single-users as well because it allows
to check that a segment has enough bytes allocated for its single user.

Changed theSize type from int to "size of any single object in RAM" size_t.

Bug 3192: comm.cc:216: "fd_table[fd].halfClosedReader != NULL"
Polished request reading code to fix CONNECT double-read assertion.

ConnStateData::flags.readMoreRequests, do_next_read variables, and
ClientSocketContext::mayUseConnection() methods were used (or unused!)
incorrectly or inconsistently.

This change removes all do_next_read variables to simplify the state. Instead,
the renamed ConnStateData::flags.readMore indicates whether client_side.cc
should call comm_read. The mayUseConnection() methods are now used to indicate
whether the next client-sent byte (buffered or read) should be reserved for
the current request rather than being interpreted as the beginning of the next
request.

Usually,
                      flags.readMore  mayUseConnection
      basic requests:     true             false
requests with bodies:     true             true
  malformed requests:     false            false
             tunnels:     false            true

Portability: a bit more dirent_t in squidpurge tool

Bug 3194: selinux may prevent ntlm_smb_lm_auth from using /tmp

Bug 3185: 3.1.11 fails to compile on OpenBSD 4.8 and 4.9

Portability: and dirent_t also only matters for non-GCC.

Portability: dirent_t cannot be a typedef

SourceFormat Enforcement

Used one-for-all constant page size for now; need to be made configurable.

Fixed raw page buffer type.

Portability Fix: getrlimit() / setrlimit() incompatible type 'struct rlimit'

On Linux (at least) with large file support but not full 64-bit environment.

The getrlimt / setrlimit are #define'd to getrlimite64 / setrlimit64
BUT, the struct rlimit internal fields are updated to 64-bit types individually
instead of a matching #define to struct rlimit64 as a whole.

One can only assume that GCC is casting to void* or some such major voodoo
which hides this type collision.

Portability: glob.h requires GCC to compile on Linux.

Enable MemBlob to use the services of MemPools.

Ensure that MemBlobs use MemPools manage memory areas, and remove
duplication of code with MemPools.

ICC: size_t is guaranteed to be >=0

ICC: support 64-bit environments dirent definitions

struct dirent is not consistently defined for 32-bit and 64-bit enabled
environments. Provide a dirent_t type defined appropriate to the environment
for use instead.

Fix ModPoll signedness checks

This npending test bug was preventing any poll() errors from being
noticed and displayed. Possibly leading to some of the weird hanging
reports we have been unable to replicate.

SourceFormat Enforcement

Extend the number and size of String MemPools

Define and enable 512-bytes, 1kb, 4kb and 16kb mempooled strings
to cover expected upcoming uses

Fixed chunked request forwarding in ICAP REQMOD presence.

ICAP prohibits forwarding of hop-by-hop headers in HTTP headers. If the virgin
request has a "Transfer-Encoding: chunked" header, the ICAP server will not
receive it. Thus, when the ICAP server responds with a 200 OK and what it
thinks is a copy of the HTTP request, the adapted request will be missing the
Transfer-Encoding header.

One the server side, Squid used to test whether the request had a
Transfer-Encoding header to determine whether request chunking is needed when
talking to the next HTTP hop. That test would fail in ICAP REQMOD presence.

This change implements a more direct/robust check: if we do not know the
request content length, we chunk the request.

We also no longer forward the Content-Length header if we are chunking. It
should not really be there in most cases, but an explicit check is safer and
may also prevent request smuggling attacks via Connection: Content-Length
tricks.

Portability: Provide stdio wrappers for 64-bit in cstdio C++ builds

stdio.h in that case on provides fgetpos64, fopen64 if
__USE_FILE_OFFSET64 is defined. It then checks whether a gcc-specific
 __REDIRECT macro is available (defined in sys/cdefs.h, depending on
__GNUC__ begin available).

If it is not available, it does a preprocessor #define.

Which <cstdio> undefines, with this comment:
 "// Get rid of those macros defined in <stdio.h> in lieu of real functions.".
When it does a namespace redirection ("namespace std { using ::fgetpos; }")
it goes blam, as fgetpos64 is available, while fgetpos is not.

To fix it, we need to supply global functions matching those
signatures (not macros).

e.g.

#include <stdio.h>
#if defined(__USE_FILE_OFFSET64) &&!defined(__REDIRECT) && defined(fgetpos)
#undef fgetpos
int fgetpos (FILE * f, fpos64_t *p) { return fgetpos64(f,p); }
#endif
#include <cstdio>

This every time we use <cstdio> (directly or indirectly).

This is triggered by us defining -D_FILE_OFFSET_BITS=64 when
--enable-large-files configure is used.

Initial shared memory pages implementation.

Enable string mempools to work correctly during initialization phase

Makes string mempools work before Mem::Init() was called, as may happen
during global variable initialization or early main.cc processing. If
needed, strings allocated before the Mem::Init() call are given an extra
buffer space to make sure the allocated buffer size will not match any
string pool size during deallocation.
Shortcomings: We now waste RAM on buffer increase for early allocated
strings unless they are already bigger than the maximum supported string
pool size. Statistics for early allocations are broken. Non-string
mempools still do not support early allocations.

Fixed %dt logging in the presence of REQMOD.

We use LogEntry::request to save a virgin request for future logging. However,
when that request is adapted and replaced, the adapted request has all the
stats while the saved virgin request lacks them. We have already copied error
details from the adapted to logged/virgin request. Now we copy the DNS wait
time (%dt) as well.

TODO: Move statistics to a stand-alone history object that adapted and
virgin requests can share. Longer term, we should separate HttpRequest
from Master Transaction so that we can store virgin request details without
implicitly storing not-yet-collected master transaction stats.

Polished adaptation_send_client_ip and adaptation_uses_indirect_client docs.

Display ERROR in cache.log for invalid configured paths

The validator that checks system paths for files and directories in the
configuration file sends error messages to stderr. It should send them to
cache.log for the admin to see easily.

Also, this makes the error display as FATAL ERROR when using -k parse to
indicate that it is fatal to the startup. Other management signals where
it is not necessarily fatal will only display as an ERROR.

Docs: clarify delay_parameters

Propagate pre-processor directives from enum definition to strings definition

This allows enum to contain conditional entries and build without them.

Typos in 3.1 release notes

Prep for 3.1.12 and 3.2.0.6

Simulate DIRECT tunnel to origin peers on CONNECT

Within reason. Check that at least the port matches. That gives us some
small measure of reason to believe its the same protocol inside or the
same app being CONNECTed to.

Provided a better description for the stack index updating step.

Optimization (performance regression fix): Use bigger buffer for server reads.

Change the server read buffer limits to 16KB minimum and 256KB maximum.
Used to be: 2KB and 2GB. And before r9766: 4KB and SQUID_TCP_SO_RCVBUF.

Trunk r9766 (Remove limit on HTTP headers read) made the default HTTP
server read buffer size 2KB instead of 4KB, visibly slowing down Squid
when kernel network buffers are full and can sustain larger Squid reads.
Doing up to twice as many network reads is expensive (and probably not
just because of the extra system call overheads).

We never grow that buffer size if the _parser_ does not need a bigger
buffer:  Even if the HTTP client is slower than the server, the buffer
stays small because it gives all the data to Store and Store eventually
just stalls reading via delayAwareRead() and read_ahead_gap. The
situation may be different with RESPMOD, but if the adaptation service
is fast, the buffer would still not grow.

This change does not reset the minimum buffer size to the old 4KB
default because memory is much cheaper compared to the days where that
default was set. 8KB may have worked too, but with 12KB median typical
response size a larger buffer may be a good idea for a busy Squid. More
performance work is needed to find the optimal value (which could depend
on the environment).

This change does not set the maximum buffer size to the current 2GB
limit because we have not tested how header and chunking parsers would
cope with malicious messages trying to run Squid out of RAM; and also
because no good parser should need that much lookahead space. Is 256KB
enough for all legitimate real-world response headers? We do not know.

It is tempting to use Config.tcpRcvBufsz or SQUID_TCP_SO_RCVBUF to find
the right minimum or maximum buffer size, but those parameters deal with
low-level TCP buffering aspects while this buffer deals with HTTP
parsing.

Log all transactions including those with uncertain status or no sent response.

Excluding those transactions from access log hides valuable information.

For example, it hides certain aborted client transactions which sometimes
indicate Squid bugs or configuration problems that the administrator can fix.
It also leads to wrong statistics reporting if the reporting tools are based
on access logs information.

The change just removes the logging guard and adds debugging. The logging
code itself is unchanged except for indenting.

Release Notes: add missing text about changes to range_offset_limit

Bug 3007 (extra): Set 500 status on peer proxy connection failure

rev11299 avoided 000 status, but ignores the error cases and always sends
200 success.

TODO:
Proper handling of the error cases to allow peer failovers is now possible
but not included in the scope of this patch.

Added initial API for managing shared memory cache and its shared memory pages.

Default constructor for HttpParser

rev11314 added an no-op default constructor. But that could allow creation
with broken state.

Add a clear() function to perform the default constructor initialization.
That can also be shared by the other init code.

Moved ipc/SharedMemory to ipc/mem/ and renamed it to Ipc::Mem::Segment.

All IPC things are "shared" by default.

The new name is also more specific because there are other shared memory
structures such as queues and stacks (all using shared memory segments
internally though).

Initial implementation of atomic container for free page numbers in a segment.

Added initial __sync_fetch_and_and support.

SourceFormat Enforcement

Optimization: Do not create adaptation history to check whether it is empty.

Do not send signals from the master process to parent on shutdown.

Trunk r11330 introduced a bug: When running in non-daemon mode, Squid
sends SIGUSR1 signal to the parent process on shutdown.  This results in
shell (at least zsh) exit when Squid is interrupted with C-c. The patch
adds a check to prevent the master process from killing it's parent on
shutdown.

Same check added for the kill-parent hack.

If a worker process crashes during shutdown, dump core and prevent restarts.

Before the change, if a worker process crashes during shutdown, death()
handler would exit with code 1, and master process would restart the
worker. Now workers send SIGUSR1 to master when shutting down. When
master process gets the SIGUSR1 signal, it stops restarting workers.

SIGUSR1 is already used for log rotation, but it is fine to use SIGUSR1
for master process shutdown notifications because master is never
responsible for both log rotation and kid restarts.

Terminate with abort(3) instead of exit(3) to leave a core dump if Squid
worker crashes during shutdown.

Also the patch fixes potential infinite loop in master process. Master
used to finish only when all kids exited with success, or all kids are
hopeless, or all kids were killed by a signal, but when some kids are
hopeless and others were killed, the master process would not exit.
After the change, master exits when there are no running kids and no
kids should be restarted.

Add syslog notice if kid becomes hopeless.

Better reporting of REQMOD failures during body processing.

When REQMOD body processing fails, the server-side needs to abort the
in-progress transaction. Use HTTP 500 (Internal Server Error) instead of 502
(Bad Gateway) status code and a new custom error detail for this case.

There is no perfect status code for ICAP errors because some view ICAP
processing as an integral part of the proxy (closer to the internal
proxy code) and some treat it as an external entity (closer to an
"upstream" web server).

Nevertheless, 502 (Bad Gateway) feels like a worse fit because from web
user and traffic flow point of views ICAP is less of a "gateway" or
"upstream" server than it is an "internally" used auxiliary service.
When both status codes were used, we have received reasonable complaints
about 502 responses but not (IIRC) about 500 responses.

Using custom error detail is better than errno in this context because
errno is often not set for ICAP errors and because by the time we
generate an error, the errno value is likely to be from a different
system call error anyway.

Instead of exiting, disable optional eCAP services that fail initialization.

Report all service initialization failures but mark optional services
down instead of killing Squid by propagating the failure to the Squid
core.  An initialization failure of an optional (bypass=1) service
should not lead to Squid quitting because, according to squid.conf, such
a service may be replaced by other services (using adaptation sets) or
simply ignored.

Initialization failures of essential services still lead to fatal
errors, but they are now reported better.

Ecap services should indicate failures by throwing an exception. Squid
reports exception details using std::exception::what() method if
possible.

Support dynamic adaptation plans that cover multiple vectoring points.

The dynamic adaptation plan is specified using X-Next-Services ICAP
header or eCAP meta-info, as usual. A REQMOD adaptation service may
construct an adaptation plan that starts with REQMOD and ends with
RESPMOD. Multiple adaptations may be planned at each point.

The natural transaction handling order must be preserved: the plan
cannot go from RESPMOD back to REQMOD.

Adaptation::History object is used to keep future plan steps when
crossing vectoring points.

Use prefix increment in place of postfix where appropriate in mem.cc

Include iosfwd instead of ostream in Mem.h

Port 2.7: logformat tag for logging the outgoing IP address (tcp_outgoing_address)

This adds the log format to log the local IP address used on outgoing
connections to peers and servers. Squid-2.7 called this %oa.

However it is a perfectly matching part of the existing set of %la and
%lp (local inbound) and %<lp (local outbound port).

As such, the %oa is accepted as input for backward compatibility, but the
Squid-3 version is: %<la

This is based only very loosely on the Squid-2 %oa work by Andrew Atangulov

SourceFormat Enforcement

ext_edirectory_userip_acl: Update to version 2.1

SourceLayout: namespace for Auth::Scheme top layer

Also, rename Scheme::done() to shutdownCleanup() - naming it for what it
actually does rather than when to call it.

Also includes the typo fix for revno 11319 basic auth child.

Bug 3170: "Unsupported or unconfigured/inactive proxy-auth scheme" on shutdown

SourceLayout: (Bug 3170) namespace for Auth::Scheme and children

Also,
 * fix digest shutdown process so AuthDigestConfig does the config cleanup
   and Auth::Digest::Scheme does the scheme termination
 * fix all schemes shutdown to silence scheme messages (partial bug 3170)

Cleanup: global/static function or methods should start from capital letter

This patch renames the getErrorName and getErrorDescr to GetErrorName and
GetErrorDescr

%D details for documented OpenSSL errors

This simple patch provide %D details for all errors documented at
http://www.openssl.org/docs/apps/verify.html

Also this patch add a std::map structure to optimize the ssl error description
retrieval.

This is a Measurement Factory project

SourceLayout: build auth sub-libraries in abstraction

This changes the building process for auth sub-libraries:
 libbasic.la, libdigest.la, libnegotiate.la, libntlm.la
making them build from their own Makefiles.

That allows each sub-dir to be automatically included (or not) to the main
auth/libauth.la library.

TODO: (no necessarily in this order)
 * split out the classes into their own compile units (files)
 * add namespace Auth and per-protocol child areas
 * de-duplicate the repetitive code back into the parent classes

Cleanup: rename auth Config::authenticate to Config::authenticateProgram

Making it a bit clearer what this member actually is.

Cleanup: make clientParseRequest() a member of ConnStateData

This allows the HttpParser to also become a member field and persistent
across all requests on the connection instead of newely allocated on
the stack for every read cycle.
That in turn allows the parser to retain state for efficient 'trickle'
parsing across multiple read cycles.

For now the old behaviour of reset on every read is retained in order to
prevent this shuffling from causing behaviour changes. That negates most
of the actual performance gains (for now).

Fix stdio: log module segfaults on rotate

The stdio module was still assuming old format for the parameter.

 * update the parser to detect old format and upgrade-warn.
 * update the stdio module to ignore the stdio: prefix on its parameter

Regression fix: Replacing reply headers

Restores the functionality to replace reply headers as found in Squid 2.
header_replace worked for both request and reply headers back then.

The creation of request_header_access and reply_header_access altered
replace_headers to only work on requests. It should have received this
name split back then.

TCP log: flush stream on every line

TCP logging has a buffer which can catch log traffic peaks.
per-line flushing is required to prevent the log data accumulating under
low loads.

basic_ldap_auth: error message for missing credentials

Bug 3173: Assertion bodyPipe!=NULL on SslBump CONNECT response writing failure

Do not call ConnStateData::startClosing() when we fail to write our CONNECT
response while bumping a connection. startClosing() can only be used when we
handle response bodies. Just close the connection, in hope that the connection
close handler kicks in and cleans up.