src/HttpMsg.cc

   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 /* DEBUG: section 74    HTTP Message */
  10
  11 #include "squid.h"
  12 #include "Debug.h"
  13 #include "HttpHeaderTools.h"
  14 #include "HttpMsg.h"
  15 #include "MemBuf.h"
  16 #include "mime_header.h"
  17 #include "profiler/Profiler.h"
  18 #include "SquidConfig.h"
  19
  20 HttpMsg::HttpMsg(http_hdr_owner_type owner):
  21     http_ver(Http::ProtocolVersion()),
  22     header(owner),
  23     cache_control(NULL),
  24     hdr_sz(0),
  25     content_length(0),
  26     pstate(psReadyToParseStartLine)
  27 {}
  28
  29 HttpMsg::~HttpMsg()
  30 {
  31     assert(!body_pipe);
  32 }
  33
  34 HttpMsgParseState &operator++ (HttpMsgParseState &aState)
  35 {
  36     int tmp = (int)aState;
  37     aState = (HttpMsgParseState)(++tmp);
  38     return aState;
  39 }
  40
  41 /* find end of headers */
  42 static int
  43 httpMsgIsolateHeaders(const char **parse_start, int l, const char **blk_start, const char **blk_end)
  44 {
  45     /*
  46      * parse_start points to the first line of HTTP message *headers*,
  47      * not including the request or status lines
  48      */
  49     size_t end = headersEnd(*parse_start, l);
  50     int nnl;
  51
  52     if (end) {
  53         *blk_start = *parse_start;
  54         *blk_end = *parse_start + end - 1;
  55         /*
  56          * leave blk_end pointing to the first character after the
  57          * first newline which terminates the headers
  58          */
  59         assert(**blk_end == '\n');
  60
  61         while (*(*blk_end - 1) == '\r')
  62             --(*blk_end);
  63
  64         assert(*(*blk_end - 1) == '\n');
  65
  66         *parse_start += end;
  67
  68         return 1;
  69     }
  70
  71     /*
  72      * If we didn't find the end of headers, and parse_start does
  73      * NOT point to a CR or NL character, then return failure
  74      */
  75     if (**parse_start != '\r' && **parse_start != '\n')
  76         return 0;       /* failure */
  77
  78     /*
  79      * If we didn't find the end of headers, and parse_start does point
  80      * to an empty line, then we have empty headers.  Skip all CR and
  81      * NL characters up to the first NL.  Leave parse_start pointing at
  82      * the first character after the first NL.
  83      */
  84     *blk_start = *parse_start;
  85
  86     *blk_end = *blk_start;
  87
  88     for (nnl = 0; nnl == 0; ++(*parse_start)) {
  89         if (**parse_start == '\r')
  90             (void) 0;
  91         else if (**parse_start == '\n')
  92             ++nnl;
  93         else
  94             break;
  95     }
  96
  97     return 1;
  98 }
  99
 100 /* find first CRLF */
 101 static int
 102 httpMsgIsolateStart(const char **parse_start, const char **blk_start, const char **blk_end)
 103 {
 104     int slen = strcspn(*parse_start, "\r\n");
 105
 106     if (!(*parse_start)[slen])  /* no CRLF found */
 107         return 0;
 108
 109     *blk_start = *parse_start;
 110
 111     *blk_end = *blk_start + slen;
 112
 113     while (**blk_end == '\r')   /* CR */
 114         ++(*blk_end);
 115
 116     if (**blk_end == '\n')      /* LF */
 117         ++(*blk_end);
 118
 119     *parse_start = *blk_end;
 120
 121     return 1;
 122 }
 123
 124 // negative return is the negated Http::StatusCode error code
 125 // zero return means need more data
 126 // positive return is the size of parsed headers
 127 bool
 128 HttpMsg::parse(const char *buf, const size_t sz, bool eof, Http::StatusCode *error)
 129 {
 130     assert(error);
 131     *error = Http::scNone;
 132
 133     // find the end of headers
 134     const size_t hdr_len = headersEnd(buf, sz);
 135
 136     // sanity check the start line to see if this is in fact an HTTP message
 137     if (!sanityCheckStartLine(buf, hdr_len, error)) {
 138         // NP: sanityCheck sets *error and sends debug warnings on syntax errors.
 139         // if we have seen the connection close, this is an error too
 140         if (eof && *error == Http::scNone)
 141             *error = Http::scInvalidHeader;
 142
 143         return false;
 144     }
 145
 146     if (hdr_len > Config.maxReplyHeaderSize || (hdr_len <= 0 && sz > Config.maxReplyHeaderSize)) {
 147         debugs(58, DBG_IMPORTANT, "HttpMsg::parse: Too large reply header (" << hdr_len << " > " << Config.maxReplyHeaderSize);
 148         *error = Http::scHeaderTooLarge;
 149         return false;
 150     }
 151
 152     if (hdr_len <= 0) {
 153         debugs(58, 3, "HttpMsg::parse: failed to find end of headers (eof: " << eof << ") in '" << buf << "'");
 154
 155         if (eof) // iff we have seen the end, this is an error
 156             *error = Http::scInvalidHeader;
 157
 158         return false;
 159     }
 160
 161     const int res = httpMsgParseStep(buf, sz, eof);
 162
 163     if (res < 0) { // error
 164         debugs(58, 3, "HttpMsg::parse: cannot parse isolated headers in '" << buf << "'");
 165         *error = Http::scInvalidHeader;
 166         return false;
 167     }
 168
 169     if (res == 0) {
 170         debugs(58, 2, "HttpMsg::parse: strange, need more data near '" << buf << "'");
 171         *error = Http::scInvalidHeader;
 172         return false; // but this should not happen due to headersEnd() above
 173     }
 174
 175     assert(res > 0);
 176     debugs(58, 9, "HttpMsg::parse success (" << hdr_len << " bytes) near '" << buf << "'");
 177
 178     if (hdr_sz != (int)hdr_len) {
 179         debugs(58, DBG_IMPORTANT, "internal HttpMsg::parse vs. headersEnd error: " <<
 180                hdr_sz << " != " << hdr_len);
 181         hdr_sz = (int)hdr_len; // because old http.cc code used hdr_len
 182     }
 183
 184     return true;
 185 }
 186
 187 /*
 188  * parseCharBuf() takes character buffer of HTTP headers (buf),
 189  * which may not be NULL-terminated, and fills in an HttpMsg
 190  * structure.  The parameter 'end' specifies the offset to
 191  * the end of the reply headers.  The caller may know where the
 192  * end is, but is unable to NULL-terminate the buffer.  This function
 193  * returns true on success.
 194  */
 195 bool
 196 HttpMsg::parseCharBuf(const char *buf, ssize_t end)
 197 {
 198     MemBuf mb;
 199     int success;
 200     /* reset current state, because we are not used in incremental fashion */
 201     reset();
 202     mb.init();
 203     mb.append(buf, end);
 204     mb.terminate();
 205     success = httpMsgParseStep(mb.buf, mb.size, 0);
 206     mb.clean();
 207     return success == 1;
 208 }
 209
 210 /*
 211  * parses a 0-terminating buffer into HttpMsg.
 212  * Returns:
 213  *      1 -- success
 214  *       0 -- need more data (partial parse)
 215  *      -1 -- parse error
 216  */
 217 int
 218 HttpMsg::httpMsgParseStep(const char *buf, int len, int atEnd)
 219 {
 220     const char *parse_start = buf;
 221     int parse_len = len;
 222     const char *blk_start, *blk_end;
 223     const char **parse_end_ptr = &blk_end;
 224     assert(parse_start);
 225     assert(pstate < psParsed);
 226
 227     *parse_end_ptr = parse_start;
 228
 229     PROF_start(HttpMsg_httpMsgParseStep);
 230
 231     if (pstate == psReadyToParseStartLine) {
 232         if (!httpMsgIsolateStart(&parse_start, &blk_start, &blk_end)) {
 233             PROF_stop(HttpMsg_httpMsgParseStep);
 234             return 0;
 235         }
 236
 237         if (!parseFirstLine(blk_start, blk_end)) {
 238             PROF_stop(HttpMsg_httpMsgParseStep);
 239             return httpMsgParseError();
 240         }
 241
 242         *parse_end_ptr = parse_start;
 243
 244         hdr_sz = *parse_end_ptr - buf;
 245         parse_len = parse_len - hdr_sz;
 246
 247         ++pstate;
 248     }
 249
 250     /*
 251      * XXX This code uses parse_start; but if we're incrementally parsing then
 252      * this code might not actually be given parse_start at the right spot (just
 253      * after headers.) Grr.
 254      */
 255     if (pstate == psReadyToParseHeaders) {
 256         if (!httpMsgIsolateHeaders(&parse_start, parse_len, &blk_start, &blk_end)) {
 257             if (atEnd) {
 258                 blk_start = parse_start;
 259                 blk_end = blk_start + strlen(blk_start);
 260             } else {
 261                 PROF_stop(HttpMsg_httpMsgParseStep);
 262                 return 0;
 263             }
 264         }
 265
 266         if (!header.parse(blk_start, blk_end-blk_start)) {
 267             PROF_stop(HttpMsg_httpMsgParseStep);
 268             return httpMsgParseError();
 269         }
 270
 271         hdrCacheInit();
 272
 273         *parse_end_ptr = parse_start;
 274
 275         hdr_sz = *parse_end_ptr - buf;
 276
 277         ++pstate;
 278     }
 279
 280     PROF_stop(HttpMsg_httpMsgParseStep);
 281     return 1;
 282 }
 283
 284 /* handy: resets and returns -1 */
 285 int
 286 HttpMsg::httpMsgParseError()
 287 {
 288     reset();
 289     return -1;
 290 }
 291
 292 void
 293 HttpMsg::setContentLength(int64_t clen)
 294 {
 295     header.delById(Http::HdrType::CONTENT_LENGTH); // if any
 296     header.putInt64(Http::HdrType::CONTENT_LENGTH, clen);
 297     content_length = clen;
 298 }
 299
 300 bool
 301 HttpMsg::persistent() const
 302 {
 303     if (http_ver > Http::ProtocolVersion(1,0)) {
 304         /*
 305          * for modern versions of HTTP: persistent unless there is
 306          * a "Connection: close" header.
 307          */
 308         return !httpHeaderHasConnDir(&header, "close");
 309     } else {
 310         /* for old versions of HTTP: persistent if has "keep-alive" */
 311         return httpHeaderHasConnDir(&header, "keep-alive");
 312     }
 313 }
 314
 315 void HttpMsg::packInto(Packable *p, bool full_uri) const
 316 {
 317     packFirstLineInto(p, full_uri);
 318     header.packInto(p);
 319     p->append("\r\n", 2);
 320 }
 321
 322 void HttpMsg::hdrCacheInit()
 323 {
 324     content_length = header.getInt64(Http::HdrType::CONTENT_LENGTH);
 325     assert(NULL == cache_control);
 326     cache_control = header.getCc();
 327 }
 328
 329 /*
 330  * useful for debugging
 331  */
 332 void HttpMsg::firstLineBuf(MemBuf& mb)
 333 {
 334     packFirstLineInto(&mb, true);
 335 }
 336