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.

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.

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.

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.

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.

Regression fix: upgrade existing icons

This adds an automatic upgrade to move the old pre-3.2.0.5 icons into the
new icons area.
This also retains any local customizations that may have been done,
ie. new icons added outside Squid.

signal.h is required before defining SA_* macros

uncovered by LZZ precompiler.

ICC: useless code removals

size_t is guaranteed to be >=0 so these checks are useless.

Also some optimization of the tunnel and whois comm result handling after
the size_t test changes.

Bug 3181: /dev/poll fails to build on Solaris with GCC 4.5.0

Made cache.log less noisy about usually benign events outside of admin control.

Raised reporting level from 1 to 2 for 'statusIfComplete: Request not yet
fully sent' and 'clientProcessRequest: Invalid Request' messages after
observing important information drowning in their noise on busy proxies.

Propagate details of ICAP errors happened after adapted HTTP header creation.

We used to update the virgin HTTP request with error details even after REQMOD
resulted in creation of a new/adapted HTTP request object. When the client
side replaced the old/virgin request headers with the new adapted request
object, the error details were lost and %err_detail was not logged to the
transaction log.

This is one more place where a Master Transaction object (with a shared error
detail field) should be extracted from the HttpRequest and persist throughout
the HTTP transaction lifetime.

ICC: dead code removal

Further eCAP startup message polish

Not all time-based options should accept milliseconds

After last changes, squid  accepts "millisecond" units for all time-based
options, silently rounding millisecond-based values down if they are not
supported. We should not allow millisecond units for options that do not
support millisecond.
This patch add the allowMsec parameter to parseTimeLine function to allow/deny
the use of milliseconds.

Bug 3007: CONNECT to cache_peer returns 000 status code

SourceFormat Enforcement

Remove useless checks and debug. size_t is guaranteed to be signed

Detected by ICC.

Language: hy\n

Bug Fix: Squid may crash, when accessing an SSL certificate with errors

This is a security bug.
The bug report is:
   When accessing a revoked certificate (i.e., X509_V_ERR_CERT_REVOKED) Squid
crashes. In ssl/ErrorDetail.cc:223 the detailed message is left blank if the
error is not specifically handled by Squid and the errorpage.cc:1193 assertion
fails while trying to convert the message.

This patch:
 - Handle inside ErrorState::Convert the cases where the ErrorDetail return
   blank error detail string
 - Use a default  detail error message in ssl::ErrorDetail, for the cases
   where the detail error is not defined in TheSslDetailMap.
 - If a name for the ssl::ErrorDetail error code is not defined return the
   numeric error code when the "%err_name" formating code used

Wrap time_msec parse functions properly

Parsers complain about unused functions.
These are currently only used by code wrapped in !USE_DNSSERVERS.

SourceFormat Enforcement

Bug fix: Fix a formating code: should be %ssl_subject not %subject

Change the default dns_timeout value from 2 minutes to 30 seconds

The related squid-dev discussion is here:
  http://www.mail-archive.com/squid-dev@squid-cache.org/msg15152.html

Convert dns_timeout and dns_retransmit_interval configuration options to use millisecond resolution.

One second resolution is too coarse for small timeouts in delay-sensitive
environments, especially when a retransmit, bypass, or another corrective
action is available and is likely to produce a positive outcome. In DNS world
specifically, most timeouts are measured in milliseconds.

This is a Measurement Factory project

Bug 3175: IPv6 PTR lookup crashes on raw-IP URLs when IPv6 disabled

negotiate_kerberos_auth update to version 3.0.4sq

Fixes a minor error in printing gss errors

ext_kerberos_ldap_group_acl version 1.3.0sq

Remove redundant FTP/Gopher checks

Identified by ICC.

ICC build issue in ConnStateData::getConn

ICC complains about:
"type qualifier on return type is meaningless
      inline ConnStateData * const getConn() const;
"

I believe this is const-correct. The incorrect version would be "& const"
But there is no harm in combining the two getConn() methods.

SourceFormat: Moved Adaptation::Answer class to its dedicated source files.

Moved AccessLogEntry.headers.adapt_last to AccessLogEntry.adapt.last_meta

Added AccessLogEntry::AdaptationDetails to keep general adaptation-related
fields together and away from the HTTP fields.

Fixed propagation of eCAP transaction meta-information to core Squid
by synchronizing the history of the virgin and eCAP-adapted/cloned request.

If the request history is created after the request got cloned, the cloned
request will have no history unless we explicitly import the newly created
history. Hopefully, it is not possible for the cloned request to get its own,
diverging history before the import (we check and throw if that happens).

This is one more example why a MasterTransaction class (with history) needs
to be extracted and separated from the HttpRequest class.

Polished SGML formatting.

Documented changes related to libecap v0.2.0 support.

Grouped methods related to the same API and documented which API they implement

Report eCAP service [re]start to cache.log by default.

Reporting eCAP services may be important, especially since we have no other
interface to detect their presence and since folks will have to deal with
rogue services eventually.

Also raised eCAP service configuration notice level to 2.

Fixed send_username typo. The correct option name is adaptation_send_username.

Expand Makefile sources macros

Expand several macros used in earlier attempts to omtimize the Makefile
content. With the SourceLayout and modular changes underway these are
proving to be more of a problem than they are worth.

At some future time when the convenience libraries are settled it may be
worth revisiting some shared lists. But not yet.

SourceFormat Enforcement

Apply uri_whitespace before logging malformed requests

This patch try to implement  the first option from those described at the
squid-dev thread with subject "Request URI logging for malformed requests":
  http://www.squid-cache.org/mail-archive/squid-dev/201101/0004.html

Currently the logged URI set using the setLogUri method (in client_side.cc and
client_side_reply.cc files). Also the setLogUri called at least two times for
every normal request. Moreover the setLogUri always check if the URI contains
characters which must escaped which in the case of normal requests it is not
needed because urlCanonicalClean always used before pass the URI to setLogUri.

This patch:
 - add a parameter to the setLogUri to say if the URI must cleaned and the
   uri_whitespace filtering must applied.
 - Remove the setLogUri call from the parseHttpRequest.
 - Call in all cases (HTTP request error or not) the setLogUri in
   clientProcessRequest
 - In the case the URL is not a valid HTTP request applies the uri_whitespace
   filtering.
 - In the case the URI is valid the uri_whitespace filtering is not required
   because it is already applied by the urpParse function.

This is a Measurement Factory project

proto ACL overly verbose on "Ignoring unknown protocol"

Minor logic error in display. No actual operational effects.

SourceFormat Enforcement

Support libecap v0.2.0; fixed eCAP body handling and logging.

Summary of changes:

libecap v0.2.0 support: accept/update/log eCAP transaction meta-info.
libecap v0.2.0 support: supply client IP and username to eCAP adapter.
libecap v0.1.0 support: Support blockVirgin() API with ERR_ACCESS_DENIED.

Use pkg-config's PKG_CHECK_MODULES to check for and link with libecap.

Support adapter-specific parameters as a part of ecap_service configuration.
Allow uri=value parameter when specifying adaptation service URIs.

Fixed virgin body handling in our eCAP transaction wrapper (Ecap::XactionRep).
Fixed BodyPipe.cc:144 "!theConsumer" assertion.

Log "important" messages from eCAP adapters with DBG_IMPORTANT not DBG_DATA!

Added XXXs to identify old unrelated problems to be fixed separately.

Merged from parent (trunk 11270, circa 3.2.0.5+)

Give full Request-URI to eCAP adapters.

Implement libecap::RequestLine::uri() to return full Request-URI instead
of URL path.

Niether full URL nor URL path is perfect because the actual request may
have full URI or a path, but Squid does not really keep that
information. This change makes our eCAP implementation consistent with
our ICAP implementation.

Eventually, eCAP may have an API that is guaranteed to return full
Request-URI and Squid may remember what kind of URI it got in the virgin
request, allowing for a more truthful implementation.

Bug 2621: Provide request headers to RESPMOD when using cache_peer.
A short-term fix.

When FwdServer::_peer is set, HttpStateData constructor creates a new special
HttpRequest, overwriting the request pointer set in the parent
(ServerStateData) constructor to fwd->request.

To make matters worse, this special peer request has no headers at all (even
though flags and some cached/computed header values are copied). We initialize
it with the right URL, method, and protocol. We copy flags and a few other
random properties from the original request. We never copy the original
headers.

Furthermore, regardless of the peering, when we create the headers to send to
the next hop, those headers are temporary and not stored in any request
structure (see HttpStateData::buildRequestPrefix). The non-peering code
survives this because the request member points to fwd->request, which has the
headers. The peering code fails as illustrated by this bug.

I believe both cases are buggy because server-side adaptation and core code
should have access to the request headers we sent rather than the request
headers we received and adapted (or no headers at all). After all, it is the
sent headers that determine the next hop view of our Squid and adaptation
services should see a pair of _matching_ request and response headers.

I am pretty sure there are other bugs related to HttpStateData using a special
peer request structure instead of fwd->request. Please note that FwdState has
no idea that this substitution is going on.

This quick short-term fix uses the original request and its headers when
checking RESPMOD ACLs. This is what the patch in bug #2562 did for Squid v3.0.
For the reasons described above, this patch may be either insufficient or
wrong for the long-term fix.

Import external libecap in adaptation/ecap/, where it belongs.
Either we finally found the working combination of libtool variables or the
previous attempts were failing due to libtool confusion over leftovers in
the build directory (or we will discover more build failures later!).

Polished libecap-related Makefile variable names based on squid-dev review.

Polished to address Squid Project review comments.

IDNS missing casts

Make DNS report failure on all packet construction errors

The attached patch alters the DNS lookup behaviour to abort with an error
in ALL cases where the rfc1035 library generates an error (negative result).

I'm not sure there is any noticable effect other than better code. The
error case *should* in old code be picked up on the initial packet
construction rather than the repeat packet. This may have been incorrect
given that the packet type is changing between A/AAAA.

Bug 2976: invalid URL on intercepted requests during reconfigure

Listening ports abuse the cbdata type as a pseudo refcount. This breaks
during reconfigure when the config is erased and the active requests
handles all become invalid pointers.

Interception only works on HTTP protocol. We can hard-code the scheme
and avoid this problem until a complete fix is written.

SourceFormat Enforcement

RFC 1738 encoder upgraded action flags

This updates the encoder flags parameter to allow selection of individual
character sets of CTRLS, UNSAFE, and RESERVED.

Also, to permit selective omission of the % and space characters from the
UNSAFE set.

Also, an optimization is added to skip SAFE characters on a short-circuit.

SourceFormat Enforcement

Bug 2885: Compile errors on AIX

Support AIX unusual definition of in_addr/in6_addr unions.

Fix typos and missing if in libTrie inline support.

Correct debug statement about non-IPs on parse

Bug 2965: Compile errors on MinGW

SourceLayout: protocol_t upgrade fix

The proto acls does not work due to a mistyped strcasecmp if check

Fix Solaris warning: strands hides Ipc::Inquirer::strands

SourceFormat Enforcement

Add support for parameterized Cache Manager queries, compile errors fix

The regex.h file if required included in compat.h file, must not used directly
in squid sources

Update PROTO_CACHEOBJ to PROTO_CACHE_OBJECT name

Also catches several eCAP uses which were missed.

Add support for parameterized Cache Manager queries fix warnings in CentOS 5.3 amd64

Add support for parameterized Cache Manager queries.

Currently, one sends mgr queries to the "whole" Squid. Kids responses may get
aggregated by Coordinator, and we, in general, want to aggregate all responses
that can be aggregated.

This patch allow us to aggregate stats for a subset of kids. For example,
the following query aggregates stats for just the first and the third workers:

    mgr:info?workers=1,3

When query response information cannot be aggregated (or at least is not
aggregated right now), then a parameterized query will result in several
matching "byKid { ..." blocks.

This patch support the following scope variants:

    * raw interface with access to any kid process or groups of kids; similar
      to ${process_number} macro we already support in squid.conf:
          mgr:foo?processes=id,id,id...
    * higher-level interface to isolate workers by their numbers, starting
      with 1 for the first worker:
          mgr:foo?workers=num,num,num...

Currently, all kids except Coordinator are workers, but that will change in
the future as we get more kinds of kids.Currently, one sends mgr queries
to the "whole" Squid. Kids responses may get aggregated by Coordinator,
and we, in general, want to aggregate all responses that can be aggregated.

This is a Measurement Factory project