src/HttpMsg.cc

   1
   2 /*
   3  * DEBUG: section 74    HTTP Message
   4  * AUTHOR: Alex Rousskov
   5  *
   6  * SQUID Web Proxy Cache          http://www.squid-cache.org/
   7  * ----------------------------------------------------------
   8  *
   9  *  Squid is the result of efforts by numerous individuals from
  10  *  the Internet community; see the CONTRIBUTORS file for full
  11  *  details.   Many organizations have provided support for Squid's
  12  *  development; see the SPONSORS file for full details.  Squid is
  13  *  Copyrighted (C) 2001 by the Regents of the University of
  14  *  California; see the COPYRIGHT file for full details.  Squid
  15  *  incorporates software developed and/or copyrighted by other
  16  *  sources; see the CREDITS file for full details.
  17  *
  18  *  This program is free software; you can redistribute it and/or modify
  19  *  it under the terms of the GNU General Public License as published by
  20  *  the Free Software Foundation; either version 2 of the License, or
  21  *  (at your option) any later version.
  22  *
  23  *  This program is distributed in the hope that it will be useful,
  24  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  25  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  26  *  GNU General Public License for more details.
  27  *
  28  *  You should have received a copy of the GNU General Public License
  29  *  along with this program; if not, write to the Free Software
  30  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
  31  *
  32  */
  33
  34 #include "squid.h"
  35 #include "Debug.h"
  36 #include "HttpHeaderTools.h"
  37 #include "HttpMsg.h"
  38 #include "MemBuf.h"
  39 #include "mime_header.h"
  40 #include "profiler/Profiler.h"
  41 #include "SquidConfig.h"
  42
  43 HttpMsg::HttpMsg(http_hdr_owner_type owner): header(owner),
  44         cache_control(NULL), hdr_sz(0), content_length(0), protocol(AnyP::PROTO_NONE),
  45         pstate(psReadyToParseStartLine), lock_count(0)
  46 {}
  47
  48 HttpMsg::~HttpMsg()
  49 {
  50     assert(lock_count == 0);
  51     assert(!body_pipe);
  52 }
  53
  54 HttpMsgParseState &operator++ (HttpMsgParseState &aState)
  55 {
  56     int tmp = (int)aState;
  57     aState = (HttpMsgParseState)(++tmp);
  58     return aState;
  59 }
  60
  61 /* find end of headers */
  62 int
  63 httpMsgIsolateHeaders(const char **parse_start, int l, const char **blk_start, const char **blk_end)
  64 {
  65     /*
  66      * parse_start points to the first line of HTTP message *headers*,
  67      * not including the request or status lines
  68      */
  69     size_t end = headersEnd(*parse_start, l);
  70     int nnl;
  71
  72     if (end) {
  73         *blk_start = *parse_start;
  74         *blk_end = *parse_start + end - 1;
  75         /*
  76          * leave blk_end pointing to the first character after the
  77          * first newline which terminates the headers
  78          */
  79         assert(**blk_end == '\n');
  80
  81         while (*(*blk_end - 1) == '\r')
  82             --(*blk_end);
  83
  84         assert(*(*blk_end - 1) == '\n');
  85
  86         *parse_start += end;
  87
  88         return 1;
  89     }
  90
  91     /*
  92      * If we didn't find the end of headers, and parse_start does
  93      * NOT point to a CR or NL character, then return failure
  94      */
  95     if (**parse_start != '\r' && **parse_start != '\n')
  96         return 0;               /* failure */
  97
  98     /*
  99      * If we didn't find the end of headers, and parse_start does point
 100      * to an empty line, then we have empty headers.  Skip all CR and
 101      * NL characters up to the first NL.  Leave parse_start pointing at
 102      * the first character after the first NL.
 103      */
 104     *blk_start = *parse_start;
 105
 106     *blk_end = *blk_start;
 107
 108     for (nnl = 0; nnl == 0; ++(*parse_start)) {
 109         if (**parse_start == '\r')
 110             (void) 0;
 111         else if (**parse_start == '\n')
 112             ++nnl;
 113         else
 114             break;
 115     }
 116
 117     return 1;
 118 }
 119
 120 /* find first CRLF */
 121 static int
 122 httpMsgIsolateStart(const char **parse_start, const char **blk_start, const char **blk_end)
 123 {
 124     int slen = strcspn(*parse_start, "\r\n");
 125
 126     if (!(*parse_start)[slen])  /* no CRLF found */
 127         return 0;
 128
 129     *blk_start = *parse_start;
 130
 131     *blk_end = *blk_start + slen;
 132
 133     while (**blk_end == '\r')   /* CR */
 134         ++(*blk_end);
 135
 136     if (**blk_end == '\n')      /* LF */
 137         ++(*blk_end);
 138
 139     *parse_start = *blk_end;
 140
 141     return 1;
 142 }
 143
 144 // negative return is the negated HTTP_ error code
 145 // zero return means need more data
 146 // positive return is the size of parsed headers
 147 bool HttpMsg::parse(MemBuf *buf, bool eof, http_status *error)
 148 {
 149     assert(error);
 150     *error = HTTP_STATUS_NONE;
 151
 152     // httpMsgParseStep() and debugging require 0-termination, unfortunately
 153     buf->terminate(); // does not affect content size
 154
 155     // find the end of headers
 156     const size_t hdr_len = headersEnd(buf->content(), buf->contentSize());
 157
 158     // sanity check the start line to see if this is in fact an HTTP message
 159     if (!sanityCheckStartLine(buf, hdr_len, error)) {
 160         // NP: sanityCheck sets *error and sends debug warnings on syntax errors.
 161         // if we have seen the connection close, this is an error too
 162         if (eof && *error==HTTP_STATUS_NONE)
 163             *error = HTTP_INVALID_HEADER;
 164
 165         return false;
 166     }
 167
 168     // TODO: move to httpReplyParseStep()
 169     if (hdr_len > Config.maxReplyHeaderSize || (hdr_len <= 0 && (size_t)buf->contentSize() > Config.maxReplyHeaderSize)) {
 170         debugs(58, DBG_IMPORTANT, "HttpMsg::parse: Too large reply header (" << hdr_len << " > " << Config.maxReplyHeaderSize);
 171         *error = HTTP_HEADER_TOO_LARGE;
 172         return false;
 173     }
 174
 175     if (hdr_len <= 0) {
 176         debugs(58, 3, "HttpMsg::parse: failed to find end of headers (eof: " << eof << ") in '" << buf->content() << "'");
 177
 178         if (eof) // iff we have seen the end, this is an error
 179             *error = HTTP_INVALID_HEADER;
 180
 181         return false;
 182     }
 183
 184     const int res = httpMsgParseStep(buf->content(), buf->contentSize(), eof);
 185
 186     if (res < 0) { // error
 187         debugs(58, 3, "HttpMsg::parse: cannot parse isolated headers in '" << buf->content() << "'");
 188         *error = HTTP_INVALID_HEADER;
 189         return false;
 190     }
 191
 192     if (res == 0) {
 193         debugs(58, 2, "HttpMsg::parse: strange, need more data near '" << buf->content() << "'");
 194         *error = HTTP_INVALID_HEADER;
 195         return false; // but this should not happen due to headersEnd() above
 196     }
 197
 198     assert(res > 0);
 199     debugs(58, 9, "HttpMsg::parse success (" << hdr_len << " bytes) near '" << buf->content() << "'");
 200
 201     if (hdr_sz != (int)hdr_len) {
 202         debugs(58, DBG_IMPORTANT, "internal HttpMsg::parse vs. headersEnd error: " <<
 203                hdr_sz << " != " << hdr_len);
 204         hdr_sz = (int)hdr_len; // because old http.cc code used hdr_len
 205     }
 206
 207     return true;
 208 }
 209
 210 /*
 211  * parseCharBuf() takes character buffer of HTTP headers (buf),
 212  * which may not be NULL-terminated, and fills in an HttpMsg
 213  * structure.  The parameter 'end' specifies the offset to
 214  * the end of the reply headers.  The caller may know where the
 215  * end is, but is unable to NULL-terminate the buffer.  This function
 216  * returns true on success.
 217  */
 218 bool
 219 HttpMsg::parseCharBuf(const char *buf, ssize_t end)
 220 {
 221     MemBuf mb;
 222     int success;
 223     /* reset current state, because we are not used in incremental fashion */
 224     reset();
 225     mb.init();
 226     mb.append(buf, end);
 227     mb.terminate();
 228     success = httpMsgParseStep(mb.buf, mb.size, 0);
 229     mb.clean();
 230     return success == 1;
 231 }
 232
 233 /*
 234  * parses a 0-terminating buffer into HttpMsg.
 235  * Returns:
 236  *      1 -- success
 237  *       0 -- need more data (partial parse)
 238  *      -1 -- parse error
 239  */
 240 int
 241 HttpMsg::httpMsgParseStep(const char *buf, int len, int atEnd)
 242 {
 243     const char *parse_start = buf;
 244     int parse_len = len;
 245     const char *blk_start, *blk_end;
 246     const char **parse_end_ptr = &blk_end;
 247     assert(parse_start);
 248     assert(pstate < psParsed);
 249
 250     *parse_end_ptr = parse_start;
 251
 252     PROF_start(HttpMsg_httpMsgParseStep);
 253
 254     if (pstate == psReadyToParseStartLine) {
 255         if (!httpMsgIsolateStart(&parse_start, &blk_start, &blk_end)) {
 256             PROF_stop(HttpMsg_httpMsgParseStep);
 257             return 0;
 258         }
 259
 260         if (!parseFirstLine(blk_start, blk_end)) {
 261             PROF_stop(HttpMsg_httpMsgParseStep);
 262             return httpMsgParseError();
 263         }
 264
 265         *parse_end_ptr = parse_start;
 266
 267         hdr_sz = *parse_end_ptr - buf;
 268         parse_len = parse_len - hdr_sz;
 269
 270         ++pstate;
 271     }
 272
 273     /*
 274      * XXX This code uses parse_start; but if we're incrementally parsing then
 275      * this code might not actually be given parse_start at the right spot (just
 276      * after headers.) Grr.
 277      */
 278     if (pstate == psReadyToParseHeaders) {
 279         if (!httpMsgIsolateHeaders(&parse_start, parse_len, &blk_start, &blk_end)) {
 280             if (atEnd) {
 281                 blk_start = parse_start, blk_end = blk_start + strlen(blk_start);
 282             } else {
 283                 PROF_stop(HttpMsg_httpMsgParseStep);
 284                 return 0;
 285             }
 286         }
 287
 288         if (!header.parse(blk_start, blk_end)) {
 289             PROF_stop(HttpMsg_httpMsgParseStep);
 290             return httpMsgParseError();
 291         }
 292
 293         hdrCacheInit();
 294
 295         *parse_end_ptr = parse_start;
 296
 297         hdr_sz = *parse_end_ptr - buf;
 298
 299         ++pstate;
 300     }
 301
 302     PROF_stop(HttpMsg_httpMsgParseStep);
 303     return 1;
 304 }
 305
 306 /* handy: resets and returns -1 */
 307 int
 308 HttpMsg::httpMsgParseError()
 309 {
 310     reset();
 311     return -1;
 312 }
 313
 314 void
 315 HttpMsg::setContentLength(int64_t clen)
 316 {
 317     header.delById(HDR_CONTENT_LENGTH); // if any
 318     header.putInt64(HDR_CONTENT_LENGTH, clen);
 319     content_length = clen;
 320 }
 321
 322 bool
 323 HttpMsg::persistent() const
 324 {
 325     if (http_ver > HttpVersion(1, 0)) {
 326         /*
 327          * for modern versions of HTTP: persistent unless there is
 328          * a "Connection: close" header.
 329          */
 330         return !httpHeaderHasConnDir(&header, "close");
 331     } else {
 332         /* for old versions of HTTP: persistent if has "keep-alive" */
 333         return httpHeaderHasConnDir(&header, "keep-alive");
 334     }
 335 }
 336
 337 void HttpMsg::packInto(Packer *p, bool full_uri) const
 338 {
 339     packFirstLineInto(p, full_uri);
 340     header.packInto(p);
 341     packerAppend(p, "\r\n", 2);
 342 }
 343
 344 void HttpMsg::hdrCacheInit()
 345 {
 346     content_length = header.getInt64(HDR_CONTENT_LENGTH);
 347     assert(NULL == cache_control);
 348     cache_control = header.getCc();
 349 }
 350
 351 /*
 352  * useful for debugging
 353  */
 354 void HttpMsg::firstLineBuf(MemBuf& mb)
 355 {
 356     Packer p;
 357     packerToMemInit(&p, &mb);
 358     packFirstLineInto(&p, true);
 359     packerClean(&p);
 360 }
 361
 362 // use HTTPMSGLOCK() instead of calling this directly
 363 HttpMsg *
 364 HttpMsg::_lock()
 365 {
 366     ++lock_count;
 367     return this;
 368 }
 369
 370 // use HTTPMSGUNLOCK() instead of calling this directly
 371 void
 372 HttpMsg::_unlock()
 373 {
 374     assert(lock_count > 0);
 375     --lock_count;
 376
 377     if (0 == lock_count)
 378         delete this;
 379 }