src/third_party/WebKit/Source/modules/websockets/WebSocketDeflater.cpp

   1 /*
   2  * Copyright (C) 2012 Google Inc.  All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * met:
   7  *
   8  *     * Redistributions of source code must retain the above copyright
   9  * notice, this list of conditions and the following disclaimer.
  10  *     * Redistributions in binary form must reproduce the above
  11  * copyright notice, this list of conditions and the following disclaimer
  12  * in the documentation and/or other materials provided with the
  13  * distribution.
  14  *     * Neither the name of Google Inc. nor the names of its
  15  * contributors may be used to endorse or promote products derived from
  16  * this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #include "config.h"
  32 #include "modules/websockets/WebSocketDeflater.h"
  33
  34 #include "platform/Logging.h"
  35 #include "wtf/FastMalloc.h"
  36 #include "wtf/HashMap.h"
  37 #include "wtf/StdLibExtras.h"
  38 #include "wtf/StringExtras.h"
  39 #include "wtf/text/StringHash.h"
  40 #include "wtf/text/WTFString.h"
  41 #include <zlib.h>
  42
  43 namespace blink {
  44
  45 static const int defaultMemLevel = 1;
  46 static const size_t bufferIncrementUnit = 4096;
  47
  48 PassOwnPtr<WebSocketDeflater> WebSocketDeflater::create(int windowBits, ContextTakeOverMode contextTakeOverMode)
  49 {
  50     return adoptPtr(new WebSocketDeflater(windowBits, contextTakeOverMode));
  51 }
  52
  53 WebSocketDeflater::WebSocketDeflater(int windowBits, ContextTakeOverMode contextTakeOverMode)
  54     : m_windowBits(windowBits)
  55     , m_contextTakeOverMode(contextTakeOverMode)
  56     , m_isBytesAdded(false)
  57 {
  58     ASSERT(m_windowBits >= 8);
  59     ASSERT(m_windowBits <= 15);
  60     m_stream = adoptPtr(new z_stream);
  61     memset(m_stream.get(), 0, sizeof(z_stream));
  62 }
  63
  64 bool WebSocketDeflater::initialize()
  65 {
  66     return deflateInit2(m_stream.get(), Z_DEFAULT_COMPRESSION, Z_DEFLATED, -m_windowBits, defaultMemLevel, Z_DEFAULT_STRATEGY) == Z_OK;
  67 }
  68
  69 WebSocketDeflater::~WebSocketDeflater()
  70 {
  71     int result = deflateEnd(m_stream.get());
  72     if (result != Z_OK)
  73         WTF_LOG(Network, "WebSocketDeflater %p Destructor deflateEnd() failed: %d is returned", this, result);
  74 }
  75
  76 static void setStreamParameter(z_stream* stream, const char* inputData, size_t inputLength, char* outputData, size_t outputLength)
  77 {
  78     stream->next_in = reinterpret_cast<Bytef*>(const_cast<char*>(inputData));
  79     stream->avail_in = inputLength;
  80     stream->next_out = reinterpret_cast<Bytef*>(outputData);
  81     stream->avail_out = outputLength;
  82 }
  83
  84 bool WebSocketDeflater::addBytes(const char* data, size_t length)
  85 {
  86     if (!length)
  87         return false;
  88
  89     // The estimation by deflateBound is not accurate if the zlib has some remaining input of the last compression.
  90     size_t maxLength = deflateBound(m_stream.get(), length);
  91     do {
  92         size_t writePosition = m_buffer.size();
  93         m_buffer.grow(writePosition + maxLength);
  94         setStreamParameter(m_stream.get(), data, length, m_buffer.data() + writePosition, maxLength);
  95         int result = deflate(m_stream.get(), Z_NO_FLUSH);
  96         if (result != Z_OK)
  97             return false;
  98         m_buffer.shrink(writePosition + maxLength - m_stream->avail_out);
  99         maxLength *= 2;
 100     } while (m_stream->avail_in > 0);
 101     m_isBytesAdded = true;
 102     return true;
 103 }
 104
 105 bool WebSocketDeflater::finish()
 106 {
 107     if (!m_isBytesAdded) {
 108         // Since consecutive calls of deflate with Z_SYNC_FLUSH and no input lead to an error,
 109         // we create and return the output for the empty input manually.
 110         ASSERT(!m_buffer.size());
 111         m_buffer.append("\x00", 1);
 112         return true;
 113     }
 114     while (true) {
 115         size_t writePosition = m_buffer.size();
 116         m_buffer.grow(writePosition + bufferIncrementUnit);
 117         size_t availableCapacity = m_buffer.size() - writePosition;
 118         setStreamParameter(m_stream.get(), 0, 0, m_buffer.data() + writePosition, availableCapacity);
 119         int result = deflate(m_stream.get(), Z_SYNC_FLUSH);
 120         m_buffer.shrink(writePosition + availableCapacity - m_stream->avail_out);
 121         if (result == Z_OK)
 122             break;
 123         if (result != Z_BUF_ERROR)
 124             return false;
 125     }
 126     // Remove 4 octets from the tail as the specification requires.
 127     if (m_buffer.size() <= 4)
 128         return false;
 129     m_buffer.resize(m_buffer.size() - 4);
 130     m_isBytesAdded = false;
 131     return true;
 132 }
 133
 134 void WebSocketDeflater::reset()
 135 {
 136     m_buffer.clear();
 137     m_isBytesAdded = false;
 138     if (m_contextTakeOverMode == DoNotTakeOverContext)
 139         deflateReset(m_stream.get());
 140 }
 141
 142 void WebSocketDeflater::softReset()
 143 {
 144     m_buffer.clear();
 145 }
 146
 147 PassOwnPtr<WebSocketInflater> WebSocketInflater::create(int windowBits)
 148 {
 149     return adoptPtr(new WebSocketInflater(windowBits));
 150 }
 151
 152 WebSocketInflater::WebSocketInflater(int windowBits)
 153     : m_windowBits(windowBits)
 154 {
 155     m_stream = adoptPtr(new z_stream);
 156     memset(m_stream.get(), 0, sizeof(z_stream));
 157 }
 158
 159 bool WebSocketInflater::initialize()
 160 {
 161     return inflateInit2(m_stream.get(), -m_windowBits) == Z_OK;
 162 }
 163
 164 WebSocketInflater::~WebSocketInflater()
 165 {
 166     int result = inflateEnd(m_stream.get());
 167     if (result != Z_OK)
 168         WTF_LOG(Network, "WebSocketInflater %p Destructor inflateEnd() failed: %d is returned", this, result);
 169 }
 170
 171 bool WebSocketInflater::addBytes(const char* data, size_t length)
 172 {
 173     if (!length)
 174         return false;
 175
 176     size_t consumedSoFar = 0;
 177     while (consumedSoFar < length) {
 178         size_t writePosition = m_buffer.size();
 179         m_buffer.grow(writePosition + bufferIncrementUnit);
 180         size_t availableCapacity = m_buffer.size() - writePosition;
 181         size_t remainingLength = length - consumedSoFar;
 182         setStreamParameter(m_stream.get(), data + consumedSoFar, remainingLength, m_buffer.data() + writePosition, availableCapacity);
 183         int result = inflate(m_stream.get(), Z_NO_FLUSH);
 184         consumedSoFar += remainingLength - m_stream->avail_in;
 185         m_buffer.shrink(writePosition + availableCapacity - m_stream->avail_out);
 186         if (result == Z_BUF_ERROR)
 187             continue;
 188         if (result == Z_STREAM_END) {
 189             // Received a block with BFINAL set to 1. Reset decompression state.
 190             if (inflateReset(m_stream.get()) != Z_OK)
 191                 return false;
 192             continue;
 193         }
 194         if (result != Z_OK)
 195             return false;
 196         ASSERT(remainingLength > m_stream->avail_in);
 197     }
 198     ASSERT(consumedSoFar == length);
 199     return true;
 200 }
 201
 202 bool WebSocketInflater::finish()
 203 {
 204     static const char strippedFields[] = "\0\0\xff\xff";
 205     static const size_t strippedLength = 4;
 206
 207     // Appends 4 octests of 0x00 0x00 0xff 0xff
 208     size_t consumedSoFar = 0;
 209     while (consumedSoFar < strippedLength) {
 210         size_t writePosition = m_buffer.size();
 211         m_buffer.grow(writePosition + bufferIncrementUnit);
 212         size_t availableCapacity = m_buffer.size() - writePosition;
 213         size_t remainingLength = strippedLength - consumedSoFar;
 214         setStreamParameter(m_stream.get(), strippedFields + consumedSoFar, remainingLength, m_buffer.data() + writePosition, availableCapacity);
 215         int result = inflate(m_stream.get(), Z_FINISH);
 216         consumedSoFar += remainingLength - m_stream->avail_in;
 217         m_buffer.shrink(writePosition + availableCapacity - m_stream->avail_out);
 218         if (result == Z_BUF_ERROR)
 219             continue;
 220         if (result != Z_OK && result != Z_STREAM_END)
 221             return false;
 222         ASSERT(remainingLength > m_stream->avail_in);
 223     }
 224     ASSERT(consumedSoFar == strippedLength);
 225
 226     return true;
 227 }
 228
 229 void WebSocketInflater::reset()
 230 {
 231     m_buffer.clear();
 232 }
 233
 234 } // namespace blink
 235