/// <summary>
/// Valida se uma requisição recebida, que tenha sido enviada pelo PagCoin, é autentica.
/// </summary>
/// <param name="request">WebRequest recebido após efetuar o request</param>
/// <param name="conteudo">Variável out para fornecer o conteúdo da resposta, não necessitando efetuar a leitura da stream novamente.</param>
/// <returns>true caso válida, falso caso inválida</returns>
/// <remarks>Não use este método passando uma WebRequest montada por você. Apenas use para requisições recebidas.</remarks>
public bool ValidarAssinatura(WebRequest request, out string conteudo)
{
var assinatura = request.Headers["AssinaturaPagCoin"];
var endereco = request.Headers["EnderecoPagCoin"];
var getRequestAsyncResult = request.BeginGetRequestStream(asynchronousResult => { }, request);
getRequestAsyncResult.AsyncWaitHandle.WaitOne();
var requestStream = request.EndGetRequestStream(getRequestAsyncResult);
using (var streamRead = new StreamReader(requestStream))
{
conteudo = streamRead.ReadToEnd();
}
var assinaturaValida = ValidarAssinatura(assinatura, endereco, conteudo);
if (!assinaturaValida)
{
conteudo = null;
}
return(assinaturaValida);
}
protected void GetRequestStreamCallback(IAsyncResult asynchronousResult)
{
WebRequest webRequest = (WebRequest)asynchronousResult.AsyncState;
Stream postStream = webRequest.EndGetRequestStream(asynchronousResult);
var formData = new Dictionary <string, string>();
using (var responseSetRepository = new ResponseSetRepository())
formData["surveyId"] = responseSetRepository.GetResponseSetForUserByID(_responseSetID).Survey.SystemID;
Stream postDataStream = MultipartRequestFactory.GetMultipartRequestForResultUpload(formData, _boundary, _responseSetID, formData["surveyId"]);
postDataStream.Position = 0;
byte[] buffer = new byte[1024];
int bytesRead = 0;
while ((bytesRead = postDataStream.Read(buffer, 0, buffer.Length)) != 0)
{
postStream.Write(buffer, 0, bytesRead);
}
postDataStream.Close();
postStream.Flush();
postStream.Close();
webRequest.BeginGetResponse(new AsyncCallback(SendResponseSetCallback), webRequest);
}
/// <summary>
/// Do asynchronous web post.
/// Register EndAsyncResponse and callback method.
/// </summary>
/// <param name="state">Async Web method state</param>
private void EndAsyncRequest(IAsyncResult state)
{
AsyncWebMethodRequest input = state.AsyncState as AsyncWebMethodRequest;
try
{
WebRequest request = input.Request;
Stream requestStream = request.EndGetRequestStream(state);
ASCIIEncoding encoding = new ASCIIEncoding();
byte[] postBytes = encoding.GetBytes(input.PostData);
requestStream.Write(postBytes, 0, postBytes.Length);
requestStream.Close();
request.BeginGetResponse(EndAsyncResponse, input);
}
catch (Exception ex)
{
AsyncWebMethodResponse asyncResponse = new AsyncWebMethodResponse(input.State);
asyncResponse.StatusDescription = ex.Message;
if (ex.InnerException != null)
{
asyncResponse.StatusDescription = string.Format(CultureInfo.InvariantCulture,
"{0}\n{1}",
asyncResponse.StatusDescription,
ex.InnerException.Message);
}
asyncResponse.Status = AsyncMethodState.Failed;
asyncResponse.Error = ex;
input.Callback(asyncResponse);
}
}
/// <summary>
/// Complete the attach-body portion of the request and continue executing the call.
/// </summary>
/// <param name="asyncResult">The asyncResult of the attach body call.</param>
internal void EndAttachBody(IAsyncResult asyncResult)
{
object[] state = (object[])asyncResult.AsyncState;
WebRequest request = (WebRequest)state[0];
Action <WebRequest> onRequestReady = (Action <WebRequest>)state[1];
Stream bodyStream = request.EndGetRequestStream(asyncResult);
// If enabled: Encapsulate in GZipStream.
#if !SILVERLIGHT
if (Service.GZipEnabled)
{
// Change the content encoding and apply a gzip filter.
request.Headers.Add(HttpRequestHeader.ContentEncoding, GZipEncoding);
bodyStream = new GZipStream(bodyStream, CompressionMode.Compress);
}
#endif
// Write data into the stream.
using (bodyStream)
{
byte[] postBody = ContentCharset.GetBytes(Body);
bodyStream.Write(postBody, 0, postBody.Length);
}
onRequestReady(request);
}
/// <summary>
/// Submit data asynchronously
/// </summary>
/// <param name="result"></param>
private void ReadCallback(IAsyncResult result)
{
RequestState state = (RequestState)result.AsyncState;
WebRequest request = state.request;
// End the Asynchronus request.
using (Stream streamResponse = request.EndGetRequestStream(result))
{
// Submit content
if (state.content != null)
{
streamResponse.Write(state.content, 0, state.content.Length);
}
else
{
using (FileStream fs = new FileStream(state.uploadFilePath, FileMode.Open, FileAccess.Read))
{
byte[] content = new byte[4096];
int bytesRead = 0;
do
{
bytesRead = fs.Read(content, 0, content.Length);
streamResponse.Write(content, 0, bytesRead);
} while (bytesRead > 0);
//XXX: perform upload status callback
}
}
}
}
public static Task <Stream> GetRequestStreamAsync(this WebRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
var tcs = new TaskCompletionSource <Stream>();
request.BeginGetRequestStream(ar =>
{
Stream stream = null;
try
{
stream = request.EndGetRequestStream(ar);
tcs.SetResult(stream);
}
catch (Exception ex)
{
tcs.SetException(ex);
}
}, null);
return(tcs.Task);
}
public static async Task <Stream> GetRequestStreamAsync(this WebRequest request)
{
return(await new Task <Stream>(() => {
IAsyncResult result = request.BeginGetRequestStream(ar => { }, null);
return request.EndGetRequestStream(result);
}));
}
/// <summary>
/// Gets a Stream object to use to write request data.
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public static Stream GetRequestStream(this WebRequest request)
{
var tcs = new TaskCompletionSource <Stream>();
try
{
request.BeginGetRequestStream(iar =>
{
try
{
var response = request.EndGetRequestStream(iar);
tcs.SetResult(response);
}
catch (Exception exc)
{
tcs.SetException(exc);
}
}, null);
}
catch (Exception exc)
{
tcs.SetException(exc);
}
return(tcs.Task.Result);
}
private void ProcessRequest(WebRequest request,
IAsyncResult requestAsyncResult,
Action <Stream> requestStreamWriter,
Action <FaceRestAPI.FaceAPI> success,
Action <Exception> error)
{
try
{
using (var requestStream = request.EndGetRequestStream(requestAsyncResult))
{
requestStreamWriter(requestStream);
}
request.BeginGetResponse((responseAsyncResult) => ProcessResponse(request, responseAsyncResult, success, error)
, null);
}
catch (ThreadAbortException)
{
throw;
}
catch (Exception exception)
{
error(exception);
}
}
private void GetRequestCallback(IAsyncResult result)
{
try
{
WebRequest request = (WebRequest)result.AsyncState;
using (Stream stream = request.EndGetRequestStream(result))
{
stream.Write(postData, 0, postData.Length);
}
request.BeginGetResponse(new AsyncCallback(GetResponseCallback), request);
}
catch (WebException e)
{
if (retryCount < retryMax)
{
System.Diagnostics.Debug.WriteLine(e.Message);
++retryCount;
Start();
}
else
{
OnException(e);
}
}
catch (Exception e)
{
OnException(e);
}
}
private IAsyncResult BeginMessageInternal(MessageBase message, AsyncCallback storedCallback, object asyncState, AsyncCallback callback)
{
byte[] body;
WebRequest request = message.Encode(out body);
PortMapAsyncResult mappingResult = PortMapAsyncResult.Create(message, request, storedCallback, asyncState);
if (body.Length > 0)
{
request.ContentLength = body.Length;
request.BeginGetRequestStream(delegate(IAsyncResult result) {
try
{
Stream s = request.EndGetRequestStream(result);
s.Write(body, 0, body.Length);
request.BeginGetResponse(callback, mappingResult);
}
catch (Exception ex)
{
mappingResult.Complete(ex);
}
}, null);
}
else
{
request.BeginGetResponse(callback, mappingResult);
}
return(mappingResult);
}
private void GetRequestCallback(IAsyncResult asynchronousResult)
{
RequestState requestState = (RequestState)asynchronousResult.AsyncState;
if (requestState.IsCancelled)
{
return;
}
WebRequest webRequest = (WebRequest)requestState.WebRequest;
try
{
// End the operation
Stream postStream = webRequest.EndGetRequestStream(asynchronousResult);
//m_brainCloudClientRef.Log("GetRequestStreamCallback - JsonRequeststring GOING OUT: " + requestState.JsonRequestString);
// Convert the string into a byte array.
byte[] byteArray = Encoding.UTF8.GetBytes(requestState.RequestString);
// Write to the request stream.
postStream.Write(byteArray, 0, requestState.RequestString.Length);
postStream.Close();
// Start the asynchronous operation to get the response
webRequest.BeginGetResponse(new AsyncCallback(GetResponseCallback), requestState);
}
catch (Exception ex)
{
m_brainCloudClientRef.Log("GetResponseCallback - Exception: " + ex.ToString());
requestState.DotNetRequestStatus = RequestState.eWebRequestStatus.STATUS_ERROR;
}
}
/// <summary>
/// Ends the write operation.
/// </summary>
/// <param name="result">The result.</param>
public void EndWrite(IAsyncResult result)
{
using (var dataStream = webRequest.EndGetRequestStream(result))
{
dataStream.Write(bytesForNextWrite, 0, bytesForNextWrite.Length);
dataStream.Close();
}
bytesForNextWrite = null;
}
public override void SendRequest(Action callback, int timeout)
{
_callback = callback;
_webRequest = HttpWebRequest.Create(ServiceUrl);
_webRequest.Method = "POST";
_webRequest.Proxy = null;
_webRequest.ContentType = "multipart/byteranges";
_webRequest.Headers.Add(HttpRequestHeader.From, Request.ServiceAtComputer);
_webRequest.Headers.Add(HttpRequestHeader.Pragma, ServiceUrl);
if (!string.IsNullOrEmpty(Request.ContextUri))
{
_webRequest.Headers.Add("ToUri", Request.ContextUri);
}
byte[] buffer = null;
if (Request.BodyBuffer == null)
{
_webRequest.Headers.Add("Null", "true");
_webRequest.ContentLength = 0;
}
else
{
buffer = Request.BodyBuffer.GetByteArray();
_webRequest.ContentLength = buffer.Length;
}
timeout = timeout > 0 ? timeout : _channel.Timeout;
if (timeout > 0)
{
_waitHandle = new ManualResetEvent(false);
_registeredHandle = ThreadPool.RegisterWaitForSingleObject(_waitHandle, new WaitOrTimerCallback(TimeoutCallback), this, timeout, true);
}
if (_webRequest.ContentLength == 0)
{
_webRequest.BeginGetResponse(new AsyncCallback(ResponseCallback), this);
}
else
{
_webRequest.BeginGetRequestStream(
delegate(IAsyncResult asyncResult) {
try {
Stream stream = _webRequest.EndGetRequestStream(asyncResult);
stream.Write(buffer, 0, buffer.Length);
stream.Close();
_webRequest.BeginGetResponse(new AsyncCallback(ResponseCallback), this);
} catch (Exception ex) {
Response = RpcResponse.Create(RpcErrorCode.SendFailed, ex);
_callback();
}
},
this
);
}
}
private void RequestStreamCallback(IAsyncResult asynchronousResult)
{
webRequest = (HttpWebRequest)asynchronousResult.AsyncState;
using (var postStream = webRequest.EndGetRequestStream(asynchronousResult))
{
//send yoour data here
}
webRequest.BeginGetResponse(new AsyncCallback(ResponseCallback), webRequest);
}
void IRpcClientTransaction.SendRequest <T>(RpcRequestHeader request, T args, Action <RpcResponseHeader> callback, int timeout)
{
_callback = callback;
_serviceUrl = string.Format("{0}/{1}.{2}", request.ServerUri, request.Service, request.Method);
_webRequest = HttpWebRequest.Create(_serviceUrl);
_webRequest.Method = "POST";
_webRequest.Proxy = null;
_webRequest.ContentType = "multipart/byteranges";
_webRequest.Headers.Add(HttpRequestHeader.From, request.ServiceAtComputer);
_webRequest.Headers.Add(HttpRequestHeader.Pragma, _serviceUrl);
_webRequest.Headers.Add(HttpRequestHeader.Cookie, "to=" + ObjectHelper.ToString(request.ToUri));
byte[] buffer = null;
if (!request.HasBody)
{
_webRequest.Headers.Add("Null", "true");
_webRequest.ContentLength = 0;
}
else
{
buffer = ProtoBufSerializer.ToByteArray <T>(args);
_webRequest.ContentLength = buffer.Length;
}
timeout = timeout > 0 ? timeout : _channel.Timeout;
if (timeout > 0)
{
_waitHandle = new ManualResetEvent(false);
ThreadPool.RegisterWaitForSingleObject(_waitHandle, new WaitOrTimerCallback(TimeoutCallback), this, timeout, true);
}
if (_webRequest.ContentLength == 0)
{
_webRequest.BeginGetResponse(new AsyncCallback(ResponseCallback), this);
}
else
{
_webRequest.BeginGetRequestStream(
delegate(IAsyncResult asyncResult) {
try {
Stream stream = _webRequest.EndGetRequestStream(asyncResult);
stream.Write(buffer, 0, buffer.Length);
stream.Close();
_webRequest.BeginGetResponse(new AsyncCallback(ResponseCallback), this);
} catch (Exception ex) {
var resp = RpcResponseHeader.CreateError(RpcErrorCode.SendFailed, ex);
_callback(resp);
}
},
this
);
}
}
/// <summary>
/// Writes post data to stream and begin to retrieve response from server
/// </summary>
/// <param name="ar"></param>
void BeginRequest(IAsyncResult ar)
{
using (Stream stm = _webRequest.EndGetRequestStream(ar))
{
var postData = (byte[])ar.AsyncState;
stm.Write(postData, 0, (int)postData.Length);
stm.Close();
}
_webRequest.BeginGetResponse(BeginResponse, null);
}
// extension method for web request to get the request stream with a proper timeout
public static Stream GetRequestStreamWithTimeout(this WebRequest request)
{
IAsyncResult worker = request.BeginGetRequestStream(null, null);
if (!worker.AsyncWaitHandle.WaitOne(request.Timeout))
{
TimeoutException ex = new TimeoutException();
throw new WebException(ex.Message, ex, WebExceptionStatus.Timeout, null);
}
return(request.EndGetRequestStream(worker));
}
public static Stream GetWebRequestStream(this WebRequest request)
{
AutoResetEvent autoResetEvent = new AutoResetEvent(false);
IAsyncResult asyncResult = request.BeginGetRequestStream(r => autoResetEvent.Set(), null);
// Wait until the call is finished
autoResetEvent.WaitOne();
return(request.EndGetRequestStream(asyncResult));
}
internal Stream GetRequestStream(WebRequest request)
{
Stream stream = null;
request.BeginGetRequestStream(a =>
{
stream = request.EndGetRequestStream(a);
allDone.Set();
}, null);
allDone.WaitOne(TimeSpan.FromSeconds(30));
return(stream);
}
/// <summary>
/// Callback used to process request stream.
/// </summary>
/// <param name="asynchronousResult">Server response state.</param>
protected void GetRequestStreamCallback(IAsyncResult asynchronousResult)
{
WebRequest webRequest = (WebRequest)asynchronousResult.AsyncState;
Stream postStream = webRequest.EndGetRequestStream(asynchronousResult);
string postData = GetStringFromXDocument();
byte[] bytesToSend = CompressResult(postData);
postStream.Write(bytesToSend, 0, bytesToSend.Length);
postStream.Close();
webRequest.BeginGetResponse(new AsyncCallback(GetResponseCallback), webRequest);
}
void WriteToRequestStream(IAsyncResult result)
{
WebRequest req = (WebRequest)result.AsyncState;
Stream post_data = req.EndGetRequestStream(result);
byte[] request_buffer = Encoding.UTF8.GetBytes(_Message);
_Message = null;
post_data.Write(request_buffer, 0, request_buffer.Length);
post_data.Close();
req.BeginGetResponse(ReadResponseStream, req);
}
private void OnGetRequestStreamCompleted(IAsyncResult ar, WebRequest request, byte[] data)
{
try {
using (var output = request.EndGetRequestStream(ar)) {
output.Write(data, 0, data.Length);
}
request.BeginGetResponse(OnGetResponseCompleted, request);
}
catch (Exception e) {
OnWebPostError(request, e);
}
}
public Stream GetRequestStream(WebRequest request)
{
ManualResetEvent evt = new ManualResetEvent(false);
Stream requestStream = null;
request.BeginGetRequestStream((IAsyncResult ar) => {
requestStream = request.EndGetRequestStream(ar);
evt.Set();
}, null);
evt.WaitOne();
return(requestStream);
}
private void GetRequestStreamCallback(IAsyncResult result)
{
WebRequest request = (WebRequest)result.AsyncState;
using (Stream stream = request.EndGetRequestStream(result))
{
stream.Write(postData, 0, postData.Length);
stream.Close();
}
request.BeginGetResponse(new AsyncCallback(GetResponseCallback), request);
}
private void RequestReadySocket(IAsyncResult asyncResult)
{
WebRequest request = asyncResult.AsyncState as WebRequest;
Stream requestStream = request.EndGetRequestStream(asyncResult);
using (StreamWriter writer = new StreamWriter(requestStream))
{
writer.Write(postData);
writer.Flush();
}
request.BeginGetResponse(new AsyncCallback(ResponseReadySocket), request);
}
public void CustomIsolatedStorageWebRequest()
{
IWebRequestCreate creator = (IWebRequestCreate) new IsolatedStorageWebRequest();
Assert.IsTrue(WebRequest.RegisterPrefix("iso", creator), "iso-1");
Assert.IsFalse(WebRequest.RegisterPrefix("iso", creator), "iso-2");
WebRequest wr = WebRequest.Create(new Uri("iso://site/data.log"));
wr.Method = "SAVE";
IAsyncResult result = wr.BeginGetRequestStream(null, String.Empty);
result.AsyncWaitHandle.WaitOne();
Stream s = wr.EndGetRequestStream(result);
using (StreamWriter sw = new StreamWriter(s)) {
sw.WriteLine("hello");
}
result = wr.BeginGetResponse(null, String.Empty);
result.AsyncWaitHandle.WaitOne();
Assert.IsNull(wr.EndGetResponse(result), "Response-Write");
wr.Method = "LOAD";
// should be in response but that would require a lot of extra code ;-)
result = wr.BeginGetRequestStream(null, String.Empty);
result.AsyncWaitHandle.WaitOne();
s = wr.EndGetRequestStream(result);
using (StreamReader sr = new StreamReader(s)) {
Assert.IsTrue(sr.ReadToEnd().StartsWith("hello"), "ReadToEnd");
}
result = wr.BeginGetResponse(null, String.Empty);
result.AsyncWaitHandle.WaitOne();
Assert.IsNull(wr.EndGetResponse(result), "Response-Read");
}
private void UploadContent(IAsyncResult result)
{
if (Builder.Log != null)
{
Builder.Log.WriteLine();
var r = new StreamReader(content);
Builder.Log.WriteLine(r.ReadToEnd());
content.Position = 0;
}
using (Stream response = Request.EndGetRequestStream(result))
content.CopyTo(response);
content.Close();
}
public Response Send(Event e)
{
Validate(e);
string json = GenerateRequestJSONString(e);
// Make POST request
WebRequest request = WebRequest.Create(ClusterURL + "/save");
request.ContentType = "text/json";
request.Method = "POST";
// Set JSON data
AutoResetEvent autoResetEventStream = new AutoResetEvent(false);
IAsyncResult asyncResultStream = request.BeginGetRequestStream(r => autoResetEventStream.Set(), null);
// Wait until tit's finished
autoResetEventStream.WaitOne();
Stream stream = request.EndGetRequestStream(asyncResultStream) as Stream;
StreamWriter streamWriter = new StreamWriter(stream);
streamWriter.Write(json);
streamWriter.Flush();
// Send and wait
AutoResetEvent autoResetEvent = new AutoResetEvent(false);
IAsyncResult asyncResult = request.BeginGetResponse(r => autoResetEvent.Set(), null);
// Wait until the call is finished
autoResetEvent.WaitOne();
HttpWebResponse response = request.EndGetResponse(asyncResult) as HttpWebResponse;
int code = (int)response.StatusCode;
if (code != 200)
{
throw new WebException(code.ToString() + ": " + ClusterURL + "/save isn't reachable");
}
// Parse JSON body
string body;
using (var sr = new StreamReader(response.GetResponseStream()))
{
body = sr.ReadToEnd();
}
// Decode JSON string into Response object
Response decoded = JsonConvert.DeserializeObject <Response>(body);
return(decoded);
}
public void SetUp()
{
var uri = OAuthRequestHandler.OAuthRequestUri;
var factory = new TestWebRequestFactory();
factory.RegisterResultForUri(uri.AbsoluteUri, "null");
_request = factory.Create(uri);
_stream = new MemoryStream();
_request.EndGetRequestStream(Arg.Any <IAsyncResult>()).Returns(c => _stream);
_request.GetRequestStreamAsync().Returns(async c => (Stream)_stream);
_handler = new OAuthRequestHandler(new ApiConfiguration("<<clientid>>", "<<clientsecret>>", "http://desktop/"));
}