/// <summary> /// Begins the parsing of the stream into objects. /// </summary> /// <param name="reader"> /// The multipart/form-data binary reader to parse from. /// </param> /// <exception cref="MultipartParseException"> /// thrown on finding unexpected data such as a boundary before we are ready for one. /// </exception> private void Parse(RebufferableBinaryReader reader) { // Parsing references include: // RFC1341 section 7: http://www.w3.org/Protocols/rfc1341/7_2_Multipart.html // RFC2388: http://www.ietf.org/rfc/rfc2388.txt // First we need to read untill we find a boundary while (true) { string line = reader.ReadLine(); if (line == this.boundary) { break; } if (line == null) { throw new MultipartParseException("Could not find expected boundary"); } } // Now that we've found the initial boundary we know where to start. // We need parse each individual section while (!this.readEndBoundary) { // ParseSection will parse up to and including // the next boundary. this.ParseSection(reader); } }
/// <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); }
/// <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.Name, part); } else { ParameterPart part = this.ParseParameterPart(parameters, reader); this.Parameters.Add(part.Name, part); } }