protected override async Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
using (var stream = await request.Content.ReadAsStreamAsync())
{
var parameters = MultipartFormDataParser.Parse(stream);
var from = parameters.Parameters.Where(x => x.Name == "from")
.Select(x => GetSingleMailAddress(x.Data))
.FirstOrDefault();
var tos = parameters.Parameters.Where(x => x.Name == "to")
.Select(x => GetMultipleMailAddress(x.Data));
var mailGunResponse = new MailGunResponse();
if (from == _validSenderMailAddress && tos.Any(x => x.Contains(_validRecipientMailAddress)))
{
mailGunResponse.Id = "<fake-domain.mailgun.org>";
mailGunResponse.Message = "Queued. Thank you.";
}
else
{
mailGunResponse.Id = string.Empty;
}
var httpResponseMessage = new HttpResponseMessage(HttpStatusCode.OK);
httpResponseMessage.Content = new ReadOnlyMemoryContent(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(mailGunResponse)));
return(httpResponseMessage);
}
}
// Make sure the parsed multipart form data has been parsed
private void GetBodyFiles()
{
if (_BodyParser == null)
{
_BodyParser = MultipartFormDataParser.Parse(_listenerContext.Request.InputStream);
}
}
public void DoesntInfiniteLoopOnUnclosedInput()
{
using (Stream stream = TestUtil.StringToStream(_testCase.Request, Encoding.UTF8))
{
// We expect this to throw!
Assert.Throws <MultipartParseException>(() => MultipartFormDataParser.Parse(stream, Encoding.UTF8));
}
}
public void MultipleFilesWithNoNameTest()
{
using (Stream stream = TestUtil.StringToStream(MultipleFilesSameName_testData, Encoding.UTF8))
{
var parser = MultipartFormDataParser.Parse(stream, "boundry", Encoding.UTF8, 16);
Assert.True(_testCase.Validate(parser));
}
}
public void AcceptSeveralValuesWithSameProperty()
{
using (Stream stream = TestUtil.StringToStream(_testCase.Request, Encoding.UTF8))
{
var parser = MultipartFormDataParser.Parse(stream, Encoding.UTF8);
Assert.True(_testCase.Validate(parser));
}
}
public void HandlesFullPathAsFileNameWithSemicolonCorrectly()
{
using (Stream stream = TestUtil.StringToStream(_testCase.Request, Encoding.UTF8))
{
var parser = MultipartFormDataParser.Parse(stream, Encoding.UTF8);
Assert.True(_testCase.Validate(parser));
}
}
public void Parse_empty_form_boundary_omitted()
{
using (Stream stream = TestUtil.StringToStream(_testCase.Request, Encoding.UTF8))
{
var parser = MultipartFormDataParser.Parse(stream);
Assert.True(_testCase.Validate(parser));
}
}
public void CanHandleFileAsLastSection()
{
using (Stream stream = TestUtil.StringToStream(_testCase.Request, Encoding.UTF8))
{
var parser = MultipartFormDataParser.Parse(stream, Encoding.UTF8);
Assert.True(_testCase.Validate(parser));
}
}
public void Parse_empty_form_boundary_specified()
{
using (Stream stream = TestUtil.StringToStream(_testCase.Request, Encoding.UTF8))
{
var parser = MultipartFormDataParser.Parse(stream, "----WebKitFormBoundaryb4SfPlH9Bv7c2PKS");
Assert.True(_testCase.Validate(parser));
}
}
public void MjpegStreamTest()
{
using (Stream stream = TestUtil.StringToStream(_testCase.Request, Encoding.UTF8))
{
var parser = MultipartFormDataParser.Parse(stream, "MOBOTIX_Fast_Serverpush", Encoding.UTF8, 32);
Assert.True(_testCase.Validate(parser));
}
}
public void FileWithAdditionalParameterTest()
{
using (Stream stream = TestUtil.StringToStream(_testCase.Request, Encoding.UTF8))
{
var parser = MultipartFormDataParser.Parse(stream, Encoding.UTF8);
Assert.True(_testCase.Validate(parser));
}
}
public void CanHandleFinalDashesInSeperateBufferFromEndBinary()
{
using (Stream stream = TestUtil.StringToStream(_testCase.Request, Encoding.UTF8))
{
var parser = MultipartFormDataParser.Parse(stream, "boundry", Encoding.UTF8, 16);
Assert.True(_testCase.Validate(parser));
}
}
public void CanAutoDetectBoundary()
{
using (Stream stream = TestUtil.StringToStream(_testCase.Request, Encoding.UTF8))
{
var parser = MultipartFormDataParser.Parse(stream);
Assert.True(_testCase.Validate(parser));
}
}
public void CanDetectBoundariesCrossBuffer()
{
using (Stream stream = TestUtil.StringToStream(_testCase.Request, Encoding.UTF8))
{
var parser = MultipartFormDataParser.Parse(stream, "boundry", Encoding.UTF8, 16);
Assert.True(_testCase.Validate(parser));
}
}
public void GetParameterValueReturnsNullIfNoParameterFound()
{
using (Stream stream = TestUtil.StringToStream(_testCase.Request, Encoding.UTF8))
{
var parser = MultipartFormDataParser.Parse(stream, "boundry", Encoding.UTF8);
Assert.Null(parser.GetParameterValue("does not exist"));
}
}
public void MultipleFilesAndParamsTest()
{
using (Stream stream = TestUtil.StringToStream(_testCase.Request, Encoding.UTF8))
{
var parser = MultipartFormDataParser.Parse(stream, "boundry", Encoding.UTF8, 16);
Assert.True(_testCase.Validate(parser));
}
}
public void CanHandleUnicodeWidthAndAsciiWidthCharacters()
{
using (
Stream stream = TestUtil.StringToStream(_testCase.Request, Encoding.UTF8))
{
var parser = MultipartFormDataParser.Parse(stream, Encoding.UTF8);
Assert.True(_testCase.Validate(parser));
}
}
public void CorrectlyHandlesCRLF()
{
string request = _testCase.Request.Replace("\n", "\r\n");
using (Stream stream = TestUtil.StringToStream(request, Encoding.UTF8))
{
var parser = MultipartFormDataParser.Parse(stream, "boundry", Encoding.UTF8);
Assert.True(_testCase.Validate(parser));
}
}
void parseMultipartForm()
{
var parsed = MultipartFormDataParser.Parse(Request.InputStream);
foreach (var x in parsed.Parameters)
{
paramaters[x.Name] = x.Data;
}
Files = parsed.Files.ToList();
}
/// <summary>
/// Parses the inbound email webhook.
/// </summary>
/// <param name="stream">The stream.</param>
/// <returns>The <see cref="InboundEmail"/>.</returns>
public InboundEmail ParseInboundEmailWebhook(Stream stream)
{
// We need to be able to rewind the stream.
// Therefore, we must make a copy of the stream if it doesn't allow changing the position
if (!stream.CanSeek)
{
using (var ms = Utils.MemoryStreamManager.GetStream())
{
stream.CopyTo(ms);
return(ParseInboundEmailWebhook(ms));
}
}
// It's important to rewind the stream
stream.Position = 0;
// Parse the multipart content received from SendGrid
var parser = MultipartFormDataParser.Parse(stream, Encoding.UTF8);
// Convert the 'charset' from a string into array of KeyValuePair
var charsetsAsJObject = JObject.Parse(parser.GetParameterValue("charsets", "{}"));
var charsets = charsetsAsJObject
.Properties()
.Select(prop =>
{
var key = prop.Name;
var value = Encoding.GetEncoding(prop.Value.ToString());
return(new KeyValuePair <string, Encoding>(key, value));
}).ToArray();
// Create a dictionary of parsers, one parser for each desired encoding.
// This is necessary because MultipartFormDataParser can only handle one
// encoding and SendGrid can use different encodings for parameters such
// as "from", "to", "text" and "html".
var encodedParsers = charsets
.Where(c => c.Value != Encoding.UTF8)
.Select(c => c.Value)
.Distinct()
.Select(encoding =>
{
stream.Position = 0; // It's important to rewind the stream
return(new
{
Encoding = encoding,
Parser = MultipartFormDataParser.Parse(stream, encoding)
});
})
.Union(new[]
{
new { Encoding = Encoding.UTF8, Parser = parser }
})
.ToDictionary(ep => ep.Encoding, ep => ep.Parser);
return(ParseInboundEmail(encodedParsers, charsets));
}
public void CanDetectBoundriesWithNewLineInNextBuffer()
{
for (int i = 16; i < _testCase.Request.Length; i++)
{
using (Stream stream = TestUtil.StringToStream(_testCase.Request, Encoding.UTF8))
{
var parser = MultipartFormDataParser.Parse(stream, "boundry", Encoding.UTF8, i);
Assert.True(_testCase.Validate(parser), $"Failure in buffer length {i}");
}
}
}
public void DoesNotCloseTheStream()
{
using (Stream stream = TestUtil.StringToStream(_testCase.Request, Encoding.UTF8))
{
var parser = MultipartFormDataParser.Parse(stream, "boundry", Encoding.UTF8);
Assert.True(_testCase.Validate(parser));
stream.Position = 0;
Assert.True(true, "A closed stream would throw ObjectDisposedException");
}
}
public static void ScanRequest(HttpListenerRequest request, HttpListenerResponse response)
{
if (!request.ContentType.StartsWith("multipart/form-data", StringComparison.OrdinalIgnoreCase))
{
Log.Error("Wrong request Content-type for scanning, {requestContentType}", request.ContentType);
return;
}
;
var scanner = new WindowsDefenderScanner();
var parser = MultipartFormDataParser.Parse(request.InputStream);
var file = parser.Files.First();
Log.Information("filename: {fileName}", file.FileName);
string tempFileName = FileUtilities.SaveToTempFile(file.Data);
if (tempFileName == null)
{
Log.Error("Can't save the file received in the request");
return;
}
var result = scanner.Scan(tempFileName);
if (result.isError)
{
Log.Error("Error during the scanning Error message:{errorMessage}", result.errorMessage);
var data = new
{
ErrorMessage = result.errorMessage,
};
SendResponse(response, HttpStatusCode.InternalServerError, data);
return;
}
var responseData = new
{
FileName = file.FileName,
isThreat = result.isThreat,
ThreatType = result.threatType
};
SendResponse(response, HttpStatusCode.OK, responseData);
try{
File.Delete(tempFileName);
}
catch (Exception e)
{
Log.Error(e, "Exception caught when trying to delete temp file:{tempFileName}.", tempFileName);
}
}
public void SmallDataTest()
{
using (Stream stream = TestUtil.StringToStream(_testCase.Request))
{
// The boundry is missing the first two -- in accordance with the multipart
// spec. (A -- is added by the parser, this boundry is what would be sent in the
// requset header)
var parser = MultipartFormDataParser.Parse(stream, "---------------------------265001916915724");
Assert.True(_testCase.Validate(parser));
}
}
public void CorrectlyHandleMixedNewlineFormats()
{
// Replace the first '\n' with '\r\n'
var regex = new Regex(Regex.Escape("\n"));
string request = regex.Replace(_testCase.Request, "\r\n", 1);
using (Stream stream = TestUtil.StringToStream(request, Encoding.UTF8))
{
var parser = MultipartFormDataParser.Parse(stream, "boundry", Encoding.UTF8);
Assert.True(_testCase.Validate(parser));
}
}
public SystemHttpRequest(System.Net.HttpListenerRequest request)
{
_request = request;
if (!String.IsNullOrEmpty(ContentType) && ContentType.Contains("multipart/form-data"))
{
multipartFormDataParser = MultipartFormDataParser.Parse(InputStream);
_form = multipartFormDataParser.Parameters;
_files = multipartFormDataParser.Files;
}
else
{
_form = new List <ParameterPart>();
_files = new List <FilePart>();
}
}
public async Task UploadFile()
{
// 找到当前的用户名
var userId = Token.UserId;
if (string.IsNullOrEmpty(userId))
{
await ResponseErrorAsync("需要登陆才能上传");
return;
}
// 获取文件流
var parser = MultipartFormDataParser.Parse(Request.InputStream);
if (parser.Files.Any() == false)
{
throw new Exception("Invalid request, you need to post a file");
}
// 获取子目录
var subPaths = parser.Parameters.Where(p => p.Name == Fields.subPath);
string subPath = "files";
if (subPaths.Count() > 0)
{
subPath = subPaths.First().Data;
}
var fs = LiteDb.Database.FileStorage;
List <string> fileIds = new List <string>();
// 可能会同时上传多个文件
foreach (var file in parser.Files)
{
// 获取文件名
var fileId = $"_{userId}/{subPath}/{file.FileName}";
// 保存到数据库中
fs.Upload(fileId, file.FileName, file.Data);
fileIds.Add(fileId);
}
// 返回id
await ResponseSuccessAsync(fileIds);
}
public void CorrectlyHandlesMultilineParameter()
{
string request = TestUtil.TrimAllLines(
@"-----------------------------41952539122868
Content-Disposition: form-data; name=""multilined""
line 1
line 2
line 3
-----------------------------41952539122868--");
using (Stream stream = TestUtil.StringToStream(request, Encoding.UTF8))
{
var parser = MultipartFormDataParser.Parse(stream, Encoding.UTF8);
Assert.Equal("line 1\r\nline 2\r\nline 3", parser.GetParameterValue("multilined"));
Assert.Equal("line 1\r\nline 2\r\nline 3", parser.GetParameterValues("multilined").First());
}
}
private static RelayRequest DeserializeFormData(Stream body)
{
var form = MultipartFormDataParser.Parse(body);
var req = new RelayRequest
{
Files = form.Files.Select(f => new HttpFile {
ContentDisposition = f.ContentDisposition,
ContentType = f.ContentType,
Data = f.Data,
FileName = f.FileName,
Name = f.Name
})
};
req.Add(new RelayQuery {
Query = form.Parameters.Find(p => p.Name == "query").Data,
Variables = form.Parameters.Find(p => p.Name == "variables").Data.ToInputs(),
});
return(req);
}
public void HandlesFileWithLastCrLfAtBufferLength()
{
string request =
@"------WebKitFormBoundaryphElSb1aBJGfLyAP
Content-Disposition: form-data; name=""fileName""
Testfile
------WebKitFormBoundaryphElSb1aBJGfLyAP
Content-Disposition: form-data; name=""file""; filename=""Testfile""
Content-Type: application/pdf
"
+ new string('\0', 8147)
+ @"
------WebKitFormBoundaryphElSb1aBJGfLyAP--
";
using (Stream stream = TestUtil.StringToStream(request, Encoding.UTF8))
{
var parser = MultipartFormDataParser.Parse(stream, Encoding.UTF8);
}
}
