src/adaptation/icap/ModXact.h

   1 /*
   2  * Copyright (C) 1996-2015 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_ICAPMODXACT_H
  10 #define SQUID_ICAPMODXACT_H
  11
  12 #include "AccessLogEntry.h"
  13 #include "adaptation/icap/InOut.h"
  14 #include "adaptation/icap/Launcher.h"
  15 #include "adaptation/icap/Xaction.h"
  16 #include "BodyPipe.h"
  17 #include "http/one/forward.h"
  18
  19 /*
  20  * ICAPModXact implements ICAP REQMOD and RESPMOD transaction using
  21  * ICAPXaction as the base. The ICAPModXact receives a virgin HTTP message
  22  * from an ICAP vecoring point, (a.k.a., initiator), communicates with the
  23  * ICAP server, and sends the adapted HTTP message headers back.
  24  * Virgin/adapted HTTP message body is reveived/sent using BodyPipe
  25  * interface. The initiator (or its associate) is expected to send and/or
  26  * receive the HTTP body.
  27  */
  28
  29 namespace Adaptation
  30 {
  31 namespace Icap
  32 {
  33
  34 // estimated future presence and size of something (e.g., HTTP body)
  35
  36 class SizedEstimate
  37 {
  38
  39 public:
  40     SizedEstimate(); // not expected by default
  41     void expect(int64_t aSize); // expect with any, even unknown size
  42     bool expected() const;
  43
  44     /* other members can be accessed iff expected() */
  45
  46     bool knownSize() const;
  47     uint64_t size() const; // can be accessed iff knownSize()
  48
  49 private:
  50     enum { dtUnexpected = -2, dtUnknown = -1 };
  51     int64_t theData; // combines expectation and size info to save RAM
  52 };
  53
  54 // Virgin body may be used for two activities: (a) writing preview or prime
  55 // body to the ICAP server and (b) sending the body back in the echo mode.
  56 // Both activities use the same BodyPipe and may be active at the same time.
  57 // This class is used to maintain the state of body writing or sending
  58 // activity and to coordinate consumption of the shared virgin body buffer.
  59 class VirginBodyAct
  60 {
  61
  62 public:
  63     VirginBodyAct();
  64
  65     void plan(); // the activity may happen; do not consume at or above offset
  66     void disable(); // the activity wont continue; no consumption restrictions
  67
  68     bool active() const { return theState == stActive; }
  69     bool disabled() const { return theState == stDisabled; }
  70
  71     // methods below require active()
  72
  73     uint64_t offset() const; // the absolute beginning of not-yet-acted-on data
  74     void progress(size_t size); // note processed body bytes
  75
  76 private:
  77     int64_t theStart; // unprocessed virgin body data offset
  78
  79     typedef enum { stUndecided, stActive, stDisabled } State;
  80     State theState;
  81 };
  82
  83 // maintains preview-related sizes
  84
  85 class Preview
  86 {
  87
  88 public:
  89     Preview();            // disabled
  90     void enable(size_t anAd); // enabled with advertised size
  91     bool enabled() const;
  92
  93     /* other members can be accessed iff enabled() */
  94
  95     size_t ad() const;      // advertised preview size
  96     size_t debt() const;    // remains to write
  97     bool done() const;      // wrote everything
  98     bool ieof() const;      // premature EOF
  99
 100     void wrote(size_t size, bool wroteEof);
 101
 102 private:
 103     size_t theWritten;
 104     size_t theAd;
 105     enum State { stDisabled, stWriting, stIeof, stDone } theState;
 106 };
 107
 108 class ModXact: public Xaction, public BodyProducer, public BodyConsumer
 109 {
 110     CBDATA_CLASS(ModXact);
 111
 112 public:
 113     ModXact(HttpMsg *virginHeader, HttpRequest *virginCause, AccessLogEntry::Pointer &alp, ServiceRep::Pointer &s);
 114     virtual ~ModXact();
 115
 116     // BodyProducer methods
 117     virtual void noteMoreBodySpaceAvailable(BodyPipe::Pointer);
 118     virtual void noteBodyConsumerAborted(BodyPipe::Pointer);
 119
 120     // BodyConsumer methods
 121     virtual void noteMoreBodyDataAvailable(BodyPipe::Pointer);
 122     virtual void noteBodyProductionEnded(BodyPipe::Pointer);
 123     virtual void noteBodyProducerAborted(BodyPipe::Pointer);
 124
 125     // comm handlers
 126     virtual void handleCommConnected();
 127     virtual void handleCommWrote(size_t size);
 128     virtual void handleCommRead(size_t size);
 129     void handleCommWroteHeaders();
 130     void handleCommWroteBody();
 131
 132     // service waiting
 133     void noteServiceReady();
 134     void noteServiceAvailable();
 135
 136 public:
 137     InOut virgin;
 138     InOut adapted;
 139
 140     // bypasses exceptions if needed and possible
 141     virtual void callException(const std::exception &e);
 142
 143     /// record error detail in the virgin request if possible
 144     virtual void detailError(int errDetail);
 145     // Icap::Xaction API
 146     virtual void clearError();
 147
 148 private:
 149     virtual void start();
 150
 151     /// locates the request, either as a cause or as a virgin message itself
 152     const HttpRequest &virginRequest() const; // Must always be available
 153
 154     void estimateVirginBody();
 155     void makeAdaptedBodyPipe(const char *what);
 156
 157     void waitForService();
 158
 159     // will not send anything [else] on the adapted pipe
 160     bool doneSending() const;
 161
 162     void startWriting();
 163     void writeMore();
 164     void writePreviewBody();
 165     void writePrimeBody();
 166     void writeSomeBody(const char *label, size_t size);
 167     void decideWritingAfterPreview(const char *previewKind);
 168
 169     void startReading();
 170     void readMore();
 171     virtual bool doneReading() const { return commEof || state.doneParsing(); }
 172     virtual bool doneWriting() const { return state.doneWriting(); }
 173
 174     size_t virginContentSize(const VirginBodyAct &act) const;
 175     const char *virginContentData(const VirginBodyAct &act) const;
 176     bool virginBodyEndReached(const VirginBodyAct &act) const;
 177
 178     void makeRequestHeaders(MemBuf &buf);
 179     void makeAllowHeader(MemBuf &buf);
 180     void makeUsernameHeader(const HttpRequest *request, MemBuf &buf);
 181     void addLastRequestChunk(MemBuf &buf);
 182     void openChunk(MemBuf &buf, size_t chunkSize, bool ieof);
 183     void closeChunk(MemBuf &buf);
 184     void virginConsume();
 185     void finishNullOrEmptyBodyPreview(MemBuf &buf);
 186
 187     void decideOnPreview();
 188     void decideOnRetries();
 189     bool shouldAllow204();
 190     bool shouldAllow206any();
 191     bool shouldAllow206in();
 192     bool shouldAllow206out();
 193     bool canBackupEverything() const;
 194
 195     void prepBackup(size_t expectedSize);
 196     void backup(const MemBuf &buf);
 197
 198     void parseMore();
 199
 200     void parseHeaders();
 201     void parseIcapHead();
 202     void parseHttpHead();
 203     bool parseHead(HttpMsg *head);
 204
 205     void decideOnParsingBody();
 206     void parseBody();
 207     void maybeAllocateHttpMsg();
 208
 209     void handle100Continue();
 210     bool validate200Ok();
 211     void handle200Ok();
 212     void handle204NoContent();
 213     void handle206PartialContent();
 214     void handleUnknownScode();
 215
 216     void bypassFailure();
 217
 218     void startSending();
 219     void disableBypass(const char *reason, bool includeGroupBypass);
 220
 221     void prepEchoing();
 222     void prepPartialBodyEchoing(uint64_t pos);
 223     void echoMore();
 224
 225     virtual bool doneAll() const;
 226     virtual void swanSong();
 227
 228     void stopReceiving();
 229     void stopSending(bool nicely);
 230     void stopWriting(bool nicely);
 231     void stopParsing();
 232     void stopBackup();
 233
 234     virtual void fillPendingStatus(MemBuf &buf) const;
 235     virtual void fillDoneStatus(MemBuf &buf) const;
 236     virtual bool fillVirginHttpHeader(MemBuf&) const;
 237
 238 private:
 239     void packHead(MemBuf &httpBuf, const HttpMsg *head);
 240     void encapsulateHead(MemBuf &icapBuf, const char *section, MemBuf &httpBuf, const HttpMsg *head);
 241     bool gotEncapsulated(const char *section) const;
 242     void checkConsuming();
 243
 244     virtual void finalizeLogInfo();
 245
 246     SizedEstimate virginBody;
 247     VirginBodyAct virginBodyWriting; // virgin body writing state
 248     VirginBodyAct virginBodySending;  // virgin body sending state
 249     uint64_t virginConsumed;        // virgin data consumed so far
 250     Preview preview; // use for creating (writing) the preview
 251
 252     Http1::ChunkedCodingParser *bodyParser; // ICAP response body parser
 253
 254     bool canStartBypass; // enables bypass of transaction failures
 255     bool protectGroupBypass; // protects ServiceGroup-wide bypass of failures
 256
 257     /**
 258      * size of HTTP header in ICAP reply or -1 if there is not any encapsulated
 259      * message data
 260      */
 261     int64_t replyHttpHeaderSize;
 262     /**
 263      * size of dechunked HTTP body in ICAP reply or -1 if there is not any
 264      * encapsulated message data
 265      */
 266     int64_t replyHttpBodySize;
 267
 268     int adaptHistoryId; ///< adaptation history slot reservation
 269
 270     class State
 271     {
 272
 273     public:
 274         State();
 275
 276     public:
 277
 278         bool serviceWaiting; // waiting for ICAP service options
 279         bool allowedPostview204; // mmust handle 204 No Content outside preview
 280         bool allowedPostview206; // must handle 206 Partial Content outside preview
 281         bool allowedPreview206; // must handle 206 Partial Content inside preview
 282         bool readyForUob; ///< got a 206 response and expect a use-origin-body
 283         bool waitedForService; ///< true if was queued at least once
 284
 285         // will not write anything [else] to the ICAP server connection
 286         bool doneWriting() const { return writing == writingReallyDone; }
 287
 288         // will not use virgin.body_pipe
 289         bool doneConsumingVirgin() const {
 290             return writing >= writingAlmostDone
 291                    && ((sending == sendingAdapted && !readyForUob) ||
 292                        sending == sendingDone);
 293         }
 294
 295         // parsed entire ICAP response from the ICAP server
 296         bool doneParsing() const { return parsing == psDone; }
 297
 298         // is parsing ICAP or HTTP headers read from the ICAP server
 299         bool parsingHeaders() const {
 300             return parsing == psIcapHeader ||
 301                    parsing == psHttpHeader;
 302         }
 303
 304         enum Parsing { psIcapHeader, psHttpHeader, psBody, psDone } parsing;
 305
 306         // measures ICAP request writing progress
 307         enum Writing { writingInit, writingConnect, writingHeaders,
 308                        writingPreview, writingPaused, writingPrime,
 309                        writingAlmostDone, // waiting for the last write() call to finish
 310                        writingReallyDone
 311                      } writing;
 312
 313         enum Sending { sendingUndecided, sendingVirgin, sendingAdapted,
 314                        sendingDone
 315                      } sending;
 316     } state;
 317
 318     AccessLogEntry::Pointer alMaster; ///< Master transaction AccessLogEntry
 319 };
 320
 321 // An Launcher that stores ModXact construction info and
 322 // creates ModXact when needed
 323 class ModXactLauncher: public Launcher
 324 {
 325     CBDATA_CLASS(ModXactLauncher);
 326
 327 public:
 328     ModXactLauncher(HttpMsg *virginHeader, HttpRequest *virginCause, AccessLogEntry::Pointer &alp, Adaptation::ServicePointer s);
 329
 330 protected:
 331     virtual Xaction *createXaction();
 332
 333     virtual void swanSong();
 334
 335     /// starts or stops transaction accounting in ICAP history
 336     void updateHistory(bool start);
 337
 338     InOut virgin;
 339
 340     AccessLogEntry::Pointer al;
 341 };
 342
 343 } // namespace Icap
 344 } // namespace Adaptation
 345
 346 #endif /* SQUID_ICAPMOD_XACT_H */
 347