/// <summary>
/// 监听WebSocket
/// </summary>
/// <param name="context">HttpContext</param>
/// <param name="userName">用户名称</param>
public void Monitor(HttpContextBase context, string userName)
{
if (context.IsWebSocketRequest)
{
context.AcceptWebSocketRequest((c) => ProcessChat(c, userName));
}
}
private async Task ProcessRequestAsync(HttpContextBase context)
{
// block hosts with more than 10 bad requests in the last 10 seconds..
// (item1 is last request time, item2 is count of previous requests)
if (blockedHosts.TryGetValue(context.Request.UserHostAddress, out Tuple <DateTime, int> t) && DateTime.UtcNow.Subtract(t.Item1).TotalSeconds < 10 && t.Item2 > 10)
{
return;
}
if (context.IsWebSocketRequest)
{
if (AcceptSocketConnections)
{
context.AcceptWebSocketRequest((Func <WebSocketContext, Task>)HandleWebsocketRequest);
}
return;
}
// get download code from querystring or subdomain..
// (http://9fakr.mydomain.com or http://mydomain.com/9fakr or http://somedomain.dom/mysite/9fakr)
string path = context.Request.RawUrl.Substring(context.Request.ApplicationPath.Length).ToLower().Trim(new char[] { '/', '\\', ' ' });
string code = (string.IsNullOrEmpty(path) && context.Request.Url.Host.Split('.').Length == 3) ? context.Request.Url.Host.Split('.')[0].ToLower() : path;
bool validCode = DownloadCode.Check(code);
bool mainpageRequest = (path == "") && !validCode;
if (mainpageRequest && !(EnableBuiltinWebclient && AcceptSocketConnections))
{
return;
}
try
{
if (validCode)
{
if (activeRelays.TryGetValue(code, out IRelay relay) && !botAgents.IsMatch(context.Request.UserAgent ?? ""))
{
await relay.HandleDownloadRequest(context);
}
else
{
context.Response.StatusCode = 410;
}
}
else if (!await staticContent.HandleRequest(context, path))
{
context.Response.StatusCode = 404;
blockedHosts.AddOrUpdate(context.Request.UserHostAddress, new Tuple <DateTime, int>(DateTime.UtcNow, 1),
(k, v) => new Tuple <DateTime, int>(DateTime.UtcNow, DateTime.UtcNow.Subtract(v.Item1).TotalSeconds < 10 ? v.Item2 + 1 : 1));
}
}
finally
{
context.Response.OutputStream.Dispose();
}
}
public Func <Task> ProcessRequest(IConnection connection)
{
// Never time out for websocket requests
connection.ReceiveTimeout = TimeSpan.FromTicks(Int32.MaxValue - 1);
_context.AcceptWebSocketRequest(this);
_connection = connection;
return(() => Task.FromResult <object>(null));
}
public void AcceptWebSocketRequest(Func <IWebSocket, Task> callback)
{
#if NET45
_context.AcceptWebSocketRequest(ws =>
{
var handler = new AspNetWebSocketHandler();
var task = handler.ProcessWebSocketRequestAsync(ws);
callback(handler).Then(h => h.CleanClose(), handler);
return(task);
});
#else
throw new NotSupportedException();
#endif
}
public Task AcceptWebSocketRequest(Func <IWebSocket, Task> callback)
{
#if NET45
_context.AcceptWebSocketRequest(ws =>
{
var handler = new SignalR.WebSockets.DefaultWebSocketHandler();
var task = handler.ProcessWebSocketRequestAsync(ws);
callback(handler).Then(h => h.CleanClose(), handler);
return(task);
});
return(TaskAsyncHelper.Empty);
#else
throw new NotSupportedException();
#endif
}
public void ProcessRequest(HttpContextBase context)
{
if (context.IsWebSocketRequest)
{
if (AccessCode == null)
{
AccessCode = TheBaseAssets.MySettings.GetSetting("WSTestCode");
}
if (!string.IsNullOrEmpty(AccessCode))
{
var RequestUri = HttpContext.Current.Request.Url;
if (!RequestUri.PathAndQuery.Contains(AccessCode))
{
return;
}
}
context.AcceptWebSocketRequest(ProcessSocketRequest);
}
}
public override void AcceptWebSocketRequest(Func <AspNetWebSocketContext, Task> userFunc)
{
_inner.AcceptWebSocketRequest(userFunc);
}
public IAsyncResult BeginProcessRequest(HttpContextBase context, AsyncCallback callback, object state)
{
var tcs = new TaskCompletionSource <Action>(state);
if (callback != null)
{
tcs.Task.ContinueWith(task => callback(task), TaskContinuationOptions.ExecuteSynchronously);
}
var request = context.Request;
var response = context.Response;
var pathBase = request.ApplicationPath;
if (pathBase == "/" || pathBase == null)
{
pathBase = string.Empty;
}
if (root != null)
{
pathBase += root;
}
var path = request.Path;
if (path.StartsWith(pathBase))
{
path = path.Substring(pathBase.Length);
}
var serverVarsToAddToEnv = request.ServerVariables.AllKeys
.Where(key => !key.StartsWith("HTTP_") && !string.Equals(key, "ALL_HTTP") && !string.Equals(key, "ALL_RAW"))
.Select(key => new KeyValuePair <string, object>(key, request.ServerVariables.Get(key)));
var env = new Dictionary <string, object>();
env[OwinConstants.Version] = "1.0";
env[OwinConstants.RequestMethod] = request.HttpMethod;
env[OwinConstants.RequestScheme] = request.Url.Scheme;
env[OwinConstants.RequestPathBase] = pathBase;
env[OwinConstants.RequestPath] = path;
env[OwinConstants.RequestQueryString] = request.ServerVariables["QUERY_STRING"];
env[OwinConstants.RequestProtocol] = request.ServerVariables["SERVER_PROTOCOL"];
env[OwinConstants.RequestBody] = request.InputStream;
env[OwinConstants.RequestHeaders] = request.Headers.AllKeys
.ToDictionary(x => x, x => request.Headers.GetValues(x), StringComparer.OrdinalIgnoreCase);
if (request.ClientCertificate != null && request.ClientCertificate.Certificate.Length != 0)
{
env[OwinConstants.ClientCertificate] = new X509Certificate(request.ClientCertificate.Certificate);
}
env[OwinConstants.CallCancelled] = CancellationToken.None;
env[OwinConstants.ResponseHeaders] = new Dictionary <string, string[]>(StringComparer.OrdinalIgnoreCase);
int?responseStatusCode = null;
env[OwinConstants.ResponseBody] =
new TriggerStream(response.OutputStream)
{
OnFirstWrite = () =>
{
responseStatusCode = Get <int>(env, OwinConstants.ResponseStatusCode, 200);
response.StatusCode = responseStatusCode.Value;
object reasonPhrase;
if (env.TryGetValue(OwinConstants.ResponseReasonPhrase, out reasonPhrase))
{
response.StatusDescription = Convert.ToString(reasonPhrase);
}
var responseHeaders = Get <IDictionary <string, string[]> >(env, OwinConstants.ResponseHeaders, null);
if (responseHeaders != null)
{
foreach (var responseHeader in responseHeaders)
{
foreach (var headerValue in responseHeader.Value)
{
response.AddHeader(responseHeader.Key, headerValue);
}
}
}
}
};
SetEnvironmentServerVariables(env, serverVarsToAddToEnv);
env[OwinConstants.HttpContextBase] = context;
#if ASPNET_WEBSOCKETS
if (context.IsWebSocketRequest)
{
env[OwinConstants.WebSocketVersion] = "1.0";
env[OwinConstants.WebSocketSupport] = "WebSocketFunc";
}
#endif
response.BufferOutput = false;
try
{
appFunc(env)
.ContinueWith(t =>
{
if (t.IsFaulted)
{
tcs.TrySetException(t.Exception.InnerExceptions);
}
else if (t.IsCanceled)
{
tcs.TrySetCanceled();
}
else
{
#if ASPNET_WEBSOCKETS
object tempWsBodyDelegate;
if (responseStatusCode == null)
{
responseStatusCode = Get <int>(env, OwinConstants.ResponseStatusCode, 200);
}
if (responseStatusCode.Value == 101 &&
env.TryGetValue(OwinConstants.WebSocketFunc, out tempWsBodyDelegate) &&
tempWsBodyDelegate != null)
{
var wsBodyDelegate = (WebSocketFunc)tempWsBodyDelegate;
context.AcceptWebSocketRequest(async websocketContext => // todo: AcceptWebSocketRequest throws error
{
var webSocket = websocketContext.WebSocket;
var wsEnv = new Dictionary <string, object>(StringComparer.OrdinalIgnoreCase);
wsEnv[OwinConstants.WebSocketSendAsyncFunc] = WebSocketSendAsync(webSocket);
wsEnv[OwinConstants.WebSocketReceiveAsyncFunc] = WebSocketReceiveAsync(webSocket);
wsEnv[OwinConstants.WebSocketCloseAsyncFunc] = WebSocketCloseAsync(webSocket);
wsEnv[OwinConstants.WebSocketVersion] = "1.0";
wsEnv[OwinConstants.WebSocketCallCancelled] = CancellationToken.None;
wsEnv[OwinConstants.AspNetWebSocketContext] = websocketContext;
await wsBodyDelegate(wsEnv);
switch (webSocket.State)
{
case WebSocketState.Closed: // closed gracefully, no action needed
case WebSocketState.Aborted: // closed abortively, no action needed
break;
case WebSocketState.CloseReceived:
await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None);
break;
case WebSocketState.Open:
case WebSocketState.CloseSent: // No close received, abort so we don't have to drain the pipe.
websocketContext.WebSocket.Abort();
break;
default:
throw new ArgumentOutOfRangeException("state", webSocket.State, string.Empty);
}
response.Close();
});
}
#endif
tcs.TrySetResult(() => { });
}
});
}
catch (Exception ex)
{
tcs.TrySetException(ex);
}
return(tcs.Task);
}
