DXR is a code search and navigation tool aimed at making sense of large projects. It supports full-text and regex searches as well as structural queries.

Header

Mercurial (b3ecb5aef45a)

VCS Links

Line Code
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

// HttpLog.h should generally be included first
#include "HttpLog.h"

#include <errno.h>
#include "nsHttpChunkedDecoder.h"
#include <algorithm>
#include "plstr.h"

#include "mozilla/Unused.h"

namespace mozilla {
namespace net {

//-----------------------------------------------------------------------------
// nsHttpChunkedDecoder <public>
//-----------------------------------------------------------------------------

nsresult nsHttpChunkedDecoder::HandleChunkedContent(
    char* buf, uint32_t count, uint32_t* contentRead,
    uint32_t* contentRemaining) {
  LOG(("nsHttpChunkedDecoder::HandleChunkedContent [count=%u]\n", count));

  *contentRead = 0;

  // from RFC2616 section 3.6.1, the chunked transfer coding is defined as:
  //
  //   Chunked-Body    = *chunk
  //                     last-chunk
  //                     trailer
  //                     CRLF
  //   chunk           = chunk-size [ chunk-extension ] CRLF
  //                     chunk-data CRLF
  //   chunk-size      = 1*HEX
  //   last-chunk      = 1*("0") [ chunk-extension ] CRLF
  //
  //   chunk-extension = *( ";" chunk-ext-name [ "=" chunk-ext-val ] )
  //   chunk-ext-name  = token
  //   chunk-ext-val   = token | quoted-string
  //   chunk-data      = chunk-size(OCTET)
  //   trailer         = *(entity-header CRLF)
  //
  // the chunk-size field is a string of hex digits indicating the size of the
  // chunk.  the chunked encoding is ended by any chunk whose size is zero,
  // followed by the trailer, which is terminated by an empty line.

  while (count) {
    if (mChunkRemaining) {
      uint32_t amt = std::min(mChunkRemaining, count);

      count -= amt;
      mChunkRemaining -= amt;

      *contentRead += amt;
      buf += amt;
    } else if (mReachedEOF)
      break;  // done
    else {
      uint32_t bytesConsumed = 0;

      nsresult rv = ParseChunkRemaining(buf, count, &bytesConsumed);
      if (NS_FAILED(rv)) return rv;

      count -= bytesConsumed;

      if (count) {
        // shift buf by bytesConsumed
        memmove(buf, buf + bytesConsumed, count);
      }
    }
  }

  *contentRemaining = count;
  return NS_OK;
}

//-----------------------------------------------------------------------------
// nsHttpChunkedDecoder <private>
//-----------------------------------------------------------------------------

nsresult nsHttpChunkedDecoder::ParseChunkRemaining(char* buf, uint32_t count,
                                                   uint32_t* bytesConsumed) {
  MOZ_ASSERT(mChunkRemaining == 0, "chunk remaining should be zero");
  MOZ_ASSERT(count, "unexpected");

  *bytesConsumed = 0;

  char* p = static_cast<char*>(memchr(buf, '\n', count));
  if (p) {
    *p = 0;
    count = p - buf;                        // new length
    *bytesConsumed = count + 1;             // length + newline
    if ((p > buf) && (*(p - 1) == '\r')) {  // eliminate a preceding CR
      *(p - 1) = 0;
      count--;
    }

    // make buf point to the full line buffer to parse
    if (!mLineBuf.IsEmpty()) {
      mLineBuf.Append(buf, count);
      buf = (char*)mLineBuf.get();
      count = mLineBuf.Length();
    }

    if (mWaitEOF) {
      if (*buf) {
        LOG(("got trailer: %s\n", buf));
        // allocate a header array for the trailers on demand
        if (!mTrailers) {
          mTrailers = new nsHttpHeaderArray();
        }

        nsHttpAtom hdr = {nullptr};
        nsAutoCString headerNameOriginal;
        nsAutoCString val;
        if (NS_SUCCEEDED(
                mTrailers->ParseHeaderLine(nsDependentCSubstring(buf, count),
                                           &hdr, &headerNameOriginal, &val))) {
          if (hdr == nsHttp::Server_Timing) {
            Unused << mTrailers->SetHeaderFromNet(hdr, headerNameOriginal, val,
                                                  true);
          }
        }
      } else {
        mWaitEOF = false;
        mReachedEOF = true;
        LOG(("reached end of chunked-body\n"));
      }
    } else if (*buf) {
      char* endptr;
      unsigned long parsedval;  // could be 64 bit, could be 32

      // ignore any chunk-extensions
      if ((p = PL_strchr(buf, ';')) != nullptr) *p = 0;

      // mChunkRemaining is an uint32_t!
      parsedval = strtoul(buf, &endptr, 16);
      mChunkRemaining = (uint32_t)parsedval;

      if ((endptr == buf) || ((errno == ERANGE) && (parsedval == ULONG_MAX)) ||
          (parsedval != mChunkRemaining)) {
        LOG(("failed parsing hex on string [%s]\n", buf));
        return NS_ERROR_UNEXPECTED;
      }

      // we've discovered the last chunk
      if (mChunkRemaining == 0) mWaitEOF = true;
    }

    // ensure that the line buffer is clear
    mLineBuf.Truncate();
  } else {
    // save the partial line; wait for more data
    *bytesConsumed = count;
    // ignore a trailing CR
    if (buf[count - 1] == '\r') count--;
    mLineBuf.Append(buf, count);
  }

  return NS_OK;
}

}  // namespace net
}  // namespace mozilla