← Back to branch summary

~ubuntu-branches/ubuntu/natty/clamav/natty-security

« back to all changes in this revision

Viewing changes to win32/3rdparty/zlib/contrib/iostream2/zstream.h

  • Committer: Bazaar Package Importer
  • Author(s): Scott Kitterman
  • Date: 2011-02-19 09:51:33 UTC
  • mfrom: (0.35.19 sid)
  • Revision ID: james.westby@ubuntu.com-20110219095133-sde2dyj8a6bjbkdh
Tags: 0.97+dfsg-0ubuntu1
* Merge from debian unstable (0ubuntu1 because the Debian upload was
  inadvertently left marked UNRELEASED).  Remaining changes:
  - Drop initial signature definitions from clamav-base
  - Drop build-dep on electric-fence (in Universe)
  - Add apparmor profiles for clamd and freshclam along with maintainer
    script changes

Show diffs side-by-side

added added

removed removed

Lines of Context:
win32/3rdparty/zlib/contrib/iostream2/zstream.h
 
1
/*
 
2
 *
 
3
 * Copyright (c) 1997
 
4
 * Christian Michelsen Research AS
 
5
 * Advanced Computing
 
6
 * Fantoftvegen 38, 5036 BERGEN, Norway
 
7
 * http://www.cmr.no
 
8
 *
 
9
 * Permission to use, copy, modify, distribute and sell this software
 
10
 * and its documentation for any purpose is hereby granted without fee,
 
11
 * provided that the above copyright notice appear in all copies and
 
12
 * that both that copyright notice and this permission notice appear
 
13
 * in supporting documentation.  Christian Michelsen Research AS makes no
 
14
 * representations about the suitability of this software for any
 
15
 * purpose.  It is provided "as is" without express or implied warranty.
 
16
 *
 
17
 */
 
18
 
 
19
#ifndef ZSTREAM__H
 
20
#define ZSTREAM__H
 
21
 
 
22
/*
 
23
 * zstream.h - C++ interface to the 'zlib' general purpose compression library
 
24
 * $Id: zstream.h 1.1 1997-06-25 12:00:56+02 tyge Exp tyge $
 
25
 */
 
26
 
 
27
#include <strstream.h>
 
28
#include <string.h>
 
29
#include <stdio.h>
 
30
#include "zlib.h"
 
31
 
 
32
#if defined(_WIN32)
 
33
#   include <fcntl.h>
 
34
#   include <io.h>
 
35
#   define SET_BINARY_MODE(file) setmode(fileno(file), O_BINARY)
 
36
#else
 
37
#   define SET_BINARY_MODE(file)
 
38
#endif
 
39
 
 
40
class zstringlen {
 
41
public:
 
42
    zstringlen(class izstream&);
 
43
    zstringlen(class ozstream&, const char*);
 
44
    size_t value() const { return val.word; }
 
45
private:
 
46
    struct Val { unsigned char byte; size_t word; } val;
 
47
};
 
48
 
 
49
//  ----------------------------- izstream -----------------------------
 
50
 
 
51
class izstream
 
52
{
 
53
    public:
 
54
        izstream() : m_fp(0) {}
 
55
        izstream(FILE* fp) : m_fp(0) { open(fp); }
 
56
        izstream(const char* name) : m_fp(0) { open(name); }
 
57
        ~izstream() { close(); }
 
58
 
 
59
        /* Opens a gzip (.gz) file for reading.
 
60
         * open() can be used to read a file which is not in gzip format;
 
61
         * in this case read() will directly read from the file without
 
62
         * decompression. errno can be checked to distinguish two error
 
63
         * cases (if errno is zero, the zlib error is Z_MEM_ERROR).
 
64
         */
 
65
        void open(const char* name) {
 
66
            if (m_fp) close();
 
67
            m_fp = ::gzopen(name, "rb");
 
68
        }
 
69
 
 
70
        void open(FILE* fp) {
 
71
            SET_BINARY_MODE(fp);
 
72
            if (m_fp) close();
 
73
            m_fp = ::gzdopen(fileno(fp), "rb");
 
74
        }
 
75
 
 
76
        /* Flushes all pending input if necessary, closes the compressed file
 
77
         * and deallocates all the (de)compression state. The return value is
 
78
         * the zlib error number (see function error() below).
 
79
         */
 
80
        int close() {
 
81
            int r = ::gzclose(m_fp);
 
82
            m_fp = 0; return r;
 
83
        }
 
84
 
 
85
        /* Binary read the given number of bytes from the compressed file.
 
86
         */
 
87
        int read(void* buf, size_t len) {
 
88
            return ::gzread(m_fp, buf, len);
 
89
        }
 
90
 
 
91
        /* Returns the error message for the last error which occurred on the
 
92
         * given compressed file. errnum is set to zlib error number. If an
 
93
         * error occurred in the file system and not in the compression library,
 
94
         * errnum is set to Z_ERRNO and the application may consult errno
 
95
         * to get the exact error code.
 
96
         */
 
97
        const char* error(int* errnum) {
 
98
            return ::gzerror(m_fp, errnum);
 
99
        }
 
100
 
 
101
        gzFile fp() { return m_fp; }
 
102
 
 
103
    private:
 
104
        gzFile m_fp;
 
105
};
 
106
 
 
107
/*
 
108
 * Binary read the given (array of) object(s) from the compressed file.
 
109
 * If the input file was not in gzip format, read() copies the objects number
 
110
 * of bytes into the buffer.
 
111
 * returns the number of uncompressed bytes actually read
 
112
 * (0 for end of file, -1 for error).
 
113
 */
 
114
template <class T, class Items>
 
115
inline int read(izstream& zs, T* x, Items items) {
 
116
    return ::gzread(zs.fp(), x, items*sizeof(T));
 
117
}
 
118
 
 
119
/*
 
120
 * Binary input with the '>' operator.
 
121
 */
 
122
template <class T>
 
123
inline izstream& operator>(izstream& zs, T& x) {
 
124
    ::gzread(zs.fp(), &x, sizeof(T));
 
125
    return zs;
 
126
}
 
127
 
 
128
 
 
129
inline zstringlen::zstringlen(izstream& zs) {
 
130
    zs > val.byte;
 
131
    if (val.byte == 255) zs > val.word;
 
132
    else val.word = val.byte;
 
133
}
 
134
 
 
135
/*
 
136
 * Read length of string + the string with the '>' operator.
 
137
 */
 
138
inline izstream& operator>(izstream& zs, char* x) {
 
139
    zstringlen len(zs);
 
140
    ::gzread(zs.fp(), x, len.value());
 
141
    x[len.value()] = '\0';
 
142
    return zs;
 
143
}
 
144
 
 
145
inline char* read_string(izstream& zs) {
 
146
    zstringlen len(zs);
 
147
    char* x = new char[len.value()+1];
 
148
    ::gzread(zs.fp(), x, len.value());
 
149
    x[len.value()] = '\0';
 
150
    return x;
 
151
}
 
152
 
 
153
// ----------------------------- ozstream -----------------------------
 
154
 
 
155
class ozstream
 
156
{
 
157
    public:
 
158
        ozstream() : m_fp(0), m_os(0) {
 
159
        }
 
160
        ozstream(FILE* fp, int level = Z_DEFAULT_COMPRESSION)
 
161
            : m_fp(0), m_os(0) {
 
162
            open(fp, level);
 
163
        }
 
164
        ozstream(const char* name, int level = Z_DEFAULT_COMPRESSION)
 
165
            : m_fp(0), m_os(0) {
 
166
            open(name, level);
 
167
        }
 
168
        ~ozstream() {
 
169
            close();
 
170
        }
 
171
 
 
172
        /* Opens a gzip (.gz) file for writing.
 
173
         * The compression level parameter should be in 0..9
 
174
         * errno can be checked to distinguish two error cases
 
175
         * (if errno is zero, the zlib error is Z_MEM_ERROR).
 
176
         */
 
177
        void open(const char* name, int level = Z_DEFAULT_COMPRESSION) {
 
178
            char mode[4] = "wb\0";
 
179
            if (level != Z_DEFAULT_COMPRESSION) mode[2] = '0'+level;
 
180
            if (m_fp) close();
 
181
            m_fp = ::gzopen(name, mode);
 
182
        }
 
183
 
 
184
        /* open from a FILE pointer.
 
185
         */
 
186
        void open(FILE* fp, int level = Z_DEFAULT_COMPRESSION) {
 
187
            SET_BINARY_MODE(fp);
 
188
            char mode[4] = "wb\0";
 
189
            if (level != Z_DEFAULT_COMPRESSION) mode[2] = '0'+level;
 
190
            if (m_fp) close();
 
191
            m_fp = ::gzdopen(fileno(fp), mode);
 
192
        }
 
193
 
 
194
        /* Flushes all pending output if necessary, closes the compressed file
 
195
         * and deallocates all the (de)compression state. The return value is
 
196
         * the zlib error number (see function error() below).
 
197
         */
 
198
        int close() {
 
199
            if (m_os) {
 
200
                ::gzwrite(m_fp, m_os->str(), m_os->pcount());
 
201
                delete[] m_os->str(); delete m_os; m_os = 0;
 
202
            }
 
203
            int r = ::gzclose(m_fp); m_fp = 0; return r;
 
204
        }
 
205
 
 
206
        /* Binary write the given number of bytes into the compressed file.
 
207
         */
 
208
        int write(const void* buf, size_t len) {
 
209
            return ::gzwrite(m_fp, (voidp) buf, len);
 
210
        }
 
211
 
 
212
        /* Flushes all pending output into the compressed file. The parameter
 
213
         * _flush is as in the deflate() function. The return value is the zlib
 
214
         * error number (see function gzerror below). flush() returns Z_OK if
 
215
         * the flush_ parameter is Z_FINISH and all output could be flushed.
 
216
         * flush() should be called only when strictly necessary because it can
 
217
         * degrade compression.
 
218
         */
 
219
        int flush(int _flush) {
 
220
            os_flush();
 
221
            return ::gzflush(m_fp, _flush);
 
222
        }
 
223
 
 
224
        /* Returns the error message for the last error which occurred on the
 
225
         * given compressed file. errnum is set to zlib error number. If an
 
226
         * error occurred in the file system and not in the compression library,
 
227
         * errnum is set to Z_ERRNO and the application may consult errno
 
228
         * to get the exact error code.
 
229
         */
 
230
        const char* error(int* errnum) {
 
231
            return ::gzerror(m_fp, errnum);
 
232
        }
 
233
 
 
234
        gzFile fp() { return m_fp; }
 
235
 
 
236
        ostream& os() {
 
237
            if (m_os == 0) m_os = new ostrstream;
 
238
            return *m_os;
 
239
        }
 
240
 
 
241
        void os_flush() {
 
242
            if (m_os && m_os->pcount()>0) {
 
243
                ostrstream* oss = new ostrstream;
 
244
                oss->fill(m_os->fill());
 
245
                oss->flags(m_os->flags());
 
246
                oss->precision(m_os->precision());
 
247
                oss->width(m_os->width());
 
248
                ::gzwrite(m_fp, m_os->str(), m_os->pcount());
 
249
                delete[] m_os->str(); delete m_os; m_os = oss;
 
250
            }
 
251
        }
 
252
 
 
253
    private:
 
254
        gzFile m_fp;
 
255
        ostrstream* m_os;
 
256
};
 
257
 
 
258
/*
 
259
 * Binary write the given (array of) object(s) into the compressed file.
 
260
 * returns the number of uncompressed bytes actually written
 
261
 * (0 in case of error).
 
262
 */
 
263
template <class T, class Items>
 
264
inline int write(ozstream& zs, const T* x, Items items) {
 
265
    return ::gzwrite(zs.fp(), (voidp) x, items*sizeof(T));
 
266
}
 
267
 
 
268
/*
 
269
 * Binary output with the '<' operator.
 
270
 */
 
271
template <class T>
 
272
inline ozstream& operator<(ozstream& zs, const T& x) {
 
273
    ::gzwrite(zs.fp(), (voidp) &x, sizeof(T));
 
274
    return zs;
 
275
}
 
276
 
 
277
inline zstringlen::zstringlen(ozstream& zs, const char* x) {
 
278
    val.byte = 255;  val.word = ::strlen(x);
 
279
    if (val.word < 255) zs < (val.byte = val.word);
 
280
    else zs < val;
 
281
}
 
282
 
 
283
/*
 
284
 * Write length of string + the string with the '<' operator.
 
285
 */
 
286
inline ozstream& operator<(ozstream& zs, const char* x) {
 
287
    zstringlen len(zs, x);
 
288
    ::gzwrite(zs.fp(), (voidp) x, len.value());
 
289
    return zs;
 
290
}
 
291
 
 
292
#ifdef _MSC_VER
 
293
inline ozstream& operator<(ozstream& zs, char* const& x) {
 
294
    return zs < (const char*) x;
 
295
}
 
296
#endif
 
297
 
 
298
/*
 
299
 * Ascii write with the << operator;
 
300
 */
 
301
template <class T>
 
302
inline ostream& operator<<(ozstream& zs, const T& x) {
 
303
    zs.os_flush();
 
304
    return zs.os() << x;
 
305
}
 
306
 
 
307
#endif