internal TcpAcceptor( TcpEndpoint endpoint, Communicator communicator, string host, ushort port, string adapterName) { _adapterName = adapterName; _endpoint = endpoint; _communicator = communicator; _backlog = communicator.GetPropertyAsInt("Ice.TCP.Backlog") ?? 511; try { int ipVersion = _communicator.IPVersion; _addr = Network.GetAddressForServerEndpoint(host, port, ipVersion, _communicator.PreferIPv6); _fd = Network.CreateServerSocket(false, _addr.AddressFamily, ipVersion); Network.SetBlock(_fd, false); Network.SetTcpBufSize(_fd, _communicator); } catch (Exception) { _fd = null; throw; } }
public StreamSocket(Communicator communicator, Socket fd) { _communicator = communicator; _fd = fd; _state = StateConnected; try { _desc = Network.FdToString(_fd); } catch (Exception) { Network.CloseSocketNoThrow(_fd); throw; } Network.SetBlock(_fd, false); Network.SetTcpBufSize(_fd, _communicator); _readEventArgs = new SocketAsyncEventArgs(); _readEventArgs.Completed += new EventHandler <SocketAsyncEventArgs>(IoCompleted); _writeEventArgs = new SocketAsyncEventArgs(); _writeEventArgs.Completed += new EventHandler <SocketAsyncEventArgs>(IoCompleted); // // For timeouts to work properly, we need to receive/send // the data in several chunks. Otherwise, we would only be // notified when all the data is received/written. The // connection timeout could easily be triggered when // receiving/sending large frames. // _maxSendPacketSize = Math.Max(512, Network.GetSendBufferSize(_fd)); _maxRecvPacketSize = Math.Max(512, Network.GetRecvBufferSize(_fd)); }
public StreamSocket(Communicator communicator, INetworkProxy?proxy, EndPoint addr, IPAddress?sourceAddr) { _communicator = communicator; _proxy = proxy; _addr = addr; _sourceAddr = sourceAddr; _fd = Network.CreateSocket(false, (_proxy != null ? _proxy.GetAddress() : _addr).AddressFamily); _state = StateNeedConnect; Network.SetBlock(_fd, false); Network.SetTcpBufSize(_fd, _communicator); _readEventArgs = new SocketAsyncEventArgs(); _readEventArgs.Completed += new EventHandler <SocketAsyncEventArgs>(IoCompleted); _writeEventArgs = new SocketAsyncEventArgs(); _writeEventArgs.Completed += new EventHandler <SocketAsyncEventArgs>(IoCompleted); // // For timeouts to work properly, we need to receive/send // the data in several chunks. Otherwise, we would only be // notified when all the data is received/written. The // connection timeout could easily be triggered when // receiving/sending large frames. // _maxSendPacketSize = Math.Max(512, Network.GetSendBufferSize(_fd)); _maxRecvPacketSize = Math.Max(512, Network.GetRecvBufferSize(_fd)); }
public int Initialize(ref ArraySegment <byte> readBuffer, IList <ArraySegment <byte> > writeBuffer) { if (!_isConnected) { int status = _delegate.Initialize(ref readBuffer, writeBuffer); if (status != SocketOperation.None) { return(status); } _isConnected = true; } if (SslStream == null) { try { Socket?fd = _delegate.Fd(); Debug.Assert(fd != null); Network.SetBlock(fd, true); // SSL requires a blocking socket // For timeouts to work properly, we need to receive/send the data in several chunks. Otherwise, // we would only be notified when all the data is received/written. The connection timeout could // easily be triggered when receiving/sending large frames. _maxSendPacketSize = Math.Max(512, Network.GetSendBufferSize(fd)); _maxRecvPacketSize = Math.Max(512, Network.GetRecvBufferSize(fd)); if (_incoming) { SslStream = new SslStream( new NetworkStream(fd, false), false, _engine.TlsServerOptions.ClientCertificateValidationCallback ?? RemoteCertificateValidationCallback); } else { SslStream = new SslStream( new NetworkStream(fd, false), false, _engine.TlsClientOptions.ServerCertificateValidationCallback ?? RemoteCertificateValidationCallback, _engine.TlsClientOptions.ClientCertificateSelectionCallback ?? CertificateSelectionCallback); } } catch (Exception ex) { if (ex is IOException ioException && Network.ConnectionLost(ioException)) { throw new ConnectionLostException(ex); } else { throw new TransportException(ex); } }
// // Only for use by UdpConnector. // internal UdpTransceiver(Communicator communicator, string transport, EndPoint addr, IPAddress?sourceAddr, string mcastInterface, int mcastTtl) { _communicator = communicator; Transport = transport; _addr = addr; if (sourceAddr != null) { _sourceAddr = new IPEndPoint(sourceAddr, 0); } _readEventArgs = new SocketAsyncEventArgs(); _readEventArgs.RemoteEndPoint = _addr; _readEventArgs.Completed += new EventHandler <SocketAsyncEventArgs>(IoCompleted); _writeEventArgs = new SocketAsyncEventArgs(); _writeEventArgs.RemoteEndPoint = _addr; _writeEventArgs.Completed += new EventHandler <SocketAsyncEventArgs>(IoCompleted); _mcastInterface = mcastInterface; _state = StateNeedConnect; _incoming = false; try { _fd = Network.CreateSocket(true, _addr.AddressFamily); SetBufSize(-1, -1); Network.SetBlock(_fd, false); if (Network.IsMulticast((IPEndPoint)_addr)) { if (_mcastInterface.Length > 0) { Network.SetMcastInterface(_fd, _mcastInterface, _addr.AddressFamily); } if (mcastTtl != -1) { Network.SetMcastTtl(_fd, mcastTtl, _addr.AddressFamily); } } } catch (System.Exception) { _fd = null; throw; } }
internal TcpAcceptor(TcpEndpoint endpoint, ObjectAdapter adapter) { _adapter = adapter; _addr = Network.GetAddressForServerEndpoint(endpoint.Host, endpoint.Port, endpoint.Communicator.IPVersion, endpoint.Communicator.PreferIPv6); _fd = Network.CreateServerSocket(false, _addr.AddressFamily, endpoint.Communicator.IPVersion); Network.SetBlock(_fd, false); Network.SetTcpBufSize(_fd, endpoint.Communicator); _addr = Network.DoBind(_fd, _addr); Network.DoListen(_fd, endpoint.Communicator.GetPropertyAsInt("Ice.TCP.Backlog") ?? 511); Endpoint = endpoint.NewPort((ushort)_addr.Port); }
// // Only for use by UdpEndpoint. // internal UdpTransceiver(UdpEndpoint endpoint, Communicator communicator, string transport, string host, int port, string mcastInterface, bool connect) { _endpoint = endpoint; _communicator = communicator; Transport = transport; _state = connect ? StateNeedConnect : StateNotConnected; _mcastInterface = mcastInterface; _incoming = true; _port = port; try { _addr = Network.GetAddressForServerEndpoint(host, port, communicator.IPVersion, communicator.PreferIPv6); _readEventArgs = new SocketAsyncEventArgs(); _readEventArgs.RemoteEndPoint = _addr; _readEventArgs.Completed += new EventHandler <SocketAsyncEventArgs>(IoCompleted); _writeEventArgs = new SocketAsyncEventArgs(); _writeEventArgs.RemoteEndPoint = _addr; _writeEventArgs.Completed += new EventHandler <SocketAsyncEventArgs>(IoCompleted); _fd = Network.CreateServerSocket(true, _addr.AddressFamily, communicator.IPVersion); SetBufSize(-1, -1); Network.SetBlock(_fd, false); } catch (System.Exception) { if (_readEventArgs != null) { _readEventArgs.Dispose(); } if (_writeEventArgs != null) { _writeEventArgs.Dispose(); } _fd = null; throw; } }
public int Initialize(ref ArraySegment <byte> readBuffer, IList <ArraySegment <byte> > writeBuffer) { if (!_isConnected) { int status = _delegate.Initialize(ref readBuffer, writeBuffer); if (status != SocketOperation.None) { return(status); } _isConnected = true; } Socket?fd = _delegate.Fd(); Debug.Assert(fd != null); Network.SetBlock(fd, true); // SSL requires a blocking socket // // For timeouts to work properly, we need to receive/send // the data in several chunks. Otherwise, we would only be // notified when all the data is received/written. The // connection timeout could easily be triggered when // receiving/sending large messages. // _maxSendPacketSize = Math.Max(512, Network.GetSendBufferSize(fd)); _maxRecvPacketSize = Math.Max(512, Network.GetRecvBufferSize(fd)); if (_sslStream == null) { try { _sslStream = new SslStream(new NetworkStream(fd, false), false, new RemoteCertificateValidationCallback(ValidationCallback), new LocalCertificateSelectionCallback(SelectCertificate)); } catch (IOException ex) { if (Network.ConnectionLost(ex)) { throw new ConnectionLostException(ex); } else { throw new TransportException(ex); } } return(SocketOperation.Connect); } Debug.Assert(_sslStream.IsAuthenticated); _authenticated = true; _cipher = _sslStream.CipherAlgorithm.ToString(); _engine.VerifyPeer((SslConnectionInfo)GetInfo(), ToString()); if (_engine.SecurityTraceLevel >= 1) { _engine.TraceStream(_sslStream, ToString()); } return(SocketOperation.None); }
public int Initialize(ref ArraySegment <byte> readBuffer, IList <ArraySegment <byte> > writeBuffer) { if (!_isConnected) { int status = _delegate.Initialize(ref readBuffer, writeBuffer); if (status != SocketOperation.None) { return(status); } _isConnected = true; } Socket?fd = _delegate.Fd(); Debug.Assert(fd != null); Network.SetBlock(fd, true); // SSL requires a blocking socket // // For timeouts to work properly, we need to receive/send // the data in several chunks. Otherwise, we would only be // notified when all the data is received/written. The // connection timeout could easily be triggered when // receiving/sending large frames. // _maxSendPacketSize = Math.Max(512, Network.GetSendBufferSize(fd)); _maxRecvPacketSize = Math.Max(512, Network.GetRecvBufferSize(fd)); if (SslStream == null) { try { SslStream = new SslStream( new NetworkStream(fd, false), false, _engine.RemoteCertificateValidationCallback ?? RemoteCertificateValidationCallback, _engine.CertificateSelectionCallback ?? CertificateSelectionCallback); } catch (IOException ex) { if (Network.ConnectionLost(ex)) { throw new ConnectionLostException(ex); } else { throw new TransportException(ex); } } return(SocketOperation.Connect); } Debug.Assert(SslStream.IsAuthenticated); _authenticated = true; string description = ToString(); if (!_engine.TrustManager.Verify(_incoming, SslStream.RemoteCertificate as X509Certificate2, _adapterName ?? "", description)) { string msg = string.Format("{0} connection rejected by trust manager\n{1}", _incoming ? "incoming" : "outgoing", description); if (_engine.SecurityTraceLevel >= 1) { _communicator.Logger.Trace(_engine.SecurityTraceCategory, msg); } throw new TransportException(msg); } if (_engine.SecurityTraceLevel >= 1) { _engine.TraceStream(SslStream, ToString()); } return(SocketOperation.None); }
public void SetBlock(bool block) { Debug.Assert(_fd != null); Network.SetBlock(_fd, block); }