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
|
using System;
using System.IO;
using Org.BouncyCastle.Utilities.IO.Compression;
using Org.BouncyCastle.Utilities.Zlib;
namespace Org.BouncyCastle.Bcpg.OpenPgp
{
/// <remarks>Class for producing compressed data packets.</remarks>
public class PgpCompressedDataGenerator
: IStreamGenerator
{
private readonly CompressionAlgorithmTag algorithm;
private readonly int compression;
private Stream dOut;
private BcpgOutputStream pkOut;
public PgpCompressedDataGenerator(
CompressionAlgorithmTag algorithm)
: this(algorithm, JZlib.Z_DEFAULT_COMPRESSION)
{
}
public PgpCompressedDataGenerator(
CompressionAlgorithmTag algorithm,
int compression)
{
switch (algorithm)
{
case CompressionAlgorithmTag.Uncompressed:
case CompressionAlgorithmTag.Zip:
case CompressionAlgorithmTag.ZLib:
case CompressionAlgorithmTag.BZip2:
break;
default:
throw new ArgumentException("unknown compression algorithm", "algorithm");
}
if (compression != JZlib.Z_DEFAULT_COMPRESSION)
{
if ((compression < JZlib.Z_NO_COMPRESSION) || (compression > JZlib.Z_BEST_COMPRESSION))
{
throw new ArgumentException("unknown compression level: " + compression);
}
}
this.algorithm = algorithm;
this.compression = compression;
}
/// <summary>
/// <p>
/// Return an output stream which will save the data being written to
/// the compressed object.
/// </p>
/// <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 Stream parameter <c>outStr</c>.
/// </p>
/// </summary>
/// <param name="outStr">Stream to be used for output.</param>
/// <returns>A Stream for output of the compressed data.</returns>
/// <exception cref="ArgumentNullException"></exception>
/// <exception cref="InvalidOperationException"></exception>
/// <exception cref="IOException"></exception>
public Stream Open(
Stream outStr)
{
if (dOut != null)
throw new InvalidOperationException("generator already in open state");
if (outStr == null)
throw new ArgumentNullException("outStr");
this.pkOut = new BcpgOutputStream(outStr, PacketTag.CompressedData);
DoOpen();
return new WrappedGeneratorStream(this, dOut);
}
/// <summary>
/// <p>
/// Return an output stream 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>
/// <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 Stream parameter <c>outStr</c>.
/// </p>
/// <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>
/// </summary>
/// <param name="outStr">Stream to be used for output.</param>
/// <param name="buffer">The buffer to use.</param>
/// <returns>A Stream for output of the compressed data.</returns>
/// <exception cref="ArgumentNullException"></exception>
/// <exception cref="InvalidOperationException"></exception>
/// <exception cref="IOException"></exception>
/// <exception cref="PgpException"></exception>
public Stream Open(
Stream outStr,
byte[] buffer)
{
if (dOut != null)
throw new InvalidOperationException("generator already in open state");
if (outStr == null)
throw new ArgumentNullException("outStr");
if (buffer == null)
throw new ArgumentNullException("buffer");
this.pkOut = new BcpgOutputStream(outStr, PacketTag.CompressedData, buffer);
DoOpen();
return new WrappedGeneratorStream(this, dOut);
}
private void DoOpen()
{
pkOut.WriteByte((byte) algorithm);
switch (algorithm)
{
case CompressionAlgorithmTag.Uncompressed:
dOut = pkOut;
break;
case CompressionAlgorithmTag.Zip:
dOut = Zip.CompressOutput(pkOut, compression, true);
break;
case CompressionAlgorithmTag.ZLib:
dOut = ZLib.CompressOutput(pkOut, compression, true);
break;
case CompressionAlgorithmTag.BZip2:
dOut = Bzip2.CompressOutput(pkOut, true);
break;
default:
// Constructor should guard against this possibility
throw new InvalidOperationException();
}
}
#region IDisposable
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
if (dOut != null)
{
if (dOut != pkOut)
{
dOut.Dispose();
}
dOut = null;
pkOut.Finish();
pkOut.Flush();
pkOut = null;
}
}
}
#endregion
}
}
|
