public override void Handle(ProxyRequest req)
{
using (var proxyStreamSsl = new SslStream(this.ProxyStream, true))
{
if (req.KeepAlive)
{
this.ProxyStream.Write(ConnectionEstablishedKA, 0, ConnectionEstablishedKA.Length);
}
else
{
this.ProxyStream.Write(ConnectionEstablished, 0, ConnectionEstablished.Length);
}
proxyStreamSsl.AuthenticateAsServer(this.m_certificate, false, this.m_sslProtocols, false);
req.Dispose();
while (ProxyRequest.TryParse(proxyStreamSsl, true, out req))
{
using (req)
using (var resp = new ProxyResponse(proxyStreamSsl))
{
try
{
this.m_handler(new ProxyContext(req, resp));
}
catch
{
if (!resp.HeaderSent)
{
resp.Headers.Clear();
resp.StatusCode = HttpStatusCode.InternalServerError;
}
throw;
}
}
if (!req.KeepAlive)
{
break;
}
}
}
}
public override void Handle(ProxyRequest req)
{
do
{
using (req)
using (var resp = new ProxyResponse(this.ProxyStream))
{
if (req.KeepAlive)
{
resp.Headers.Set(HttpResponseHeader.Connection, "Keep-Alive");
resp.Headers.Set(HttpResponseHeader.KeepAlive, "timeout=30");
}
this.m_handler(new ProxyContext(req, resp));
if (!req.KeepAlive)
{
break;
}
}
} while (ProxyRequest.TryParse(this.ProxyStream, false, out req));
}
public override void Handle(ProxyRequest req)
{
HttpWebRequest hreq = null;
this.CancelSource.Token.Register(() =>
{
try
{
hreq.Abort();
}
catch
{
}
});
do
{
using (req)
using (var resp = new ProxyResponse(this.ProxyStream))
{
hreq = req.CreateRequest(null, true) as HttpWebRequest;
if (req.RequestBodyReader != null)
{
var hreqStream = hreq.GetRequestStream();
req.RequestBodyReader.CopyTo(hreqStream);
}
HttpWebResponse hresp = null;
try
{
hresp = hreq.GetResponse() as HttpWebResponse;
}
catch (WebException ex)
{
hresp = ex.Response as HttpWebResponse;
}
catch
{
}
if (hresp == null)
{
resp.StatusCode = HttpStatusCode.InternalServerError;
req.RequestBodyReader?.CopyTo(Stream.Null);
}
else
{
using (hresp)
{
if (req.KeepAlive)
{
resp.Headers.Set(HttpResponseHeader.Connection, "Keep-Alive");
resp.Headers.Set(HttpResponseHeader.KeepAlive, "timeout=30");
}
using (var hrespBody = hresp.GetResponseStream())
resp.FromHttpWebResponse(hresp, hrespBody);
}
}
if (!req.KeepAlive)
{
break;
}
}
} while (ProxyRequest.TryParse(this.ProxyStream, false, out req));
}
private void SocketThreadSub(ProxyStream proxyStream)
{
// https 연결인지, plain 인지 확인하는 과정
// ContentType type
// https://tools.ietf.org/html/rfc5246#page-41
var buff = new byte[1];
var read = proxyStream.Peek(buff, 0, buff.Length);
if (read != buff.Length)
{
throw new NotSupportedException();
}
if (buff[0] == 22)
{
var ssl = new SslStream(proxyStream, false);
ssl.AuthenticateAsServer(Certificates.Client, false, SslProtocol, false);
proxyStream = new ProxyStream(ssl);
}
Handler handler = null;
if (!ProxyRequest.TryParse(proxyStream, false, out var req))
{
return;
}
using (req)
{
// HTTPS
if (req.Method == "CONNECT")
{
// 호스트 확인하고 처리
switch (req.RemoteHost)
{
case "userstream.twitter.com":
case "api.twitter.com":
case "localhost":
case "127.0.0.1":
handler = new TunnelSslMitm(proxyStream, this.m_tunnelCancel.Token, Certificates.Client, SslProtocol, this.HandleContext);
break;
default:
handler = new TunnelSslForward(proxyStream, this.m_tunnelCancel.Token);
break;
}
}
// HTTP
else
{
// 호스트 확인하고 처리
switch (req.RemoteHost)
{
case "localhost":
case "127.0.0.1":
handler = new HandlerPlain(proxyStream, this.m_tunnelCancel.Token, this.HandleContext);
break;
default:
handler = new TunnelPlain(proxyStream, this.m_tunnelCancel.Token);
break;
}
}
using (handler)
handler.Handle(req);
}
}
