Refactor how connection is established to server.

Author: drieseng

src/Renci.SshNet/Connection/ConnectorBase.cs

@@ -0,0 +1,71 @@
+using Renci.SshNet.Abstractions;
+using Renci.SshNet.Common;
+using Renci.SshNet.Messages.Transport;
+using System;
+using System.Net;
+using System.Net.Sockets;
+
+namespace Renci.SshNet.Connection
+{
+    internal abstract class ConnectorBase : IConnector
+    {
+        public abstract Socket Connect(IConnectionInfo connectionInfo);
+
+        /// <summary>
+        /// Establishes a socket connection to the specified host and port.
+        /// </summary>
+        /// <param name="host">The host name of the server to connect to.</param>
+        /// <param name="port">The port to connect to.</param>
+        /// <param name="timeout">The maximum time to wait for the connection to be established.</param>
+        /// <exception cref="SshOperationTimeoutException">The connection failed to establish within the configured <see cref="ConnectionInfo.Timeout"/>.</exception>
+        /// <exception cref="SocketException">An error occurred trying to establish the connection.</exception>
+        protected Socket SocketConnect(string host, int port, TimeSpan timeout)
+        {
+            var ipAddress = DnsAbstraction.GetHostAddresses(host)[0];
+            var ep = new IPEndPoint(ipAddress, port);
+
+            DiagnosticAbstraction.Log(string.Format("Initiating connection to '{0}:{1}'.", host, port));
+
+            var socket = SocketAbstraction.Connect(ep, timeout);
+
+            const int socketBufferSize = 2 * Session.MaximumSshPacketSize;
+            socket.SendBufferSize = socketBufferSize;
+            socket.ReceiveBufferSize = socketBufferSize;
+            return socket;
+        }
+
+        protected static byte SocketReadByte(Socket socket)
+        {
+            var buffer = new byte[1];
+            SocketRead(socket, buffer, 0, 1);
+            return buffer[0];
+        }
+
+        /// <summary>
+        /// Performs a blocking read on the socket until <paramref name="length"/> bytes are received.
+        /// </summary>
+        /// <param name="socket">The <see cref="Socket"/> to read from.</param>
+        /// <param name="buffer">An array of type <see cref="byte"/> that is the storage location for the received data.</param>
+        /// <param name="offset">The position in <paramref name="buffer"/> parameter to store the received data.</param>
+        /// <param name="length">The number of bytes to read.</param>
+        /// <returns>
+        /// The number of bytes read.
+        /// </returns>
+        /// <exception cref="SshConnectionException">The socket is closed.</exception>
+        /// <exception cref="SshOperationTimeoutException">The read has timed-out.</exception>
+        /// <exception cref="SocketException">The read failed.</exception>
+        protected static int SocketRead(Socket socket, byte[] buffer, int offset, int length)
+        {
+            var bytesRead = SocketAbstraction.Read(socket, buffer, offset, length, Session.InfiniteTimeSpan);
+            if (bytesRead == 0)
+            {
+                // when we're in the disconnecting state (either triggered by client or server), then the
+                // SshConnectionException will interrupt the message listener loop (if not already interrupted)
+                // and the exception itself will be ignored (in RaiseError)
+                throw new SshConnectionException("An established connection was aborted by the server.",
+                                                 DisconnectReason.ConnectionLost);
+            }
+            return bytesRead;
+        }
+    }
+}

src/Renci.SshNet/Connection/DirectConnector.cs

@@ -0,0 +1,12 @@
+using System.Net.Sockets;
+
+namespace Renci.SshNet.Connection
+{
+    internal class DirectConnector : ConnectorBase
+    {
+        public override Socket Connect(IConnectionInfo connectionInfo)
+        {
+            return SocketConnect(connectionInfo.Host, connectionInfo.Port, connectionInfo.Timeout);
+        }
+    }
+}

src/Renci.SshNet/Connection/HttpConnector.cs

@@ -0,0 +1,140 @@
+using Renci.SshNet.Abstractions;
+using Renci.SshNet.Common;
+using System;
+using System.Collections.Generic;
+using System.Net;
+using System.Net.Sockets;
+using System.Text.RegularExpressions;
+
+namespace Renci.SshNet.Connection
+{
+    internal class HttpConnector : ConnectorBase
+    {
+        public override Socket Connect(IConnectionInfo connectionInfo)
+        {
+            var socket = SocketConnect(connectionInfo.ProxyHost, connectionInfo.ProxyPort, connectionInfo.Timeout);
+
+            var httpResponseRe = new Regex(@"HTTP/(?<version>\d[.]\d) (?<statusCode>\d{3}) (?<reasonPhrase>.+)$");
+            var httpHeaderRe = new Regex(@"(?<fieldName>[^\[\]()<>@,;:\""/?={} \t]+):(?<fieldValue>.+)?");
+
+            SocketAbstraction.Send(socket, SshData.Ascii.GetBytes(string.Format("CONNECT {0}:{1} HTTP/1.0\r\n", connectionInfo.Host, connectionInfo.Port)));
+
+            //  Sent proxy authorization is specified
+            if (!string.IsNullOrEmpty(connectionInfo.ProxyUsername))
+            {
+                var authorization = string.Format("Proxy-Authorization: Basic {0}\r\n",
+                                                  Convert.ToBase64String(SshData.Ascii.GetBytes(string.Format("{0}:{1}", connectionInfo.ProxyUsername, connectionInfo.ProxyPassword))));
+                SocketAbstraction.Send(socket, SshData.Ascii.GetBytes(authorization));
+            }
+
+            SocketAbstraction.Send(socket, SshData.Ascii.GetBytes("\r\n"));
+
+            HttpStatusCode? statusCode = null;
+            var contentLength = 0;
+
+            while (true)
+            {
+                var response = SocketReadLine(socket, connectionInfo.Timeout);
+                if (response == null)
+                {
+                    // server shut down socket
+                    break;
+                }
+
+                if (statusCode == null)
+                {
+                    var statusMatch = httpResponseRe.Match(response);
+                    if (statusMatch.Success)
+                    {
+                        var httpStatusCode = statusMatch.Result("${statusCode}");
+                        statusCode = (HttpStatusCode)int.Parse(httpStatusCode);
+                        if (statusCode != HttpStatusCode.OK)
+                        {
+                            var reasonPhrase = statusMatch.Result("${reasonPhrase}");
+                            throw new ProxyException(string.Format("HTTP: Status code {0}, \"{1}\"", httpStatusCode,
+                                reasonPhrase));
+                        }
+                    }
+
+                    continue;
+                }
+
+                // continue on parsing message headers coming from the server
+                var headerMatch = httpHeaderRe.Match(response);
+                if (headerMatch.Success)
+                {
+                    var fieldName = headerMatch.Result("${fieldName}");
+                    if (fieldName.Equals("Content-Length", StringComparison.OrdinalIgnoreCase))
+                    {
+                        contentLength = int.Parse(headerMatch.Result("${fieldValue}"));
+                    }
+                    continue;
+                }
+
+                // check if we've reached the CRLF which separates request line and headers from the message body
+                if (response.Length == 0)
+                {
+                    //  read response body if specified
+                    if (contentLength > 0)
+                    {
+                        var contentBody = new byte[contentLength];
+                        SocketRead(socket, contentBody, 0, contentLength);
+                    }
+                    break;
+                }
+            }
+
+            if (statusCode == null)
+            {
+                throw new ProxyException("HTTP response does not contain status line.");
+            }
+
+            return socket;
+        }
+
+        /// <summary>
+        /// Performs a blocking read on the socket until a line is read.
+        /// </summary>
+        /// <param name="socket">The <see cref="Socket"/> to read from.</param>
+        /// <param name="timeout">A <see cref="TimeSpan"/> that represents the time to wait until a line is read.</param>
+        /// <exception cref="SshOperationTimeoutException">The read has timed-out.</exception>
+        /// <exception cref="SocketException">An error occurred when trying to access the socket.</exception>
+        /// <returns>
+        /// The line read from the socket, or <c>null</c> when the remote server has shutdown and all data has been received.
+        /// </returns>
+        private static string SocketReadLine(Socket socket, TimeSpan timeout)
+        {
+            var encoding = SshData.Ascii;
+            var buffer = new List<byte>();
+            var data = new byte[1];
+
+            // read data one byte at a time to find end of line and leave any unhandled information in the buffer
+            // to be processed by subsequent invocations
+            do
+            {
+                var bytesRead = SocketAbstraction.Read(socket, data, 0, data.Length, timeout);
+                if (bytesRead == 0)
+                    // the remote server shut down the socket
+                    break;
+
+                var b = data[0];
+
+                if (b == Session.LineFeed && buffer.Count > 1 && buffer[buffer.Count - 1] == Session.CarriageReturn)
+                {
+                    // Return line without CR
+                    return encoding.GetString(buffer.ToArray(), 0, buffer.Count - 1);
+                }
+
+                buffer.Add(b);
+            }
+            while (true);
+
+            if (buffer.Count == 0)
+            {
+                return null;
+            }
+
+            return encoding.GetString(buffer.ToArray(), 0, buffer.Count);
+        }
+    }
+}

src/Renci.SshNet/Connection/IConnector.cs

@@ -0,0 +1,9 @@
+using System.Net.Sockets;
+
+namespace Renci.SshNet.Connection
+{
+    internal interface IConnector
+    {
+        Socket Connect(IConnectionInfo connectionInfo);
+    }
+}

src/Renci.SshNet/Connection/Socks4Connector.cs

@@ -0,0 +1,103 @@
+using Renci.SshNet.Abstractions;
+using Renci.SshNet.Common;
+using System;
+using System.Net.Sockets;
+
+namespace Renci.SshNet.Connection
+{
+    internal class Socks4Connector : ConnectorBase
+    {
+        public override Socket Connect(IConnectionInfo connectionInfo)
+        {
+            var socket = SocketConnect(connectionInfo.ProxyHost, connectionInfo.ProxyPort, connectionInfo.Timeout);
+
+            var connectionRequest = CreateSocks4ConnectionRequest(connectionInfo.Host, (ushort)connectionInfo.Port, connectionInfo.ProxyUsername);
+            SocketAbstraction.Send(socket, connectionRequest);
+
+            //  Read null byte
+            if (SocketReadByte(socket) != 0)
+            {
+                throw new ProxyException("SOCKS4: Null is expected.");
+            }
+
+            //  Read response code
+            var code = SocketReadByte(socket);
+
+            switch (code)
+            {
+                case 0x5a:
+                    break;
+                case 0x5b:
+                    throw new ProxyException("SOCKS4: Connection rejected.");
+                case 0x5c:
+                    throw new ProxyException("SOCKS4: Client is not running identd or not reachable from the server.");
+                case 0x5d:
+                    throw new ProxyException("SOCKS4: Client's identd could not confirm the user ID string in the request.");
+                default:
+                    throw new ProxyException("SOCKS4: Not valid response.");
+            }
+
+            var dummyBuffer = new byte[6]; // field 3 (2 bytes) and field 4 (4) should be ignored
+            SocketRead(socket, dummyBuffer, 0, 6);
+
+            return socket;
+        }
+
+        private static byte[] CreateSocks4ConnectionRequest(string hostname, ushort port, string username)
+        {
+            var addressBytes = GetSocks4DestinationAddress(hostname);
+
+            var connectionRequest = new byte
+                [
+                    // SOCKS version number
+                    1 +
+                    // Command code
+                    1 +
+                    // Port number
+                    2 +
+                    // IP address
+                    addressBytes.Length +
+                    // Username
+                    username.Length +
+                    // Null terminator
+                    1
+                ];
+
+            var index = 0;
+
+            // SOCKS version number
+            connectionRequest[index++] = 0x04;
+
+            // Command code
+            connectionRequest[index++] = 0x01; // establish a TCP/IP stream connection
+
+            // Port number
+            Pack.UInt16ToBigEndian(port, connectionRequest, index);
+            index += 2;
+
+            // Address
+            Buffer.BlockCopy(addressBytes, 0, connectionRequest, index, addressBytes.Length);
+            index += addressBytes.Length;
+
+            connectionRequest[index] = 0x00;
+
+            return connectionRequest;
+        }
+
+        private static byte[] GetSocks4DestinationAddress(string hostname)
+        {
+            var addresses = DnsAbstraction.GetHostAddresses(hostname);
+
+            for (var i = 0; i < addresses.Length; i++)
+            {
+                var address = addresses[i];
+                if (address.AddressFamily == AddressFamily.InterNetwork)
+                {
+                    return address.GetAddressBytes();
+                }
+            }
+
+            throw new ProxyException(string.Format("SOCKS4 only supports IPv4. No such address found for '{0}'.", hostname));
+        }
+    }
+}