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
|
using System;
using System.IO;
namespace Org.BouncyCastle.Utilities.IO
{
public sealed class Streams
{
private const int BufferSize = 4096;
private Streams()
{
}
public static void Drain(Stream inStr)
{
byte[] bs = new byte[BufferSize];
while (inStr.Read(bs, 0, bs.Length) > 0)
{
}
}
public static byte[] ReadAll(Stream inStr)
{
MemoryStream buf = new MemoryStream();
PipeAll(inStr, buf);
return buf.ToArray();
}
public static byte[] ReadAllLimited(Stream inStr, int limit)
{
MemoryStream buf = new MemoryStream();
PipeAllLimited(inStr, limit, buf);
return buf.ToArray();
}
public static int ReadFully(Stream inStr, byte[] buf)
{
return ReadFully(inStr, buf, 0, buf.Length);
}
public static int ReadFully(Stream inStr, byte[] buf, int off, int len)
{
int totalRead = 0;
while (totalRead < len)
{
int numRead = inStr.Read(buf, off + totalRead, len - totalRead);
if (numRead < 1)
break;
totalRead += numRead;
}
return totalRead;
}
/// <summary>Write the full contents of inStr to the destination stream outStr.</summary>
/// <param name="inStr">Source stream.</param>
/// <param name="outStr">Destination stream.</param>
/// <exception cref="IOException">In case of IO failure.</exception>
public static void PipeAll(Stream inStr, Stream outStr)
{
PipeAll(inStr, outStr, BufferSize);
}
/// <summary>Write the full contents of inStr to the destination stream outStr.</summary>
/// <param name="inStr">Source stream.</param>
/// <param name="outStr">Destination stream.</param>
/// <param name="bufferSize">The size of temporary buffer to use.</param>
/// <exception cref="IOException">In case of IO failure.</exception>
public static void PipeAll(Stream inStr, Stream outStr, int bufferSize)
{
byte[] bs = new byte[bufferSize];
int numRead;
while ((numRead = inStr.Read(bs, 0, bs.Length)) > 0)
{
outStr.Write(bs, 0, numRead);
}
}
/// <summary>
/// Pipe all bytes from <c>inStr</c> to <c>outStr</c>, throwing <c>StreamFlowException</c> if greater
/// than <c>limit</c> bytes in <c>inStr</c>.
/// </summary>
/// <param name="inStr">
/// A <see cref="Stream"/>
/// </param>
/// <param name="limit">
/// A <see cref="System.Int64"/>
/// </param>
/// <param name="outStr">
/// A <see cref="Stream"/>
/// </param>
/// <returns>The number of bytes actually transferred, if not greater than <c>limit</c></returns>
/// <exception cref="IOException"></exception>
public static long PipeAllLimited(Stream inStr, long limit, Stream outStr)
{
byte[] bs = new byte[BufferSize];
long total = 0;
int numRead;
while ((numRead = inStr.Read(bs, 0, bs.Length)) > 0)
{
if ((limit - total) < numRead)
throw new StreamOverflowException("Data Overflow");
total += numRead;
outStr.Write(bs, 0, numRead);
}
return total;
}
/// <exception cref="IOException"></exception>
public static void WriteBufTo(MemoryStream buf, Stream output)
{
buf.WriteTo(output);
}
/// <exception cref="IOException"></exception>
public static int WriteBufTo(MemoryStream buf, byte[] output, int offset)
{
int size = (int)buf.Length;
WriteBufTo(buf, new MemoryStream(output, offset, size));
return size;
}
public static void WriteZeroes(Stream outStr, long count)
{
byte[] zeroes = new byte[BufferSize];
while (count > BufferSize)
{
outStr.Write(zeroes, 0, BufferSize);
count -= BufferSize;
}
outStr.Write(zeroes, 0, (int)count);
}
}
}
|
