public static DuplexStream CreateStream() { var options = new SecurityOptions(SecureProtocol.Tls1, null, new[] { Protocols.Http1 }, ConnectionEnd.Client); var socket = new SecureSocket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp, options); return new Mock<DuplexStream>(socket, false).Object; }
public override void Attach(SecureSocket socket) { this.Socket = socket; this.AlpnExtension = this.Socket.m_Options.ExtensionList.GetExtesionOfType<ALPNExtension>(); AttachToExtension(this.AlpnExtension); }
public void Start() { // create a new ManualResetEvent. This will be used to make the main application // thread wait until the full server reply has been received. m_ResetEvent = new ManualResetEvent(false); // initialize the security options SecurityOptions options = new SecurityOptions( SecureProtocol.Ssl3 | SecureProtocol.Tls1, // use SSL3 or TLS1 null, // do not use client authentication ConnectionEnd.Client, // this is the client side CredentialVerification.None, // do not check the certificate -- this should not be used in a real-life application :-) null, // not used with automatic certificate verification "www.microsoft.com", // this is the common name of the Microsoft web server SecurityFlags.Default, // use the default security flags SslAlgorithms.SECURE_CIPHERS, // only use secure ciphers null); // do not process certificate requests. try { // create the securesocket with the specified security options m_Socket = new SecureSocket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp, options); // resolve www.microsoft.com IPEndPoint endpoint = new IPEndPoint(Dns.GetHostEntry("www.microsoft.com").AddressList[0], 443); // start connecting to www.microsoft.com m_Socket.BeginConnect(endpoint, new AsyncCallback(this.OnConnect), null); // wait until the entire web page has been received m_ResetEvent.WaitOne(); // close the SecureSocket m_Socket.Close(); } catch { OnError("Could not connect to the website"); } }
internal void Attach(SecureSocket socket, ServerHandshakeLayer layer) { this.Socket = socket; this.Layer = layer; layer.OnHandshakeFinished += this.Socket.HandshakeFinishedHandler; }
public void Close() { if (fAcceptSocket != null) { fAcceptSocket.Close(); fAcceptSocket = null; } }
///<summary>Starts the authentication process.</summary> ///<param name="Connection">The connection with the SOCKS client.</param> ///<param name="Callback">The method to call when the authentication is complete.</param> internal override void StartAuthentication(SecureSocket Connection, AuthenticationCompleteDelegate Callback) { this.Connection = Connection; this.Callback = Callback; try { Bytes = null; Connection.BeginReceive(Buffer, 0, Buffer.Length, SocketFlags.None, new AsyncCallback(this.OnRecvRequest), Connection); } catch { Callback(false); } }
/// <summary> /// Initializes a new instance of the SecureTcpListener class with the specified listener SecureSocket. /// </summary> /// <param name="listener">The listener <see cref="SecureSocket"/>.</param> /// <param name="options">The security options to use.</param> /// <exception cref="ArgumentNullException"><paramref name="listener"/> is a null reference (<b>Nothing</b> in Visual Basic).</exception> /// <exception cref="SocketException">An error occurs while reading the LocalEndPoint property.</exception> /// <exception cref="ObjectDisposedException">The SecureSocket has been closed.</exception> protected SecureTcpListener(SecureSocket listener, SecurityOptions options) { if (listener == null) { throw new ArgumentNullException(); } m_Server = listener; m_LocalEndpoint = listener.LocalEndPoint; m_SecurityOptions = options; }
private void HandleAcceptedClient(SecureSocket incomingClient, ALPNExtensionMonitor monitor) { bool backToHttp11 = false; string selectedProtocol = Protocols.Http1; if (_useHandshake) { try { if (_options.Protocol != SecureProtocol.None) { incomingClient.MakeSecureHandshake(_options); selectedProtocol = incomingClient.SelectedProtocol; } } catch (SecureHandshakeException ex) { switch (ex.Reason) { case SecureHandshakeFailureReason.HandshakeInternalError: backToHttp11 = true; break; case SecureHandshakeFailureReason.HandshakeTimeout: incomingClient.Close(); Http2Logger.LogError("Handshake timeout. Client was disconnected."); return; default: incomingClient.Close(); Http2Logger.LogError("Unknown error occurred during secure handshake"); return; } } catch (Exception e) { Http2Logger.LogError("Exception occurred. Closing client's socket. " + e.Message); incomingClient.Close(); return; } } var clientStream = new DuplexStream(incomingClient, true); var transportInfo = GetTransportInfo(incomingClient); monitor.Dispose(); try { HandleRequest(clientStream, selectedProtocol, transportInfo, backToHttp11); } catch (Exception e) { Http2Logger.LogError("Exception occurred. Closing client's socket. " + e.Message); incomingClient.Close(); } }
public void Bind( IPEndPoint endPoint ) { if( fAcceptSocket != null ) { throw new InvalidOperationException( "Socket is already bound" ); } fAcceptSocket = new SecureSocket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp, fOptions ); fAcceptSocket.Bind( endPoint ); fAcceptSocket.Listen( 10 ); }
private IDictionary<string, object> MakeHandshakeEnvironment(SecureSocket incomingClient) { var result = new Dictionary<string, object> { {"securityOptions", _options}, {"secureSocket", incomingClient}, {"end", ConnectionEnd.Server} }; return result; }
public Http2Session(SecureSocket sessionSocket, ConnectionEnd end, bool usePriorities, bool useFlowControl, IDictionary<string, object> handshakeResult = null) { _ourEnd = end; _usePriorities = usePriorities; _useFlowControl = useFlowControl; _handshakeHeaders = new Dictionary<string, string>(16); ApplyHandshakeResults(handshakeResult); if (_ourEnd == ConnectionEnd.Client) { _remoteEnd = ConnectionEnd.Server; _lastId = -1; // Streams opened by client are odd } else { _remoteEnd = ConnectionEnd.Client; _lastId = 0; // Streams opened by server are even } _goAwayReceived = false; _settingsManager = new SettingsManager(); _comprProc = new CompressionProcessor(_ourEnd); _sessionSocket = sessionSocket; _frameReader = new FrameReader(_sessionSocket); ActiveStreams = new ActiveStreams(); _writeQueue = new WriteQueue(_sessionSocket, ActiveStreams, _usePriorities); if (_sessionSocket != null && sessionSocket.SecureProtocol == SecureProtocol.None) { OurMaxConcurrentStreams = int.Parse(_handshakeHeaders[":max_concurrent_streams"]); RemoteMaxConcurrentStreams = int.Parse(_handshakeHeaders[":max_concurrent_streams"]); InitialWindowSize = int.Parse(_handshakeHeaders[":initial_window_size"]); } else { OurMaxConcurrentStreams = 100; //Spec recommends value 100 by default RemoteMaxConcurrentStreams = 100; InitialWindowSize = 2000000; } _flowControlManager = new FlowControlManager(this); if (!_useFlowControl) { _flowControlManager.Options = (byte) FlowControlOptions.DontUseFlowControl; } SessionWindowSize = 0; _toBeContinuedHeaders = new HeadersList(); }
/// <summary> /// Starts listening to network requests. /// </summary> /// <exception cref="SocketException">An error occurs while opening the network socket.</exception> /// <exception cref="SecurityException">Unable to create the SSPI credentials.</exception> public virtual void Start() { if (Server != null) { return; } EndPoint ep = LocalEndpoint; m_Server = new SecureSocket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp, this.SecurityOptions); Server.Bind(ep); Server.Listen(int.MaxValue); }
/// <summary> /// Creates a new instance of the SecureNetworkStream class for the specified <see cref="SecureSocket"/>. /// </summary> /// <param name="socket">The SecureSocket that provides the network data.</param> /// <param name="access">One of the FileAccess values that sets the CanRead and CanWrite properties of the SecureNetworkStream.</param> /// <param name="ownsSocket"><b>true</b> if the socket will be owned by this SecureNetworkStream instance; otherwise, <b>false</b>.</param> /// <exception cref="ArgumentNullException"><paramref name="socket"/> is a null reference (<b>Nothing</b> in Visual Basic).</exception> /// <exception cref="ArgumentException"><paramref name="socket"/> is not connected -or- the SocketType property of socket is not SocketType.Stream.</exception> /// <exception cref="IOException"><paramref name="socket"/> is a nonblocking socket.</exception> public SecureNetworkStream(SecureSocket socket, FileAccess access, bool ownsSocket) { if (socket == null) throw new ArgumentNullException(); if (!socket.Blocking) throw new IOException(); if (!socket.Connected || socket.SocketType != SocketType.Stream) throw new ArgumentException(); m_CanRead = (access == FileAccess.Read || access == FileAccess.ReadWrite); m_CanWrite = (access == FileAccess.Write || access == FileAccess.ReadWrite); m_OwnsSocket = ownsSocket; m_Socket = socket; }
public SecureHandshaker(SecureSocket socket, SecurityOptions options) { InternalSocket = socket; InternalSocket.OnHandshakeFinish += HandshakeFinishedHandler; Options = options; _handshakeFinishedEventRaised = new ManualResetEvent(false); if (Options.Protocol == SecureProtocol.None) { HandshakeFinishedHandler(this, null); } }
///<summary>Initializes a new instance of the FtpDataConnection class.</summary> ///<param name="RemoteAddress">The address on the local FTP client to connect to.</param> ///<returns>The PORT command string to send to the FTP server.</returns> public string ProcessPort(IPEndPoint RemoteAddress) { try { ListenSocket = new SecureSocket(IPAddress.Any.AddressFamily, SocketType.Stream, ProtocolType.Tcp); ListenSocket.Bind(new IPEndPoint(IPAddress.Any, 0)); ListenSocket.Listen(1); ListenSocket.BeginAccept(new AsyncCallback(this.OnPortAccept), ListenSocket); ClientSocket = new SecureSocket(RemoteAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp); ClientSocket.BeginConnect(RemoteAddress, new AsyncCallback(this.OnPortConnected), ClientSocket); return "PORT " + Listener.GetLocalExternalIP().ToString().Replace('.', ',') + "," + Math.Floor(((IPEndPoint)ListenSocket.LocalEndPoint).Port / 256).ToString() + "," + (((IPEndPoint)ListenSocket.LocalEndPoint).Port % 256).ToString() + "\r\n"; } catch { Dispose(); return "PORT 0,0,0,0,0,0\r\n"; } }
public WriteQueue(SecureSocket socket, ActiveStreams streams, bool isPriorityTurnedOn) { IsPriorityTurnedOn = isPriorityTurnedOn; _streams = streams; if (isPriorityTurnedOn) { _messageQueue = new PriorityQueue(); } else { _messageQueue = new QueueWrapper(); } _socket = socket; _disposed = false; }
public static string[] GetHttp11Headers(SecureSocket socket) { var headers = new List<string>(5); var lineBuffer = new byte[1024]; string header = String.Empty; int totalBytesCame = 0; int bytesOfLastHeader = 0; while (true) { bool gotException = false; var bf = new byte[1]; int bytesCame = socket.Receive(bf); if (bytesCame == 0) break; Buffer.BlockCopy(bf, 0, lineBuffer, totalBytesCame, bytesCame); totalBytesCame += bytesCame; try { header = Encoding.UTF8.GetString(lineBuffer, bytesOfLastHeader, totalBytesCame - bytesOfLastHeader); } catch { gotException = true; } if (totalBytesCame != 0 && !gotException && header[header.Length - 1] == '\n') { headers.Add(header.TrimEnd('\n', '\r')); bytesOfLastHeader = totalBytesCame; } // empty header means we got \r\n\r\n which was trimmed. This means end of headers block. if (headers.Count >= 2 && String.IsNullOrEmpty(headers.LastOrDefault())) { break; } } headers.RemoveAll(String.IsNullOrEmpty); return headers.ToArray(); }
/// <summary> /// Creates a new instance of the SecureNetworkStream class for the specified <see cref="SecureSocket"/>. /// </summary> /// <param name="socket">The SecureSocket that provides the network data.</param> /// <param name="access">One of the FileAccess values that sets the CanRead and CanWrite properties of the SecureNetworkStream.</param> /// <param name="ownsSocket"><b>true</b> if the socket will be owned by this SecureNetworkStream instance; otherwise, <b>false</b>.</param> /// <exception cref="ArgumentNullException"><paramref name="socket"/> is a null reference (<b>Nothing</b> in Visual Basic).</exception> /// <exception cref="ArgumentException"><paramref name="socket"/> is not connected -or- the SocketType property of socket is not SocketType.Stream.</exception> /// <exception cref="IOException"><paramref name="socket"/> is a nonblocking socket.</exception> public SecureNetworkStream(SecureSocket socket, FileAccess access, bool ownsSocket) { if (socket == null) { throw new ArgumentNullException(); } if (!socket.Blocking) { throw new IOException(); } if (!socket.Connected || socket.SocketType != SocketType.Stream) { throw new ArgumentException(); } m_CanRead = (access == FileAccess.Read || access == FileAccess.ReadWrite); m_CanWrite = (access == FileAccess.Write || access == FileAccess.ReadWrite); m_OwnsSocket = ownsSocket; m_Socket = socket; }
///<summary>Processes a SOCKS request from a client.</summary> ///<param name="Request">The request to process.</param> protected override void ProcessRequest(byte [] Request) { int Ret; try { if (Request[0] == 1) { // CONNECT IPAddress RemoteIP; int RemotePort = Request[1] * 256 + Request[2]; Ret = Array.IndexOf(Request, (byte)0, 7); Username = Encoding.ASCII.GetString(Request, 7, Ret - 7); if (Request[3] == 0 && Request[4] == 0 && Request[5] == 0 && Request[6] != 0) {// Use remote DNS Ret = Array.IndexOf(Request, (byte)0, Ret + 1); RemoteIP = Dns.Resolve(Encoding.ASCII.GetString(Request, Username.Length + 8, Ret - Username.Length - 8)).AddressList[0]; } else { //Do not use remote DNS RemoteIP = IPAddress.Parse(Request[3].ToString() + "." + Request[4].ToString() + "." + Request[5].ToString() + "." + Request[6].ToString()); } RemoteConnection = new SecureSocket(RemoteIP.AddressFamily, SocketType.Stream, ProtocolType.Tcp); RemoteConnection.BeginConnect(new IPEndPoint(RemoteIP, RemotePort), new AsyncCallback(this.OnConnected), RemoteConnection); } else if (Request[0] == 2) { // BIND byte [] Reply = new byte[8]; long LocalIP = Listener.GetLocalExternalIP().Address; AcceptSocket = new SecureSocket(IPAddress.Any.AddressFamily, SocketType.Stream, ProtocolType.Tcp); AcceptSocket.Bind(new IPEndPoint(IPAddress.Any, 0)); AcceptSocket.Listen(50); RemoteBindIP = IPAddress.Parse(Request[3].ToString() + "." + Request[4].ToString() + "." + Request[5].ToString() + "." + Request[6].ToString()); Reply[0] = 0; //Reply version 0 Reply[1] = 90; //Everything is ok :) Reply[2] = (byte)(Math.Floor(((IPEndPoint)AcceptSocket.LocalEndPoint).Port / 256)); //Port/1 Reply[3] = (byte)(((IPEndPoint)AcceptSocket.LocalEndPoint).Port % 256); //Port/2 Reply[4] = (byte)(Math.Floor((LocalIP % 256))); //IP Address/1 Reply[5] = (byte)(Math.Floor((LocalIP % 65536) / 256)); //IP Address/2 Reply[6] = (byte)(Math.Floor((LocalIP % 16777216) / 65536)); //IP Address/3 Reply[7] = (byte)(Math.Floor(LocalIP / 16777216)); //IP Address/4 Connection.BeginSend(Reply, 0, Reply.Length, SocketFlags.None, new AsyncCallback(this.OnStartAccept), Connection); } } catch { Dispose(91); } }
public DuplexStream(SecureSocket socket, bool ownsSocket = false) { if (socket == null) throw new ArgumentNullException("socket is null"); _writeBuffer = new StreamBuffer(1024); _readBuffer = new StreamBuffer(1024); _ownsSocket = ownsSocket; _socket = socket; _isClosed = false; _waitLock = new object(); _closeLock = new object(); _streamStateChangeRaised = new ManualResetEvent(false); OnDataAvailable += (sender, args) => _streamStateChangeRaised.Set(); OnClose += (sender, args) => _streamStateChangeRaised.Set(); Task.Run(async () => { Thread.CurrentThread.Name = "Duplex listening thread"; await PumpIncomingData(); }); }
public AdkSSLConnectedSocket( SecureSocket wrappedSocket ) { fSocket = wrappedSocket; }
public bool Connect(Uri connectUri) { _path = connectUri.PathAndQuery; _version = Protocols.Http2; _scheme = connectUri.Scheme; _host = connectUri.Host; _port = connectUri.Port; ServerUri = connectUri.Authority; if (_sessionAdapter != null) { return false; } try { int port = connectUri.Port; int securePort; if (!int.TryParse(ConfigurationManager.AppSettings["securePort"], out securePort)) { Http2Logger.LogError("Incorrect port in the config file!"); return false; } //Connect alpn extension, set known protocols var extensions = new[] {ExtensionType.Renegotiation, ExtensionType.ALPN}; Options = port == securePort ? new SecurityOptions(SecureProtocol.Tls1, extensions, new[] { Protocols.Http1, Protocols.Http2 }, ConnectionEnd.Client) : new SecurityOptions(SecureProtocol.None, extensions, new[] { Protocols.Http1, Protocols.Http2 }, ConnectionEnd.Client); Options.VerificationType = CredentialVerification.None; Options.Certificate = Org.Mentalis.Security.Certificates.Certificate.CreateFromCerFile(CertificatePath); Options.Flags = SecurityFlags.Default; Options.AllowedAlgorithms = SslAlgorithms.RSA_AES_256_SHA | SslAlgorithms.NULL_COMPRESSION; var socket = new SecureSocket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp, Options); using (var monitor = new ALPNExtensionMonitor()) { monitor.OnProtocolSelected += (o, args) => { _selectedProtocol = args.SelectedProtocol; }; socket.Connect(new DnsEndPoint(connectUri.Host, connectUri.Port), monitor); _clientStream = new DuplexStream(socket, true); if (_useHandshake) { MakeHandshakeEnvironment(); //Handshake manager determines what handshake must be used: upgrade or secure if (socket.SecureProtocol != SecureProtocol.None) { socket.MakeSecureHandshake(Options); _selectedProtocol = socket.SelectedProtocol; } if (socket.SecureProtocol == SecureProtocol.None || _selectedProtocol == Protocols.Http1) { try { var handshakeResult = new UpgradeHandshaker(_environment).Handshake(); _environment.Add(HandshakeKeys.Result, handshakeResult); _useHttp20 = handshakeResult[HandshakeKeys.Successful] as string == HandshakeKeys.True; if (!_useHttp20) { Dispose(false); return true; } } catch (Http2HandshakeFailed ex) { if (ex.Reason == HandshakeFailureReason.InternalError) { _useHttp20 = false; } else { Http2Logger.LogError("Specified server did not respond"); Dispose(true); return false; } } } } } Http2Logger.LogDebug("Handshake finished"); if (_useHttp20) { //TODO provide transport info _sessionAdapter = new Http2ClientMessageHandler(_clientStream, ConnectionEnd.Client, default(TransportInformation), CancellationToken.None); } } catch (SocketException) { Http2Logger.LogError("Check if any server listens port " + connectUri.Port); Dispose(true); return false; } catch (Exception ex) { Http2Logger.LogError("Unknown connection exception was caught: " + ex.Message); Dispose(true); return false; } return true; }
public void OnVerify(SecureSocket socket, Certificate remote, CertificateChain chain, VerifyEventArgs e) { Console.WriteLine("\r\nThe certificate of the FTP server:"); Console.WriteLine(remote.ToString(true) + "\r\n"); // certificate chain verification can be placed here }
private void DownloadFile(Url url, int choice) { SecurityOptions options = new SecurityOptions(SecureProtocol.None);; m_Socket = new SecureSocket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp, options); // connect to the FTP server using a normal TCP connection m_Socket.Connect(new IPEndPoint(Dns.GetHostEntry(url.Host).AddressList[0], url.Port)); // wait for the server hello ReceiveReply(); // if the user selected to use the AUTH command.. if (choice == 2) { // ..send the command to the server and start the SSL handshake DoAuthCommand(url.Host); } // log on and quit if (!SendCommand("USER " + url.Username)) return; if (!SendCommand("PASS " + url.Password)) return; if (!SendCommand("QUIT")) return; // clean up m_Socket.Shutdown(SocketShutdown.Both); m_Socket.Close(); }
public bool Connect(Uri connectUri) { _path = connectUri.PathAndQuery; _version = Protocols.Http2; _scheme = connectUri.Scheme; _host = connectUri.Host; _port = connectUri.Port; ServerUri = connectUri.Authority; if (_clientSession != null) { return false; } try { int port = connectUri.Port; int securePort; if (!int.TryParse(ConfigurationManager.AppSettings["securePort"], out securePort)) { Http2Logger.LogError("Incorrect port in the config file!"); return false; } //Connect alpn extension, set known protocols var extensions = new[] {ExtensionType.Renegotiation, ExtensionType.ALPN}; Options = port == securePort ? new SecurityOptions(SecureProtocol.Tls1, extensions, new[] { Protocols.Http1, Protocols.Http2 }, ConnectionEnd.Client) : new SecurityOptions(SecureProtocol.None, extensions, new[] { Protocols.Http1, Protocols.Http2 }, ConnectionEnd.Client); Options.VerificationType = CredentialVerification.None; Options.Certificate = Org.Mentalis.Security.Certificates.Certificate.CreateFromCerFile(CertificatePath); Options.Flags = SecurityFlags.Default; Options.AllowedAlgorithms = SslAlgorithms.RSA_AES_256_SHA | SslAlgorithms.NULL_COMPRESSION; _socket = new SecureSocket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp, Options); IDictionary<string, object> handshakeResult = null; using (var monitor = new ALPNExtensionMonitor()) { monitor.OnProtocolSelected += (o, args) => { _selectedProtocol = args.SelectedProtocol; }; _socket.Connect(new DnsEndPoint(connectUri.Host, connectUri.Port), monitor); if (_useHandshake) { var handshakeEnvironment = MakeHandshakeEnvironment(_socket); //Handshake manager determines what handshake must be used: upgrade or secure handshakeResult = HandshakeManager.GetHandshakeAction(handshakeEnvironment).Invoke(); Http2Logger.LogDebug("Handshake finished"); if (_selectedProtocol == Protocols.Http1) { _useHttp20 = false; return true; } } } SendSessionHeader(); _useHttp20 = true; _clientSession = new Http2Session(_socket, ConnectionEnd.Client, _usePriorities, _useFlowControl, handshakeResult); //For saving incoming data _clientSession.OnFrameReceived += FrameReceivedHandler; _clientSession.OnRequestSent += RequestSentHandler; _clientSession.OnSessionDisposed += (sender, args) => Dispose(false); } catch (Http2HandshakeFailed ex) { if (ex.Reason == HandshakeFailureReason.InternalError) { _useHttp20 = false; } else { Http2Logger.LogError("Specified server did not respond"); Dispose(true); return false; } } catch (SocketException) { Http2Logger.LogError("Check if any server listens port " + connectUri.Port); Dispose(true); return false; } catch (Exception ex) { Http2Logger.LogError("Unknown connection exception was caught: " + ex.Message); Dispose(true); return false; } return true; }
private IDictionary<string, object> MakeHandshakeEnvironment(SecureSocket socket) { var result = new Dictionary<string, object> { {":path", _path}, {":version", _version}, {":scheme", _scheme}, {":host", _host}, {"securityOptions", Options}, {"secureSocket", socket}, {"end", ConnectionEnd.Client} }; return result; }
/// <summary> /// Creates a new instance of the SecureNetworkStream class for the specified <see cref="SecureSocket"/>. /// </summary> /// <param name="socket">The SecureSocket that provides the network data. </param> /// <exception cref="ArgumentNullException"><paramref name="socket"/> is a null reference (<b>Nothing</b> in Visual Basic).</exception> /// <exception cref="ArgumentException"><paramref name="socket"/> is not connected -or- the SocketType property of <paramref name="socket"/> is not SocketType.Stream.</exception> /// <exception cref="IOException"><paramref name="socket"/> is a nonblocking socket.</exception> public SecureNetworkStream(SecureSocket socket) : this(socket, FileAccess.ReadWrite, false) { }
/// <summary> /// Initializes a new instance of the <see cref="SecureTcpClient"/> class. /// </summary> /// <param name="options">The security options to use.</param> public SecureTcpClient(SecurityOptions options) { m_Client = new SecureSocket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp, options); }
/// <summary> /// Initializes a new instance of the SecureTcpListener class with the specified listener SecureSocket. /// </summary> /// <param name="listener">The listener <see cref="SecureSocket"/>.</param> /// <param name="options">The security options to use.</param> /// <exception cref="ArgumentNullException"><paramref name="listener"/> is a null reference (<b>Nothing</b> in Visual Basic).</exception> /// <exception cref="SocketException">An error occurs while reading the LocalEndPoint property.</exception> /// <exception cref="ObjectDisposedException">The SecureSocket has been closed.</exception> protected SecureTcpListener(SecureSocket listener, SecurityOptions options) { if (listener == null) throw new ArgumentNullException(); m_Server = listener; m_LocalEndpoint = listener.LocalEndPoint; m_SecurityOptions = options; }
///<summary>Initializes a new instance of the FtpClient class.</summary> ///<param name="ClientSocket">The Socket connection between this proxy server and the local client.</param> ///<param name="Destroyer">The callback method to be called when this Client object disconnects from the local client and the remote server.</param> public FtpClient(SecureSocket ClientSocket, DestroyDelegate Destroyer) : base(ClientSocket, Destroyer) {}
/// <summary> /// Creates a new instance of the SecureNetworkStream class for the specified <see cref="SecureSocket"/>. /// </summary> /// <param name="socket">The SecureSocket that provides the network data. </param> /// <param name="access">One of the <see cref="FileAccess"/> values that sets the CanRead and CanWrite properties of the SecureNetworkStream.</param> /// <exception cref="ArgumentNullException"><paramref name="socket"/> is a null reference (<b>Nothing</b> in Visual Basic).</exception> /// <exception cref="ArgumentException"><paramref name="socket"/> is not connected -or- The SocketType property of socket is not SocketType.Stream.</exception> /// <exception cref="IOException"><paramref name="socket"/> is a nonblocking socket.</exception> public SecureNetworkStream(SecureSocket socket, FileAccess access) : this(socket, access, false) { }
/// <summary> /// Creates a new instance of the SecureNetworkStream class for the specified <see cref="SecureSocket"/>. /// </summary> /// <param name="socket">The SecureSocket that provides the network data. </param> /// <param name="ownsSocket"><b>true</b> if the socket will be owned by this NetworkStream instance; otherwise, <b>false</b>.</param> /// <exception cref="ArgumentNullException"><paramref name="socket"/> is a null reference (<b>Nothing</b> in Visual Basic).</exception> /// <exception cref="ArgumentException"><paramref name="socket"/> is not connected -or- the SocketType property of <paramref name="socket"/> is not SocketType.Stream.</exception> /// <exception cref="IOException"><paramref name="socket"/> is a nonblocking socket.</exception> public SecureNetworkStream(SecureSocket socket, bool ownsSocket) : this(socket, FileAccess.ReadWrite, ownsSocket) { }
/// <summary> /// Initializes a new instance of <see cref="SecureTcpClient"/>. /// </summary> /// <param name="socket">The accepted socket.</param> /// <remarks>This constructor is used by the SecureTcpListener class.</remarks> internal SecureTcpClient(SecureSocket socket) : base() { m_Client = socket; m_Active = true; }
/// <summary> /// Initializes a new instance of the <see cref="SecureTcpClient"/> class. /// </summary> /// <param name="options">The security options to use.</param> public SecureTcpClient(SecurityOptions options) { m_Client = new SecureSocket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp, options); }
/// <summary> /// Starts listening to network requests. /// </summary> /// <exception cref="SocketException">An error occurs while opening the network socket.</exception> /// <exception cref="SecurityException">Unable to create the SSPI credentials.</exception> public virtual void Start() { if (Server != null) return; EndPoint ep = LocalEndpoint; m_Server = new SecureSocket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp, this.SecurityOptions); Server.Bind(ep); Server.Listen(int.MaxValue); }
/// <summary> /// Create a new SecureTcpClient based on an existing one. /// </summary> /// <param name="client">The SecureTcpClient to copy from.</param> public SecureTcpClient(SecureTcpClient client) : base() { m_Client = client.Client; m_Active = client.Active; m_CleanedUp = client.CleanedUp; m_DataStream = client.DataStream; }
/// <summary> /// Closes the listener. /// </summary> /// <remarks>Stop closes the listener.</remarks> public virtual void Stop() { if (Server == null) return; Server.Close(); m_Server = null; }
/// <summary> /// Initializes a new instance of <see cref="SecureTcpClient"/>. /// </summary> /// <param name="socket">The accepted socket.</param> /// <remarks>This constructor is used by the SecureTcpListener class.</remarks> internal SecureTcpClient(SecureSocket socket) : base() { m_Client = socket; m_Active = true; }