1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
|
package org.spongycastle.openpgp;
import org.spongycastle.apache.bzip2.CBZip2OutputStream;
import org.spongycastle.bcpg.BCPGOutputStream;
import org.spongycastle.bcpg.CompressionAlgorithmTags;
import org.spongycastle.bcpg.PacketTags;
import java.io.IOException;
import java.io.OutputStream;
import java.util.zip.Deflater;
import java.util.zip.DeflaterOutputStream;
/**
*class for producing compressed data packets.
*/
public class PGPCompressedDataGenerator
implements CompressionAlgorithmTags, StreamGenerator
{
private int algorithm;
private int compression;
private OutputStream dOut;
private BCPGOutputStream pkOut;
public PGPCompressedDataGenerator(
int algorithm)
{
this(algorithm, Deflater.DEFAULT_COMPRESSION);
}
public PGPCompressedDataGenerator(
int algorithm,
int compression)
{
switch (algorithm)
{
case CompressionAlgorithmTags.UNCOMPRESSED:
case CompressionAlgorithmTags.ZIP:
case CompressionAlgorithmTags.ZLIB:
case CompressionAlgorithmTags.BZIP2:
break;
default:
throw new IllegalArgumentException("unknown compression algorithm");
}
if (compression != Deflater.DEFAULT_COMPRESSION)
{
if ((compression < Deflater.NO_COMPRESSION) || (compression > Deflater.BEST_COMPRESSION))
{
throw new IllegalArgumentException("unknown compression level: " + compression);
}
}
this.algorithm = algorithm;
this.compression = compression;
}
/**
* Return an OutputStream which will save the data being written to
* the compressed object.
* <p>
* The stream created can be closed off by either calling close()
* on the stream or close() on the generator. Closing the returned
* stream does not close off the OutputStream parameter out.
*
* @param out underlying OutputStream to be used.
* @return OutputStream
* @throws IOException, IllegalStateException
*/
public OutputStream open(
OutputStream out)
throws IOException
{
if (dOut != null)
{
throw new IllegalStateException("generator already in open state");
}
this.pkOut = new BCPGOutputStream(out, PacketTags.COMPRESSED_DATA);
doOpen();
return new WrappedGeneratorStream(dOut, this);
}
/**
* Return an OutputStream which will compress the data as it is written
* to it. The stream will be written out in chunks according to the size of the
* passed in buffer.
* <p>
* The stream created can be closed off by either calling close()
* on the stream or close() on the generator. Closing the returned
* stream does not close off the OutputStream parameter out.
* <p>
* <b>Note</b>: if the buffer is not a power of 2 in length only the largest power of 2
* bytes worth of the buffer will be used.
* </p>
* <p>
* <b>Note</b>: using this may break compatibility with RFC 1991 compliant tools. Only recent OpenPGP
* implementations are capable of accepting these streams.
* </p>
*
* @param out underlying OutputStream to be used.
* @param buffer the buffer to use.
* @return OutputStream
* @throws IOException
* @throws PGPException
*/
public OutputStream open(
OutputStream out,
byte[] buffer)
throws IOException, PGPException
{
if (dOut != null)
{
throw new IllegalStateException("generator already in open state");
}
this.pkOut = new BCPGOutputStream(out, PacketTags.COMPRESSED_DATA, buffer);
doOpen();
return new WrappedGeneratorStream(dOut, this);
}
private void doOpen() throws IOException
{
pkOut.write(algorithm);
switch (algorithm)
{
case CompressionAlgorithmTags.UNCOMPRESSED:
dOut = pkOut;
break;
case CompressionAlgorithmTags.ZIP:
dOut = new SafeDeflaterOutputStream(pkOut, compression, true);
break;
case CompressionAlgorithmTags.ZLIB:
dOut = new SafeDeflaterOutputStream(pkOut, compression, false);
break;
case CompressionAlgorithmTags.BZIP2:
dOut = new SafeCBZip2OutputStream(pkOut);
break;
default:
// Constructor should guard against this possibility
throw new IllegalStateException();
}
}
/**
* Close the compressed object - this is equivalent to calling close on the stream
* returned by the open() method.
*
* @throws IOException
*/
public void close()
throws IOException
{
if (dOut != null)
{
if (dOut != pkOut)
{
dOut.close();
dOut.flush();
}
dOut = null;
pkOut.finish();
pkOut.flush();
pkOut = null;
}
}
private static class SafeCBZip2OutputStream extends CBZip2OutputStream
{
public SafeCBZip2OutputStream(OutputStream output) throws IOException
{
super(output);
}
public void close() throws IOException
{
finish();
}
}
private class SafeDeflaterOutputStream extends DeflaterOutputStream
{
public SafeDeflaterOutputStream(OutputStream output, int compression, boolean nowrap)
{
super(output, new Deflater(compression, nowrap));
}
public void close() throws IOException
{
finish();
def.end();
}
}
}
|
