Socks5ToHttpProxyServer

using MihaZupan;
using System;
using System.IO;
using System.Linq;
using System.Net;
using System.Threading;

namespace Socks5ToHttpProxy
{
    public class Program
    {
        private static void Main(string[] args)
        {

            var listener = new HttpListener();
            listener.Prefixes.Add("http://*:46353/");
            listener.Start();
            Console.WriteLine("Listening...");
            while (true)
            {
                var ctx = listener.GetContext();
                new Thread(new Relay(ctx, args).ProcessRequest).Start();
            }
        }
    }

    public class Relay
    {

        string host;
        int port;
        string user;
        string passwd;
        private readonly HttpListenerContext originalContext;

        public Relay(HttpListenerContext originalContext, string[] args)
        {
            this.originalContext = originalContext;
            host = args[0];
            port = int.Parse(args[1]);
            user = args[2];
            passwd = args[3];
        }

        public void ProcessRequest()
        {
            string rawUrl = originalContext.Request.RawUrl;
            Console.WriteLine("Proxy receive a request for: " + rawUrl);

            var relayRequest = (HttpWebRequest) WebRequest.Create(rawUrl);
            relayRequest.KeepAlive = true;
            try
            {

                foreach (var item in originalContext.Request.AcceptTypes)
                {
                    relayRequest.Accept += item + " ";
                }
            }
            catch (Exception)
            {
            }

            try
            {
                relayRequest.CookieContainer.Add(originalContext.Request.Cookies);
            }
            catch
            {

            }
            var proxy = new HttpToSocks5Proxy(host, port, user, passwd);
            relayRequest.Proxy = proxy;
            relayRequest.UserAgent = originalContext.Request.UserAgent;

            var requestData = new RequestState(relayRequest, originalContext);
            relayRequest.BeginGetResponse(ResponseCallBack, requestData);
        }

        private static void ResponseCallBack(IAsyncResult asynchronousResult)
        {
            var requestData = (RequestState) asynchronousResult.AsyncState;
            Console.WriteLine("Proxy receive a response from " + requestData.context.Request.RawUrl);
            try
            {
                using (var responseFromWebSiteBeingRelayed = (HttpWebResponse)requestData.webRequest.EndGetResponse(asynchronousResult))
                {
                    using (var responseStreamFromWebSiteBeingRelayed = responseFromWebSiteBeingRelayed.GetResponseStream())
                    {
                        var originalResponse = requestData.context.Response;

                        if (responseFromWebSiteBeingRelayed.ContentType.Contains("text/html"))
                        {
                            try
                            {

                                var reader = new StreamReader(responseStreamFromWebSiteBeingRelayed);
                                string html = reader.ReadToEnd();
                                byte[] byteArray = System.Text.Encoding.UTF8.GetBytes(html);
                                var stream = new MemoryStream(byteArray);
                                stream.CopyTo(originalResponse.OutputStream);
                            }
                            catch (Exception ex)
                            {
                                Console.WriteLine(ex.ToString());
                            }
                        }
                        else
                        {
                            try
                            {

                                responseStreamFromWebSiteBeingRelayed.CopyTo(originalResponse.OutputStream);
                            }
                            catch (Exception ex)
                            {
                                Console.WriteLine(ex.ToString());
                            }
                        }
                        originalResponse.OutputStream.Close();
                    }
                }
            }
            catch (Exception)
            {

            }

        }
    }

    public class RequestState
    {
        public readonly HttpWebRequest webRequest;
        public readonly HttpListenerContext context;

        public RequestState(HttpWebRequest request, HttpListenerContext context)
        {
            webRequest = request;
            this.context = context;
        }
    }

}