493 lines
14 KiB
C#
493 lines
14 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Net.Sockets;
|
|
using System.Text;
|
|
using System.Text.RegularExpressions;
|
|
using Shadowsocks.ForwardProxy;
|
|
using Shadowsocks.Util.Sockets;
|
|
|
|
namespace Shadowsocks.Controller.Service
|
|
{
|
|
class Http2Socks5 : Listener.Service
|
|
{
|
|
|
|
private readonly ByteSearch.SearchTarget _connectSearch =
|
|
new ByteSearch.SearchTarget(Encoding.UTF8.GetBytes("HTTP"));
|
|
|
|
private readonly int _socks5Port;
|
|
|
|
public Http2Socks5(int socks5Port)
|
|
{
|
|
_socks5Port = socks5Port;
|
|
}
|
|
|
|
public override bool Handle(byte[] firstPacket, int length, Socket socket, object state)
|
|
{
|
|
if (socket.ProtocolType != ProtocolType.Tcp)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (_connectSearch.SearchIn(firstPacket, 0, length) != -1)
|
|
{
|
|
new HttpHandler(_socks5Port, firstPacket, length, socket);
|
|
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private class HttpHandler
|
|
{
|
|
private const string HTTP_CRLF = "\r\n";
|
|
|
|
private const string HTTP_CONNECT_200 =
|
|
"HTTP/1.1 200 Connection established" + HTTP_CRLF +
|
|
"Proxy-Connection: close" + HTTP_CRLF +
|
|
"Proxy-Agent: Shadowsocks" + HTTP_CRLF +
|
|
"" + HTTP_CRLF; // End with an empty line
|
|
|
|
private readonly WrappedSocket _localSocket;
|
|
private readonly int _socks5Port;
|
|
private Socks5Proxy _socks5;
|
|
|
|
|
|
private bool _closed = false;
|
|
private bool _localShutdown = false;
|
|
private bool _remoteShutdown = false;
|
|
private readonly object _Lock = new object();
|
|
|
|
|
|
private const int RecvSize = 16384;
|
|
// remote receive buffer
|
|
private readonly byte[] _remoteRecvBuffer = new byte[RecvSize];
|
|
// connection receive buffer
|
|
private readonly byte[] _connetionRecvBuffer = new byte[RecvSize];
|
|
|
|
|
|
public HttpHandler(int socks5Port, byte[] firstPacket, int length, Socket socket)
|
|
{
|
|
_socks5Port = socks5Port;
|
|
_localSocket = new WrappedSocket(socket);
|
|
_localSocket.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.NoDelay, true);
|
|
new LineReader(_localSocket, firstPacket, 0, length, OnLineRead, OnException, OnFinish,
|
|
Encoding.UTF8, HTTP_CRLF, 1024, null);
|
|
}
|
|
|
|
private void CheckClose()
|
|
{
|
|
if (_localShutdown && _remoteShutdown)
|
|
{
|
|
Close();
|
|
}
|
|
}
|
|
|
|
private void Close()
|
|
{
|
|
lock (_Lock)
|
|
{
|
|
if (_closed)
|
|
{
|
|
return;
|
|
}
|
|
_closed = true;
|
|
}
|
|
|
|
_localSocket.Dispose();
|
|
_socks5?.Close();
|
|
}
|
|
|
|
private byte[] _lastBytes;
|
|
private int _lastBytesIndex;
|
|
private int _lastBytesLength;
|
|
|
|
#region Socks5 Process
|
|
|
|
private void ProxyConnectCallback(IAsyncResult ar)
|
|
{
|
|
if (_closed)
|
|
{
|
|
return;
|
|
}
|
|
|
|
try
|
|
{
|
|
_socks5.EndConnectProxy(ar);
|
|
|
|
_socks5.BeginConnectDest(SocketUtil.GetEndPoint(_targetHost, _targetPort), ConnectCallback, null);
|
|
}
|
|
catch (ArgumentException)
|
|
{
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Logging.LogUsefulException(e);
|
|
Close();
|
|
}
|
|
}
|
|
|
|
private void ConnectCallback(IAsyncResult ar)
|
|
{
|
|
if (_closed)
|
|
{
|
|
return;
|
|
}
|
|
|
|
try
|
|
{
|
|
_socks5.EndConnectDest(ar);
|
|
|
|
if (_isConnect)
|
|
{
|
|
// http connect response
|
|
SendConnectResponse();
|
|
}
|
|
else
|
|
{
|
|
// send header
|
|
SendHeader();
|
|
}
|
|
}
|
|
catch (ArgumentException)
|
|
{
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Logging.LogUsefulException(e);
|
|
Close();
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region CONNECT
|
|
|
|
private void SendConnectResponse()
|
|
{
|
|
var b = Encoding.UTF8.GetBytes(HTTP_CONNECT_200);
|
|
_localSocket.BeginSend(b, 0, b.Length, SocketFlags.None, Http200SendCallback, null);
|
|
}
|
|
|
|
private void Http200SendCallback(IAsyncResult ar)
|
|
{
|
|
if (_closed)
|
|
{
|
|
return;
|
|
}
|
|
|
|
try
|
|
{
|
|
_localSocket.EndSend(ar);
|
|
|
|
StartPipe();
|
|
}
|
|
catch (ArgumentException)
|
|
{
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Logging.LogUsefulException(e);
|
|
Close();
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Other http method except CONNECT
|
|
|
|
private void SendHeader()
|
|
{
|
|
var h = _headers.Dequeue() + HTTP_CRLF;
|
|
var len = Encoding.UTF8.GetBytes(h, 0, h.Length, _connetionRecvBuffer, 0);
|
|
_socks5.BeginSend(_connetionRecvBuffer, 0, len, SocketFlags.None, HeaderSendCallback, null);
|
|
|
|
}
|
|
|
|
private void HeaderSendCallback(IAsyncResult ar)
|
|
{
|
|
if (_closed)
|
|
{
|
|
return;
|
|
}
|
|
|
|
try
|
|
{
|
|
_socks5.EndSend(ar);
|
|
|
|
if (_headers.Count > 0)
|
|
{
|
|
SendHeader();
|
|
}
|
|
else
|
|
{
|
|
StartPipe();
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Logging.LogUsefulException(e);
|
|
Close();
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Pipe
|
|
|
|
private void StartPipe()
|
|
{
|
|
if (_closed)
|
|
{
|
|
return;
|
|
}
|
|
|
|
try
|
|
{
|
|
_socks5.BeginReceive(_remoteRecvBuffer, 0, RecvSize, 0,
|
|
PipeRemoteReceiveCallback, null);
|
|
|
|
if (_lastBytesLength > 0)
|
|
{
|
|
_socks5.BeginSend(_lastBytes, _lastBytesIndex, _lastBytesLength, SocketFlags.None,
|
|
PipeRemoteSendCallback, null);
|
|
}
|
|
else
|
|
{
|
|
_localSocket.BeginReceive(_connetionRecvBuffer, 0, RecvSize, 0,
|
|
PipeConnectionReceiveCallback, null);
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Logging.LogUsefulException(e);
|
|
Close();
|
|
}
|
|
}
|
|
|
|
private void PipeRemoteReceiveCallback(IAsyncResult ar)
|
|
{
|
|
if (_closed)
|
|
{
|
|
return;
|
|
}
|
|
try
|
|
{
|
|
int bytesRead = _socks5.EndReceive(ar);
|
|
Logging.Debug("Read from remote: " + bytesRead);
|
|
|
|
if (bytesRead > 0)
|
|
{
|
|
_localSocket.BeginSend(_remoteRecvBuffer, 0, bytesRead, 0, PipeConnectionSendCallback, null);
|
|
}
|
|
else
|
|
{
|
|
_localSocket.Shutdown(SocketShutdown.Send);
|
|
_localShutdown = true;
|
|
CheckClose();
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Logging.LogUsefulException(e);
|
|
Close();
|
|
}
|
|
}
|
|
|
|
private void PipeConnectionReceiveCallback(IAsyncResult ar)
|
|
{
|
|
if (_closed)
|
|
{
|
|
return;
|
|
}
|
|
try
|
|
{
|
|
int bytesRead = _localSocket.EndReceive(ar);
|
|
Logging.Debug("Read from local: " + bytesRead);
|
|
|
|
if (bytesRead > 0)
|
|
{
|
|
_socks5.BeginSend(_connetionRecvBuffer, 0, bytesRead, 0, PipeRemoteSendCallback, null);
|
|
}
|
|
else
|
|
{
|
|
_socks5.Shutdown(SocketShutdown.Send);
|
|
_remoteShutdown = true;
|
|
CheckClose();
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Logging.LogUsefulException(e);
|
|
Close();
|
|
}
|
|
}
|
|
|
|
private void PipeRemoteSendCallback(IAsyncResult ar)
|
|
{
|
|
if (_closed)
|
|
{
|
|
return;
|
|
}
|
|
try
|
|
{
|
|
_socks5.EndSend(ar);
|
|
_localSocket.BeginReceive(_connetionRecvBuffer, 0, RecvSize, 0,
|
|
PipeConnectionReceiveCallback, null);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Logging.LogUsefulException(e);
|
|
Close();
|
|
}
|
|
}
|
|
|
|
private void PipeConnectionSendCallback(IAsyncResult ar)
|
|
{
|
|
if (_closed)
|
|
{
|
|
return;
|
|
}
|
|
try
|
|
{
|
|
_localSocket.EndSend(ar);
|
|
_socks5.BeginReceive(_remoteRecvBuffer, 0, RecvSize, 0,
|
|
PipeRemoteReceiveCallback, null);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Logging.LogUsefulException(e);
|
|
Close();
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Header Parse
|
|
|
|
private void OnException(Exception ex, object state)
|
|
{
|
|
throw ex;
|
|
}
|
|
|
|
private static readonly Regex HttpRequestHeaderRegex = new Regex(@"^([A-Z]+?) ([^\s]+) HTTP/1\.\d$");
|
|
|
|
private int _requestLineCount = 0;
|
|
private volatile bool _isConnect = false;
|
|
|
|
private string _targetHost;
|
|
private int _targetPort;
|
|
private readonly Queue<string> _headers = new Queue<string>();
|
|
|
|
private bool OnLineRead(string line, object state)
|
|
{
|
|
if (_closed)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
Logging.Debug(line);
|
|
|
|
if (_requestLineCount == 0)
|
|
{
|
|
var m = HttpRequestHeaderRegex.Match(line);
|
|
if (m.Success)
|
|
{
|
|
var method = m.Groups[1].Value;
|
|
|
|
if (method == "CONNECT")
|
|
{
|
|
_isConnect = true;
|
|
|
|
var location = m.Groups[2].Value;
|
|
var locs = location.Split(':');
|
|
_targetHost = locs[0];
|
|
if (locs.Length > 1)
|
|
{
|
|
if (!int.TryParse(locs[1], out _targetPort))
|
|
{
|
|
throw new Exception("Bad http header: " + line);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_targetPort = 80;
|
|
}
|
|
}
|
|
|
|
_headers.Enqueue(line);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (line.IsNullOrEmpty())
|
|
{
|
|
_headers.Enqueue("");
|
|
return true;
|
|
}
|
|
if (!line.StartsWith("Proxy-"))
|
|
{
|
|
_headers.Enqueue(line);
|
|
}
|
|
|
|
if (!_isConnect)
|
|
{
|
|
if (line.StartsWith("Host: "))
|
|
{
|
|
var location = line.Substring(6).Trim();
|
|
var locs = location.Split(':');
|
|
_targetHost = locs[0];
|
|
if (locs.Length > 1)
|
|
{
|
|
if (!int.TryParse(locs[1], out _targetPort))
|
|
{
|
|
throw new Exception("Bad http header: " + line);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_targetPort = 80;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
_requestLineCount++;
|
|
|
|
return false;
|
|
}
|
|
|
|
private void OnFinish(byte[] lastBytes, int index, int length, object state)
|
|
{
|
|
if (_closed)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (_targetHost == null)
|
|
{
|
|
Logging.Error("Unkonwn host");
|
|
Close();
|
|
}
|
|
else
|
|
{
|
|
if (length > 0)
|
|
{
|
|
_lastBytes = lastBytes;
|
|
_lastBytesIndex = index;
|
|
_lastBytesLength = length;
|
|
}
|
|
|
|
// Start socks5 conn
|
|
_socks5 = new Socks5Proxy();
|
|
|
|
_socks5.BeginConnectProxy(SocketUtil.GetEndPoint("127.0.0.1", _socks5Port), ProxyConnectCallback,
|
|
null);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
}
|
|
}
|
|
}
|