public Stream GetInputStream()
{
try
{
// CSDMain #133228: "Consume GetBufferlessInputStream"
// The ReadEntityBodyMode property on the HttpRequest keeps track of whether the request stream has already been accessed, and if so, what API was used to access the request.
// - "None" means that the request stream hasn't been accessed.
// - "Bufferless" means that GetBufferlessInputStream() was used to access it.
// - "Buffered" means GetBufferedInputStream() was used to access it.
// - "Classic" means that either the InputStream, Form, Files, or BinaryRead APIs were invoked already.
// In general, these values are incompatible with one another, meaning that once the request was accessed in a "Classic" way, only "Classic" APIs can be invoked on the HttpRequest.
// If incompatible APIs are invoked, an HttpException is thrown.
// In order to prevent HttpExceptions from being thrown for this reason, we will check the ReadEntityBodyMode, and access the request stream with the corresponding API
// If the request stream hasn't been accessed yet (eg, by an HttpModule which executed earlier), then we will use GetBufferlessInputStream by default.
ReadEntityBodyMode mode = this.context.Request.ReadEntityBodyMode;
Fx.Assert(mode == ReadEntityBodyMode.None || mode == ReadEntityBodyMode.Bufferless || mode == ReadEntityBodyMode.Buffered || mode == ReadEntityBodyMode.Classic,
"Unknown value for System.Web.ReadEntityBodyMode enum");
if (mode == ReadEntityBodyMode.None && ServiceHostingEnvironment.AspNetCompatibilityEnabled && AppSettings.UseClassicReadEntityMode)
{
mode = ReadEntityBodyMode.Classic;
}
switch (mode)
{
case ReadEntityBodyMode.None:
case ReadEntityBodyMode.Bufferless:
return(this.context.Request.GetBufferlessInputStream(true)); // ignores system.web/httpRuntime/maxRequestLength
case ReadEntityBodyMode.Buffered:
return(this.context.Request.GetBufferedInputStream());
default:
// ReadEntityBodyMode.Classic:
return(this.context.Request.InputStream);
}
}
catch (HttpException hostedException)
{
if (hostedException.WebEventCode == WebEventCodes.RuntimeErrorPostTooLarge)
{
throw FxTrace.Exception.AsError(HttpInput.CreateHttpProtocolException(SR.Hosting_MaxRequestLengthExceeded, HttpStatusCode.RequestEntityTooLarge, null, hostedException));
}
else
{
throw FxTrace.Exception.AsError(new CommunicationException(hostedException.Message, hostedException));
}
}
}
/*
* Read entire raw content as byte array
*/
private HttpRawUploadedContent GetEntireRawContent() {
if (_wr == null)
return null;
if (_rawContent != null) {
// if _rawContent was set by HttpBufferlessInputStream, then we will apply the filter here
if (_installedFilter != null && !_filterApplied) {
ApplyFilter(ref _rawContent, RuntimeConfig.GetConfig(_context).HttpRuntime.RequestLengthDiskThresholdBytes);
}
return _rawContent;
}
if (_readEntityBodyMode == ReadEntityBodyMode.None) {
_readEntityBodyMode = ReadEntityBodyMode.Classic;
}
else if (_readEntityBodyMode == ReadEntityBodyMode.Buffered) {
// _rawContent should have been set already
throw new InvalidOperationException(SR.GetString(SR.Invalid_operation_with_get_buffered_input_stream));
}
else if (_readEntityBodyMode == ReadEntityBodyMode.Bufferless) {
throw new HttpException(SR.GetString(SR.Incompatible_with_get_bufferless_input_stream));
}
// enforce the limit
HttpRuntimeSection cfg = RuntimeConfig.GetConfig(_context).HttpRuntime;
int limit = cfg.MaxRequestLengthBytes;
if (ContentLength > limit) {
if ( !(_wr is IIS7WorkerRequest) ) {
Response.CloseConnectionAfterError();
}
throw new HttpException(SR.GetString(SR.Max_request_length_exceeded),
null, WebEventCodes.RuntimeErrorPostTooLarge);
}
// threshold to go to file
int fileThreshold = cfg.RequestLengthDiskThresholdBytes;
// read the preloaded content
HttpRawUploadedContent rawContent = new HttpRawUploadedContent(fileThreshold, ContentLength);
byte[] preloadedContent = _wr.GetPreloadedEntityBody();
if (preloadedContent != null) {
_wr.UpdateRequestCounters(preloadedContent.Length);
rawContent.AddBytes(preloadedContent, 0, preloadedContent.Length);
}
// read the remaing content
if (!_wr.IsEntireEntityBodyIsPreloaded()) {
int remainingBytes = (ContentLength > 0) ? ContentLength - rawContent.Length : Int32.MaxValue;
HttpApplication app = _context.ApplicationInstance;
byte[] buf = (app != null) ? app.EntityBuffer : new byte[8 * 1024];
int numBytesRead = rawContent.Length;
while (remainingBytes > 0) {
int bytesToRead = buf.Length;
if (bytesToRead > remainingBytes)
bytesToRead = remainingBytes;
int bytesRead = _wr.ReadEntityBody(buf, bytesToRead);
if (bytesRead <= 0)
break;
_wr.UpdateRequestCounters(bytesRead);
rawContent.AddBytes(buf, 0, bytesRead);
remainingBytes -= bytesRead;
numBytesRead += bytesRead;
if (numBytesRead > limit) {
throw new HttpException(SR.GetString(SR.Max_request_length_exceeded),
null, WebEventCodes.RuntimeErrorPostTooLarge);
}
// Fail synchrously if receiving the request content takes too long
// RequestTimeoutManager is not efficient in case of ThreadPool starvation
// as the timer callback doing Thread.Abort may not trigger for a long time
if (remainingBytes > 0 && _context.HasTimeoutExpired) {
throw new HttpException(SR.GetString(SR.Request_timed_out));
}
}
}
rawContent.DoneAddingBytes();
// filter content
if (_installedFilter != null) {
ApplyFilter(ref rawContent, fileThreshold);
}
SetRawContent(rawContent);
return _rawContent;
}
private Stream GetInputStream(bool persistEntityBody, bool disableMaxRequestLength = false) {
EnsureHasNotTransitionedToWebSocket();
ReadEntityBodyMode requestedMode = (persistEntityBody) ? ReadEntityBodyMode.Buffered : ReadEntityBodyMode.Bufferless;
ReadEntityBodyMode currentMode = _readEntityBodyMode;
if (currentMode == ReadEntityBodyMode.None) {
_readEntityBodyMode = requestedMode;
_readEntityBodyStream = new HttpBufferlessInputStream(_context, persistEntityBody, disableMaxRequestLength);
}
else if (currentMode == ReadEntityBodyMode.Classic) {
throw new HttpException(SR.GetString(SR.Incompatible_with_input_stream));
}
else if (currentMode != requestedMode) {
throw new HttpException((persistEntityBody) ? SR.GetString(SR.Incompatible_with_get_bufferless_input_stream) : SR.GetString(SR.Incompatible_with_get_buffered_input_stream));
}
return _readEntityBodyStream;
}
public void SetReadEntityBodyMode(ReadEntityBodyMode value)
{
readEntityBodyMode = value;
}
public void SetReadEntityBodyMode(ReadEntityBodyMode val)
{
_readEntityBodyMode = val;
}
public void SetReadEntityBodyMode(ReadEntityBodyMode val)
{
}
public virtual void ProcessRequest(HttpContext context)
{
try {
HttpRequest request = context.Request;
WobCredentials credentials = new WobCredentials(
WebConfigurationManager.AppSettings["ServiceAccountId"],
WebConfigurationManager.AppSettings["ServiceAccountPrivateKey"],
WebConfigurationManager.AppSettings["ApplicationName"],
WebConfigurationManager.AppSettings["IssuerId"]);
// OAuth - setup certificate based on private key file
X509Certificate2 certificate = new X509Certificate2(
AppDomain.CurrentDomain.BaseDirectory + credentials.serviceAccountPrivateKey,
"notasecret",
X509KeyStorageFlags.Exportable);
WobUtils utils = null;
WebserviceRequest webRequest = null;
JsonWebToken.Payload.WebserviceResponse webResponse = null;
string jwt = null;
ReadEntityBodyMode read = request.ReadEntityBodyMode;
Stream inputStream = null;
if (read == ReadEntityBodyMode.None)
{
inputStream = request.GetBufferedInputStream();
}
else
{
inputStream = request.InputStream;
}
webRequest = NewtonsoftJsonSerializer.Instance.Deserialize <WebserviceRequest>(inputStream);
if (webRequest.Method.Equals("signup"))
{
webResponse = new JsonWebToken.Payload.WebserviceResponse()
{
Message = "Welcome to baconrista",
Result = "approved"
};
}
else
{
webResponse = new JsonWebToken.Payload.WebserviceResponse()
{
Message = "Thanks for linking to baconrista",
Result = "approved"
};
}
utils = new WobUtils(credentials.IssuerId, certificate);
string linkId = webRequest.Params.LinkingId;
LoyaltyObject loyaltyObject = Loyalty.generateLoyaltyObject(credentials.IssuerId, "LoyaltyClass", (linkId != null) ? linkId : "LoyaltyObject");
utils.addObject(loyaltyObject);
jwt = utils.GenerateWsJwt(webResponse);
HttpResponse response = context.Response;
response.Write(jwt);
}
catch (Exception e) {
Console.Write(e.StackTrace);
}
}
