/// <summary> /// Creates a TCP socket and binds to the CommunicationPort. /// Use the default JsonSerializer if null is passed into the serializer parameter. /// Returns false if you are already listening. /// </summary> public async Task <bool> StartListeningAsync() { if (_localSocket == null) { _localSocket = new StreamSocketListener(); _localSocket.ConnectionReceived += LocalSocketConnectionReceived; await _localSocket.BindServiceNameAsync(CommunicationPort); return(true); } return(false); }
public async Task StartAsync() { try { await Listener.BindServiceNameAsync(Port.ToString()); } catch (Exception) { Port++; await StartAsync().ConfigureAwait(false); } RegisterDeviceAsync(IP, Port, Hostname); }
public async Task Start() { DebugHelper.LogInformation($"StreamSocket Server starting on port {SharedConstants.DEVICE_API_PORT}"); await WaitForAPInterface(); StreamSocketListener listener = new StreamSocketListener(); listener.ConnectionReceived += ConnectionReceived; await listener.BindServiceNameAsync(SharedConstants.DEVICE_API_PORT.ToString()); DebugHelper.LogInformation($"Listening for StreamSocket connection on {SharedConstants.DEVICE_API_PORT}"); }
public void Start() { Lock(this) //prevent any other code interupting { if (!Running) //prevent multiple starts { listener = new StreamSocketListener(); listener.BindServiceNameAsync("8080"); listener.ConnectionReceived += listener_ConnectionReceived; Running = true; } } }
/// <summary> /// Configures the network transmitter as the source. /// </summary> public void ConfigureAsServer() { Task t = new Task(() => { Debug.Log("Starting import export server"); networkListener = new StreamSocketListener(); networkListener.ConnectionReceived += NetworkListener_ConnectionReceived; networkListener.BindServiceNameAsync(SendConnectionPort.ToString()).GetResults(); } ); t.Start(); }
} // End of Constructor public async Task StartListener(Action <string> action) { _action = action; //Create a StreamSocketListener to start listening for TCP connections. StreamSocketListener socketListener = new StreamSocketListener(); //Hook up an event handler to call when connections are received. socketListener.ConnectionReceived += SocketListener_ConnectionReceived; //Start listening for incoming TCP connections on the specified port. You can specify any port that' s not currently in use. await socketListener.BindServiceNameAsync(_portNumber); } // End of StartListener
/// <summary> /// Binds the <code>TcpSocketListener</code> to the specified port on all endpoints and listens for TCP connections. /// </summary> /// <param name="port">The port to listen on. If '0', selection is delegated to the operating system.</param> /// <param name="listenOn">The <code>CommsInterface</code> to listen on. If unspecified, all interfaces will be bound.</param> /// <returns></returns> public Task StartListeningAsync(int port, ICommsInterface listenOn = null) { if (listenOn != null && !listenOn.IsUsable) { throw new InvalidOperationException("Cannot listen on an unusable interface. Check the IsUsable property before attemping to bind."); } _listenCanceller = new CancellationTokenSource(); _backingStreamSocketListener = new StreamSocketListener(); _backingStreamSocketListener.ConnectionReceived += (sender, args) => { var nativeSocket = args.Socket; var wrappedSocket = new TcpSocketClient(nativeSocket, _bufferSize); var eventArgs = new TcpSocketListenerConnectEventArgs(wrappedSocket); if (ConnectionReceived != null) { ConnectionReceived(this, eventArgs); } }; var sn = port == 0 ? "" : port.ToString(); #if !WP80 if (listenOn != null) { var adapter = ((CommsInterface)listenOn).NativeNetworkAdapter; return(_backingStreamSocketListener .BindServiceNameAsync(sn, SocketProtectionLevel.PlainSocket, adapter) .AsTask()); } else #endif return(_backingStreamSocketListener .BindServiceNameAsync(sn) .AsTask()); }
public void Start(MqttServerOptions options) { if (_socket != null) { throw new InvalidOperationException("Server is already started."); } _cancellationTokenSource = new CancellationTokenSource(); _socket = new StreamSocketListener(); _socket.BindServiceNameAsync(options.Port.ToString()).AsTask().Wait(); _socket.ConnectionReceived += ConnectionReceived; }
/// <summary> /// Server listens to specified port and accepts connection from client /// </summary> public async void StartListen() { // var ip = (networkInterface != null) // ? GetInterfaceIpAddress() // : IPAddress.Any; tcpServer = new StreamSocketListener(); tcpServer.ConnectionReceived += TcpServer_ConnectionReceived; await tcpServer.BindServiceNameAsync(portNumber.ToString(), SocketProtectionLevel.PlainSocket); isRunning = true; }
protected override async Task StartCoreAsync() { var serviceId = RfcommServiceId.FromUuid(_serviceUuid); _serviceProvider = await RfcommServiceProvider.CreateAsync(serviceId); _listener.ConnectionReceived += OnConnectionReceived; await _listener.BindServiceNameAsync(serviceId.AsString(), SocketProtectionLevel.BluetoothEncryptionAllowNullAuthentication); InitializeServiceSdpAttributes(_serviceProvider); _serviceProvider.StartAdvertising(_listener, true); }
public async Task StartListener() { try { _streamSocketListener = new StreamSocketListener(); _streamSocketListener.ConnectionReceived += StreamSocketListener_ConnectionReceived; await _streamSocketListener.BindServiceNameAsync("4537"); } catch (Exception ex) { SocketErrorStatus webErrorStatus = SocketError.GetStatus(ex.GetBaseException().HResult); } }
private async void StartServer() { try { // Start listening for incoming TCP connections on the specified port. You can specify any port that's not currently in use. await streamSocketListener.BindServiceNameAsync(port.ToString()); Debug.Log("server is listening..."); } catch (System.Exception ex) { Windows.Networking.Sockets.SocketErrorStatus webErrorStatus = Windows.Networking.Sockets.SocketError.GetStatus(ex.GetBaseException().HResult); Debug.Log(webErrorStatus.ToString() != "Unknown" ? webErrorStatus.ToString() : ex.Message); } }
/// <summary> /// Initialize the REST server and open a socket for listening on port 80. /// </summary> /// <param name="wwwroot">storage folder from which files are served</param> public async void Initialise(StorageFolder wwwroot) { listener = new StreamSocketListener(); this.wwwroot = wwwroot; // listen on port 80, this is the standard HTTP port (use a different port if you have a service already running on 80) await listener.BindServiceNameAsync("80", SocketProtectionLevel.PlainSocket); listener.ConnectionReceived += (sender, args) => { // call the handle request function when a request comes in HandleRequest(sender, args); }; }
private async void StartListing_Click(object sender, RoutedEventArgs e) { // Listener für Annahme von TCP-Verbindungsanfragen erzeugen _listener = new StreamSocketListener(); // Eventhandler registrieren, um Verbindungsanfragen zu bearbeiten _listener.ConnectionReceived += Listener_ConnectionReceived; // Lauschen und warten auf Verbindungen starten Status.Text = "Starte Listener..."; await _listener.BindServiceNameAsync(Port); Status.Text = "Listener bereit."; }
private async void Launch() { Debug.Log("Listener started"); try { await listener_.BindServiceNameAsync(port_); } catch (Exception e) { Debug.Log("Error: " + e.Message); } Debug.Log("Listening"); }
public async void Start() { var listener = new StreamSocketListener(); await listener.BindServiceNameAsync("8085"); listener.ConnectionReceived += async(sender, args) => { var request = new StringBuilder(); using (var input = args.Socket.InputStream) { var data = new byte[BufferSize]; IBuffer buffer = data.AsBuffer(); var dataRead = BufferSize; while (dataRead == BufferSize) { await input.ReadAsync( buffer, BufferSize, InputStreamOptions.Partial); request.Append(Encoding.UTF8.GetString( data, 0, data.Length)); dataRead = buffer.Length; } } string pinStatus = GetPinStatus(); using (var output = args.Socket.OutputStream) { using (var response = output.AsStreamForWrite()) { var html = Encoding.UTF8.GetBytes( $"<html><head><title>Background Message</title></head><body>Hello from the background process!<br/>{pinStatus}</body></html>"); using (var bodyStream = new MemoryStream(html)) { var header = $"HTTP/1.1 200 OK\r\nContent-Length: {bodyStream.Length}\r\nConnection: close\r\n\r\n"; var headerArray = Encoding.UTF8.GetBytes(header); await response.WriteAsync(headerArray, 0, headerArray.Length); await bodyStream.CopyToAsync(response); await response.FlushAsync(); } } } }; }
/* public MyWebserver(AppServiceConnection connection) * { * _connection = connection; * _connection.RequestReceived += ConnectionRequestReceived; * } * * private void ConnectionRequestReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args) * { * _name = (string)args.Request.Message.First().Value; * } */ public async void Start() { var listener = new StreamSocketListener(); await listener.BindServiceNameAsync("8081"); listener.ConnectionReceived += async(sender, args) => { StringBuilder request = new StringBuilder(); using (IInputStream input = args.Socket.InputStream) { byte[] data = new byte[BufferSize]; IBuffer buffer = data.AsBuffer(); uint dataRead = BufferSize; while (dataRead == BufferSize) { await input.ReadAsync( buffer, BufferSize, InputStreamOptions.Partial); request.Append(Encoding.UTF8.GetString( data, 0, data.Length)); dataRead = buffer.Length; } } string query = GetQuery(request); using (IOutputStream output = args.Socket.OutputStream) { using (Stream response = output.AsStreamForWrite()) { byte[] html = Encoding.GetEncoding("iso-8859-1").GetBytes($"<html><head><title>Background Message</title></head><body>Hello from the background process!<br/>{query}</body></html>"); MemoryStream bodyStream = new MemoryStream(html); string header = "HTTP/1.1 200 OK\r\n" + $"Content-Length: {bodyStream.Length}\r\n" + "Connection: close\r\n\r\n"; //var headerArray = Encoding.UTF8.GetBytes(header); byte[] headerArray = Encoding.GetEncoding("iso-8859-1").GetBytes(header); await response.WriteAsync(headerArray, 0, headerArray.Length); await bodyStream.CopyToAsync(response); await response.FlushAsync(); } } }; }
/// <summary> /// Starts the service listener if it is in a stopped state. /// </summary> /// <param name="servicePort">The port used to listen on.</param> public bool Start(string servicePort) { try { _listener = new StreamSocketListener(); #pragma warning disable CS4014 if (InterfaceAdapter == null) { _listener.BindServiceNameAsync(servicePort); } else { _listener.BindServiceNameAsync(servicePort, SocketProtectionLevel.PlainSocket, InterfaceAdapter); } #pragma warning restore CS4014 _listener.ConnectionReceived += OnClientConnected; _logger.Info("Websocket listener Started on {0}", _listener.Information.LocalPort.ToString()); //_logger.Info("Listener Started on {0}", ActivePort.ToString()); } catch (Exception ex) { // If this is an unknown status it means that the error is fatal and retry will likely fail. if (SocketError.GetStatus(ex.HResult) == SocketErrorStatus.Unknown) { IsActive = false; ListenerError(_listener, ex); return(false); } _logger.Error("Start listening failed with error: {0}" + ex.Message, ex); } IsActive = true; return(true); }
public async Task <bool> CreateListener() { bool alright = false; //Create a StreamSocketListener to start listening for TCP connections. try { try { string myIP = Networking.GetLocalIp(); mp.myIP(myIP); await Networking.sendIP(myIP); mp.status("Sent my IP.", Colors.LightGray); mp.print("Sent my ip " + myIP + " on web server for client to read"); alright = true; } catch (Exception ex) { mp.print("Error while sending my IP: " + ex.Message); mp.status("Couldn't send my IP", Colors.DarkRed); } try { StreamSocketListener socketListener = new StreamSocketListener(); await socketListener.BindServiceNameAsync(mp.Port); socketListener.ConnectionReceived += SocketListener_ConnectionReceived; if (Connected) { Connected = false; } else { Connected = true; } } catch (Exception ex) { mp.print("Error while creaitng listener: " + ex.Message); alright = false; } } catch (Exception ex) { mp.print(ex.Message); alright = false; } return(alright); }
Task listenProcess() => Task.Run(async() => { var p = await RfcommServiceProvider.CreateAsync(BluetoothUtils.RfcommConnectionService); using (var l = new StreamSocketListener()) { l.ConnectionReceived += (sender, e) => new ErebusLink(new SplitStream(e.Socket.InputStream.AsStreamForRead(), e.Socket.OutputStream.AsStreamForWrite()), ei, true); await l.BindServiceNameAsync(BluetoothUtils.RfcommConnectionService.AsString(), SocketProtectionLevel.BluetoothEncryptionWithAuthentication); p.StartAdvertising(l); while (process) { await Task.Delay(10); } p.StopAdvertising(); } });
public async void StartServer() { // Initialize the provider for the hosted RFCOMM service. provider = await RfcommServiceProvider.CreateAsync(RfcommServiceId.ObexObjectPush); // Create a listener for this service and start listening. socketListener = new StreamSocketListener(); socketListener.ConnectionReceived += OnConnectionReceived; await socketListener.BindServiceNameAsync(provider.ServiceId.AsString(), SocketProtectionLevel.BluetoothEncryptionAllowNullAuthentication); // Set the SDP attributes and start advertising. InitializeServiceSdpAttributes(provider); provider.StartAdvertising(socketListener); isAdvertising = true; }
public async Task Start() { DebugHelper.LogInformation($"WebServer starting on port {SharedConstants.DEVICE_API_PORT}"); var network = await WaitForAPInterface(); var listener = new StreamSocketListener(); listener.Control.QualityOfService = SocketQualityOfService.LowLatency; await listener.BindServiceNameAsync(SharedConstants.DEVICE_API_PORT.ToString()); listener.ConnectionReceived += ConnectionReceived; DebugHelper.LogInformation($"Listening for WebServer connection on {SharedConstants.DEVICE_API_PORT}"); }
public void ConnectServer(int port) { #if WINDOWS_UWP Task.Run(async() => { socketlistener = new StreamSocketListener(); socketlistener.ConnectionReceived += ConnectionReceived; await socketlistener.BindServiceNameAsync(port.ToString()); }); #else tcpListener = new TcpListener(IPAddress.Any, port); tcpListener.Start(); tcpListener.BeginAcceptTcpClient(AcceptTcpClient, tcpListener); #endif }
public static async void StartListener() { try { listener = new StreamSocketListener(); listener.ConnectionReceived += OnConnection; await listener.BindServiceNameAsync(hostPort); Debug.WriteLine("Listening on {0}", hostPort); } catch (Exception e) { Debug.WriteLine("StartListener() - Unable to bind listener. " + e.Message); } }
private async void Listener_Start() { tm.text = "Started"; Debug.Log("Listener started"); try { await listener.BindServiceNameAsync(port); } catch (Exception e) { tm.text = "Error: " + e.Message; Debug.Log("Error: " + e.Message); } //tm.text = "Listening~"; }
public async Task start(string servicename) { try { await listener.BindServiceNameAsync(servicename); } catch (Exception exception) { // If this is an unknown status it means that the error is fatal and retry will likely fail. if (SocketError.GetStatus(exception.HResult) == SocketErrorStatus.Unknown) { throw; } } }
public async Task InitializeAsync() { // Initialize the provider for the hosted RFCOMM service _provider = await RfcommServiceProvider.CreateAsync(RfcommServiceId.FromUuid(Constants.SERVICE_UUID)); // Create a listener for this service and start listening _listener = new StreamSocketListener(); _listener.ConnectionReceived += OnConnectionReceivedAsync; await _listener.BindServiceNameAsync(_provider.ServiceId.AsString(), SocketProtectionLevel.BluetoothEncryptionAllowNullAuthentication); // Set the SDP attributes and start advertising InitializeServiceSdpAttributes(_provider); _provider.StartAdvertising(_listener, true); }
public async void Init() { listener = new StreamSocketListener(); listener.ConnectionReceived += Connected; CoreApplication.Properties.Add("listener", listener); try { await listener.BindServiceNameAsync("moviePlayer"); } catch (Exception e) { throw e; } }
/// <summary> /// Starts server. /// </summary> /// <param name="port">Port</param> public async void Start(int port) { try { //Create a StreamSocketListener to start listening for TCP connections. StreamSocketListener socketListener = new StreamSocketListener(); //Hook up an event handler to call when connections are received. socketListener.ConnectionReceived += SocketListener_ConnectionReceived; //Start listening for incoming TCP connections on the specified port. You can specify any port that's not currently in use. await socketListener.BindServiceNameAsync(port.ToString()); } catch { } }
public async void InitializeReceiver() { // Initialize the provider for the hosted RFCOMM service // RfcommServiceId FromUuid(Guid uuid); _provider = await RfcommServiceProvider.CreateAsync(RfcommServiceId.FromUuid(btUuid)); // Create a listener for this service and start listening _listener = new StreamSocketListener(); _listener.ConnectionReceived += Listener_ConnectionReceived; await _listener.BindServiceNameAsync(_provider.ServiceId.AsString(), SocketProtectionLevel.BluetoothEncryptionAllowNullAuthentication); // Set the SDP attributes and start advertising InitializeServiceSdpAttributes(_provider); _provider.StartAdvertising(_listener); }