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
|
using System;
using System.IO;
namespace Org.BouncyCastle.Utilities.IO
{
public static class Streams
{
private const int BufferSize = 4096;
public static void Drain(Stream inStr)
{
inStr.CopyTo(Stream.Null, 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>
/// <exception cref="IOException">In case of IO failure.</exception>
public static void PipeAll(Stream inStr, Stream outStr)
{
inStr.CopyTo(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)
{
inStr.CopyTo(outStr, bufferSize);
}
/// <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)
{
var limited = new LimitedInputStream(inStr, limit);
limited.CopyTo(outStr, BufferSize);
return limit - limited.CurrentLimit;
}
public static byte[] ReadAll(Stream inStr)
{
MemoryStream buf = new MemoryStream();
PipeAll(inStr, buf);
return buf.ToArray();
}
public static byte[] ReadAll(MemoryStream inStr)
{
return inStr.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;
}
#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER
public static int ReadFully(Stream inStr, Span<byte> buffer)
{
int totalRead = 0;
while (totalRead < buffer.Length)
{
int numRead = inStr.Read(buffer[totalRead..]);
if (numRead < 1)
break;
totalRead += numRead;
}
return totalRead;
}
#endif
public static void ValidateBufferArguments(byte[] buffer, int offset, int count)
{
if (buffer == null)
throw new ArgumentNullException("buffer");
int available = buffer.Length - offset;
if ((offset | available) < 0)
throw new ArgumentOutOfRangeException("offset");
int remaining = available - count;
if ((count | remaining) < 0)
throw new ArgumentOutOfRangeException("count");
}
/// <exception cref="IOException"></exception>
public static int WriteBufTo(MemoryStream buf, byte[] output, int offset)
{
#if NETCOREAPP2_0_OR_GREATER || NETSTANDARD2_1_OR_GREATER
if (buf.TryGetBuffer(out var buffer))
{
buffer.CopyTo(output, offset);
return buffer.Count;
}
#endif
int size = Convert.ToInt32(buf.Length);
buf.WriteTo(new MemoryStream(output, offset, size));
return size;
}
}
}
|
