1// Protocol Buffers - Google's data interchange format
2// Copyright 2008 Google Inc.  All rights reserved.
3// https://developers.google.com/protocol-buffers/
4//
5// Redistribution and use in source and binary forms, with or without
6// modification, are permitted provided that the following conditions are
7// met:
8//
9//     * Redistributions of source code must retain the above copyright
10// notice, this list of conditions and the following disclaimer.
11//     * Redistributions in binary form must reproduce the above
12// copyright notice, this list of conditions and the following disclaimer
13// in the documentation and/or other materials provided with the
14// distribution.
15//     * Neither the name of Google Inc. nor the names of its
16// contributors may be used to endorse or promote products derived from
17// this software without specific prior written permission.
18//
19// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30
31// Author: brianolson@google.com (Brian Olson)
32//
33// This file contains the definition for classes GzipInputStream and
34// GzipOutputStream.
35//
36// GzipInputStream decompresses data from an underlying
37// ZeroCopyInputStream and provides the decompressed data as a
38// ZeroCopyInputStream.
39//
40// GzipOutputStream is an ZeroCopyOutputStream that compresses data to
41// an underlying ZeroCopyOutputStream.
42
43#ifndef GOOGLE_PROTOBUF_IO_GZIP_STREAM_H__
44#define GOOGLE_PROTOBUF_IO_GZIP_STREAM_H__
45
46#include <google/protobuf/stubs/common.h>
47#include <google/protobuf/io/zero_copy_stream.h>
48#include <zlib.h>
49
50namespace google {
51namespace protobuf {
52namespace io {
53
54// A ZeroCopyInputStream that reads compressed data through zlib
55class LIBPROTOBUF_EXPORT GzipInputStream : public ZeroCopyInputStream {
56 public:
57  // Format key for constructor
58  enum Format {
59    // zlib will autodetect gzip header or deflate stream
60    AUTO = 0,
61
62    // GZIP streams have some extra header data for file attributes.
63    GZIP = 1,
64
65    // Simpler zlib stream format.
66    ZLIB = 2,
67  };
68
69  // buffer_size and format may be -1 for default of 64kB and GZIP format
70  explicit GzipInputStream(
71      ZeroCopyInputStream* sub_stream,
72      Format format = AUTO,
73      int buffer_size = -1);
74  virtual ~GzipInputStream();
75
76  // Return last error message or NULL if no error.
77  inline const char* ZlibErrorMessage() const {
78    return zcontext_.msg;
79  }
80  inline int ZlibErrorCode() const {
81    return zerror_;
82  }
83
84  // implements ZeroCopyInputStream ----------------------------------
85  bool Next(const void** data, int* size);
86  void BackUp(int count);
87  bool Skip(int count);
88  int64 ByteCount() const;
89
90 private:
91  Format format_;
92
93  ZeroCopyInputStream* sub_stream_;
94
95  z_stream zcontext_;
96  int zerror_;
97
98  void* output_buffer_;
99  void* output_position_;
100  size_t output_buffer_length_;
101  int64 byte_count_;
102
103  int Inflate(int flush);
104  void DoNextOutput(const void** data, int* size);
105
106  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(GzipInputStream);
107};
108
109
110class LIBPROTOBUF_EXPORT GzipOutputStream : public ZeroCopyOutputStream {
111 public:
112  // Format key for constructor
113  enum Format {
114    // GZIP streams have some extra header data for file attributes.
115    GZIP = 1,
116
117    // Simpler zlib stream format.
118    ZLIB = 2,
119  };
120
121  struct Options {
122    // Defaults to GZIP.
123    Format format;
124
125    // What size buffer to use internally.  Defaults to 64kB.
126    int buffer_size;
127
128    // A number between 0 and 9, where 0 is no compression and 9 is best
129    // compression.  Defaults to Z_DEFAULT_COMPRESSION (see zlib.h).
130    int compression_level;
131
132    // Defaults to Z_DEFAULT_STRATEGY.  Can also be set to Z_FILTERED,
133    // Z_HUFFMAN_ONLY, or Z_RLE.  See the documentation for deflateInit2 in
134    // zlib.h for definitions of these constants.
135    int compression_strategy;
136
137    Options();  // Initializes with default values.
138  };
139
140  // Create a GzipOutputStream with default options.
141  explicit GzipOutputStream(ZeroCopyOutputStream* sub_stream);
142
143  // Create a GzipOutputStream with the given options.
144  GzipOutputStream(
145      ZeroCopyOutputStream* sub_stream,
146      const Options& options);
147
148  virtual ~GzipOutputStream();
149
150  // Return last error message or NULL if no error.
151  inline const char* ZlibErrorMessage() const {
152    return zcontext_.msg;
153  }
154  inline int ZlibErrorCode() const {
155    return zerror_;
156  }
157
158  // Flushes data written so far to zipped data in the underlying stream.
159  // It is the caller's responsibility to flush the underlying stream if
160  // necessary.
161  // Compression may be less efficient stopping and starting around flushes.
162  // Returns true if no error.
163  //
164  // Please ensure that block size is > 6. Here is an excerpt from the zlib
165  // doc that explains why:
166  //
167  // In the case of a Z_FULL_FLUSH or Z_SYNC_FLUSH, make sure that avail_out
168  // is greater than six to avoid repeated flush markers due to
169  // avail_out == 0 on return.
170  bool Flush();
171
172  // Writes out all data and closes the gzip stream.
173  // It is the caller's responsibility to close the underlying stream if
174  // necessary.
175  // Returns true if no error.
176  bool Close();
177
178  // implements ZeroCopyOutputStream ---------------------------------
179  bool Next(void** data, int* size);
180  void BackUp(int count);
181  int64 ByteCount() const;
182
183 private:
184  ZeroCopyOutputStream* sub_stream_;
185  // Result from calling Next() on sub_stream_
186  void* sub_data_;
187  int sub_data_size_;
188
189  z_stream zcontext_;
190  int zerror_;
191  void* input_buffer_;
192  size_t input_buffer_length_;
193
194  // Shared constructor code.
195  void Init(ZeroCopyOutputStream* sub_stream, const Options& options);
196
197  // Do some compression.
198  // Takes zlib flush mode.
199  // Returns zlib error code.
200  int Deflate(int flush);
201
202  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(GzipOutputStream);
203};
204
205}  // namespace io
206}  // namespace protobuf
207
208}  // namespace google
209#endif  // GOOGLE_PROTOBUF_IO_GZIP_STREAM_H__
210