Update errors/list to match the actual list of error pages used

Author: Klaubert Herr <klaubert@gmail.com>
Patch to strip kerberos realm from username

This patch add a new option to squid_ldap_group to strip kerberos realm from
username received from squid.
This is useful when you make kerberos authentication on squid, and try to
authorize the user using ldap in MS Active Directory, quering for
sAMAccountName.

Ran indent.

Bug 2230 possible fix: segmentation fault with a "pure virtual method called"

Added forgotten member initializations. For so many years I have wished
that GCC would warn about these things :-(!

This change may not be enough to fix the bug.

Bug 2224 fix: reentrant debugging crashes Squid

This patch does not fix the true/core problem, but it changes some pieces of
code that expose that problem. There are probably other pieces not masked
by this patch.

Bootstrapped

Windows Port: Windows select loop must be equivalent to Unix select loop.

Windows Port: don't set opt_no_daemon=1 when running as a service.

Convert debug statements to debugs

Clean up of deferred reads and delay pools was not applied to comm_select_win32.cc

Clean up a unused reference to the statCounter.syscalls.polls removed counter

Add check for glob() and glob.h availability

glob() and glob.h are not available on all platforms.

Fix compile error when cpu profiling is enabled.

Added Italian translation of new ERR_SECURE_CONNECT_FAIL error message

Polished clientReplyContext::purgeAllCached.

When METHOD_ENUM_END and METHOD_OTHER were reordered, the rest of the
code was not reviewed and an infinite loop in
clientReplyContext::purgeAllCached was created.

Polished the ++ operator and added a TODO to replace it eventually.

Fixed id() comments.

Bug 2225 fix: method CONNECT acl wrongly applied to method GET

The method comparison operator was broken for all methods other than "other".

I did not check whether we need to do case-insensitive compare of method
strings when the method is "other". We have to if Squid does not convert all
unknown methods to uppercase.

Loosen GetAddrInfo Unit-Tests.

Squid does not need certain OS defaults, which are known to vary.

Boost debugging on IP-conversion halt to critical info.

GCC 3.4.2 does not like cbdataReference() macro calls with unused result.

GCC 3.4.2 does not like cbdataReference() calls with unused results.

Merging async-call branch changes to HEAD:

Adding forgotten source files.

Merging async-call branch changes to HEAD:

Added file forgotten in the initial merge.

Bootstrapped

Merging async-call branch changes to HEAD:

        Removed class fdc_t. After CommCallbackData removal, fdc_t was
        only used to check that a FD is "active" and to check that a FD
        is half_closed.  fd_table flags.open seems to be identical to
        the "active" state flag so we use that now, via newly added
        isOpen() static function. AbortChecker already maintains
        half_closed status.

        Synced ipc code to call fd_open instead of fdc_open.

Merging async-call branch changes to HEAD:

Async-call work replaces event-based asynchronous calls with
stand-alone implementation. The common async call API allows Squid
core do call, debug, and troubleshoot all callback handlers in a
uniform way.

An async "job" API is introduced to manage independent logical threads
or work such as protocol transaction handlers on client, server, and
ICAP sides. These jobs should communicate with each other using async
calls to minimize dependencies and avoid reentrant callback loops.

These changes will eventually improve overall code quality, debugging
quality, and Squid robustness.

Below you will find log messages from the async-call branch that are
relevant to the file(s) being committed.

        Made comm_read and comm_write calls to use the new CommCalls.

        Converted the ConnStateData related code in client_side.cc to
        use CommCalls.

        BodyPipe now uses the  new job calls interface. Many changes in
        BodyPipe's related code.

Merging async-call branch changes to HEAD:

        ConnStateData is not a RefCountable class any more and cbdata
        used instead (I just forgot to commit these files)

Merging async-call branch changes to HEAD:

Async-call work replaces event-based asynchronous calls with
stand-alone implementation. The common async call API allows Squid
core do call, debug, and troubleshoot all callback handlers in a
uniform way.

An async "job" API is introduced to manage independent logical threads
or work such as protocol transaction handlers on client, server, and
ICAP sides. These jobs should communicate with each other using async
calls to minimize dependencies and avoid reentrant callback loops.

These changes will eventually improve overall code quality, debugging
quality, and Squid robustness.

Below you will find log messages from the async-call branch that are
relevant to the file(s) being committed.

        Removed CommDispatcher as unused.

        Use async calls for firing ready events. Deleted
        EventDispatcher as unused.

        Converted CompletionDispatcher-based SignalDispatcher into
        AsyncEngine-based SignalEngine to get rid of CompletionDispatchers.

Merging async-call branch changes to HEAD:

Async-call work replaces event-based asynchronous calls with
stand-alone implementation. The common async call API allows Squid
core do call, debug, and troubleshoot all callback handlers in a
uniform way.

An async "job" API is introduced to manage independent logical threads
or work such as protocol transaction handlers on client, server, and
ICAP sides. These jobs should communicate with each other using async
calls to minimize dependencies and avoid reentrant callback loops.

These changes will eventually improve overall code quality, debugging
quality, and Squid robustness.

Below you will find log messages from the async-call branch that are
relevant to the file(s) being committed.

        Convert the comm_* calls to use CommCalls.

        Use the AsyncJob::deleteThis method as "delete this"
        replacement instead of the previously commited block "if
        (inCall) musStop(...) else delete this"

        ICAPInitiate::sendAnswer dialers take care of message locking
        now.

Merging async-call branch changes to HEAD:

        ClientHttpRequest::getConn now returns a ConnStateData *
        pointer not ConnStateData::Pointer

Merging async-call branch changes to HEAD:

Async-call work replaces event-based asynchronous calls with
stand-alone implementation. The common async call API allows Squid
core do call, debug, and troubleshoot all callback handlers in a
uniform way.

An async "job" API is introduced to manage independent logical threads
or work such as protocol transaction handlers on client, server, and
ICAP sides. These jobs should communicate with each other using async
calls to minimize dependencies and avoid reentrant callback loops.

These changes will eventually improve overall code quality, debugging
quality, and Squid robustness.

Below you will find log messages from the async-call branch that are
relevant to the file(s) being committed.

    Added initial implelentation of AsyncCall-based wrappers for
    comm callbacks. The comm layer no longer calls callbacks from
    the select loop. Instead, the select loop schedules async
    calls. Scheduled calls are then called from the main loop (like
    all other async calls), after the select loop completes.

    Removed accept loop. We cannot loop because async calls do not
    get fired during the loop and, hence, cannot register new
    callbacks for new ready FDs.

    The loop is implicit now. When the next callback is registered,
    we check whether the last accept(2) call was successful or
    OPTIMISTIC_IO is defined and call acceptNext() again if yes.
    AcceptNext() may schedule another async call (using the
    being-submitted callback) if the socket was still ready. Since
    callbacks are fired until there are no callabacks left, we
    still have an accept loop.

    Removed CommDispatcher as unused.

    Removed unused IOFCB, IOWCB, and CWCB.

    Removed class fdc_t. After CommCallbackData removal, fdc_t was
    only used to check that a FD is "active" and to check that a FD
    is half_closed.  fd_table flags.open seems to be identical to
    the "active" state flag so we use that now, via newly added
    isOpen() static function. AbortChecker already maintains
    half_closed status.

    The accept-specific functionality is still implemented by
    AcceptFD class. Removed fdc_t used to marshall accept-ralted
    calls to AcceptFD anyway. fdc_table now stores AcceptFDs
    directly. I did not rename the table to ease merging with other
    code, but added a TODO for that.

    Removed calls to comm_iocallbackpending(). They were added to
    "Speed up processing of queued events significantly, to not
    cause large delays when under low load" but I do not see how
    having pending callbacks can be relevant because all pending
    callbacks are (should be) executed before FDs are probed.

    Removed unused nullCallback() methods.

    Removed CommCallbackData and related code. It looks like it
    remained after one of the big comm rewrites, just to handle
    accept errors. We can now schedule an async call to notify of
    those errors and do not seem to need CommCallbackData at all.

    Removed commfd_completed_events: a list of completed (but not
    yet fired) callbacks. We simply schedule the async call now
    instead of maintaining our own list of callbacks to call.  This
    change allows us to eliminate the CommDispatcher class (which
    was the motivation behind these changes), but I have not done
    that yet.

    For comm_io_callback_t, being active seems to be the same as
    having a callback. Replaced active data member with a method
    that checks for the callback presence.

    Relaxed comm_read_cancel() preconditions so that the callers do
    not have to check all the assertions inside before calling that
    function.

Merging async-call branch changes to HEAD:

Async-call work replaces event-based asynchronous calls with
stand-alone implementation. The common async call API allows Squid
core do call, debug, and troubleshoot all callback handlers in a
uniform way.

An async "job" API is introduced to manage independent logical threads
or work such as protocol transaction handlers on client, server, and
ICAP sides. These jobs should communicate with each other using async
calls to minimize dependencies and avoid reentrant callback loops.

These changes will eventually improve overall code quality, debugging
quality, and Squid robustness.

Below you will find log messages from the async-call branch that are
relevant to the file(s) being committed.

        Do not use CompletionDispatcher.

        Async calls are not longer using time-based events with zero
        delay. They have a dedicated AsyncCallQueue.

        Moved duplicated code into dispatchCalls().

EventLoop will need further internal polishing to polish, simplify and
possibly speed up the code.

Merging async-call branch changes to HEAD:

BodyPipe now uses the new job calls interface:
 - Instead of scheduling BodyPipe calls we are scheduling BodyProducer
   and BodyCosnumer calls
 - BodyProducer/BodyConsumer::noteXXXXXX(BodyPipe &bp) methods converted
   to Body*::noteXXXXXX(BodyPipe::Pointer) to allow them used with new
   async calls interface.
 - BodyPipe::tell* methods and related AsyncCallWrappers removed.
 - Implement the CallNoteBodyProducer and CallNoteBodyConsumer JobCall based
   classes. These classes used too schedule calls for BodyConsumer and
   BodyProducer respectivelly. They are like the normal JobCalls but
   aditionally checks if the BodyConsumer and BodyProducer is still part
   of the pipe.
 - Implement the NullBodyConsumer class as a BodyConsumer child which just
   reads the data from pipe and discard them. This class used to replace
   old AutoConsume mechanism.
 - Removing the ICAPXaction_{Enter,Exit} calls from ICAPModXact::note* methods
   Their logic implemented inside the new async calls code.

Remove the old "late call avoidance" code from BodyPipe as no longer needed.

Merging async-call branch changes to HEAD:

Async-call work replaces event-based asynchronous calls with
stand-alone implementation. The common async call API allows Squid
core do call, debug, and troubleshoot all callback handlers in a
uniform way.

An async "job" API is introduced to manage independent logical threads
or work such as protocol transaction handlers on client, server, and
ICAP sides. These jobs should communicate with each other using async
calls to minimize dependencies and avoid reentrant callback loops.

These changes will eventually improve overall code quality, debugging
quality, and Squid robustness.

The code is still more complex than I want it to be. However, these are
low-level interfaces that most developers will not have to deal with and
the complexity will be significantly reduced if we get rid of old style
function-pointer based callbacks, which is probably desirable for several
reasons. Other simplifications will be found in time as well.

TODO: src/ICAP/AsyncJob needs to be moved to src/. It is not moved yet to
preserve commit logs.

Merging async-call branch changes to HEAD:

        Synced after changing delayed read callback storage model from
        (function pointer, opaque parameter) pair to AsyncCall.
        Internally, comm module uses AsyncCalls to store callback
        information now.

Merging async-call branch changes to HEAD:

ConnStateData used a RefCount pointer (the openReference) to keep itself alive
which is not compatible with the cbdata used by CommCalls. This change makes
the ConnStateData class non RefCountable and uses cbdata instead.

Merging async-call branch changes to HEAD:

        Use async calls for firing ready events. Deleted
        EventDispatcher as unused.

Merging async-call branch changes to HEAD:

Added toCbdata() method to deal with multiple inheritence in cbdata-protected
objects. The pointers to the object used by others may not point to the part
of the object with the cbdata magic.

Merging async-call branch changes to HEAD:

        comm_has_pending_read() is now comm_monitors_read() to reflect
        our inability to track pending async callbacks. This call is
        used for debugging only.

        Converting commSetTimeout to use CommCalls. Also the
        CommTimeoutCbParams and CommTimeoutCbPtrFun classes added.

        comm_close handlers now scheduled as CommCalls.

Merging async-call branch changes to HEAD:

ConnStateData used a RefCount pointer (the openReference) to keep itself alive
which is not compatible with the cbdata used by CommCalls. This change makes
the ConnStateData class non RefCountable and uses cbdata instead.

Merging async-call branch changes to HEAD:

Async-call work replaces event-based asynchronous calls with
stand-alone implementation. The common async call API allows Squid
core do call, debug, and troubleshoot all callback handlers in a
uniform way.

An async "job" API is introduced to manage independent logical threads
or work such as protocol transaction handlers on client, server, and
ICAP sides. These jobs should communicate with each other using async
calls to minimize dependencies and avoid reentrant callback loops.

These changes will eventually improve overall code quality, debugging
quality, and Squid robustness.

Most of the changes in the ICAP/ICAP* files are related to removing handler
wrappers and using CommCalls. AsyncJob is now a [virtual] base class for
ICAPInitiator. All ICAP initiators and ICAP transactions are now "jobs".

Merging async-call branch changes to HEAD:

Async-call work replaces event-based asynchronous calls with
stand-alone implementation. The common async call API allows Squid
core do call, debug, and troubleshoot all callback handlers in a
uniform way.

An async "job" API is introduced to manage independent logical threads
or work such as protocol transaction handlers on client, server, and
ICAP sides. These jobs should communicate with each other using async
calls to minimize dependencies and avoid reentrant callback loops.

These changes will eventually improve overall code quality, debugging
quality, and Squid robustness.

Below you will find log messages from the async-call branch that are
relevant to the file(s) being committed.

        Made comm_read and comm_write calls to use the new CommCalls.

        Converted the ConnStateData related code in client_side.cc to
        use CommCalls.

        BodyPipe now uses the  new job calls interface. Many changes in
        BodyPipe's related code.

Merging async-call branch changes to HEAD:

        Removed calls to comm_iocallbackpending(). They were added to
        "Speed up processing of queued events significantly, to not
        cause large delays when under low load" but I do not see how
        having pending callbacks can be relevant because all pending
        callbacks are (should be) executed before FDs are probed.

        Converting commSetTimeout to use CommCalls.

Merging async-call branch changes to HEAD:

Async-call work replaces event-based asynchronous calls with
stand-alone implementation. The common async call API allows Squid
core do call, debug, and troubleshoot all callback handlers in a
uniform way.

An async "job" API is introduced to manage independent logical threads
or work such as protocol transaction handlers on client, server, and
ICAP sides. These jobs should communicate with each other using async
calls to minimize dependencies and avoid reentrant callback loops.

These changes will eventually improve overall code quality, debugging
quality, and Squid robustness.

Below you will find log messages from the async-call branch that are
relevant to the file(s) being committed.

    Added initial implelentation of AsyncCall-based wrappers for
    comm callbacks. The comm layer no longer calls callbacks from
    the select loop. Instead, the select loop schedules async
    calls. Scheduled calls are then called from the main loop (like
    all other async calls), after the select loop completes.

    Removed accept loop. We cannot loop because async calls do not
    get fired during the loop and, hence, cannot register new
    callbacks for new ready FDs.

    The loop is implicit now. When the next callback is registered,
    we check whether the last accept(2) call was successful or
    OPTIMISTIC_IO is defined and call acceptNext() again if yes.
    AcceptNext() may schedule another async call (using the
    being-submitted callback) if the socket was still ready. Since
    callbacks are fired until there are no callabacks left, we
    still have an accept loop.

    Removed CommDispatcher as unused.

    Removed unused IOFCB, IOWCB, and CWCB.

    Removed class fdc_t. After CommCallbackData removal, fdc_t was
    only used to check that a FD is "active" and to check that a FD
    is half_closed.  fd_table flags.open seems to be identical to
    the "active" state flag so we use that now, via newly added
    isOpen() static function. AbortChecker already maintains
    half_closed status.

    The accept-specific functionality is still implemented by
    AcceptFD class. Removed fdc_t used to marshall accept-ralted
    calls to AcceptFD anyway. fdc_table now stores AcceptFDs
    directly. I did not rename the table to ease merging with other
    code, but added a TODO for that.

    Removed calls to comm_iocallbackpending(). They were added to
    "Speed up processing of queued events significantly, to not
    cause large delays when under low load" but I do not see how
    having pending callbacks can be relevant because all pending
    callbacks are (should be) executed before FDs are probed.

    Removed unused nullCallback() methods.

    Removed CommCallbackData and related code. It looks like it
    remained after one of the big comm rewrites, just to handle
    accept errors. We can now schedule an async call to notify of
    those errors and do not seem to need CommCallbackData at all.

    Removed commfd_completed_events: a list of completed (but not
    yet fired) callbacks. We simply schedule the async call now
    instead of maintaining our own list of callbacks to call.  This
    change allows us to eliminate the CommDispatcher class (which
    was the motivation behind these changes), but I have not done
    that yet.

    For comm_io_callback_t, being active seems to be the same as
    having a callback. Replaced active data member with a method
    that checks for the callback presence.

    Relaxed comm_read_cancel() preconditions so that the callers do
    not have to check all the assertions inside before calling that
    function.

    The CommCall code is still more complex than I want it to be.
    However, these are low-level interfaces that most developers
    will not have to deal with and the complexity will be
    significantly reduced if we get rid of old style
    function-pointer based callbacks, which is probably desirable
    for several reasons.

Added SslBump change.

Bootstrapped

extension_methods directive is now obsolete.
METHOD_OTHER type now cleanly handles unknown methods in squid.

Part 1:
  - removes the directive from squid default config.
  - removes the placeholder EXT methods enumerations
  - deprecates the code which previously handled config parsing.

part 2: (TODO)
 - needs to cleanup the remaining enumerated methods to reduce
   memory footprint

Several String fixes.

- Add two missing includes when configured --disable-inline
- SegFault when newly allocated string set to 0-length.
  buf_ may be NULL and buffer overruns on truncate attempt

Importing SslBump feature from Squid3 ssl-bump branch:

        Added Palisade Systems as a sponsor.

Importing SslBump feature from Squid3 ssl-bump branch:

        http_port-related types were moved to ProtoPort.{cc,h}

Importing SslBump feature from Squid3 ssl-bump branch:

        Added sslproxy_cert_error ACL to be able to bypass some
        certificate validation errors. The default is to bypass
        nothing.

        Only a few SSL certificate validation errors are currently
        recognized by name, including the newly defined
        SQUID_X509_V_ERR_DOMAIN_MISMATCH error which is raised when
        Squid certificate domain validation fails.

Importing SslBump feature from Squid3 ssl-bump branch:

        Added sslproxy_cert_error ACL to be able to bypass some
        certificate validation errors. The default is to bypass
        nothing.

Importing SslBump feature from Squid3 ssl-bump branch:

        When SslBump is activated, Squid responds to CONNECT request
        with HTTP 200 "Connection established" and switches to SSL
        encryption on the connection.

        Added ssl_bump ACL. The ACL controls which CONNECT requests to
        an http_port marked with an sslBump flag are actually "bumped".
        This was needed to bypass the bump and tunnel requests to sites
        that Squid cannot handle well (with or without the bump), with
        other use cases likely to surface.

        By default, no requests are bumped. Squid warns if http_port(s)
        have SslBump but no ssl_bump ACL was configured.

        The ACL applies to all http_ports, but I suspect that, if
        needed, specific ACL rules can distinguish ports using
        "myport".

        Added ERR_SECURE_CONNECT_FAIL that is returned when we cannot
        secure the established connection with the server. Formerly,
        ERR_CONNECT_FAIL was returned.

The connect(2) system call might return "connection ready"
status even for a non-blocking file descriptor. The connection
itself can never be immediately ready in reality because of the
TCP handshake, but I am guessing that in some environments, the
TCP stack fakes/optimizes local connection readiness. We have
seen that for loopback sockets on FreeBSD 6.2, for example, but
the behavior is probably OS- or OS-configuration specific.

If connect(2) is immediately successful, comm module
immediately calls the callback. This means that the callback is
called while the same callback is being registered with comm.
ICAP does not allow this "re-entrance" and other code might not
deal well with it.

The change overwrites connect(2) result so that Squid does not
think that connect(2) was immediately successful. Instead of
calling the callback, Squid then schedules the connection
write-ability check.

The NativeAsyncCall development will fix this and remove the
need to overwrite connect(2) result because comm will always
call callbacks asynchronously.

Importing SslBump feature from Squid3 ssl-bump branch:

        Use newly added ACLChecklist::fd() method to get to the file
        descriptor, to get to the SSL structure.

Importing SslBump feature from Squid3 ssl-bump branch:

        SslBump needs access to SSL-related options when responding to
        CONNECT requests. We could add a new squid.conf option to
        accept those options, but I decided to add SSL-related options
        to http_port, where CONNECT requests will arrive. This design
        avoids the necessity to map SSL options to an HTTP port or to a
        CONNECT request when a global default would not do.

        Adding SSL options to http_port makes http_port_list and
        https_port_list almost identical. I moved stuff around to
        reduce duplication between the two classes, moving related
        code to ProtoPort.{cc,h} in the process. More work is needed
        to remove the distinction completely or, at least, remove the
        https_port::http hack.

        Added sslproxy_cert_error ACL to be able to bypass some
        certificate validation errors. The default is to bypass
        nothing.

        Only a few SSL certificate validation errors are currently
        recognized by name, including the newly defined
        SQUID_X509_V_ERR_DOMAIN_MISMATCH error which is raised when
        Squid certificate domain validation fails.

        Added support for ssl_error ACL (ACLSslError*).

Importing SslBump feature from Squid3 ssl-bump branch:

        Parse/dump the newly added sslBump http_port option. The option
        does not imply an accelerated port because it only accelerates
        after intercepting a CONNECT request.

        Configure SSL Context if SSL certificate or key are specified
        for an HTTP port.

Importing SslBump feature from Squid3 ssl-bump branch:

        Added ERR_SECURE_CONNECT_FAIL that is returned when we cannot
        secure the established connection with the server. Formerly,
        ERR_CONNECT_FAIL was returned.

        Supply the SSL error check ACL when forwarding SSL connections.
        The check list is stored as SSL ex_data and is destroyed by
        OpenSSL when the SSL struct is destroyed.

Importing SslBump feature from Squid3 ssl-bump branch:

        When SslBump is activated, Squid responds to CONNECT request
        with HTTP 200 "Connection established" and switches to SSL
        encryption on the connection.

        Added ssl_bump ACL. The ACL controls which CONNECT requests to
        an http_port marked with an sslBump flag are actually "bumped".
        This was needed to bypass the bump and tunnel requests to sites
        that Squid cannot handle well (with or without the bump), with
        other use cases likely to surface.

        By default, no requests are bumped. Squid warns if http_port(s)
        have SslBump but no ssl_bump ACL was configured.

        The ACL applies to all http_ports, but I suspect that, if
        needed, specific ACL rules can distinguish ports using
        "myport".

        Added ERR_SECURE_CONNECT_FAIL that is returned when we cannot
        secure the established connection with the server. Formerly,
        ERR_CONNECT_FAIL was returned.

Importing SslBump feature from Squid3 ssl-bump branch:

        Store connection file descriptor, to be used to get to the
        connection SSL structure when client-side ConnStateData is not
        available.

        Store SSL error code, to be used by ssl_error ACL
        (ACLSslError*).

        Polished comments. Added TODO.

Importing SslBump feature from Squid3 ssl-bump branch:

        Added ConnStateData::switchToHttps() method that attempts to
        switch regular connection into SSL encryption mode. It is meant
        to be called after Squid responds to the CONNECT request,
        pretending to be an origin server (SslBump feature).

        Moved SSL structure creation to httpsCreate() so that the code
        can be used for httpsAccept() and the new switchToHttps() code.

        Mark connection that switched to SSL so that others can treat
        associated requests specially (e.g., accelerate them).

        Use configured SSL context of http_port. This means that we
        can no longer rely on connection port protocol when
        accelerating request. The port is HTTP but we need to prepend
        https:// after switching to SSL mode.

        Warn if sslBump is enabled but there is no usable SSL context.
        This may need to be a fatal error.

        Ignore https_port where we failed to create an SSL context. We
        used to warn but did not ignore. Polished the warning message.

        Disable SslBump for http_port where we failed to create an SSL
        context. We used to warn but did not disable. Polished the
        warning message.

        Polished the "You have too many 'https_port' lines" warning.

Importing SslBump feature from Squid3 ssl-bump branch:

        SslBump needs access to SSL-related options when responding to
        CONNECT requests. We could add a new squid.conf option to
        accept those options, but I decided to add SSL-related options
        to http_port, where CONNECT requests will arrive. This design
        avoids the necessity to map SSL options to an HTTP port or to a
        CONNECT request when a global default would not do.

        Adding SSL options to http_port makes http_port_list and
        https_port_list almost identical. I moved stuff around to
        reduce duplication between the two classes, moving related
        code to ProtoPort.{cc,h} in the process. More work is needed
        to remove the distinction completely or, at least, remove the
        https_port::http hack.

        Added support for ssl_error ACL (ACLSslError*).

Importing SslBump feature from Squid3 ssl-bump branch:

        Added ERR_SECURE_CONNECT_FAIL that is returned when we cannot
        secure the established connection with the server. Formerly,
        ERR_CONNECT_FAIL was returned.

        I copied new English/ERR_SECURE_CONNECT_FAIL to other
        languages. Perhaps it would be better to use translated (but
        less specific) ERR_CONNECT_FAIL text instead.

Author: Steven Wilton <swilton@q-net.net.au>
Sort cache list in wccpv2 to ensure a consistent hash allocation across all serv
ices

Under some circumstances different caches were being allocated differnet hash
assignments for different wccpv2 services.  This caused problems when using
TPROXY as the reply traffic was being sent to a different cache than the request
causing problems in browsing web pages.

This patch applied a selection sort algorithm to the cache list to ensure that
as long as the same group of caches are registered for any number of wccpv2
services, they will be allocated the same hash assignments in the router.

Bug 2038: check reply_body_max_size before ICAP

Use newly added HttpReply::*BodyTooLarge() checks to support the
reply_body_max_size ACL when the expected body size may be known and when more
body data is coming. The checks are now shared between server and client
sides.

The server side needs to do the checks before feeding the data to ICAP.
Otherwise, ICAP service may suck a large response in and spit a small response
out. It was decided that the reply_body_max_size ACL should apply to the
virgin response as well.

The server side does not perform receivedBodyTooLarge check yet.

Bug 2038: check reply_body_max_size before ICAP

Use newly added HttpReply::expectedBodyTooLarge() check to support the
reply_body_max_size ACL when the expected body size may be known. The check
is now shared between server and client sides.

The server side needs to do the checks before feeding the data to ICAP.
Otherwise, ICAP service may suck a large response in and spit a small response
out. It was decided that the reply_body_max_size ACL should apply to the
virgin response as well.

The server side does not perform HttpReply::receivedBodyTooLarge() check yet.

Bug 2038: check reply_body_max_size before ICAP

Moved maxReplyBodySize-related code from ClientHttpRequest to HttpReply
because server-side needs it too to check limits before ICAP sucks all the
data in.

Calculating limit requires knowing HttpRequest because it affects expected
content length. Since I did not find a single place where any HttpReply would
be guaranteed to be given the request to calculate the limit, we now supply
the request whenever a limit check is performed. The limit calculation result
is cached and the calculation should not be repeated.

Restrict the cgi-bin refresh pattern to just */cgi-bin/*

make include support wildcards, and document the directive (copied from squid-2)

TCP keepalive support

Bug 1978: fwdServerClose retries non-idempotent methods

checkRetry is now guaranteed to return false for requests that checkRetriable
previously returned false. This prevents retries of requests with
non-idempotent methods, for example.

Author:  Christos Tsantilas <chtsanti@users.sourceforge.net>
Bug 2172: When user fails authentification Squid restarts

Replaced an assertion that there is no auth_user_request, a comment what
to do when there is no auth_user_request, and a comment that there can
be no auth_user_request with what the first comment suggested to do.

Bug 2186: NONE/- due to persistent connections

When reusing a persistent server connection, update hierarchy data even
if _peer is not set. We can get the destination host info from the request.

Author: adrian
Extend the Memory Allocator infrastructure to not need to zero buffers.

Alter caching policy for Dynamic Objects.

- Alters squid caching policy for dynamically generated objects
to allow caching when objects have Cache-Control headers.
- Default policy now follows RFC 2616 section 13.9 exactly as stated.

see http://www.mail-archive.com/squid-dev@squid-cache.org/msg06963.html

Bug #2166 - Error compiling on Mac OS X 10.5 Leopard

Remove last remains of IN_ADDR ANY_ADDR and NO_ADDR from Squid

- Uses of struct in_addr do remain at places where IPv4 is forced.
- This just removes the glue macros no longer needed.

Documentation updates.

- Adds auto-documentation to some ACLARP code
- Adds peer address to NAT filure debugging on Linux.

Fixes many Unit-test compile errors and testing problems in HttpRequestMethod

- Removes implicit conversion from HttpRequestMethod to other types.
- Adds id() accessor to retrieve an ID for known methods.
- Adds more boolean operators to class library

Also adds auto-documantation in some METHOD-related places.

Fix compile error when cpu profiling is enabled.

Windows port: Handle notification of IP address changes for dial-up connections

On Windows 2000 and later, the NotifyAddrChange() function allow a
process to be notified of the changes in the system IP addresses table.
This patch generate a reconfigure request after any notification, this
allow the hot addition/reconfiguration of network interfaces without
manually restart/reconfigure Squid.

Undid recent clean()-related changes that broke strListAdd() and possibly
other String-manipulating functions.

Separated low-level private methods from public ones. Documented and polished
some of the code. More work needed (see TODOs).

Reduced the number of double-clean() calls in the spirit of the undone changes.

Protect String::limitInit() against empty strings.

Is being caleld at least once in squid3 with a NULL ptr and 0 length.
This patch prevents memory allocation on 0 length and a will continue
to assert if a NULL pointer is given with a length.
(We may want to re-think that later)

String 'call duplication' optimization(?) bypassed calling String::init()
when copying a String and called limitInit() directly. That results in
an assertion when an empty String is copied. The fix avoids calling
limitInit() when an empty String is copied.

Reduce call duplication in String.

- Removes duplicate clean() calls
- Pushes clean() calls as far down the stack as possible on each init*
- Removes small memory leak in limitInit()

Bootstrapped

removeConnectionHeaderEntries() is removeHopByHopEntries() now.

Windows port: fix ACL ARP build error.

Optimization: INADDR_ANY is the default for IPAddress.

This removes an explicit double-init/memset of the object.

Author: Klaus Singvogel <kssingvo@suse.de>
Bug 2189 fix: when dumping SNMP oids, do not overrun the result buffer.

Bug 2168 fix: Avoid tcp_outgoing_address selection for ICAP requests.
Let OS pick the outgoing (i.e., source) address instead.

Code did not supply info required for tcp_outgoing_address ACL match to work,
and tcp_outgoing_address is usually not applicable to ICAP communication.
Eventually, we may add icap_outgoing_address.

Assert that checklist and request are set instead of segfaulting as in bug 2168

Windows port: workaround for Visual Studio odd EAI_NODATA definition.

Bug 1923 fix: Do not send hop-by-hop headers to the ICAP server.
Send Proxy-Authenticate&Proxy-Authorization in ICAP request headers.

bug1933 fix: Fixed memory pools configuration reporting.
We used to report too early, before Squid configuration was parsed.

Bug 2110 fix: When Squid is shutting down, disable persistent connections
in responses.

This change should discourage clients from sending us more requests.
It should only affect hit responses because misses are denied during shutdown.

Use our own strwordtok instead of strtok_r. Not only is it portable, but also understands quoting and escaping

Windows port: Fix warning error building with Visual Studio.

Compile error introduced by previosu patch.

Squid-defined types need to be included where used.

Windows port: fix build error for missing ostream declaration.