private void ProccesRequest(HttpListenerRequest request)
{
Console.WriteLine("I have an request: " + request.ContentType);
var parser = new MultipartFormDataParser(request.InputStream, Encoding.UTF8);
string method = parser.Parameters[0].Data;
var file = parser.Files.First();
var filename = file.FileName;
Stream data = file.Data;
switch (method)
{
case "Create":
ProcessCreate(filename, data);
break;
case "Change":
ProcessChange(filename, data);
break;
default:
break;
}
}
/// <summary>
/// Binds the model.
/// </summary>
/// <typeparam name="T">Model type</typeparam>
/// <param name="args">The <see cref="ModelBinderEventArgs{T}" /> instance containing the event data.</param>
public async Task BindAsync <T>(ModelBinderEventArgs <T> args)
{
if (!args.Context.Request.ContentType.Contains("multipart/form-data"))
{
return;
}
var multipartModelType = typeof(MultipartViewModel);
if (typeof(T) != multipartModelType)
{
throw new ModelBindingException("For HTTP multipart form data model type should be: " + multipartModelType.Name);
}
var parser = await MultipartFormDataParser.ParseAsync(args.Context.Request.Body);
var obj = Activator.CreateInstance <T>();
var model = (MultipartViewModel)(object)obj;
model.Files = parser.Files;
model.Parameters = parser.Parameters;
args.SetModel(obj);
}
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);
}
}
public ServiceDetailsModule() : base("/service")
{
Get("/", _ => "Hello again, Swagger!", null, "ServiceHome");
Get("/details", _ => new ServiceDetails()
{
Name = "Nancy Swagger Service",
Owner = new ServiceOwner()
{
CompanyName = "Swagger Example Inc.",
CompanyContactEmail = "*****@*****.**"
},
Customers = new []
{
new ServiceCustomer()
{
CustomerName = "Jack"
},
new ServiceCustomer()
{
CustomerName = "Jill"
}
}
}, null, "GetDetails");
Get("/customers", _ => new[]
{
new ServiceCustomer()
{
CustomerName = "Jack"
},
new ServiceCustomer()
{
CustomerName = "Jill"
}
}, null, "GetCustomers");
Get("/customers/{name}", _ => new ServiceCustomer()
{
CustomerName = "Jack"
}, null, "GetCustomer");
Post("/customer/{service}", parameters =>
{
var result = this.Bind <ServiceCustomer>();
return(result);
}, null, "PostNewCustomer");
Post("/customer/{name}/file", async parameters =>
{
var parsed = new MultipartFormDataParser(Request.Body);
var file = parsed.Files.FirstOrDefault()?.Data;
if (file == null)
{
return("File Parsing Failed");
}
var reader = new StreamReader(file);
return(await reader.ReadToEndAsync());
}, null, "PostCustomerReview");
}
// Make sure the parsed multipart form data has been parsed
private void GetBodyFiles()
{
if (_BodyParser == null)
{
_BodyParser = MultipartFormDataParser.Parse(_listenerContext.Request.InputStream);
}
}
internal HttpResponse UploadWorld(HttpRequest req)
{
try
{
var header = req.ContentType;
var parser = new MultipartFormDataParser(new MemoryStream(req.Data), req.GetMultipartBoundary(), Encoding.UTF8);
var uid = parser.GetParameterValue("uid");
var token = parser.GetParameterValue("token");
this.characterService.FindAndAuthorize(token, Convert.ToUInt32(uid));
if (parser.Files.Count() < 1)
{
Log.Error("Client {ip}:{port} failed to provide file for UploadWorld", req.SourceIp, req.SourcePort);
return(req.FailureResponse());
}
var file = parser.Files[0];
Log.Information("Uploading world {uid} from client {ip}:{port}", uid, req.SourceIp, req.SourcePort);
this.storage.SaveWorldData(uid, file.Data);
Log.Information("Successfully saved world {uid} from client {ip}:{port}", uid, req.SourceIp, req.SourcePort);
return(new HttpResponse(req, 200, null));
}
catch (Exception e)
{
Request.HandleException(req, e, false);
if (e is CharacterService.NotAuthorizedException || e is CharacterService.NotFoundException)
{
return(req.FailureResponse());
}
else
{
throw e;
}
}
}
private bool ValidateParameters(MultipartFormDataParser parser)
{
var actualParameters = parser.Parameters.GroupBy(p => p.Name);
var expectedParameters = ExpectedParams.GroupBy(p => p.Name);
// Make sure the number of actual parameters matches the number of expected parameters
if (actualParameters.Count() != expectedParameters.Count())
{
return(false);
}
// Validate that each expected value has a corresponding actual value
return(actualParameters.Zip(expectedParameters, Tuple.Create).All(t =>
{
// Make sure the name of the actual parameter matches the name of the expected parameter
if (t.Item1.Key != t.Item2.Key)
{
return false;
}
var actualValues = t.Item1.Select(i => i.Data);
var expectedValues = t.Item2.Select(i => i.Data);
// Make sure the number of actual values matches the number of expected values
if (actualValues.Count() != expectedValues.Count())
{
return false;
}
// Validate that each expected value has a corresponding actual value
return actualValues.Zip(expectedValues, Tuple.Create).All(v => v.Item1 == v.Item2);
}));
}
public Object[] handle(Hashtable httpHeaders, MemoryStream ms)
{
ArrayList responseDatas = new ArrayList();
var parser = new MultipartFormDataParser(ms, Encoding.UTF8);
// Multi-file access
int i = 0;
logger.Debug("Input face images: " + parser.Files.Count);
foreach (var f in parser.Files)
{
HttpRequestDataObj reqObject = JsonConvert.DeserializeObject <HttpRequestDataObj>(parser.Parameters[i].Data);
logger.Debug("reqHeader.uid: [ " + reqObject.capturedTime + " ]");
logger.Debug("reqHeader.imageFilename: [ " + parser.Files.ElementAt(i).Name + " ]");
//string filename = reqObject.imageFilename;
//CopyStream(f.Data, filename);
//f.Data.Flush();
//f.Data.Close();
// do
Thread.Sleep(300);
HttpResponseDataObj resp = new HttpResponseDataObj();
resp.capturedTime = reqObject.capturedTime;
resp.message = @"got " + reqObject.imageFilename;
responseDatas.Add(resp);
i++;
}
return(responseDatas.ToArray(typeof(Object)) as Object[]);
}
private bool ValidateMultipleValuesParameters(MultipartFormDataParser parser)
{
// Deal with the parameters that are expected to have more than one value
var expectedParametersWithMultiValues = ExpectedParams
.GroupBy(p => p.Name)
.Where(a => a.Count() > 1);
foreach (var expectedParameters in expectedParametersWithMultiValues)
{
var key = expectedParameters.Key;
if (!parser.HasParameter(key))
{
return(false);
}
var actualValues = parser.GetParameterValues(key);
if (actualValues.Count() != expectedParameters.Count() || actualValues.Zip(expectedParameters, Tuple.Create).Any(t => t.Item1 != t.Item2.Data))
{
return(false);
}
}
return(true);
}
public ImageJSON Upload()
{
try
{
MultipartFormDataParser parser = new MultipartFormDataParser(HttpContext.Current.Request.InputStream);
ImageJSON imageJson = new ImageJSON();
int uploadImageId = 0;
// Single file access:
FilePart file = parser.Files.First();
string filename = file.FileName;
if (file != null && file.Data != null)
{
// Save the file to db
Application.Services.Abstract.DTO.IImage image = new Application.Services.DTO.Image();
image.UserImage = parser.ReadFully(file.Data);
uploadImageId = _imageService.UploadImage(image);
imageJson.UploadedImageId = uploadImageId;
}
else
{
throw new WebException("The posted file was not recognised.", WebExceptionStatus.SendFailure);
}
return(imageJson);
}
catch (Exception ex)
{
_logger.Error(ex);
throw ex;
}
}
public bool UploadImage(WebServer serve, HttpListenerContext context, string name)
{
var path = serve.Module <StorageModule>().GetFile(name);
var parser = new MultipartFormDataParser(context.Request.InputStream);
var file = parser.Files.First();
string filename = file.FileName;
Stream data = file.Data;
var f = new File(path);
var dirs = new File(f.Parent);
if (!dirs.Exists())
{
dirs.Mkdirs();
}
f.CreateNewFile();
Log.Debug(WiFiDirectActivity.Tag, "Server: copying files " + f);
using (var stream = new FileStream(f.ToString(), FileMode.OpenOrCreate))
{
data.CopyTo(stream);
}
var intent = new Intent();
intent.SetAction(Intent.ActionView);
intent.SetDataAndType(Android.Net.Uri.Parse("file://" + path), "image/*");
_activity.StartActivity(intent);
return(context.JsonResponse(new { Success = "OK" }));
}
private bool ValidateSingleValueParameters(MultipartFormDataParser parser)
{
// Deal with the parameters that are expected to have only one value.
var expectedParametersWithSingleValue = ExpectedParams
.GroupBy(p => p.Name)
.Where(g => g.Count() == 1)
.Select(g => g.Single());
foreach (var expectedParameter in expectedParametersWithSingleValue)
{
if (!parser.HasParameter(expectedParameter.Name))
{
return(false);
}
var actualValue = parser.GetParameterValue(expectedParameter.Name);
var actualValueFromValues = parser.GetParameterValues(expectedParameter.Name).Single();
if (actualValue != actualValueFromValues)
{
return(false);
}
if (expectedParameter.Data != actualValue)
{
return(false);
}
}
return(true);
}
public void CanDetectBoundariesCrossBuffer()
{
using (Stream stream = TestUtil.StringToStream(TinyTestCase.Request, Encoding.UTF8))
{
var parser = new MultipartFormDataParser(stream, "boundry", Encoding.UTF8, 16);
Assert.IsTrue(TinyTestCase.Validate(parser));
}
}
public void CanAutoDetectBoundary()
{
using (Stream stream = TestUtil.StringToStream(TinyTestCase.Request, Encoding.UTF8))
{
var parser = new MultipartFormDataParser(stream);
Assert.IsTrue(TinyTestCase.Validate(parser));
}
}
public void DoesntInfiniteLoopOnUnclosedInput()
{
using (Stream stream = TestUtil.StringToStream(UnclosedBoundary.Request, Encoding.UTF8))
{
// We expect this to throw!
var parser = new MultipartFormDataParser(stream, Encoding.UTF8);
}
}
public void CanHandleFileAsLastSection()
{
using (Stream stream = TestUtil.StringToStream(FileIsLastTestCase.Request, Encoding.UTF8))
{
var parser = new MultipartFormDataParser(stream, Encoding.UTF8);
Assert.IsTrue(FileIsLastTestCase.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 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 MultipleFilesWithSameNameTest()
{
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 MultipleFilesAndParamsTest()
{
using (Stream stream = TestUtil.StringToStream(MultipleParamsAndFilesTestCase.Request, Encoding.UTF8))
{
var parser = new MultipartFormDataParser(stream, "boundry", Encoding.UTF8, 16);
Assert.IsTrue(MultipleParamsAndFilesTestCase.Validate(parser));
}
}
public void TinyDataTest()
{
using (Stream stream = TestUtil.StringToStream(TinyTestCase.Request, Encoding.UTF8))
{
var parser = new MultipartFormDataParser(stream, "boundry", Encoding.UTF8);
Assert.IsTrue(TinyTestCase.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 HandlesFullPathAsFileNameWithSemicolonCorrectly()
{
using (Stream stream = TestUtil.StringToStream(FullPathAsFileNameWithSemicolon.Request, Encoding.UTF8))
{
var parser = new MultipartFormDataParser(stream, Encoding.UTF8);
Assert.IsTrue(FullPathAsFileNameWithSemicolon.Validate(parser));
}
}
public void SingleFileTest()
{
using (Stream stream = TestUtil.StringToStream(SingleFileTestCase.Request, Encoding.UTF8))
{
var parser = new MultipartFormDataParser(stream, "boundry", Encoding.UTF8, 16);
Assert.True(SingleFileTestCase.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 GetParameterValueReturnsNullIfNoParameterFound()
{
using (Stream stream = TestUtil.StringToStream(TinyTestCase.Request, Encoding.UTF8))
{
var parser = new MultipartFormDataParser(stream, "boundry", Encoding.UTF8);
Assert.Null(parser.GetParameterValue("does not exist"));
}
}
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 FileWithAdditionalParameterTest()
{
using (Stream stream = TestUtil.StringToStream(_testCase.Request, Encoding.UTF8))
{
var parser = MultipartFormDataParser.Parse(stream, Encoding.UTF8);
Assert.True(_testCase.Validate(parser));
}
}
public void CanHandleMixedSingleByteAndMultiByteWidthCharacters()
{
using (var stream = TestUtil.StringToStream(MixedSingleByteAndMultiByteWidthTestCase.Request, Encoding.UTF8))
{
var parser = new MultipartFormDataParser(stream, Encoding.UTF8);
Assert.IsTrue(MixedSingleByteAndMultiByteWidthTestCase.Validate(parser));
}
}
/// <summary>
/// Validates the output of the parser against the expected outputs for
/// this test
/// </summary>
/// <param name="parser">
/// The parser to validate.
/// </param>
/// <returns>
/// The <see cref="bool" /> representing if this test passed.
/// </returns>
public bool Validate(MultipartFormDataParser parser)
{
var result = ValidateParameters(parser);
result &= ValidateFiles(parser);
return(result);
}
private void HandleLargeBody()
{
if (Request.Method != "POST" && Request.Method != "PUT")
throw new InvalidOperationException ("Large Request bodies are only allowed with PUT or POST operations.");
string ct = Request.Headers ["Content-Type"];
if (ct == null || !ct.StartsWith ("multipart/form-data", StringComparison.InvariantCultureIgnoreCase)) {
// TODO: Maybe someone wants to post large www-form-urlencoded data?
throw new InvalidOperationException ("Large Request bodies are only allowed with multipart form data.");
}
string boundary = ParseBoundary (ct);
IMFDStream stream = new TempFileMFDStream (IOStream);
MultipartFormDataParser parser = new MultipartFormDataParser (this.Request, boundary, stream, () => {
IOStream.DisableReading ();
Server.RunTransaction (this);
});
parser.ParseParts ();
}
private void OnMultiPartFormData(string boundary, byte [] data)
{
IMFDStream stream = new InMemoryMFDStream (data);
MultipartFormDataParser parser = new MultipartFormDataParser (this.Request, boundary, stream, () => {
IOStream.DisableReading ();
Server.RunTransaction (this);
});
parser.ParseParts ();
}