public void ProcessHttpRequest(string _request)
{
Console.Out.Write("[{0}]: ", Tcp.Client.RemoteEndPoint);
var httpParams = HttpHelper.GetHTTPParams(_request);
if (httpParams.ContainsKey("Sec-WebSocket-Key"))
{
string wsProtocol = "";
if (httpParams.ContainsKey("Sec-WebSocket-Protocol"))
{
WebSocketProtocol = httpParams["Sec-WebSocket-Protocol"];
WebSocketHandler = Server.GetWebSocketHandler(WebSocketProtocol);
Console.Out.WriteLine("upgradet to WebSocketL: [{0}]", WebSocketProtocol);
if (WebSocketHandler != null)
wsProtocol = this.WebSocketProtocol;
}
string response = HttpHelper.RespondWebSocketHandshake(httpParams["Sec-WebSocket-Key"], wsProtocol);
IsWebSocket = true;
HttpHelper.SendString(Tcp, response);
}
else
{
string response = Server.ProcessHTTPRequest(_request, this);
HttpHelper.SendHttpResponse(Tcp, response);
Console.Out.WriteLine("");
}
}
public static void CreateWebsocketHandler()
{
WebSocketConfigForJsonConfig websocketConfig = ConfigJson <WebSocketConfigForJsonConfig> .GetJsonFromConfigFile().Result;
socketServer = new WebSocketTcpListener(websocketConfig);
socketServer.RunServer(); // Start the Listener
}
public void Prepare()
{
_handler = Substitute.For <IWebSocketHandler>();
var module = new WsModule(_handler);
_browser = new Browser(with => with.Module(module));
}
public VersionWebSocketController(IWebSocketHandler webSocketHandler, IVersionWebSocketService versionWebSocketService, IDebugHandler debugHandler)
{
debugHandler.TraceMessage("Constructor Called.", DebugSource.CONSTRUCTOR, DebugType.ENTRY_EXIT);
DebugHandler = debugHandler;
VersionWebSocketService = versionWebSocketService;
WebSocketHandler = webSocketHandler;
}
public SettingsWebSocketController(IWebSocketHandler webSocketHandler, ISettingsWebSocketService settingsWebSocketService, IDebugHandler debugHandler)
{
debugHandler.TraceMessage("Constructor Called.", DebugSource.CONSTRUCTOR, DebugType.ENTRY_EXIT);
DebugHandler = debugHandler;
SettingsWebSocketService = settingsWebSocketService;
WebSocketHandler = webSocketHandler;
}
public DirectoryWebSocketController(IWebSocketHandler webSocketHandler, IDirectoryWebSocketService directoryWebSocketService, IDebugHandler debugHandler)
{
debugHandler.TraceMessage("Contructor Called.", DebugSource.CONSTRUCTOR, DebugType.ENTRY_EXIT);
DebugHandler = debugHandler;
DirectoryWebSocketService = directoryWebSocketService;
WebSocketHandler = webSocketHandler;
}
private void RegisterObjectHandler <T>(PathString path, IWebSocketHandler <T> handler)
{
var binaryHandler = new BinaryWebSocketHandler(new SerializingWebSocketHandler <T>(
handler, container.GetInstance <ISerializer>()));
registry.Add(path, binaryHandler);
}
public DownloadWebSocketService(
IWebSocketHandler webSocketHandler,
IDirectoryHandler directoryHandler,
IDownloadHandler downloadHandler,
IFileHandler fileHandler,
IFileHistoryHandler fileHistoryHandler,
ISettingsHandler settingsHandler,
IDebugHandler debugHandler)
{
debugHandler.TraceMessage("Constructor called.", DebugSource.CONSTRUCTOR, DebugType.ENTRY_EXIT);
DebugHandler = debugHandler;
WebSocketHandler = webSocketHandler;
DirectoryHandler = directoryHandler;
DownloadHandler = downloadHandler;
FileHandler = fileHandler;
FileHistoryHandler = fileHistoryHandler;
SettingsHandler = settingsHandler;
LastDownloadedInfo = new JsonDownloadInfo();
LittleWeebSettings = SettingsHandler.GetLittleWeebSettings();
IrcSettings = SettingsHandler.GetIrcSettings();
downloadHandler.OnDownloadUpdateEvent += OnDownloadUpdateEvent;
}
public void CreateHandler(IEnumerable <byte> data)
{
byte[] bytes = data.ToArray();
var request = RequestParser.Parse(bytes, owner.Schema);
if (request == null)
{
return;
}
handler = WebSocketHandlerFactory.BuildHandler(request, SockectConnection.OnMessage, SockectConnection.OnClose, SockectConnection.OnBinary);
if (handler == null)
{
return;
}
var subProtocol = SubProtocolNegotiator.Negotiate(owner.SupportedSubProtocols, request.SubProtocols);
ConnectionInfo = WebSocketConnectionInfo.Create(request, SockectConnection.Socket.RemoteIpAddress, SockectConnection.Socket.RemotePort, subProtocol);
if (!string.IsNullOrEmpty(ConnectionInfo.Path))
{
SockectConnection.Session.Add("WebSocket_Path", ConnectionInfo.Path);
}
foreach (string item in ConnectionInfo.Cookies.Keys)
{
SockectConnection.Session.Add(item, ConnectionInfo.Cookies[item]);
}
var handshake = handler.CreateHandshake(subProtocol);
SockectConnection.RawSend(handshake);
}
public ItemsViewModel(AdminAccess.AdminAccessClient client, IWebSocketHandler webSocketHandler)
{
_client = client;
_webSocketHandler = webSocketHandler;
Items = new ObservableCollection <QueueItem>();
webSocketHandler.ItemsChanged += OnItemsChanged;
}
public BaseWebSocketController(IWebSocketHandler webSocketHandler, IDebugHandler debugHandler)
{
debugHandler.TraceMessage("Constructor Called.", DebugSource.CONSTRUCTOR, DebugType.ENTRY_EXIT);
DebugHandler = debugHandler;
WebSocketHandler = webSocketHandler;
WebSocketHandler.OnWebSocketEvent += OnWebSocketEvent;
}
/// <summary>
/// Starts broadcast
/// </summary>
/// <param name="webSocketHandler">websocket broadcast handler</param>
/// <param name="cachedProcessesProvider">Container of processes infromation</param>
public async Task InvokeAsync(IWebSocketHandler webSocketHandler, ICachedProcessesProvider cachedProcessesProvider, CancellationToken cancellationToken)
{
while (!cancellationToken.IsCancellationRequested)
{
await webSocketHandler.SendMessageToSubscribedAsync(JsonSerializer.Serialize(cachedProcessesProvider.GetProcesses()), cancellationToken);
await Task.Delay(1000);
}
}
public SettingsWebSocketService(IWebSocketHandler webSocketHandler,
IDirectoryHandler directoryHandler, IDebugHandler debugHandler)
{
debugHandler.TraceMessage("Constructor Called", DebugSource.CONSTRUCTOR, DebugType.ENTRY_EXIT);
WebSocketHandler = webSocketHandler;
DirectoryHandler = directoryHandler;
DebugHandler = debugHandler;
}
public WebSocketHandlerMiddleware(RequestDelegate next,
IWebSocketHandler webSocketHandler,
ITempDataProvider cookie,
ILogger <WebSocketHandlerMiddleware> logger)
{
this.next = next;
this.webSocketHandler = webSocketHandler;
this.cookie = cookie;
this.logger = logger;
}
public FileWebSocketService(IWebSocketHandler webSocketHandler, IFileHandler fileHandler, IFileHistoryHandler fileHistoryHandler, IDownloadHandler downloadHandler, IDebugHandler debugHandler)
{
debugHandler.TraceMessage("Constructor called.", DebugSource.CONSTRUCTOR, DebugType.ENTRY_EXIT);
WebSocketHandler = webSocketHandler;
FileHandler = fileHandler;
FileHistoryHandler = fileHistoryHandler;
DownloadHandler = downloadHandler;
DebugHandler = debugHandler;
}
/// <summary>
/// Invoke in asp.net core pipeline
/// </summary>
/// <param name="context">Http context</param>
/// <param name="webSocketHandler">Websocket handler</param>
/// <param name="idGenerator">Unique Id generator</param>
public async Task Invoke(HttpContext context, IWebSocketHandler webSocketHandler, IUniqueIdentifierGenerator idGenerator)
{
if (!context.WebSockets.IsWebSocketRequest)
{
return;
}
var socket = new IdentifiableWebSocket(idGenerator, await context.WebSockets.AcceptWebSocketAsync());
await webSocketHandler.HandleAsync(socket, _cancellationToken);
}
public InfoApiWebSocketService(IWebSocketHandler webSocketHandler, IAnimeProfileHandler infoApiHandler, INiblHandler niblHandler, IDebugHandler debugHandler)
{
debugHandler.TraceMessage("Constructor Called.", DebugSource.CONSTRUCTOR, DebugType.ENTRY_EXIT);
WebSocketHandler = webSocketHandler;
AnimeProfileHandler = infoApiHandler;
NiblHandler = niblHandler;
DebugHandler = debugHandler;
WeebFileNameParser = new WeebFileNameParser();
}
public WebSocketClient(Uri uri, ClientEtiquette etiquette, IWebSocketHandler handler)
: this(uri, etiquette)
{
if (handler == null)
{
throw new ArgumentNullException("handler");
}
webSocket.Connected = handler.Connected;
webSocket.Received = handler.Received;
webSocket.Disconnected = sender => handler.Disconnected(uri.ToString());
}
public WebSocketClient(Uri remoteUri,
ClientEtiquette etiquette,
IWebSocketHandler handler,
RemoteCertificateValidationCallback certificateValidationCallback)
: this(remoteUri, etiquette, handler)
{
if (certificateValidationCallback == null)
{
throw new ArgumentNullException("certificateValidationCallback");
}
this.certificateValidationCallback = certificateValidationCallback;
}
public void Configure(
IApplicationBuilder app,
IWebHostEnvironment env,
IWebSocketHandler webSocketHandler,
IServiceScopeFactory serviceScopeFactory
)
{
_webSocketHandler = webSocketHandler;
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
app.UseSwagger();
app.UseSwaggerUI(c => c.SwaggerEndpoint("/swagger/v1/swagger.json", "Communicator v1"));
}
app.UseHttpsRedirection();
app.UseRouting();
app.UseAuthorization();
app.UseSession();
app.UseWebSockets();
app.Use(async(context, next) =>
{
if (context.Request.Path == "/ws")
{
if (context.WebSockets.IsWebSocketRequest)
{
using var scope = serviceScopeFactory.CreateScope();
var db = scope.ServiceProvider.GetService <CommunicatorDbContex>();
WebSocket webSocket = await context.WebSockets.AcceptWebSocketAsync();
await _webSocketHandler.Handle(context.Session, webSocket, new Service(db));
}
else
{
context.Response.StatusCode = 400;
}
}
else
{
await next();
}
});
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
});
}
public WebSocketNetworkFeature(IConnectionManager connectionManager, IWebSocketHandler socketHandler, IOptions <WebSocketManagerOptions> options)
{
Guard.NotNull(connectionManager, nameof(connectionManager));
Guard.NotNull(socketHandler, nameof(socketHandler));
Guard.NotNull(options, nameof(options));
this._resources = new List <IDisposable>();
this._connectionManager = connectionManager;
this._socketHandler = socketHandler;
this._options = options.Value;
_resources.Add(this._connectionManager);
}
public static async Task ReceiveAsync(this WebSocket ws, IWebSocketHandler handler)
{
try
{
while (ws.State == WebSocketState.Open)
{
var stringResult = new StringBuilder();
WebSocketReceiveResult received;
var buffer = new ArraySegment <byte>(new byte[ChunkSize]);
var webSocket = ws;
do
{
received = await ws.ReceiveAsync(buffer, CancellationToken.None);
switch (received.MessageType)
{
case WebSocketMessageType.Close:
await ws.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None);
await handler.OnDisconected(webSocket);
break;
case WebSocketMessageType.Binary:
break;
case WebSocketMessageType.Text:
var data = Encoding.Default.GetString(buffer.Array, buffer.Offset, buffer.Count);
stringResult.Append(data.TrimEnd('\0'));
break;
default:
throw new ArgumentOutOfRangeException($"Unknown WebSocket MessageType: {received.MessageType}");
}
} while (!received.EndOfMessage);
RunInTask(async() => await handler.OnMessage(webSocket, stringResult.ToString()));
}
}
catch (Exception e)
{
await handler.OnError(e);
await handler.OnDisconected(ws);
}
finally
{
ws.Dispose();
}
}
public void Listen(IWebSocketHandler handler)
{
Handler = handler;
Handler.OnConnent();
try
{
ListenerLoop();
}
finally
{
Handler.OnDisconnect();
}
}
public void Listen(IWebSocketHandler handler)
{
Handler = handler;
Handler.OnConnent();
try
{
ListenerLoop();
}
finally
{
Handler.OnDisconnect();
}
}
public FilesController(
DebugRepository debugRepository,
IFileService fileService,
IUserService userService,
OpenRequestsRepository openRequestsRepository,
IWebSocketHandler webSocketHandler,
IServiceProvider serviceProvider)
{
_debugRepository = debugRepository;
_fileService = fileService;
_userService = userService;
_openRequestsRepository = openRequestsRepository;
_webSocketHandler = webSocketHandler;
_serviceProvider = serviceProvider;
}
public FileService(
OnlineUserRepository onlineUserRepository,
IServiceProvider serviceProvider,
IUserService userService,
IOptions <FileSettings> fileSettingsOptions,
IWebSocketHandler webSocketHandler,
ILogger <FileService> logger)
{
_random = new Random();
_onlineUserRepository = onlineUserRepository;
_serviceProvider = serviceProvider;
_userService = userService;
_webSocketHandler = webSocketHandler;
_logger = logger;
_fileSettings = fileSettingsOptions.Value;
}
public IrcWebSocketService(IWebSocketHandler webSocketHandler, IIrcClientHandler ircClientHandler, ISettingsHandler settingsHandler, IDebugHandler debugHandler)
{
debugHandler.TraceMessage("IrcWebSocketService Constructor called.", DebugSource.CONSTRUCTOR, DebugType.ENTRY_EXIT);
SendMessageToWebSocketClient = false;
IsIrcConnected = false;
SettingsHandler = settingsHandler;
IrcClientHandler = ircClientHandler;
WebSocketHandler = webSocketHandler;
DebugHandler = debugHandler;
LittleWeebSettings = SettingsHandler.GetLittleWeebSettings();
IrcSettings = SettingsHandler.GetIrcSettings();
IrcClientHandler.OnIrcClientMessageEvent += OnIrcClientMessageEvent;
IrcClientHandler.OnIrcClientConnectionStatusEvent += OnIrcClientConnectionStatusEvent;
}
//todo: consider joining HandleWebSocketRequest and ProcessRequest to one method
private void HandleWebSocketRequest(NetworkStream stream, HttpRequest request)
{
//todo: can URI start with protocol?
if (!requestHandler.CanCreateWebSocketHandler(request))
{
HttpResponse response = HttpResponse.NotFound();
WriteResponse(stream, response);
return;
}
ProcessWebSocketHandshake(stream, request);
WebSocket webSocket = new WebSocket(stream);
IWebSocketHandler handler = requestHandler.CreateWebSocketHandler(request, webSocket);
webSocket.Listen(handler);
}
private async Task HandleConnection(IWebSocketContext context, IWebSocketHandler <byte[]> handler)
{
var buffer = new byte[1024 * 4];
var webSocket = context.WebSocket;
while (webSocket.State == WebSocketState.Open)
{
var(message, messageType) = await ReceiveMessage(webSocket, buffer);
if (messageType == WebSocketMessageType.Close)
{
continue;
}
var type = messageType == WebSocketMessageType.Binary ? MessageType.Binary : MessageType.Text;
handler.OnMessage(context, message, type);
}
}
public async Task InvokeAsync(
HttpContext context,
IWebSocketHandler webSocketHandler,
IOptions <WebSocketOption> options)
{
if (context.WebSockets.IsWebSocketRequest && context.Request.Path == "/ws")
{
var queryString = context.Request.Query[options.Value.RequestType].ToString().AsWebSocketRequestType();
var webSocket = await context.WebSockets.AcceptWebSocketAsync();
await webSocketHandler.ProcessIncomingRequest(webSocket, queryString);
}
else
{
await _next(context);
}
}
public void RegisterHandler <T>(PathString path, IWebSocketHandler <T> handler)
{
if (registrationClosed)
{
throw new InvalidOperationException("New handlers cannot be registered after the first invocation of the GetHandler method");
}
if (typeof(T) == typeof(string))
{
RegisterStringHandler(path, (IWebSocketHandler <string>)handler);
}
else if (typeof(T) == typeof(byte[]))
{
RegisterBinaryHandler(path, (IWebSocketHandler <byte[]>)handler);
}
else
{
RegisterObjectHandler(path, handler);
}
}
