/// <summary>
/// Parses a section of the stream that is known to be parameter data.
/// </summary>
/// <param name="parameters">
/// The header parameters of this section. "name" must be a valid key.
/// </param>
/// <param name="reader">
/// The StreamReader to read the data from
/// </param>
/// <returns>
/// The <see cref="ParameterPart"/> containing the parsed data (name, value).
/// </returns>
/// <exception cref="MultipartParseException">
/// thrown if unexpected data is found such as running out of stream before hitting the boundary.
/// </exception>
private ParameterPart ParseParameterPart(Dictionary <string, string> parameters, RebufferableBinaryReader reader)
{
// Our job is to get the actual "data" part of the parameter and construct
// an actual ParameterPart object with it. All we need to do is read data into a string
// untill we hit the boundary
var data = new StringBuilder();
bool firstTime = true;
string line = reader.ReadLine();
while (line != this.boundary && line != this.endBoundary)
{
if (line == null)
{
throw new MultipartParseException("Unexpected end of section");
}
if (firstTime)
{
data.Append(line);
firstTime = false;
}
else
{
data.Append(Environment.NewLine);
data.Append(line);
}
line = reader.ReadLine();
}
if (line == this.endBoundary)
{
this.readEndBoundary = true;
}
// If we're here we've hit the boundary and have the data!
var part = new ParameterPart(parameters["name"], data.ToString());
return(part);
}
/// <summary>
/// Parses the header of the next section of the multipart stream and
/// determines if it contains file data or parameter data.
/// </summary>
/// <param name="reader">
/// The StreamReader to read data from.
/// </param>
/// <exception cref="MultipartParseException">
/// thrown if unexpected data is hit such as end of stream.
/// </exception>
private void ParseSection(RebufferableBinaryReader reader)
{
// Our first job is to determine what type of section this is: form data or file.
// This is a bit tricky because files can still be encoded with Content-Disposition: form-data
// in the case of single file uploads. Multi-file uploads have Content-Disposition: file according
// to the spec however in practise it seems that multiple files will be represented by
// multiple Content-Disposition: form-data files.
var parameters = new Dictionary <string, string>();
string line = reader.ReadLine();
while (line != string.Empty)
{
if (line == null)
{
throw new MultipartParseException("Unexpected end of stream");
}
if (line == this.boundary || line == this.endBoundary)
{
throw new MultipartParseException("Unexpected end of section");
}
// This line parses the header values into a set of key/value pairs. For example:
// Content-Disposition: form-data; name="textdata"
// ["content-disposition"] = "form-data"
// ["name"] = "textdata"
// Content-Disposition: form-data; name="file"; filename="data.txt"
// ["content-disposition"] = "form-data"
// ["name"] = "file"
// ["filename"] = "data.txt"
// Content-Type: text/plain
// ["content-type"] = "text/plain"
var values = SplitBySemicolonIgnoringSemicolonsInQuotes(line)
.Select(x => x.Split(new[] { ':', '=' }, 2)) // Limit split to 2 splits so we don't accidently split characters in file paths.
.ToDictionary(
x => x[0].Trim().Replace("\"", string.Empty).ToLower(),
x => x[1].Trim().Replace("\"", string.Empty));
// Here we just want to push all the values that we just retrieved into the
// parameters dictionary.
try
{
foreach (var pair in values)
{
parameters.Add(pair.Key, pair.Value);
}
}
catch (ArgumentException)
{
throw new MultipartParseException("Duplicate field in section");
}
line = reader.ReadLine();
}
// Now that we've consumed all the parameters we're up to the body. We're going to do
// different things depending on if we're parsing a, relatively small, form value or a
// potentially large file.
if (parameters.ContainsKey("filename"))
{
// Right now we assume that if a section contains filename then it is a file.
// This assumption needs to be checked, it holds true in firefox but is untested for other
// browsers.
FilePart part = this.ParseFilePart(parameters, reader);
this.Files.Add(part);
}
else
{
ParameterPart part = this.ParseParameterPart(parameters, reader);
this.Parameters.Add(part.Name, part);
}
}