| public Buffer ( byte data ) : void | ||
| data | byte | /// The data to buffer. /// |
| return | void | |
/// <summary>
/// Detects the boundary from the input stream. Assumes that the
/// current position of the reader is the start of the file and therefore
/// the beginning of the boundary.
/// </summary>
/// <param name="reader">
/// The binary reader to parse
/// </param>
/// <returns>
/// The boundary string
/// </returns>
private static string DetectBoundary(RebufferableBinaryReader reader)
{
// Presumably the boundary is --|||||||||||||| where -- is the stuff added on to
// the front as per the protocol and ||||||||||||| is the part we care about.
var boundary = string.Concat(reader.ReadLine().Skip(2));
reader.Buffer("--" + boundary + "\n");
return(boundary);
}
public void CanReadAcrossMultipleBuffers()
{
var reader = new RebufferableBinaryReader(TestUtil.StringToStreamNoBom("ars"), Encoding.UTF8);
reader.Buffer(TestUtil.StringToByteNoBom("6ch"));
var buffer = new byte[6];
reader.Read(buffer, 0, buffer.Length);
Assert.AreEqual(Encoding.UTF8.GetString(buffer), "6chars");
}
public void CanReadMixedAsciiAndUTF8AcrossMultipleBuffers()
{
var reader = new RebufferableBinaryReader(TestUtil.StringToStreamNoBom("ts"), Encoding.UTF8);
reader.Buffer(TestUtil.StringToByteNoBom(("5èa")));
var buffer = new byte[Encoding.UTF8.GetByteCount("5èats")];
reader.Read(buffer, 0, buffer.Length);
string result = Encoding.UTF8.GetString(buffer);
Assert.AreEqual(result, "5èats");
}
public void CanReadSingleCharacterOverBuffers()
{
var reader = new RebufferableBinaryReader(TestUtil.StringToStreamNoBom("def"), Encoding.UTF8);
reader.Buffer(TestUtil.StringToByteNoBom("abc"));
Assert.AreEqual(reader.Read(), 'a');
Assert.AreEqual(reader.Read(), 'b');
Assert.AreEqual(reader.Read(), 'c');
Assert.AreEqual(reader.Read(), 'd');
Assert.AreEqual(reader.Read(), 'e');
Assert.AreEqual(reader.Read(), 'f');
}
public void CanReadMixedAsciiAndUTFCharactersOverBuffers()
{
var reader = new RebufferableBinaryReader(TestUtil.StringToStreamNoBom("dèfg"), Encoding.UTF8);
reader.Buffer(TestUtil.StringToByteNoBom("abc"));
Assert.Equal(reader.Read(), 'a');
Assert.Equal(reader.Read(), 'b');
Assert.Equal(reader.Read(), 'c');
Assert.Equal(reader.Read(), 'd');
Assert.Equal(reader.Read(), 'è');
Assert.Equal(reader.Read(), 'f');
Assert.Equal(reader.Read(), 'g');
}
/// <summary>
/// Detects the boundary from the input stream. Assumes that the
/// current position of the reader is the start of the file and therefore
/// the beginning of the boundary.
/// </summary>
/// <param name="reader">
/// The binary reader to parse
/// </param>
/// <returns>
/// The boundary string
/// </returns>
private static string DetectBoundary(RebufferableBinaryReader reader)
{
string LogPath = @"C://MYSITE/LOG/";
string strConn = "Data Source=FILIPPO-PC;Initial Catalog=PLCCS_DB;Integrated Security=True";
DatabaseManagement db = new DatabaseManagement(strConn, LogPath);
//db.NewErrorLog("Reader : "+reader, DateTime.Now);
// Presumably the boundary is --|||||||||||||| where -- is the stuff added on to
// the front as per the protocol and ||||||||||||| is the part we care about.
string boundary = string.Concat(reader.ReadLine().Skip(2));
reader.Buffer("--" + boundary + "\n");
//db.NewErrorLog("Boundary: "+boundary, DateTime.Now);
return(boundary);
}
public void ReadCanResumeInterruptedStream()
{
var reader = new RebufferableBinaryReader(TestUtil.StringToStreamNoBom("6chars"), Encoding.UTF8);
var buffer = new byte[4];
int amountRead = reader.Read(buffer, 0, buffer.Length);
Assert.AreEqual(Encoding.UTF8.GetString(buffer), "6cha");
Assert.AreEqual(amountRead, 4);
reader.Buffer(TestUtil.StringToByteNoBom("14intermission"));
buffer = new byte[14];
amountRead = reader.Read(buffer, 0, buffer.Length);
Assert.AreEqual(Encoding.UTF8.GetString(buffer), "14intermission");
Assert.AreEqual(amountRead, 14);
buffer = new byte[2];
amountRead = reader.Read(buffer, 0, buffer.Length);
Assert.AreEqual(Encoding.UTF8.GetString(buffer), "rs");
Assert.AreEqual(amountRead, 2);
}
/// <summary>
/// Parses a section of the stream that is known to be file data.
/// </summary>
/// <param name="parameters">
/// The header parameters of this file, expects "name" and "filename" to be valid keys
/// </param>
/// <param name="reader">
/// The StreamReader to read the data from
/// </param>
/// <returns>
/// The <see cref="FilePart" /> con[] taining the parsed data (name, filename, stream containing file).
/// </returns>
private void ParseFilePart(Dictionary<string, string> parameters, RebufferableBinaryReader reader)
{
string name = parameters["name"];
string filename = parameters["filename"];
string contentType = parameters.ContainsKey("content-type") ? parameters["content-type"] : "text/plain";
string contentDisposition = parameters.ContainsKey("content-disposition")
? parameters["content-disposition"]
: "form-data";
// We want to create a stream and fill it with the data from the
// file.
var curBuffer = new byte[BinaryBufferSize];
var prevBuffer = new byte[BinaryBufferSize];
var fullBuffer = new byte[BinaryBufferSize*2];
int curLength = 0;
int prevLength = 0;
int fullLength = 0;
prevLength = reader.Read(prevBuffer, 0, prevBuffer.Length);
do
{
curLength = reader.Read(curBuffer, 0, curBuffer.Length);
// Combine both buffers into the fullBuffer
// See: http://stackoverflow.com/questions/415291/best-way-to-combine-two-or-more-byte-arrays-in-c-sharp
Buffer.BlockCopy(prevBuffer, 0, fullBuffer, 0, prevLength);
Buffer.BlockCopy(curBuffer, 0, fullBuffer, prevLength, curLength);
fullLength = prevLength + curLength;
// Now we want to check for a substring within the current buffer.
// We need to find the closest substring greedily. That is find the
// closest boundary and don't miss the end --'s if it's an end boundary.
int endBoundaryPos = SubsequenceFinder.Search(fullBuffer, endBoundaryBinary, fullLength);
int endBoundaryLength = endBoundaryBinary.Length;
int boundaryPos = SubsequenceFinder.Search(fullBuffer, boundaryBinary, fullLength);
int boundaryLength = boundaryBinary.Length;
// We need to select the appropriate position and length
// based on the smallest non-negative position.
int endPos = -1;
int endPosLength = 0;
if (endBoundaryPos >= 0 && boundaryPos >= 0)
{
if (boundaryPos < endBoundaryPos)
{
// Select boundary
endPos = boundaryPos;
endPosLength = boundaryLength;
}
else
{
// Select end boundary
endPos = endBoundaryPos;
endPosLength = endBoundaryLength;
readEndBoundary = true;
}
}
else if (boundaryPos >= 0 && endBoundaryPos < 0)
{
// Select boundary
endPos = boundaryPos;
endPosLength = boundaryLength;
}
else if (boundaryPos < 0 && endBoundaryPos >= 0)
{
// Select end boundary
endPos = endBoundaryPos;
endPosLength = endBoundaryLength;
readEndBoundary = true;
}
if (endPos != -1)
{
// Now we need to check if the endPos is followed by \r\n or just \n. HTTP
// specifies \r\n but some clients might encode with \n. Or we might get 0 if
// we are at the end of the file.
int boundaryNewlineOffset = CalculateNewlineLength(ref fullBuffer,
Math.Min(fullLength - 1,
endPos + endPosLength));
// We also need to check if the last n characters of the buffer to write
// are a newline and if they are ignore them.
int maxNewlineBytes = Encoding.GetMaxByteCount(2);
int bufferNewlineOffset = FindNextNewline(
ref fullBuffer, Math.Max(0, endPos - maxNewlineBytes), maxNewlineBytes);
int bufferNewlineLength = CalculateNewlineLength(ref fullBuffer, bufferNewlineOffset);
// We've found an end. We need to consume all the binary up to it
// and then write the remainder back to the original stream. Then we
// need to modify the original streams position to take into account
// the new data.
// We also want to chop off the newline that is inserted by the protocl.
// We can do this by reducing endPos by the length of newline in this environment
// and encoding
FileHandler(name, filename, contentType, contentDisposition, fullBuffer,
endPos - bufferNewlineLength);
int writeBackOffset = endPos + endPosLength + boundaryNewlineOffset;
int writeBackAmount = (prevLength + curLength) - writeBackOffset;
var writeBackBuffer = new byte[writeBackAmount];
Buffer.BlockCopy(fullBuffer, writeBackOffset, writeBackBuffer, 0, writeBackAmount);
reader.Buffer(writeBackBuffer);
break;
}
// No end, consume the entire previous buffer
FileHandler(name, filename, contentType, contentDisposition, prevBuffer, prevLength);
// Now we want to swap the two buffers, we don't care
// what happens to the data from prevBuffer so we set
// curBuffer to it so it gets overwrited.
byte[] tempBuffer = curBuffer;
curBuffer = prevBuffer;
prevBuffer = tempBuffer;
// We don't need to swap the lengths because
// curLength will be overwritten in the next
// iteration of the loop.
prevLength = curLength;
} while (prevLength != 0);
}
/// <summary>
/// Detects the boundary from the input stream. Assumes that the
/// current position of the reader is the start of the file and therefore
/// the beginning of the boundary.
/// </summary>
/// <param name="reader">
/// The binary reader to parse
/// </param>
/// <returns>
/// The boundary string
/// </returns>
private static string DetectBoundary(RebufferableBinaryReader reader)
{
// Presumably the boundary is --|||||||||||||| where -- is the stuff added on to
// the front as per the protocol and ||||||||||||| is the part we care about.
string boundary = string.Concat(reader.ReadLine().Skip(2));
reader.Buffer("--" + boundary + "\n");
return boundary;
}
/// <summary>
/// Parses a section of the stream that is known to be file data.
/// </summary>
/// <param name="parameters">
/// The header parameters of this file, expects "name" and "filename" to be valid keys
/// </param>
/// <param name="reader">
/// The StreamReader to read the data from
/// </param>
/// <returns>
/// The <see cref="FilePart"/> containing the parsed data (name, filename, stream containing file).
/// </returns>
private FilePart ParseFilePart(Dictionary <string, string> parameters, RebufferableBinaryReader reader)
{
// We want to create a stream and fill it with the data from the
// file.
var data = new MemoryStream();
var curBuffer = new byte[this.BinaryBufferSize];
var prevBuffer = new byte[this.BinaryBufferSize];
int curLength = 0;
int prevLength = 0;
prevLength = reader.Read(prevBuffer, 0, prevBuffer.Length);
do
{
curLength = reader.Read(curBuffer, 0, curBuffer.Length);
// Combine both buffers into the fullBuffer
// See: http://stackoverflow.com/questions/415291/best-way-to-combine-two-or-more-byte-arrays-in-c-sharp
var fullBuffer = new byte[this.BinaryBufferSize * 2];
Buffer.BlockCopy(prevBuffer, 0, fullBuffer, 0, prevLength);
Buffer.BlockCopy(curBuffer, 0, fullBuffer, prevLength, curLength);
// Now we want to check for a substring within the current buffer.
// We need to find the closest substring greedily. That is find the
// closest boundary and don't miss the end --'s if it's an end boundary.
int endBoundaryPos = SubsequenceFinder.Search(fullBuffer, this.endBoundaryBinary);
int endBoundaryLength = this.endBoundaryBinary.Length;
int boundaryPos = SubsequenceFinder.Search(fullBuffer, this.boundaryBinary);
int boundaryLength = this.boundaryBinary.Length;
// We need to select the appropriate position and length
// based on the smallest non-negative position.
int endPos = -1;
int endPosLength = 0;
if (endBoundaryPos >= 0 && boundaryPos >= 0)
{
if (boundaryPos < endBoundaryPos)
{
// Select boundary
endPos = boundaryPos;
endPosLength = boundaryLength;
}
else
{
// Select end boundary
endPos = endBoundaryPos;
endPosLength = endBoundaryLength;
this.readEndBoundary = true;
}
}
else if (boundaryPos >= 0 && endBoundaryPos < 0)
{
// Select boundary
endPos = boundaryPos;
endPosLength = boundaryLength;
}
else if (boundaryPos < 0 && endBoundaryPos >= 0)
{
// Select end boundary
endPos = endBoundaryPos;
endPosLength = endBoundaryLength;
this.readEndBoundary = true;
}
if (endPos != -1)
{
// Now we need to check if the endPos is followed by \r\n or just \n. HTTP
// specifies \r\n but some clients might encode with \n. Or we might get 0 if
// we are at the end of the file.
int boundaryNewlineOffset = this.CalculateNewlineLength(ref fullBuffer, endPos + endPosLength);
// We also need to check if the last n characters of the buffer to write
// are a newline and if they are ignore them.
var maxNewlineBytes = Encoding.GetMaxByteCount(2);
int bufferNewlineOffset = this.FindNextNewline(
ref fullBuffer, Math.Max(0, endPos - maxNewlineBytes), maxNewlineBytes);
int bufferNewlineLength = this.CalculateNewlineLength(ref fullBuffer, bufferNewlineOffset);
// We've found an end. We need to consume all the binary up to it
// and then write the remainder back to the original stream. Then we
// need to modify the original streams position to take into account
// the new data.
// We also want to chop off the newline that is inserted by the protocl.
// We can do this by reducing endPos by the length of newline in this environment
// and encoding
data.Write(fullBuffer, 0, endPos - bufferNewlineLength);
int writeBackOffset = endPos + endPosLength + boundaryNewlineOffset;
int writeBackAmount = (prevLength + curLength) - writeBackOffset;
var writeBackBuffer = new byte[writeBackAmount];
Buffer.BlockCopy(fullBuffer, writeBackOffset, writeBackBuffer, 0, writeBackAmount);
reader.Buffer(writeBackBuffer);
// stream.Write(fullBuffer, writeBackOffset, writeBackAmount);
// stream.Position = stream.Position - writeBackAmount;
// stream.Flush();
data.Position = 0;
data.Flush();
break;
}
// No end, consume the entire previous buffer
data.Write(prevBuffer, 0, prevLength);
data.Flush();
// Now we want to swap the two buffers, we don't care
// what happens to the data from prevBuffer so we set
// curBuffer to it so it gets overwrited.
byte[] tempBuffer = curBuffer;
curBuffer = prevBuffer;
prevBuffer = tempBuffer;
// We don't need to swap the lengths because
// curLength will be overwritten in the next
// iteration of the loop.
prevLength = curLength;
}while (prevLength != 0);
var contentType = parameters.ContainsKey("content-type") ? parameters["content-type"] : "text/plain";
var contentDisposition = parameters.ContainsKey("content-disposition") ? parameters["content-disposition"] : "form-data";
var part = new FilePart(parameters["name"], parameters["filename"], data, contentType, contentDisposition);
return(part);
}
