public Communicator(int serverPort, INetworkClient client, INetworkListener listener) { ServerName = Environment.MachineName; ServerPort = serverPort; Client = client; Listener = listener; }
/// <summary> /// Method responsible to connect client in server. /// </summary> /// <param name="ip">The ip address from server.</param> /// <param name="port">The port number from server, the default value us 7171</param> /// <param name="listenerType">The listener type to creation of listener, the default value is NetworkListenerType.TCP.</param> /// <param name="maxMessageBuffer">The max length of message buffer, the default value is 4096.</param> /// <returns>The boolean value of client connection.</returns> public bool Connect(string ip, ushort port = 7171, NetworkListenerType listenerType = NetworkListenerType.TCP, ushort maxMessageBuffer = 4096) { try { if (listenerType == NetworkListenerType.TCP) { _networkListener = new TcpNetworkListener(OnMessageReceived, OnDisconnected); } else if (listenerType == NetworkListenerType.UDP) { _networkListener = new UdpNetworkListener(OnMessageReceived, OnDisconnected); } else if (listenerType == NetworkListenerType.WSBinary || listenerType == NetworkListenerType.WSText) { _networkListener = new WSNetworkListener(listenerType, OnMessageReceived, OnDisconnected); } _clientThread = new Thread(() => { _networkListener.StartClient(ip, port, maxMessageBuffer); }); _clientThread.IsBackground = true; _clientThread.Start(); Thread.Sleep(15); // Delay for socket connection. } catch (Exception ex) { Console.WriteLine($"Error: {ex.Message}."); } return(HasConnected); }
public void AddListener(INetworkListener listener) { lock (m_listeners) { m_listeners.Add(listener); } }
public void RemoveListener(INetworkListener listener) { lock (m_listeners) { m_listeners.Remove(listener); } }
private void Initialize(int listenPort, INetworkListener transportListener, Envelope messageEnvelope) { Port = listenPort; listener = transportListener; Envelope = messageEnvelope; listener.Initialize(Port); }
public virtual async ValueTask BindAsync(EndPoint endpoint, CancellationToken cancellationToken = default) { if (endpoint is IPEndPoint ipEndpoint) { _ipEndpoint = ipEndpoint; } else { throw new NotSupportedException("Only IPEndPoint are currently supported by inline sockets."); } _logger.BindListenSocket(_ipEndpoint); _listener = _networkProvider.CreateListener(new NetworkListenerSettings { IPEndPoint = _ipEndpoint, AllowNatTraversal = _options.AllowNatTraversal, ExclusiveAddressUse = _options.ExclusiveAddressUse, ListenerBacklog = _options.ListenBacklog, NoDelay = _options.NoDelay, }); // the only way to cancel a call to accept a socket is to stop the listener. // this is okay, because this call is cancelled only when the listener is about to be // unbound and disposed anyway. _listenerCancellationCallback = _listener.Stop; _listener.Start(); }
private async Task Run() { INetworkListener listener = _serviceProvider.GetService <INetworkListener>(); await listener.Listen(43594); Console.ReadKey(); }
/// <summary> /// Method responsible for start the async network listener. /// </summary> /// <param name="cancellationToken">The cancellation token for the task execution.</param> /// <param name="listenerType">The listener type to creation of listener, the default value is NetworkListenerType.TCP.</param> private async Task StartListenerAsync(CancellationToken cancellationToken, NetworkListenerType listenerType = NetworkListenerType.TCP) { try { if (listenerType == NetworkListenerType.TCP) { _networkListener = new TcpNetworkListener(_port, OnClientConnected, OnMessageReceived, OnClientDisconnected, _maxMessageBuffer); } else if (listenerType == NetworkListenerType.UDP) { _networkListener = new UdpNetworkListener(_port, OnClientConnected, OnMessageReceived, OnClientDisconnected, _maxMessageBuffer); } else if (listenerType == NetworkListenerType.WSBinary || listenerType == NetworkListenerType.WSText) { _networkListener = new WebSocketNetworkListener(listenerType, _port, OnClientConnected, OnMessageReceived, OnClientDisconnected, _maxMessageBuffer); } OnServerStartedHandler?.Invoke(); while (!cancellationToken.IsCancellationRequested) { await Task.Delay(TimeSpan.FromSeconds(1), cancellationToken); } } catch (Exception ex) { Console.WriteLine($"Error: {ex.Message}."); } }
/// <summary> /// Listen indefinitely for network connections on the specified port. /// </summary> private async Task ListenForConnectionsAsync() { INetworkListener listener = null; try { var noDelay = Options?.TcpNoDelay ?? DicomServiceOptions.Default.TcpNoDelay; listener = NetworkManager.CreateNetworkListener(IPAddress, Port); await listener.StartAsync().ConfigureAwait(false); IsListening = true; while (!_cancellationSource.IsCancellationRequested) { await _hasNonMaxServicesFlag.WaitAsync().ConfigureAwait(false); var networkStream = await listener .AcceptNetworkStreamAsync(_certificateName, noDelay, _cancellationSource.Token) .ConfigureAwait(false); if (networkStream != null) { var scp = CreateScp(networkStream); if (Options != null) { scp.Options = Options; } var serviceTask = scp.RunAsync(); lock (_services) { _services.Add(new RunningDicomService(scp, serviceTask)); } _hasServicesFlag.Set(); if (IsServicesAtMax) { _hasNonMaxServicesFlag.Reset(); } } } } catch (OperationCanceledException) { } catch (Exception e) { Logger.Error("Exception listening for DICOM services, {@error}", e); Stop(); Exception = e; } finally { listener?.Stop(); IsListening = false; } }
public void SetListener(INetworkListener listener) { if (listener != null) { this.listener = listener; State = ConnectingState.NeverConnect; Connect(); } }
public AcceptState(IClientEntry new_client, string remote_endpoint, string local_endpoint, INetworkListener listener, Exception exception) { NewClient = new_client; RemoteEndpoint = remote_endpoint; LocalEndpoint = local_endpoint; Listener = listener; Exception = exception; }
private void Initialize() { rtcpNetworkListener = new UdpListener(rtpSession.RtcpEndPoint, RtpSession.DefaultNetworkTimeout * 2); threadRtcpListener = new Thread(new ThreadStart(ListenThread)); threadRtcpListener.IsBackground = true; threadRtcpListener.Name = "RtcpListener"; threadRtcpListener.Start(); }
private static void AddListener(List <string> builder, INetworkListener listener) { if (listener is AggregateNetworkListener) { AddAggregateListener(builder, (AggregateNetworkListener)listener); } else { builder.Add(listener.ToString()); } }
/// <summary> /// Clean up the RtcpListener /// /// A thread will not abort until it is in the running state. Our listening thread is /// generally blocked by the call to rtcpNetworkListener.ReceiveFrom(). In order to /// dispose things quickly and efficiently, we tell the listening thread to abort as soon /// as it is back in the running state. Then we clean up the network listener which should /// unblock us. /// </summary> /// <param name="disposing"></param> private void Dispose(bool disposing) { lock (this) { disposed = true; threadRtcpListener.Abort(); threadRtcpListener = null; rtcpNetworkListener.Dispose(); rtcpNetworkListener = null; } }
private void InitializeNetwork() { if (Utility.IsMulticast(groupEP) && (!nextHopEP.Equals(groupEP))) { // reflector based session rtpNetworkListener = new UdpListener(groupEP, nextHopEP, RtpSession.DefaultNetworkTimeout); } else { // multicast or direct unicast: no reflector needed rtpNetworkListener = new UdpListener(nextHopEP, RtpSession.DefaultNetworkTimeout); } }
public void RemoveListener(INetworkListener l) { for (int i = 0; i < networkListeners.Count; i++) { INetworkListener nl = networkListeners[i].Target as INetworkListener; if (nl != l) { continue; } networkListeners.RemoveAt(i); i--; } }
public void AddListener(INetworkListener listener, bool start) { if (this.Disposed) { throw new ObjectDisposedException(nameof(NetworkManager)); } this.NetworkListeners.Add(listener); NetworkManager.Logger.Info($"Listener binded on {listener.Bind} was added"); if (start) { listener.StartListening(); } }
public void Update() { //process received messages { List <DataPackage> received = null; lock (receiveBuffer) { received = new List <DataPackage>(receiveBuffer); receiveBuffer.Clear(); } for (int i = 0; i < networkListeners.Count; i++) { INetworkListener nl = networkListeners[i].Target as INetworkListener; if (nl == null) { networkListeners.RemoveAt(i); i--; } else { foreach (DataPackage dp in received) { nl.OnDataReceived(dp); } } } } if (!hasToken) { return; } while (queue.Count != 0) { DataPackage dp = queue[0]; queue.RemoveAt(0); WriteAll(dp); } hasToken = false; Write(nextClient, new TokenChangePackage()); }
private void Initialize() { if (Utility.IsMulticast(groupEP) && (!nextHopEP.Equals(groupEP))) { // use reflector rtcpNetworkListener = new UdpListener(groupEP, nextHopEP, RtpSession.DefaultNetworkTimeout * 2); } else { // multicast or direct unicast rtcpNetworkListener = new UdpListener(nextHopEP, RtpSession.DefaultNetworkTimeout * 2); } threadRtcpListener = new Thread(new ThreadStart(ListenThread)); threadRtcpListener.IsBackground = true; threadRtcpListener.Name = "RtcpListener"; threadRtcpListener.Start(); }
/// <summary> /// Constructor. /// </summary> /// <param name="listener"></param> /// <param name="factory"></param> /// <param name="logger"></param> /// <param name="globalMeta"></param> /// <param name="proxyServer"></param> /// <param name="proxyClient"></param> /// <param name="filters"></param> /// <param name="defaultTimeout"></param> /// <param name="afterdata"></param> public ProxyNetworkService(INetworkListener listener, NetGraphFactory factory, Logger logger, MetaDictionary globalMeta, ProxyServer proxyServer, ProxyClient proxyClient, ProxyFilter[] filters, int defaultTimeout, bool afterdata) { _packetLog = new List <LogPacket>(1000); _logger = logger; Listener = listener; _factory = factory; _connections = new List <ConnectionEntry>(); _globalMeta = globalMeta; _history = new List <ConnectionHistoryEntry>(); _subServices = new List <ProxyNetworkService>(); DefaultBinding = NetworkLayerBinding.Default; _proxyClient = proxyClient; _proxyServer = proxyServer; _filters = filters; _defaultTimeout = defaultTimeout; _afterData = afterdata; }
public virtual async ValueTask BindAsync(EndPoint endpoint, CancellationToken cancellationToken = default) { _endpoint = endpoint; _logger.BindListenSocket(_endpoint); _listener = _networkProvider.CreateListener(new NetworkListenerSettings { EndPoint = _endpoint, AllowNatTraversal = _options.AllowNatTraversal, ExclusiveAddressUse = _options.ExclusiveAddressUse, ListenerBacklog = _options.ListenBacklog, NoDelay = _options.NoDelay, }); // the only way to cancel a call to accept a socket is to stop the listener. // this is okay, because this call is cancelled only when the listener is about to be // unbound and disposed anyway. _listenerCancellationCallback = _listener.Stop; _listener.Start(); }
/// <summary> /// Constructor /// </summary> /// <param name="packetLog"></param> /// <param name="listener"></param> /// <param name="factory"></param> /// <param name="logger"></param> /// <param name="globalMeta"></param> /// <param name="history"></param> /// <param name="credentials"></param> /// <param name="proxyServer"></param> /// <param name="proxyClient"></param> /// <param name="filters"></param> /// <param name="defaultTimeout"></param> /// <param name="afterdata"></param> public ProxyNetworkService(IList <LogPacket> packetLog, INetworkListener listener, NetGraphFactory factory, Logger logger, MetaDictionary globalMeta, IList <ConnectionHistoryEntry> history, IDictionary <SecurityPrincipal, ICredentialObject> credentials, ProxyServer proxyServer, ProxyClient proxyClient, ProxyFilter[] filters, int defaultTimeout, bool afterdata) { _packetLog = packetLog; _logger = logger; Listener = listener; _factory = factory; _connections = new List <ConnectionEntry>(); _globalMeta = globalMeta; _history = history; _subServices = new List <ProxyNetworkService>(); DefaultBinding = NetworkLayerBinding.Default; _credentials = new Dictionary <SecurityPrincipal, ICredentialObject>(credentials); _credentialManager = new CredentialsManagerService(); _credentialManager.ResolveCredentials += _credentialManager_ResolveCredentials; _proxyClient = proxyClient; _proxyServer = proxyServer; _filters = filters; _defaultTimeout = defaultTimeout; _afterData = afterdata; }
/// <summary> /// Constructor /// </summary> /// <param name="left">The left listener</param> /// <param name="right">The right listener</param> public AggregateNetworkListener(INetworkListener left, INetworkListener right) { _left = left; _right = right; }
/// <summary> /// Clean up the RtcpListener /// /// A thread will not abort until it is in the running state. Our listening thread is /// generally blocked by the call to rtcpNetworkListener.ReceiveFrom(). In order to /// dispose things quickly and efficiently, we tell the listening thread to abort as soon /// as it is back in the running state. Then we clean up the network listener which should /// unblock us. /// </summary> /// <param name="disposing"></param> private void Dispose(bool disposing) { lock(this) { disposed = true; threadRtcpListener.Abort(); threadRtcpListener = null; rtcpNetworkListener.Dispose(); rtcpNetworkListener = null; } }
public SocketServer(MessageRegistry registry) { listener = new SocketListener(); this.registry = registry; }
private void DisposeNetwork() { rtpNetworkListener.Dispose(); rtpNetworkListener = null; }
public void RemoveListener(INetworkListener l) { for (int i = 0; i < networkListeners.Count; i++) { INetworkListener nl = networkListeners[i].Target as INetworkListener; if (nl != l) continue; networkListeners.RemoveAt(i); i--; } }
public void AddListener(INetworkListener l) { networkListeners.Add(new WeakReference(l)); }
private void InitializeNetwork() { rtpNetworkListener = new UdpListener(rtpSession.RtpEndPoint, RtpSession.DefaultNetworkTimeout); }
/// <summary> /// Create the base service /// </summary> /// <param name="logger">The logger to use</param> /// <returns>The new network service</returns> public override ProxyNetworkService Create(Logger logger) { ProxyNetworkService ret = null; if (logger == null) { logger = Logger.SystemLogger; } if ((LocalPort < 0) || (LocalPort > 65535)) { throw new NetServiceException(Properties.Resources.NetServerDocument_ValidPort); } else if (ServerFactory == null) { throw new NetServiceException(Properties.Resources.NetServerDocument_MustSpecifyServer); } else { try { ProxyServer server = new PassThroughProxyServer(logger, Layers); ProxyClient client = new NetServerProxyClient(ServerFactory); INetworkListener listener = null; if (!UdpEnable) { if (NetUtils.OSSupportsIPv4) { listener = new TcpNetworkListener(AnyBind, false, LocalPort, logger, false); } if (Ipv6Bind && NetUtils.OSSupportsIPv6) { INetworkListener ipv6Listener = new TcpNetworkListener(AnyBind, true, LocalPort, logger, false); if (listener != null) { listener = new AggregateNetworkListener(listener, ipv6Listener); } else { listener = ipv6Listener; } } } else { if (NetUtils.OSSupportsIPv4) { listener = new UdpNetworkListener(AnyBind, false, LocalPort, EnableBroadcast, logger); } if (Ipv6Bind && NetUtils.OSSupportsIPv6) { INetworkListener ipv6Listener = new UdpNetworkListener(AnyBind, true, LocalPort, EnableBroadcast, logger); if (listener != null) { listener = new AggregateNetworkListener(listener, ipv6Listener); } else { listener = ipv6Listener; } } } if (listener == null) { throw new NetServiceException(Properties.Resources.NetServiceDocument_CannotSetupListener); } ret = new ProxyNetworkService(listener, Graph ?? BuildDefaultProxyFactory(), logger, _globalMeta, server, client, null, Timeout.Infinite, false); ret.DefaultBinding = NetworkLayerBinding.Server; } catch (SocketException ex) { throw new NetServiceException(Properties.Resources.NetServerDocument_ErrorCreatingServer, ex); } catch (IOException ex) { throw new NetServiceException(Properties.Resources.NetServerDocument_ErrorCreatingServer, ex); } return(ret); } }
/// <summary> /// Constructor /// </summary> /// <param name="packetLog"></param> /// <param name="listener"></param> /// <param name="factory"></param> /// <param name="logger"></param> /// <param name="globalMeta"></param> /// <param name="history"></param> /// <param name="credentials"></param> /// <param name="proxyServer"></param> /// <param name="proxyClient"></param> /// <param name="filters"></param> /// <param name="defaultTimeout"></param> /// <param name="afterdata"></param> public ProxyNetworkService(IList<LogPacket> packetLog, INetworkListener listener, NetGraphFactory factory, Logger logger, MetaDictionary globalMeta, IList<ConnectionHistoryEntry> history, IDictionary<SecurityPrincipal, ICredentialObject> credentials, ProxyServer proxyServer, ProxyClient proxyClient, ProxyFilter[] filters, int defaultTimeout, bool afterdata) { _packetLog = packetLog; _logger = logger; Listener = listener; _factory = factory; _connections = new List<ConnectionEntry>(); _globalMeta = globalMeta; _history = history; _subServices = new List<ProxyNetworkService>(); DefaultBinding = NetworkLayerBinding.Default; _credentials = new Dictionary<SecurityPrincipal, ICredentialObject>(credentials); _credentialManager = new CredentialsManagerService(); _credentialManager.ResolveCredentials += _credentialManager_ResolveCredentials; _proxyClient = proxyClient; _proxyServer = proxyServer; _filters = filters; _defaultTimeout = defaultTimeout; _afterData = afterdata; }
public virtual void Dispose() { _listener?.Dispose(); _listener = null; _listenerCancellationCallback = null; }
public SocketServer(IPAddress address, MessageRegistry registry) { listener = new SocketListener(address); this.registry = registry; }
private static void AddListener(List<string> builder, INetworkListener listener) { if (listener is AggregateNetworkListener) { AddAggregateListener(builder, (AggregateNetworkListener)listener); } else { builder.Add(listener.ToString()); } }
public void SetListener(INetworkListener l) { _listener = l; _responceListener = l; _connectionListener = l; }