/// <summary> /// Start å lytte på meldinger. /// </summary> /// <param name="receiveMode">Receive mode (<see cref="ReceiveMode"/>)</param> public void StartListening(ReceiveMode receiveMode) { if (_isListening) { return; } _messagingFactory = MessagingFactory.CreateFromConnectionString(_sbCnnString); _isListening = true; _listenTask = Task.Run(() => Listen(receiveMode)); ListeningStarted?.Invoke(); }
/// <summary> /// Initializes a new instance of the Listener /// </summary> /// <param name="cancellationToken">The Cancellation Token to stop a transaction</param> /// <returns>An awaitable <see cref="Task"/> with the listener to Smtp Messages</returns> public async Task StartAsync(CancellationToken cancellationToken) { // Parameters for the SMTP Server ISmtpServerOptions options; // Setup the MessageStore SmtpMessageStore smtpMessageStore = new SmtpMessageStore(); smtpMessageStore.MessageReceived += SmtpMessageStore_MessageReceived; smtpMessageStore.MessageReceivedWithErrors += SmtpMessageStore_MessageReceivedWithErrors; // Configure the SMTP Server Parameters if (this.RequiresAuthentication) { // Setup the UserAuthenticator SmtpAuthenticator smtpAuthenticator = new SmtpAuthenticator(); options = new SmtpServerOptionsBuilder().ServerName(this.ServerName) .Port(this.Ports) .AllowUnsecureAuthentication(!this.UseSSL) .AuthenticationRequired(true) .MessageStore(smtpMessageStore) .UserAuthenticator(smtpAuthenticator) .Build(); } else { options = new SmtpServerOptionsBuilder().ServerName(this.ServerName) .Port(this.Ports) .AllowUnsecureAuthentication(!this.UseSSL) .AuthenticationRequired(false) .MessageStore(smtpMessageStore) .Build(); } // Initialize the SMTP Server Server = new SmtpServer.SmtpServer(options); // Hook the events Server.SessionCreated += Server_OnSessionCreated; Server.SessionCompleted += Server_OnSessionCompleted; // Sets the Listening to on and kick event IsListening = true; ListeningStarted?.Invoke(this, null); // Starts the SMTP Server await Server.StartAsync(cancellationToken); }
private void OnListeningStarted(ITcpListener tcpListener) => ListeningStarted?.Invoke(this, new TcpIpListenerListen12EventArgs(tcpListener));
public static void StartAutomationListener(int port) { try { // TcpListener server = new TcpListener(port); _tcpListener = new TcpListener(IPAddress.Any, port); _port = port; // Start listening for client requests. _tcpListener.Start(); _automationLogger.Information($"Automation Listener Endpoint started at {_tcpListener.LocalEndpoint}"); // Buffer for reading data Byte[] bytes = new Byte[2048]; String data = null; // Enter the listening loop. while (true) { IsListening = true; ListeningStarted?.Invoke(null, null); _automationLogger.Information($"Automation Listener Waiting for Request"); TcpClient client = _tcpListener.AcceptTcpClient(); _automationLogger.Information($"Client '{client.Client.RemoteEndPoint}' Connected to Automation Listener"); // Get a stream object for reading and writing NetworkStream stream = client.GetStream(); int i; try { // Loop to receive all the data sent by the client. while ((i = stream.Read(bytes, 0, bytes.Length)) != 0) { // Translate data bytes to a ASCII string. data = System.Text.Encoding.ASCII.GetString(bytes, 0, i); _automationLogger.Information($"Client Message Content: {data}"); //break out request content var messageContent = data.Split(new string[] { Environment.NewLine }, StringSplitOptions.None); if (_listenerSettings.EnableWhitelist) { _automationLogger.Information($"Listener requires IP Verification (Whitelist)"); //verify that client is allowed to connect var clientAddress = ((IPEndPoint)client.Client.RemoteEndPoint).Address.ToString(); //get list of ip var enabledIPs = _listenerSettings.IPWhiteList.Split(','); if (enabledIPs.Any(s => s.Trim().Contains(clientAddress))) { _automationLogger.Information($"Client '{clientAddress}' verified from WhiteList '{_listenerSettings.IPWhiteList}'"); } else { _automationLogger.Information($"Closing Client Connection due to IP verification failure"); SendResponse(HttpStatusCode.Unauthorized, $"Unauthorized", stream); return; } } else { _automationLogger.Information($"Listener does not require IP Verification"); } if (_listenerSettings.RequireListenerAuthenticationKey) { string authKey = ""; foreach (var item in messageContent) { if (item.StartsWith("AuthKey: ")) { authKey = item.Replace("AuthKey: ", ""); break; } } //auth key check if (string.IsNullOrEmpty(authKey)) { //auth key not provided _automationLogger.Information($"Closing Client Connection due to Null/Empty Auth Key"); SendResponse(HttpStatusCode.Unauthorized, $"Invalid Auth Key", stream); break; } else if (authKey != _listenerSettings.AuthKey) { //auth key invalid _automationLogger.Information($"Closing Client Connection due to Invalid Auth Key"); SendResponse(HttpStatusCode.Unauthorized, $"Invalid Auth Key", stream); break; } else if (authKey == _listenerSettings.AuthKey) { //auth key valid _automationLogger.Information($"Auth Key Verified"); ProcessRequest(data, messageContent, stream); } } else { //verification not required _automationLogger.Information($"Auth Key Verification Not Required"); ProcessRequest(data, messageContent, stream); } } } catch (Exception ex) { _automationLogger.Information($"Error Occured Reading Stream: {ex}"); } // Shutdown and end connection client.Close(); _automationLogger.Information($"Client Connection Closed"); } } catch (SocketException e) { _automationLogger.Information("SocketException: {0}", e); } finally { // Stop listening for new clients. _tcpListener.Stop(); IsListening = false; ListeningStopped?.Invoke(null, null); } }
// Fired when server is started and waiting for incoming connections private void JavaListeningStartedHandler(string empty) { ListeningStarted?.Invoke(); }
/// <summary> /// Starts Processing Commands /// </summary> /// <param name="cancellationToken">The cancellation token</param> /// <returns>A Task which performs the operation</returns> public async override Task StartAsync(CancellationToken cancellationToken) { // Validate Port before starting if (Port == 0) { throw new Exception("Invalid port number"); } // Initializes Server try { Server = new TcpListener(IPAddress.Any, Port); Server.Start(10); // Notify the listening started ListeningStarted?.Invoke(this, new ListeningStartedEventArgs(Port)); while (cancellationToken.IsCancellationRequested == false) { // Keep listening for incoming connections var client = await Server.AcceptTcpClientAsync().WithCancellation(cancellationToken).ConfigureAwait(false); cancellationToken.ThrowIfCancellationRequested(); // Creates the Communication Session var sessionID = this.BeginSession(); // Notify that a session is started var sessionStartedEventArgs = new SessionStartedEventArgs(sessionID); SessionStarted?.Invoke(this, sessionStartedEventArgs); // Make sure session is not denied if (sessionStartedEventArgs.Deny) { // Session is denied, unregister it this.EndSession(sessionID); } else { // Session is allowed, continue with it var networkCommunicationSession = new NetworkCommunicationSession(client, sessionID, ShowTimer, ShowPrompt); networkCommunicationSession.RawCommandReceived += (sender, commandEventArgs) => { // Executes the command and waits for the answer var taskResponse = Task.Run <CommandExecutionResponse>(async() => await ExecuteCommandAsync(networkCommunicationSession.ID, commandEventArgs.RawCommand)); var response = taskResponse.Result; // Outputs the response commandEventArgs.Response = this.ResponseFormatter.Format(response); // Replace "\n" by the environment NewLine commandEventArgs.Response = commandEventArgs.Response.Replace("\n", System.Environment.NewLine); }; // Add session to the collection lock (NetworkCommunicationSessionsLock) { NetworkCommunicationSessions.Add(networkCommunicationSession.ID, networkCommunicationSession); } #pragma warning disable 4014 // Run Communication Session networkCommunicationSession.RunAsync(cancellationToken).ContinueWith(t => { // Stop Session networkCommunicationSession.Stop(); // Remove Session from Internal Controls lock (NetworkCommunicationSessionsLock) { NetworkCommunicationSessions.Remove(networkCommunicationSession.ID); } // Unregister session with the Command Processor this.EndSession(networkCommunicationSession.ID); // Call SessionEnded event SessionEnded?.Invoke(this, new SessionEndedEventArgs(networkCommunicationSession.ID)); }, cancellationToken); #pragma warning restore 4014 } } } catch (Exception) { throw; } finally { if (Server != null) { Server.Stop(); } } }