Attn: Mike Belshe

net/spdy/spdy_framer.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // TODO(rtenhove) clean up frame buffer size calculations so that we aren't
 // constantly adding and subtracting header sizes; this is ugly and error-
 // prone.
 
 #include "net/spdy/spdy_framer.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/stats_counters.h"
 #include "base/third_party/valgrind/memcheck.h"
 #include "net/spdy/spdy_frame_builder.h"
 #include "net/spdy/spdy_bitmasks.h"
 
 #if defined(USE_SYSTEM_ZLIB)
 #include <zlib.h>
 #else
 #include "third_party/zlib/zlib.h"
 #endif
 
+namespace net {
+

[Mike Belshe, 2011/04/06 18:32:53]

delete lines 22-25.

+}  // namespace net
+
 namespace {
 
 // The following compression setting are based on Brian Olson's analysis. See
 // https://groups.google.com/group/spdy-dev/browse_thread/thread/dfaf498542fac792
 // for more details.
 const int kCompressorLevel = 9;
 const int kCompressorWindowSizeInBits = 11;
 const int kCompressorMemLevel = 1;
 
-uLong dictionary_id = 0;
+// TODO(jtl): Need to decide how to handle this.  The array dimension must be as
+// large as the maximum SCTP stream ID we will ever use.
+uLong dictionary_ids[100] = {0};
 
 }  // namespace
 
 namespace spdy {
 
 // This is just a hacked dictionary to use for shrinking HTTP-like headers.
 // TODO(mbelshe): Use a scientific methodology for computing the dictionary.
 const char SpdyFramer::kDictionary[] =
   "optionsgetheadpostputdeletetraceacceptaccept-charsetaccept-encodingaccept-"
   "languageauthorizationexpectfromhostif-modified-sinceif-matchif-none-matchi"
@@ skipping 43 matching lines @@
       remaining_payload_(0),
       remaining_control_payload_(0),
       current_frame_buffer_(NULL),
       current_frame_len_(0),
       current_frame_capacity_(0),
       enable_compression_(compression_default_),
       visitor_(NULL) {
 }
 
 SpdyFramer::~SpdyFramer() {
-  if (header_compressor_.get()) {
-    deflateEnd(header_compressor_.get());
-  }
-  if (header_decompressor_.get()) {
-    inflateEnd(header_decompressor_.get());
-  }
+  CleanupHeaderCompressorsAndDecompressors();
   CleanupStreamCompressorsAndDecompressors();
   delete [] current_frame_buffer_;
 }
 
 size_t SpdyFramer::ProcessInput(const char* data, size_t len) {
   DCHECK(visitor_);
   DCHECK(data);
 
   size_t original_len = len;
   while (len != 0) {
@@ skipping 681 matching lines @@
         current_data_frame.flags() & DATA_FLAG_FIN) {
       visitor_->OnStreamFrameData(current_data_frame.stream_id(), NULL, 0);
       CleanupDecompressorForStream(current_data_frame.stream_id());
     }
   } else {
     CHANGE_STATE(SPDY_AUTO_RESET);
   }
   return original_len - len;
 }
 
-z_stream* SpdyFramer::GetHeaderCompressor() {
-  if (header_compressor_.get())
-    return header_compressor_.get();  // Already initialized.
+uint16 SpdyFramer::GetDictionaryIndex(const SpdyControlFrame& control_frame) {
+  uint32 stream_id = 0;
+  // TODO(jtl): Need to reconcile this with IsCompressible() which only returns
+  // true for SYN_STREAM and SYN_REPLY control frames.
+  switch (control_frame.type()) {
+    case SYN_STREAM:
+      stream_id = reinterpret_cast<const SpdySynStreamControlFrame&>
+                      (control_frame).stream_id();
+      break;
+    case SYN_REPLY:
+      stream_id = reinterpret_cast<const SpdySynReplyControlFrame&>
+                      (control_frame).stream_id();
+      break;
+    case RST_STREAM:
+      stream_id = reinterpret_cast<const SpdyRstStreamControlFrame&>
+                      (control_frame).stream_id();
+      break;
+    case HEADERS:
+      stream_id = reinterpret_cast<const SpdyHeadersControlFrame&>
+                      (control_frame).stream_id();
+      break;
+    case WINDOW_UPDATE:
+      stream_id = reinterpret_cast<const SpdyWindowUpdateControlFrame&>
+                      (control_frame).stream_id();
+      break;
+    default:
+      break;
+  }
 
-  header_compressor_.reset(new z_stream);
-  memset(header_compressor_.get(), 0, sizeof(z_stream));
+  return stream_id ? MapSpdyToSctp(stream_id) : 0;
+}
 
-  int success = deflateInit2(header_compressor_.get(),
+z_stream* SpdyFramer::GetHeaderCompressor(int index) {
+  CompressorMap::iterator it = header_compressors_.find(index);
+  if (it != header_compressors_.end())
+    return it->second;  // Already initialized.
+
+  scoped_ptr<z_stream> compressor(new z_stream);
+  memset(compressor.get(), 0, sizeof(z_stream));
+
+  int success = deflateInit2(compressor.get(),
                              kCompressorLevel,
                              Z_DEFLATED,
                              kCompressorWindowSizeInBits,
                              kCompressorMemLevel,
                              Z_DEFAULT_STRATEGY);
   if (success == Z_OK)
-    success = deflateSetDictionary(header_compressor_.get(),
+    success = deflateSetDictionary(compressor.get(),
                                    reinterpret_cast<const Bytef*>(kDictionary),
                                    kDictionarySize);
   if (success != Z_OK) {
     LOG(WARNING) << "deflateSetDictionary failure: " << success;
-    header_compressor_.reset(NULL);
+    compressor.reset(NULL);
     return NULL;
   }
-  return header_compressor_.get();
+  return header_compressors_[index] = compressor.release();
 }
 
-z_stream* SpdyFramer::GetHeaderDecompressor() {
-  if (header_decompressor_.get())
-    return header_decompressor_.get();  // Already initialized.
+z_stream* SpdyFramer::GetHeaderDecompressor(int index) {
+  CompressorMap::iterator it = header_decompressors_.find(index);
+  if (it != header_decompressors_.end())
+    return it->second;  // Already initialized.
 
-  header_decompressor_.reset(new z_stream);
-  memset(header_decompressor_.get(), 0, sizeof(z_stream));
+  scoped_ptr<z_stream> decompressor(new z_stream);
+  memset(decompressor.get(), 0, sizeof(z_stream));
 
   // Compute the id of our dictionary so that we know we're using the
   // right one when asked for it.
-  if (dictionary_id == 0) {
-    dictionary_id = adler32(0L, Z_NULL, 0);
-    dictionary_id = adler32(dictionary_id,
+  if (dictionary_ids[index] == 0) {
+    dictionary_ids[index] = adler32(0L, Z_NULL, 0);
+    dictionary_ids[index] = adler32(dictionary_ids[index],
                             reinterpret_cast<const Bytef*>(kDictionary),
                             kDictionarySize);
   }
 
-  int success = inflateInit(header_decompressor_.get());
+  int success = inflateInit(decompressor.get());
   if (success != Z_OK) {
     LOG(WARNING) << "inflateInit failure: " << success;
-    header_decompressor_.reset(NULL);
     return NULL;
   }
-  return header_decompressor_.get();
+  return header_decompressors_[index] = decompressor.release();
 }
 
 z_stream* SpdyFramer::GetStreamCompressor(SpdyStreamId stream_id) {
   CompressorMap::iterator it = stream_compressors_.find(stream_id);
   if (it != stream_compressors_.end())
     return it->second;  // Already initialized.
 
   scoped_ptr<z_stream> compressor(new z_stream);
   memset(compressor.get(), 0, sizeof(z_stream));
 
@@ skipping 21 matching lines @@
   int success = inflateInit(decompressor.get());
   if (success != Z_OK) {
     LOG(WARNING) << "inflateInit failure: " << success;
     return NULL;
   }
   return stream_decompressors_[stream_id] = decompressor.release();
 }
 
 SpdyControlFrame* SpdyFramer::CompressControlFrame(
     const SpdyControlFrame& frame) {
-  z_stream* compressor = GetHeaderCompressor();
+  uint16 dictionary_index = 0;
+  if (using_sctp() && !using_sctp_control_stream())
+    dictionary_index = GetDictionaryIndex(frame);
+  z_stream* compressor = GetHeaderCompressor(dictionary_index);
+
   if (!compressor)
     return NULL;
   return reinterpret_cast<SpdyControlFrame*>(
       CompressFrameWithZStream(frame, compressor));
 }
 
 SpdyDataFrame* SpdyFramer::CompressDataFrame(const SpdyDataFrame& frame) {
   z_stream* compressor = GetStreamCompressor(frame.stream_id());
   if (!compressor)
     return NULL;
   return reinterpret_cast<SpdyDataFrame*>(
       CompressFrameWithZStream(frame, compressor));
 }
 
 SpdyControlFrame* SpdyFramer::DecompressControlFrame(
     const SpdyControlFrame& frame) {
-  z_stream* decompressor = GetHeaderDecompressor();
+  uint16 dictionary_index = 0;
+  if (using_sctp() && !using_sctp_control_stream())
+    dictionary_index = GetDictionaryIndex(frame);
+  z_stream* decompressor = GetHeaderDecompressor(dictionary_index);
+
   if (!decompressor)
     return NULL;
   return reinterpret_cast<SpdyControlFrame*>(
       DecompressFrameWithZStream(frame, decompressor));
 }
 
 SpdyDataFrame* SpdyFramer::DecompressDataFrame(const SpdyDataFrame& frame) {
   z_stream* decompressor = GetStreamDecompressor(frame.stream_id());
   if (!decompressor)
     return NULL;
@@ skipping 99 matching lines @@
 
   decompressor->next_in = reinterpret_cast<Bytef*>(const_cast<char*>(payload));
   decompressor->avail_in = payload_length;
   decompressor->next_out = reinterpret_cast<Bytef*>(new_frame->data()) +
       header_length;
   decompressor->avail_out = decompressed_max_size;
 
   int rv = inflate(decompressor, Z_SYNC_FLUSH);
   if (rv == Z_NEED_DICT) {
     // Need to try again with the right dictionary.
-    if (decompressor->adler == dictionary_id) {
+    uint16 dictionary_index = 0;
+    if (using_sctp() && !using_sctp_control_stream() &&
+        frame.is_control_frame()) {
+      dictionary_index = GetDictionaryIndex(
+          reinterpret_cast<const SpdyControlFrame&>(frame));
+    }
+    if (decompressor->adler == dictionary_ids[dictionary_index]) {
       rv = inflateSetDictionary(decompressor, (const Bytef*)kDictionary,
                                 kDictionarySize);
       if (rv == Z_OK)
         rv = inflate(decompressor, Z_SYNC_FLUSH);
     }
   }
   if (rv != Z_OK) {  // How can we know that it decompressed everything?
     LOG(WARNING) << "inflate failure: " << rv;
     return NULL;
   }
@@ skipping 56 matching lines @@
   it = stream_decompressors_.begin();
   while (it != stream_decompressors_.end()) {
     z_stream* decompressor = it->second;
     inflateEnd(decompressor);
     delete decompressor;
     ++it;
   }
   stream_decompressors_.clear();
 }
 
+void SpdyFramer::CleanupHeaderCompressorsAndDecompressors() {
+  CompressorMap::iterator it;
+
+  it = header_compressors_.begin();
+  while (it != header_compressors_.end()) {
+    z_stream* compressor = it->second;
+    deflateEnd(compressor);
+    delete compressor;
+    ++it;
+  }
+  header_compressors_.clear();
+
+  it = header_decompressors_.begin();
+  while (it != header_decompressors_.end()) {
+    z_stream* decompressor = it->second;
+    inflateEnd(decompressor);
+    delete decompressor;
+    ++it;
+  }
+  header_decompressors_.clear();
+}
+
 size_t SpdyFramer::BytesSafeToRead() const {
   switch (state_) {
     case SPDY_ERROR:
     case SPDY_DONE:
     case SPDY_AUTO_RESET:
     case SPDY_RESET:
       return 0;
     case SPDY_READING_COMMON_HEADER:
       DCHECK_LT(current_frame_len_, SpdyFrame::size());
       return SpdyFrame::size() - current_frame_len_;
@@ skipping 73 matching lines @@
   } else {
     frame_size = SpdyFrame::size();
     *header_length = frame_size;
     *payload_length = frame.length();
     *payload = frame.data() + SpdyFrame::size();
   }
   return true;
 }
 
 }  // namespace spdy