net/base/gzip_header.cc

   1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "net/base/gzip_header.h"
   6
   7 #include "base/logging.h"
   8 #include "third_party/zlib/zlib.h"
   9
  10 namespace net {
  11
  12 const uint8 GZipHeader::magic[] = { 0x1f, 0x8b };
  13
  14 GZipHeader::GZipHeader() {
  15   Reset();
  16 }
  17
  18 GZipHeader::~GZipHeader() {
  19 }
  20
  21 void GZipHeader::Reset() {
  22   state_        = IN_HEADER_ID1;
  23   flags_        = 0;
  24   extra_length_ = 0;
  25 }
  26
  27 GZipHeader::Status GZipHeader::ReadMore(const char* inbuf, int inbuf_len,
  28                                         const char** header_end) {
  29   DCHECK_GE(inbuf_len, 0);
  30   const uint8* pos = reinterpret_cast<const uint8*>(inbuf);
  31   const uint8* const end = pos + inbuf_len;
  32
  33   while ( pos < end ) {
  34     switch ( state_ ) {
  35       case IN_HEADER_ID1:
  36         if ( *pos != magic[0] )  return INVALID_HEADER;
  37         pos++;
  38         state_++;
  39         break;
  40       case IN_HEADER_ID2:
  41         if ( *pos != magic[1] )  return INVALID_HEADER;
  42         pos++;
  43         state_++;
  44         break;
  45       case IN_HEADER_CM:
  46         if ( *pos != Z_DEFLATED )  return INVALID_HEADER;
  47         pos++;
  48         state_++;
  49         break;
  50       case IN_HEADER_FLG:
  51         flags_ = (*pos) & (FLAG_FHCRC | FLAG_FEXTRA |
  52                            FLAG_FNAME | FLAG_FCOMMENT);
  53         pos++;
  54         state_++;
  55         break;
  56
  57       case IN_HEADER_MTIME_BYTE_0:
  58         pos++;
  59         state_++;
  60         break;
  61       case IN_HEADER_MTIME_BYTE_1:
  62         pos++;
  63         state_++;
  64         break;
  65       case IN_HEADER_MTIME_BYTE_2:
  66         pos++;
  67         state_++;
  68         break;
  69       case IN_HEADER_MTIME_BYTE_3:
  70         pos++;
  71         state_++;
  72         break;
  73
  74       case IN_HEADER_XFL:
  75         pos++;
  76         state_++;
  77         break;
  78
  79       case IN_HEADER_OS:
  80         pos++;
  81         state_++;
  82         break;
  83
  84       case IN_XLEN_BYTE_0:
  85         if ( !(flags_ & FLAG_FEXTRA) ) {
  86           state_ = IN_FNAME;
  87           break;
  88         }
  89         // We have a two-byte little-endian length, followed by a
  90         // field of that length.
  91         extra_length_ = *pos;
  92         pos++;
  93         state_++;
  94         break;
  95       case IN_XLEN_BYTE_1:
  96         extra_length_ += *pos << 8;
  97         pos++;
  98         state_++;
  99         // We intentionally fall through, because if we have a
 100         // zero-length FEXTRA, we want to check to notice that we're
 101         // done reading the FEXTRA before we exit this loop...
 102
 103       case IN_FEXTRA: {
 104         // Grab the rest of the bytes in the extra field, or as many
 105         // of them as are actually present so far.
 106         const int num_extra_bytes = static_cast<const int>(std::min(
 107             static_cast<ptrdiff_t>(extra_length_),
 108             (end - pos)));
 109         pos += num_extra_bytes;
 110         extra_length_ -= num_extra_bytes;
 111         if ( extra_length_ == 0 ) {
 112           state_ = IN_FNAME;   // advance when we've seen extra_length_ bytes
 113           flags_ &= ~FLAG_FEXTRA;   // we're done with the FEXTRA stuff
 114         }
 115         break;
 116       }
 117
 118       case IN_FNAME:
 119         if ( !(flags_ & FLAG_FNAME) ) {
 120           state_ = IN_FCOMMENT;
 121           break;
 122         }
 123         // See if we can find the end of the \0-terminated FNAME field.
 124         pos = reinterpret_cast<const uint8*>(memchr(pos, '\0', (end - pos)));
 125         if ( pos != NULL ) {
 126           pos++;  // advance past the '\0'
 127           flags_ &= ~FLAG_FNAME;   // we're done with the FNAME stuff
 128           state_ = IN_FCOMMENT;
 129         } else {
 130           pos = end;  // everything we have so far is part of the FNAME
 131         }
 132         break;
 133
 134       case IN_FCOMMENT:
 135         if ( !(flags_ & FLAG_FCOMMENT) ) {
 136           state_ = IN_FHCRC_BYTE_0;
 137           break;
 138         }
 139         // See if we can find the end of the \0-terminated FCOMMENT field.
 140         pos = reinterpret_cast<const uint8*>(memchr(pos, '\0', (end - pos)));
 141         if ( pos != NULL ) {
 142           pos++;  // advance past the '\0'
 143           flags_ &= ~FLAG_FCOMMENT;   // we're done with the FCOMMENT stuff
 144           state_ = IN_FHCRC_BYTE_0;
 145         } else {
 146           pos = end;  // everything we have so far is part of the FNAME
 147         }
 148         break;
 149
 150       case IN_FHCRC_BYTE_0:
 151         if ( !(flags_ & FLAG_FHCRC) ) {
 152           state_ = IN_DONE;
 153           break;
 154         }
 155         pos++;
 156         state_++;
 157         break;
 158
 159       case IN_FHCRC_BYTE_1:
 160         pos++;
 161         flags_ &= ~FLAG_FHCRC;   // we're done with the FHCRC stuff
 162         state_++;
 163         break;
 164
 165       case IN_DONE:
 166         *header_end = reinterpret_cast<const char*>(pos);
 167         return COMPLETE_HEADER;
 168     }
 169   }
 170
 171   if ( (state_ > IN_HEADER_OS) && (flags_ == 0) ) {
 172     *header_end = reinterpret_cast<const char*>(pos);
 173     return COMPLETE_HEADER;
 174   } else {
 175     return INCOMPLETE_HEADER;
 176   }
 177 }
 178
 179 }  // namespace net