src/FwdState.h

   1 /*
   2  * Copyright (C) 1996-2014 The Squid Software Foundation and contributors
   3  *
   4  * Squid software is distributed under GPLv2+ license and includes
   5  * contributions from numerous individuals and organizations.
   6  * Please see the COPYING and CONTRIBUTORS files for details.
   7  */
   8
   9 #ifndef SQUID_FORWARD_H
  10 #define SQUID_FORWARD_H
  11
  12 #include "base/RefCount.h"
  13 #include "comm.h"
  14 #include "comm/Connection.h"
  15 #include "err_type.h"
  16 #include "fde.h"
  17 #include "http/StatusCode.h"
  18 #include "ip/Address.h"
  19 #if USE_OPENSSL
  20 #include "ssl/support.h"
  21 #endif
  22
  23 /* forward decls */
  24
  25 class AccessLogEntry;
  26 typedef RefCount<AccessLogEntry> AccessLogEntryPointer;
  27 class PconnPool;
  28 typedef RefCount<PconnPool> PconnPoolPointer;
  29 class ErrorState;
  30 class HttpRequest;
  31
  32 #if USE_OPENSSL
  33 namespace Ssl
  34 {
  35 class ErrorDetail;
  36 class CertValidationResponse;
  37 class PeerConnectorAnswer;
  38 };
  39 #endif
  40
  41 /**
  42  * Returns the TOS value that we should be setting on the connection
  43  * to the server, based on the ACL.
  44  */
  45 tos_t GetTosToServer(HttpRequest * request);
  46
  47 /**
  48  * Returns the Netfilter mark value that we should be setting on the
  49  * connection to the server, based on the ACL.
  50  */
  51 nfmark_t GetNfmarkToServer(HttpRequest * request);
  52
  53 /// Sets initial TOS value and Netfilter for the future outgoing connection.
  54 void GetMarkingsToServer(HttpRequest * request, Comm::Connection &conn);
  55
  56 class HelperReply;
  57
  58 class FwdState : public RefCountable
  59 {
  60 public:
  61     typedef RefCount<FwdState> Pointer;
  62     ~FwdState();
  63     static void initModule();
  64
  65     /// Initiates request forwarding to a peer or origin server.
  66     static void Start(const Comm::ConnectionPointer &client, StoreEntry *, HttpRequest *, const AccessLogEntryPointer &alp);
  67     /// Same as Start() but no master xaction info (AccessLogEntry) available.
  68     static void fwdStart(const Comm::ConnectionPointer &client, StoreEntry *, HttpRequest *);
  69
  70     /// This is the real beginning of server connection. Call it whenever
  71     /// the forwarding server destination has changed and a new one needs to be opened.
  72     /// Produces the cannot-forward error on fail if no better error exists.
  73     void startConnectionOrFail();
  74
  75     void fail(ErrorState *err);
  76     void unregister(Comm::ConnectionPointer &conn);
  77     void unregister(int fd);
  78     void complete();
  79     void handleUnregisteredServerEnd();
  80     int reforward();
  81     bool reforwardableStatus(const Http::StatusCode s) const;
  82     void serverClosed(int fd);
  83     void connectStart();
  84     void connectDone(const Comm::ConnectionPointer & conn, Comm::Flag status, int xerrno);
  85     void connectTimeout(int fd);
  86     time_t timeLeft() const; ///< the time left before the forwarding timeout expired
  87     bool checkRetry();
  88     bool checkRetriable();
  89     void dispatch();
  90     /// Pops a connection from connection pool if available. If not
  91     /// checks the peer stand-by connection pool for available connection.
  92     Comm::ConnectionPointer pconnPop(const Comm::ConnectionPointer &dest, const char *domain);
  93     void pconnPush(Comm::ConnectionPointer & conn, const char *domain);
  94
  95     bool dontRetry() { return flags.dont_retry; }
  96
  97     void dontRetry(bool val) { flags.dont_retry = val; }
  98
  99     /** return a ConnectionPointer to the current server connection (may or may not be open) */
 100     Comm::ConnectionPointer const & serverConnection() const { return serverConn; };
 101
 102 private:
 103     // hidden for safer management of self; use static fwdStart
 104     FwdState(const Comm::ConnectionPointer &client, StoreEntry *, HttpRequest *, const AccessLogEntryPointer &alp);
 105     void start(Pointer aSelf);
 106
 107 #if STRICT_ORIGINAL_DST
 108     void selectPeerForIntercepted();
 109 #endif
 110     static void logReplyStatus(int tries, const Http::StatusCode status);
 111     void doneWithRetries();
 112     void completed();
 113     void retryOrBail();
 114     ErrorState *makeConnectingError(const err_type type) const;
 115 #if USE_OPENSSL
 116     void connectedToPeer(Ssl::PeerConnectorAnswer &answer);
 117 #endif
 118     static void RegisterWithCacheManager(void);
 119
 120     /// stops monitoring server connection for closure and updates pconn stats
 121     void closeServerConnection(const char *reason);
 122
 123 public:
 124     StoreEntry *entry;
 125     HttpRequest *request;
 126     AccessLogEntryPointer al; ///< info for the future access.log entry
 127
 128     static void abort(void*);
 129
 130 private:
 131     Pointer self;
 132     ErrorState *err;
 133     Comm::ConnectionPointer clientConn;        ///< a possibly open connection to the client.
 134     time_t start_t;
 135     int n_tries;
 136
 137     // AsyncCalls which we set and may need cancelling.
 138     struct {
 139         AsyncCall::Pointer connector;  ///< a call linking us to the ConnOpener producing serverConn.
 140     } calls;
 141
 142     struct {
 143         bool connected_okay; ///< TCP link ever opened properly. This affects retry of POST,PUT,CONNECT,etc
 144         bool dont_retry;
 145         bool forward_completed;
 146     } flags;
 147
 148     /** connections to open, in order, until successful */
 149     Comm::ConnectionList serverDestinations;
 150
 151     Comm::ConnectionPointer serverConn; ///< a successfully opened connection to a server.
 152
 153     /// possible pconn race states
 154     typedef enum { raceImpossible, racePossible, raceHappened } PconnRace;
 155     PconnRace pconnRace; ///< current pconn race state
 156
 157     // NP: keep this last. It plays with private/public
 158     CBDATA_CLASS2(FwdState);
 159 };
 160
 161 void getOutgoingAddress(HttpRequest * request, Comm::ConnectionPointer conn);
 162
 163 #endif /* SQUID_FORWARD_H */