Results 1 to 7 of 7

Thread: [MARAPETS] Looking for BETA testers for MaraRumble v1.0.0

  1. #1

    Rambo's Avatar
    Joined
    Sep 2013
    Posts
    136
    Userbars
    1
    Thanks
    19
    Thanked
    29/25
    DL/UL
    11/7
    Mentioned
    25 times
    Time Online
    4d 3h 14m
    Avg. Time Online
    1m

    [MARAPETS] Looking for BETA testers for MaraRumble v1.0.0

    Hey, I am looking for testers for a new project I am working on, MaraRumble. It is the ultimate "Daily Doer", but compares to more of the type of quality as Stealth Core, but for marapets. I can't go into much detail yet, but I have a nice beta version done. I also have a somewhat stable, version with less features submitted to the Downloads Section. So if your interested in helping me test for the big v1.0.0 release, please shoot me a message.

    There are 3 spots open:

    1. [OPEN]
    2. [OPEN]
    3. [OPEN]

    Can't wait to work with you : )

  2. The Following User Says Thank You to Rambo For This Useful Post:

    I_royalty_I (03-19-2014)

  3. #2
    Saiyan Race
    j03's Avatar
    Joined
    Dec 2011
    Posts
    13,722
    Userbars
    166
    Thanks
    5,906
    Thanked
    33,077/6,608
    DL/UL
    23/36
    Mentioned
    3,867 times
    Time Online
    563d 5h 25m
    Avg. Time Online
    3h 13m
    Glad to see a Stealth Core-inspired program in the works! Looking forward to seeing this.
    (you need an account to see links)
    (you need an account to see links)(you need an account to see links)

    ------------------------
    [02/24/2013] Stealth CORE is made into the first standalone Neopets auto-player.
    ------------------------


  4. #3

    Rambo's Avatar
    Joined
    Sep 2013
    Posts
    136
    Userbars
    1
    Thanks
    19
    Thanked
    29/25
    DL/UL
    11/7
    Mentioned
    25 times
    Time Online
    4d 3h 14m
    Avg. Time Online
    1m
    @(you need an account to see links) I am thinking of maybe rewriting in in c# later. Do you know of a good wrapper? (The thread you showed me didn't give a link to download)
    Last edited by Rambo; 03-19-2014 at 01:05 PM.

  5. #4
    Saiyan Race
    j03's Avatar
    Joined
    Dec 2011
    Posts
    13,722
    Userbars
    166
    Thanks
    5,906
    Thanked
    33,077/6,608
    DL/UL
    23/36
    Mentioned
    3,867 times
    Time Online
    563d 5h 25m
    Avg. Time Online
    3h 13m
    Here is a basic one I would recommend only for learning purposes, NOT for apps that you may want to present in a professional manner unless you heavily modify it for efficiency:

    Code:
    using System;
    using System.Collections.Generic;
    using System.Drawing;
    using System.Text;
    using System.Windows.Forms;
    using System.Text.RegularExpressions;
    using System.IO;
    using System.IO.Compression;
    using System.Net.Sockets;
    
    namespace goodwrap
    {
        class wrapper
        {
            private TcpClient client;
            IDictionary<string, string> colCookies = new Dictionary<string, string>();
            public string strCookies;
            public string LastPage;
    
            public string Request(string Method, string URL, string Referer)
            {
                string Host = null;
                string strFile = null;
                string strPost = null;
                int pos = 0;
    
                if (Referer == null)
                {
                    Referer = LastPage;
                }
                if (URL.Contains("http://"))
                {
                    Host = URL.Substring(7);
                }
                else
                {
                    Host = URL;
                }
                if (Host.Contains("/"))
                {
                    pos = Host.IndexOf("/", 0);
                    strFile = Host.Substring(pos);
                    Host = Host.Substring(0, pos);
                }
                else
                {
                    strFile = "/";
                }
                if (Method == "POST")
                {
                    pos = strFile.IndexOf("?");
                    if (pos != -1)
                    {
                        strPost = strFile.Substring(pos + 1);
                        strFile = strFile.Substring(0, pos);
                    }
                    else
                    {
                        strPost = null;
                    }
                }
                LastPage = URL;
    
                string ReqHeaders = null;
                if (Method == "GET" || Method == "PIC")
                {
                    ReqHeaders = "GET" + " " + strFile + " HTTP/1.1" + "\r\n"
                    + "Host: " + Host + "\r\n"
                    + "User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.0; en-US; rv:1.9.0.4) Gecko/2008102920 Firefox/3.0.4 (.NET CLR 3.5.30729)" + "\r\n"
                    + "Accept: text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5" + "\r\n"
                    + "Accept-Language: en-us,en;q=0.5" + "\r\n"
                    + "Accept-Encoding: gzip, deflate" + "\r\n"
                    + "Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7" + "\r\n"
                    + "Keep-Alive: 300" + "\r\n"
                    + "Connection: keep-alive" + "\r\n"
                    + "Referer: " + Referer + "\r\n"
                    + "Cookie: " + strCookies + "\r\n" + "\r\n";
                }
                else
                {
                    ReqHeaders = "POST " + strFile + " HTTP/1.1" + "\r\n"
                    + "Host: " + Host + "\r\n"
                    + "User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.0; en-US; rv:1.9.0.4) Gecko/2008102920 Firefox/3.0.4 (.NET CLR 3.5.30729)" + "\r\n"
                    + "Accept: text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5" + "\r\n"
                    + "Accept-Language: en-us,en;q=0.5" + "\r\n"
                    + "Accept-Encoding: gzip, deflate" + "\r\n"
                    + "Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7" + "\r\n"
                    + "Keep-Alive: 300" + "\r\n"
                    + "Connection: keep-alive" + "\r\n"
                    + "Referer: " + Referer + "\r\n"
                    + "Cookie: " + strCookies + "\r\n"
                    + "Content-Type: application/x-www-form-urlencoded" + "\r\n"
                    + "Content-Length: " + strPost.Length.ToString() + "\r\n"
                    + "Connection: close" + "\r\n" + "\r\n"
                    + strPost;
                }
                if (Method == "PIC") ReqHeaders.Replace("Accept: text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5", "Accept: image/png,*/*;q=0.5");
    
                client = new TcpClient(Host, 80);
                Byte[] headers = System.Text.Encoding.ASCII.GetBytes(ReqHeaders);
                NetworkStream ns = client.GetStream();
                ns.Write(headers, 0, headers.Length);
                StreamReader sr = new StreamReader(ns, Encoding.Default);
                String strHTML = sr.ReadToEnd();
    
                string[] strParts = Regex.Split(strHTML, Environment.NewLine + Environment.NewLine);
                strCookies = ParseCookies(strParts[0]);
                if (strParts[0].Contains("Content-Encoding"))
                {
                    strParts[1] = DecompressGzip(strParts[1]);
                }
                return strParts[0] + Environment.NewLine + Environment.NewLine + strParts[1];
            }
    
            public string DecompressGzip(string compressed)
            {
                MemoryStream memStream = new MemoryStream(System.Text.Encoding.Default.GetBytes(compressed));
                GZipStream decompressStream = new GZipStream(memStream, CompressionMode.Decompress);
    
                byte[] endBytes = new byte[4];
                int position = (int)memStream.Length - 4;
                memStream.Position = position;
                memStream.Read(endBytes, 0, 4);
                memStream.Position = 0;
                byte[] buffer = new byte[BitConverter.ToInt32(endBytes, 0) + 100];
                int offset = 0;
                int total = 0;
                while (true)
                {
                    int o = decompressStream.Read(buffer, offset, 100);
                    if (o == 0) break;
                    offset += o;
                    total += o;
                }
                return Encoding.ASCII.GetString(buffer);
            }
    
            public string NeoLogin(string user, string pass, ref bool loggedIn)
            {
                string strHTML = null;
                Request("GET", "http://neopets.com/loginpage.phtml", "http://google.com");
                Pause(1);
                Request("POST", "http://www.neopets.com/hi.phtml?destination=%2Fpetcentral.phtml&username=" + user, "http://neopets.com/loginpage.phtml");
                Pause(1);
                strHTML = Request("POST", "http://www.neopets.com/login.phtml?username=" + user + "&password=" + pass + "&destination=%2Fpetcentral.phtml", "http://neopets.com/hi.phtml");
                if (strHTML.Contains("Set-Cookie: neologin="))
                {
                    loggedIn = true;
                    return "Logged In";
                }
                else if (strHTML.Contains("too many times"))
                {
                    loggedIn = false;
                    return "To Many Login Attempts";
                }
                else if (strHTML.Contains("badpassword"))
                {
                    loggedIn = false;
                    return "Wrong Password";
                }
                else if (strHTML.Contains("frozen"))
                {
                    loggedIn = false;
                    return "Account Frozen";
                }
                else if (strHTML.Contains("just a technical problem"))
                {
                    loggedIn = false;
                    return "Neopets is down for maintenance.";
                }
                else
                {
                    loggedIn = false;
                    return strHTML;
                }
            }
    
            private static void Pause(double seconds)
            {
                double num = seconds * 1000;
                DateTime t1 = DateTime.Now, t2 = DateTime.Now;
                TimeSpan tmDiff = t2 - t1;
                while (Convert.ToDouble(tmDiff.TotalMilliseconds.ToString()) < num)
                {
                    t2 = DateTime.Now;
                    tmDiff = t2 - t1;
                    Application.DoEvents();
                }
            }
    
            public string StripHeaders(string strSource)
            {
                string[] strParts = Regex.Split(strSource, Environment.NewLine + Environment.NewLine);
                return strParts[1];
            }
    
            public Bitmap GrabPic(string strURL)
            {
                MemoryStream memStream = new MemoryStream(System.Text.Encoding.Default.GetBytes(StripHeaders(Request("GET", strURL, LastPage))));
                Bitmap bitmap = new Bitmap(memStream);
                return bitmap;
            }
    
            public void ClearCookies()
            {
                colCookies.Clear();
                strCookies = null;
            }
    
            public string ParseCookies(string Headers)
            {//Credit's to Mystical for RegEx
                string ParseCookies = null;
                MatchCollection matches;
                Regex reg = new Regex("set-cookie:\\s*([^=]+)=([^;]+);", RegexOptions.IgnoreCase);
                if (reg.IsMatch(Headers))
                {
                    matches = reg.Matches(Headers);
                    foreach (Match m in matches)
                    {
                        if (colCookies.ContainsKey(m.Groups[1].ToString()))
                        {
                            colCookies.Remove(m.Groups[1].ToString());
                            colCookies.Add(m.Groups[1].ToString(), m.Groups[1].ToString() + "=" + m.Groups[2].ToString());
                        }
                        else
                        {
                            colCookies.Add(m.Groups[1].ToString(), m.Groups[1].ToString() + "=" + m.Groups[2].ToString());
                        }
                    }
                }
                foreach (KeyValuePair<string, string> item in colCookies)
                {
                    ParseCookies = ParseCookies + item.Value.ToString() + "; ";
                }
                return ParseCookies;
    
            }
        }
    }
    It can do most of everything you'd need for a Neopets program, so that's cool. Again, when I say learning purposes, I mean you can see how some functions are handled and you can use the code for a better HTTP client.

    There is also Drew's from SDNeoClient:

    Code:
    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.Collections.Specialized;
    using System.Collections.ObjectModel;
    using System.Linq;
    using System.Text;
    using System.Net;
    using System.Net.Sockets;
    using System.Threading;
    using System.Globalization;
    using System.Text.RegularExpressions;
    
    namespace SDHttpClient
    {
        public delegate void DataReceivedEventHandler(object sender, DataReceivedEventArgs e);
        public delegate void ConnectedEventHandler(object sender, EventArgs e);
        public delegate void RequestCompletedEventHandler(object sender, EventArgs e);
    
        public class SDHttpClient
        {
            public event DataReceivedEventHandler DataReceived;
            public event ConnectedEventHandler Connected;
            public event RequestCompletedEventHandler RequestCompleted;
    
            /// <summary>
            /// The response headers from the last request
            /// </summary>
            public string ResponseHeaders
            {
                get { return this._ResponseHeaders; }
            }
    
            /// <summary>
            /// The response body from the last request
            /// </summary>
            public string ResponseBody
            {
                get { return this._ResponseBody; }
            }
    
            /// <summary>
            /// The User Agent to send in requests
            /// </summary>
            public string UserAgent
            {
                get { return this._UserAgent; }
                set { this._UserAgent = value; }
            }
    
            /// <summary>
            /// The referer to send
            /// </summary>
            public string HttpReferer
            {
                get { return this._HttpReferer; }
                set { this._HttpReferer = value; }
            }
    
            /// <summary>
            /// true to use keep-alive connections, false to send connection: close
            /// </summary>
            public bool KeepAlive
            {
                get { return this._UseKeepAlive; }
                set { this._UseKeepAlive = value; }
            }
    
            /// <summary>
            /// True to follow 300 redirects
            /// </summary>
            public bool FollowLocation
            {
                get { return this._FollowLocation; }
                set { this._FollowLocation = value; }
            }
    
            /// <summary>
            /// If the last request was cancelled
            /// </summary>
            public bool Cancelled
            {
                get { return this._Cancelled; }
            }
    
            protected const string DEFAULT_USERAGENT = "Firefox 0.3";
    
            protected string           _ResponseHeaders; // response headers from the last request
            protected string           _ResponseBody;    // response body from the last request
            protected string           _LastRequest;     // the last http request issued
            protected string           _UserAgent;       // user agent to spoof
            protected bool             _UseKeepAlive;    // send keep-alive header
            protected string           _HttpReferer;     // referer to send with the request
            protected string           _LastHttpStatusCode; // the last http response code i.e. 200, 404, 500, 302
            protected Socket           _sock; // the underlying socket to use for transport
            protected string           _LastHost;           // host that the last request was issued to
            protected bool             _WasKeepAlive;       // if the request was a keepalive request
            protected int              _LastErrorCode;      // last socket error code
            protected string           _LastErrorMessage;   // last error message
            protected ulong            _KeepAliveLastRequest; // time of the last keep-alive request
            protected int              _KeepAliveTimeout;     // keep-alive timeout
            protected string           _302Location;          // location found in the 302 redirect
            protected bool             _FollowLocation;       // automatically follow redirect responses
            protected Hashtable        _Cookies;              // hash table of cookies from the request
            protected double           _LastRequestStartTime; // start time of the last request with microseconds
            protected double           _LastRequestTotalTime; // total elapsed time of the last request with microseconds
            protected bool             _RequestInProgress;    // if a request is currently in progress
            protected bool             _CancelFlag;           // a flag raised to cancel the current operation
            protected bool             _Cancelled;            // the last request was cancelled before it could complete
    
            protected enum HTTP_STATE : int
            {
                RESPONSE_HEADER_BEGIN_H,
                RESPONSE_HEADER_BEGIN_T,
                RESPONSE_HEADER_BEGIN_T2,
                RESPONSE_HEADER_BEGIN_P,
                RESPONSE_HEADER_BEGIN_SLASH,
                RESPONSE_HEADER_BEGIN_VERMAJOR,
                RESPONSE_HEADER_BEGIN_VERDOT,
                RESPONSE_HEADER_BEGIN_VERMINOR,
                RESPONSE_HEADER_BEGIN_RESPONSECODE,
                RESPONSE_HEADER_BEGIN_MESSAGE,
                RESPONSE_HEADER_BEGIN_CR,
                RESPONSE_HEADER_BEGIN_LF,
                RESPONSE_HEADER_KEY,
                RESPONSE_HEADER_KEY_COLON,
                RESPONSE_HEADER_VALUE,
                RESPONSE_HEADER_DATA,
                RESPONSE_HEADER_CR,
                RESPONSE_HEADER_LF,
                RESPONSE_HEADER_CR2,
                RESPONSE_HEADER_LF2,
                RESPONSE_HEADER_FINISHED,
                RESPONSE_BODY_BEGIN,
                RESPONSE_READ_CHUNKED_SIZE,
                RESPONSE_READ_CHUNKED_EXTENSION,
                RESPONSE_READ_CHUNKED_SIZE_LF,
                RESPONSE_READ_CHUNKED_DATA,
                RESPONSE_READ_CHUNKED_DATA_CR,
                RESPONSE_READ_CHUNKED_DATA_LF,
                RESPONSE_READ_BODY_BYLEN,
                RESPONSE_READ_BODY_TOEND,
                RESPONSE_READ_COMPLETE
            };
    
    
            /// <summary>
            /// Create a new SDHttpClient object
            /// </summary>
            public SDHttpClient()
            {
                this._UserAgent      = DEFAULT_USERAGENT;
                this._sock           = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                this._LastHost       = "";
                this._WasKeepAlive   = false;
                this._Cookies        = new Hashtable();
                this._HttpReferer    = "";
                this._FollowLocation = false;
            }
    
            /// <summary>
            /// Perform an HTTP Get request to the URL provided with the optional referer
            /// </summary>
            /// <param name="url">The URL to fetch</param>
            /// <param name="referer">The referer to send</param>
            /// <exception cref="ArgumentException">Thrown if the url is malformed</exception>
            /// <exception cref="SDHttpClientRequestException">Thrown on failure of the request</exception>
            public void Get(string url, string referer = "")
            {
                Uri uri;
    
                try {
                    uri = new Uri(url);
                } catch (UriFormatException ex) {
                    throw new ArgumentException("Invalid URL: " + ex.Message);
                }
    
                this.HttpReferer = referer;
    
                Byte[] request = this._GetHTTPRequest("GET", uri);
    
                do {
                    if (this._CancelFlag) {
                        this._CleanupRequest();
                        return;
                    }
    
                    try {
                        this._DoRequest(request, uri);
                    } catch (SDHttpClientRequestException e) {
                        throw e;
                    }
    
                    if (this._302Location != "") {
                        uri = new Uri(uri, this._302Location);
                        request = this._GetHTTPRequest("GET", uri);
                    }
                } while (this.FollowLocation == true && this._LastHttpStatusCode == "302");
            }
    
            /// <summary>
            /// Perform an HTTP Post request to the URL provided with the post parameters and optional referer
            /// </summary>
            /// <param name="url">The URL to post to</param>
            /// <param name="postfields">The HTTP post data to send</param>
            /// <param name="referer">The referer to send</param>
            /// <exception cref="ArgumentException">Thrown if the url is malformed</exception>
            /// <exception cref="SDHttpClientRequestException">Thrown on failure of the request</exception>
            public void Post(string url, string postfields, string referer = "")
            {
                Uri uri;
    
                try {
                    uri = new Uri(url);
                } catch (UriFormatException ex) {
                    throw new ArgumentException("Invalid URL: " + ex.Message);
                }
    
                this.HttpReferer = referer;
    
                Byte[] request = this._GetHTTPRequest("POST", uri, postfields);
    
                do {
                    if (this._CancelFlag) {
                        this._CleanupRequest();
                        return;
                    }
    
                    try {
                        this._DoRequest(request, uri);
                    } catch (SDHttpClientRequestException e) {
                        throw e;
                    }
    
                    if (this._302Location != "") {
                        uri = new Uri(uri, this._302Location);
                        request = this._GetHTTPRequest("GET", uri);
                    }                    
                } while (this.FollowLocation == true && this._LastHttpStatusCode == "302");
            }
    
            /// <summary>
            /// Check if the client is busy with an operation
            /// </summary>
            /// <returns>true if a request is in process, false if not</returns>
            public bool IsBusy()
            {
                return this._RequestInProgress;
            }
    
            /// <summary>
            /// Cancel the current request immediately
            /// </summary>
            public void Cancel()
            {
                this._CancelFlag = true;
            }
    
            /// <summary>
            /// Get the CookieContainer for the specified host
            /// </summary>
            /// <param name="host">The host to get the cookies from</param>
            /// <returns>CookieContainer containing the active cookies</returns>
            public CookieContainer GetCookies(string host)
            {
                if (this._Cookies.ContainsKey(host)) {
                    return (CookieContainer)this._Cookies[host];
                } else {
                    return new CookieContainer();
                }
            }
    
            /// <summary>
            /// Set the cookies for the specified host
            /// </summary>
            /// <param name="host">The host to set cookies for</param>
            /// <param name="cookies">The cookies to set</param>
            public void SetCookies(string host, CookieContainer cookies)
            {
                this._Cookies[host] = cookies;
            }
    
            /// <summary>
            /// Get the HTTP request body for the last request issued
            /// </summary>
            /// <returns>A string containing the last request issued</returns>
            public string GetLastRequest()
            {
                return this._LastRequest;
            }
    
            /// <summary>
            /// Get the total amount of time the last request took to process from connection to completion
            /// </summary>
            /// <returns>The elapsed time in seconds</returns>
            public double GetLastRequestElapsedTime()
            {
                return this._LastRequestTotalTime;
            }
    
            /// <summary>
            /// Strip all HTML tags from the text or response body
            /// </summary>
            /// <param name="html">Optional html to strip tags from</param>
            /// <returns>The string without html tags</returns>
            public string StripTags(string html = null)
            {
                Regex re = new Regex("(?:<script[^>]*>.*?</script>)|(?:<[^>]+>)");
    
                if (html == null) {
                    if (this.ResponseBody == null) return "";
                    return re.Replace(this.ResponseBody, "");
                } else {
                    return re.Replace(html, "");
                }
            }
    
            protected void _DoRequest(Byte[] HTTPRequest, Uri uri)
            {
                this._CancelFlag = this._Cancelled = false;
                this._LastRequestStartTime = this._UnixTimestampWithMicroseconds();
                this._RequestInProgress = true;
                this._ResponseBody = "";
                this._ResponseHeaders = "";
    
                if (this._CancelFlag) {
                    this._CleanupRequest();
                    return;
                }
    
                try {
                    this._Connect(uri);
                } catch(SDHttpClientRequestException e) {
                    this._CleanupRequest();
                    throw e;
                }
    
                this._WasKeepAlive = false;
    
                Byte[] recv = new Byte[32768];
                string headers = "", body = "";
                byte c;
                int bytePointer = 0;
                Hashtable hHeaders = CollectionsUtil.CreateCaseInsensitiveHashtable();
    
                this._LastRequest = Encoding.ASCII.GetString(HTTPRequest);
    
                if (this._CancelFlag) {
                    this._CleanupRequest();
                    return;
                }
    
                Console.WriteLine("Sending.");
                try {
                    this._sock.Send(HTTPRequest, HTTPRequest.Length, 0);
                    Console.WriteLine("Sent.");
                } catch (SocketException ex) {
                    this._CleanupRequest();
                    throw new SDHttpClientRequestException(ex.Message, ex);
                }
    
                Byte[] responseBody = new Byte[0];
                int bytes = 0;
                long bytesReceived = 0;
                int resp_state = (int)HTTP_STATE.RESPONSE_HEADER_BEGIN_H;
                long contentLength = 0, contentRead = 0;
                bool connectionClose = true;
                string header = "", headerValue = "", responseCode = "", responseMessage = "";
                string contentEncoding = "", transferEncoding = "";
                string sChunkSize = "";
                int iChunkSize = 0;
                
                Console.WriteLine("Receiving Data.");
    
                this._sock.ReceiveTimeout = 1000;
                
                do {
                    try {
                        if (this._CancelFlag) {
                            this._CleanupRequest();
                            return;
                        }
    
                        bytes = this._sock.Receive(recv, recv.Length, 0);
    
                    } catch (SocketException ex) {
                        // see if this is a result of our receivetimeout
                        if (ex.SocketErrorCode == SocketError.WouldBlock ||
                            ex.SocketErrorCode == SocketError.IOPending ||
                            ex.SocketErrorCode == SocketError.NoBufferSpaceAvailable) {
                            Thread.Sleep(10);
                            continue; // go back to recv
                        }
    
                        this._LastErrorMessage = ex.Message;
                        this._LastErrorCode = ex.NativeErrorCode;
                        this._CleanupRequest();
    
                        if (ex.NativeErrorCode == 10054) {
                            throw new SDHttpClientRequestException("The connection was reset");
                        } else {
                            throw new SDHttpClientRequestException(ex.Message, ex);
                        }
                    }
                    Console.Write("Received " + bytes.ToString() + "  ");
    
                    if (resp_state > (int)HTTP_STATE.RESPONSE_HEADER_FINISHED) {
                        bytesReceived += bytes;
                    }
    
                    if (this._CancelFlag) {
                        this._CleanupRequest();
                        return;
                    }
    
                    OnDataReceivedEvent(new DataReceivedEventArgs(bytesReceived, contentLength));
    
                    for (int i = 0; resp_state != (int)HTTP_STATE.RESPONSE_READ_COMPLETE; ++i) {
                        if (i >= bytes) {
                            break; // read more data from socket
                        }
    
                        c = recv[i];
    
                        switch (resp_state) {
                            case (int)HTTP_STATE.RESPONSE_HEADER_BEGIN_H:
                                if (c == 'H') {
                                    resp_state = (int)HTTP_STATE.RESPONSE_HEADER_BEGIN_T;
                                } else {
                                    this._CleanupRequest();
                                    throw new SDHttpClientRequestException("Invalid HTTP response line, expected H");
                                }
                                
                                headers += (char)c;
                                break;
    
                            case (int)HTTP_STATE.RESPONSE_HEADER_BEGIN_T:
                                if (c == 'T') {
                                    resp_state = (int)HTTP_STATE.RESPONSE_HEADER_BEGIN_T2;
                                } else {
                                    this._CleanupRequest();
                                    throw new SDHttpClientRequestException("Invalid HTTP response line, expected HT");
                                }
    
                                headers += (char)c;
                                break;
    
                            case (int)HTTP_STATE.RESPONSE_HEADER_BEGIN_T2:
                                if (c == 'T') {
                                    resp_state = (int)HTTP_STATE.RESPONSE_HEADER_BEGIN_P;
                                } else {
                                    this._CleanupRequest();
                                    throw new SDHttpClientRequestException("Invalid HTTP response line, expected HTT");
                                }
    
                                headers += (char)c;
                                break;
    
                            case (int)HTTP_STATE.RESPONSE_HEADER_BEGIN_P:
                                if (c == 'P') {
                                    resp_state = (int)HTTP_STATE.RESPONSE_HEADER_BEGIN_SLASH;
                                } else {
                                    this._CleanupRequest();
                                    throw new SDHttpClientRequestException("Invalid HTTP response line, expected HTTP");
                                }
    
                                headers += (char)c;
                                break;
    
                            case (int)HTTP_STATE.RESPONSE_HEADER_BEGIN_SLASH:
                                if (c == '/') {
                                    resp_state = (int)HTTP_STATE.RESPONSE_HEADER_BEGIN_VERMAJOR;
                                } else {
                                    this._CleanupRequest();
                                    throw new SDHttpClientRequestException("Invalid HTTP response line, expected HTTP/");
                                }
    
                                headers += (char)c;
                                break;
    
    
                            case (int)HTTP_STATE.RESPONSE_HEADER_BEGIN_VERMAJOR:
                                if (c == '.') {
                                    resp_state = (int)HTTP_STATE.RESPONSE_HEADER_BEGIN_VERMINOR;
                                } else {
                                    if (!this._IsNumeric((char)c)) {
                                        this._CleanupRequest();
                                        throw new SDHttpClientRequestException("Invalid HTTP version");
                                    }
                                }
    
                                headers += (char)c;
                                break;
    
                            case (int)HTTP_STATE.RESPONSE_HEADER_BEGIN_VERMINOR:
                                if (c == ' ') {
                                    resp_state = (int)HTTP_STATE.RESPONSE_HEADER_BEGIN_RESPONSECODE;
                                } else {
                                    if (!this._IsNumeric((char)c)) {
                                        this._CleanupRequest();
                                        throw new SDHttpClientRequestException("Invalid HTTP version");
                                    }
                                }
    
                                headers += (char)c;
                                break;
                            
                            case (int)HTTP_STATE.RESPONSE_HEADER_BEGIN_RESPONSECODE:
                                if (this._IsNumeric((char)(c))) {
                                    responseCode += (char)c;
                                } else if (c == ' ') {
                                    if (responseCode.Length == 0) {
                                        break; // go again
                                    } else {
                                        resp_state = (int)HTTP_STATE.RESPONSE_HEADER_BEGIN_MESSAGE;
                                    }
                                } else {
                                    this._CleanupRequest();
                                    throw new SDHttpClientRequestException("Invalid response code");
                                }
    
                                headers += (char)c;
                                break;
    
                            case (int)HTTP_STATE.RESPONSE_HEADER_BEGIN_MESSAGE:
                                if (this._IsCtl((char)c)) {
                                    if (responseMessage.Length == 0) {
                                        this._CleanupRequest();
                                        throw new SDHttpClientRequestException("Expecting response message, invalid control character");
                                    } else if (c == 0x0D) {
                                        resp_state = (int)HTTP_STATE.RESPONSE_HEADER_BEGIN_LF;
                                    } else {
                                        this._CleanupRequest();
                                        throw new SDHttpClientRequestException("Expecting response message");
                                    }
                                } else {
                                    responseMessage += (char)c;
                                }
    
                                headers += (char)c;
                                break;
    
                            case (int)HTTP_STATE.RESPONSE_HEADER_BEGIN_LF:
                                if (c == 0x0A) {
                                    resp_state = (int)HTTP_STATE.RESPONSE_HEADER_KEY;
                                } else {
                                    this._CleanupRequest();
                                    throw new SDHttpClientRequestException("Expecting \\n");
                                }
    
                                headers += (char)c;
                                break;
    
                            case (int)HTTP_STATE.RESPONSE_HEADER_KEY:
                                if (c == ' ') {
                                    if (header.Length > 0) {
                                        resp_state = (int)HTTP_STATE.RESPONSE_HEADER_KEY_COLON;
                                    } else {
                                        break; // go again
                                    }
                                } else if (this._IsText((char)c) && c != ':') {
                                    header += (char)c;
                                } else if (c == ':') {
                                    if (header.Length == 0) {
                                        this._CleanupRequest();
                                        throw new SDHttpClientRequestException("Missing header value");
                                    } else {
                                        resp_state = (int)HTTP_STATE.RESPONSE_HEADER_VALUE;
                                    }
                                }
    
                                headers += (char)c;
                                break;
    
                            case (int)HTTP_STATE.RESPONSE_HEADER_KEY_COLON:
                                if (c == ' ') {
                                    break; // go again
                                } else if (c == ':') {
                                    resp_state = (int)HTTP_STATE.RESPONSE_HEADER_VALUE;
                                } else {
                                    this._CleanupRequest();
                                    throw new SDHttpClientRequestException("Invalid header line, expecting :");
                                }
    
                                headers += (char)c;
                                break;
    
                            case (int)HTTP_STATE.RESPONSE_HEADER_VALUE:
                                if (this._IsCtl((char)c)) {
                                    if (c == 0x0D) {
                                        if (hHeaders.ContainsKey(header)) {
                                            // TODO: Fix this
                                        } else {
                                            hHeaders.Add(header, headerValue);
                                        }
                                        header      = "";
                                        headerValue = "";
                                        resp_state  = (int)HTTP_STATE.RESPONSE_HEADER_LF;
                                    } else {
                                        this._CleanupRequest();
                                        throw new SDHttpClientRequestException("Invalid header line, expecting 0x0D");
                                    }
                                } else {
                                    if (c == ' ' && headerValue.Length == 0) {
                                        // consume whitespace
                                    } else {
                                        headerValue += (char)c;
                                    }
                                }
    
                                headers += (char)c;
                                break;
    
                            case (int)HTTP_STATE.RESPONSE_HEADER_CR:
                                if (c == 0x0D) {
                                    resp_state = (int)HTTP_STATE.RESPONSE_HEADER_LF;
                                } else {
                                    this._CleanupRequest();
                                    throw new SDHttpClientRequestException("Invalid header line, expecting 0x0D");
                                }
    
                                headers += (char)c;
                                break;
    
                            case (int)HTTP_STATE.RESPONSE_HEADER_LF:
                                if (c == 0x0A) {
                                    resp_state = (int)HTTP_STATE.RESPONSE_HEADER_CR2;
                                } else {
                                    this._CleanupRequest();
                                    throw new SDHttpClientRequestException("Invalid response, expecting LF");
                                }
    
                                headers += (char)c;
                                break;
    
                            case (int)HTTP_STATE.RESPONSE_HEADER_CR2:
                                if (c == 0x0D) {
                                    resp_state = (int)HTTP_STATE.RESPONSE_HEADER_LF2;
                                } else if (this._IsText((char)c)) {
                                    header += (char)c;
                                    resp_state = (int)HTTP_STATE.RESPONSE_HEADER_KEY;
                                } else {
                                    this._CleanupRequest();
                                    throw new SDHttpClientRequestException("Invalid header line, expecting 0x0D or new header");
                                }
    
                                headers += (char)c;
                                break;
    
                            case (int)HTTP_STATE.RESPONSE_HEADER_LF2:
                                if (c == 0x0A) {
                                    resp_state = (int)HTTP_STATE.RESPONSE_HEADER_FINISHED;
                                    bytePointer = i;
                                } else {
                                    this._CleanupRequest();
                                    throw new SDHttpClientRequestException("Invalid header line, expecting 0x0A");
                                }
    
                                headers += (char)c;
                                break;
    
                            case (int)HTTP_STATE.RESPONSE_HEADER_FINISHED:
                                // inspect the headers for a content-length
                                if (hHeaders.ContainsKey("Content-Length")) {
                                    // get cl
                                    if (Int64.TryParse(hHeaders["Content-Length"].ToString(), out contentLength) == false) {
                                        // invalid content length
                                        this._CleanupRequest();
                                        throw new Exception("Invalid content-length value in response");
                                    }
                                }
    
                                if (hHeaders.ContainsKey("Content-Encoding")) {
                                    contentEncoding = (string)hHeaders["Content-Encoding"];
                                }
    
                                if (hHeaders.ContainsKey("Transfer-Encoding")) {
                                    transferEncoding = (string)hHeaders["Transfer-Encoding"];
                                }
    
                                if (hHeaders.ContainsKey("Connection")) {
                                    string conn = (string)hHeaders["Connection"];
                                    if (conn.ToLower().Trim() == "close") {
                                        connectionClose = true;
                                    } else {
                                        connectionClose = false;
                                    }
                                }
    
                                if (transferEncoding.ToLower() == "chunked") {
                                    resp_state = (int)HTTP_STATE.RESPONSE_READ_CHUNKED_SIZE;
                                } else if (contentLength > 0) {
                                    resp_state = (int)HTTP_STATE.RESPONSE_READ_BODY_BYLEN;
                                } else if (connectionClose == true) {
                                    resp_state = (int)HTTP_STATE.RESPONSE_READ_BODY_TOEND;
                                } else {
                                    this._CleanupRequest();
                                    throw new Exception("Invalid body read state - could be a bug or invalid response");
                                }
    
                                i--; // step back because i is the first part of the body
    
                                break;
    
                            case (int)HTTP_STATE.RESPONSE_READ_BODY_TOEND:
                            {
                                if (bytes == 0) {
                                    resp_state = (int)HTTP_STATE.RESPONSE_READ_COMPLETE;
                                } else {
                                    Byte[] temp = new Byte[responseBody.Length + bytes - i];
                                    Buffer.BlockCopy(responseBody, 0, temp, 0, responseBody.Length);
                                    Buffer.BlockCopy(recv, i, temp, responseBody.Length, bytes - i);
                                    responseBody = temp;
                                    i = bytes + 1;
                                }
                                break;
                            }
    
                            case (int)HTTP_STATE.RESPONSE_READ_BODY_BYLEN:
                            {
                                int readLen = 0;
    
                                if (contentLength - contentRead <= (bytes - i)) {
                                    readLen = (int)contentLength;
                                    resp_state = (int)HTTP_STATE.RESPONSE_READ_COMPLETE;
                                } else {
                                    readLen = bytes - i;
                                }
    
                                Byte[] temp = new Byte[responseBody.Length + readLen];
                                Buffer.BlockCopy(responseBody, 0, temp, 0, responseBody.Length);
                                Buffer.BlockCopy(recv, i, temp, responseBody.Length, readLen);
                                responseBody = temp;
                                contentRead += readLen;
                                i += readLen - 1;
    
                                break;
                            }
    
                            case (int)HTTP_STATE.RESPONSE_READ_CHUNKED_SIZE:
                                if (this._IsHex((char)c)) {
                                    sChunkSize += (char)c;
                                } else if (c == ' ') {
                                    if (sChunkSize.Length == 0) {
                                        this._CleanupRequest();
                                        throw new SDHttpClientRequestException("Invalid response, expecting chunk size");
                                    } else {
                                        resp_state = (int)HTTP_STATE.RESPONSE_READ_CHUNKED_EXTENSION;
                                    }
                                } else if (c == 0x0D) {
                                    resp_state = (int)HTTP_STATE.RESPONSE_READ_CHUNKED_SIZE_LF;
                                }
    
                                break;
    
                            case (int)HTTP_STATE.RESPONSE_READ_CHUNKED_EXTENSION:
                                if (this._IsCtl((char)c)) {
                                    if (c == 0x0D) {
                                        resp_state = (int)HTTP_STATE.RESPONSE_READ_CHUNKED_SIZE_LF;
                                    } else {
                                        this._CleanupRequest();
                                        throw new SDHttpClientRequestException("Invalid chunked response line, expecting 0x0D");
                                    }
                                } else if (this._IsText((char)c)) {
                                    // add to chunk ext
                                    sChunkSize += (char)c;
                                } else {
                                    this._CleanupRequest();
                                    throw new SDHttpClientRequestException("Invalid response, bad chunk size");
                                }
    
                                break;
    
                            case (int)HTTP_STATE.RESPONSE_READ_CHUNKED_SIZE_LF:
                                if (c == 0x0A) {
                                    resp_state = (int)HTTP_STATE.RESPONSE_READ_CHUNKED_DATA;
    
                                    if (Int32.TryParse(sChunkSize, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out iChunkSize) == false) {
                                        // invalid state
                                        this._CleanupRequest();
                                        throw new Exception("Bad response, invalid chunk size");
                                    } else {
                                        sChunkSize = "";
    
                                        if (iChunkSize == 0) {
                                            resp_state = (int)HTTP_STATE.RESPONSE_READ_COMPLETE;
                                        }
                                    }
                                } else {
                                    this._CleanupRequest();
                                    throw new SDHttpClientRequestException("Invalid chunked response line, expecting 0x0A");
                                }
                                break;
    
                            case (int)HTTP_STATE.RESPONSE_READ_CHUNKED_DATA:
                            {
                                if (iChunkSize == 0) {
                                    resp_state = (int)HTTP_STATE.RESPONSE_READ_CHUNKED_DATA_CR;
                                    i--; // put back
                                } else {
                                    int readLen = 0;
    
                                    if (iChunkSize <= bytes - i) {
                                        readLen = iChunkSize;
                                        resp_state = (int)HTTP_STATE.RESPONSE_READ_CHUNKED_DATA_CR;
                                    } else {
                                        readLen = bytes - i;
                                    }
    
                                    Byte[] temp = new Byte[responseBody.Length + readLen];
                                    Buffer.BlockCopy(responseBody, 0, temp, 0, responseBody.Length);
                                    Buffer.BlockCopy(recv, i, temp, responseBody.Length, readLen);
                                    responseBody = temp;
    
                                    contentLength += readLen;
                                    iChunkSize -= readLen;
                                    i += readLen - 1;
                                }
                                break;
                            }
    
                            case (int)HTTP_STATE.RESPONSE_READ_CHUNKED_DATA_CR:
                                if (c == 0x0D) {
                                    resp_state = (int)HTTP_STATE.RESPONSE_READ_CHUNKED_DATA_LF;
                                } else {
                                    this._CleanupRequest();
                                    throw new SDHttpClientRequestException("Invalid chunked response line, expecting 0x0D");
                                }
                                break;
    
                            case (int)HTTP_STATE.RESPONSE_READ_CHUNKED_DATA_LF:
                                if (c == 0x0A) {
                                    resp_state = (int)HTTP_STATE.RESPONSE_READ_CHUNKED_SIZE;
                                } else {
                                    this._CleanupRequest();
                                    throw new SDHttpClientRequestException("Invalid chunked response line, expecting 0x0A");
                                }
                                break;
    
                        } // switch(resp_state)
                    }
    
                    if (resp_state == (int)HTTP_STATE.RESPONSE_READ_COMPLETE) {
                        // the response has finished being read, socket is either being closed by remote host
                        // or is being kept-alive
                        this._LastRequestTotalTime = this._UnixTimestampWithMicroseconds() - this._LastRequestStartTime;
                        break;
                    }
    
                    if (this._CancelFlag) {
                        this._CleanupRequest();
                        return;
                    }
    
                } while (bytes > 0);
    
                if (contentEncoding == "gzip") {
                    // deflate gzip content
                    this._GZInflate(ref responseBody, ref body);
                } else {
                    body = Encoding.ASCII.GetString(responseBody);
                }
    
                responseBody = null;
                this._WasKeepAlive = connectionClose == false;
    
                if (this._WasKeepAlive) {
                    if (this._CancelFlag) {
                        this._CleanupRequest();
                        return;
                    }
    
                    if (hHeaders.ContainsKey("Keep-Alive"))
                    {
                        string kaStr = hHeaders["Keep-Alive"].ToString();
                        Regex re = new Regex(@"^timeout=(\d+),", RegexOptions.IgnoreCase);
                        Match m;
                        m = re.Match(kaStr);
                        if (m.Success)
                        {
                            if (Int32.TryParse(m.Groups[1].Value.ToString(), out this._KeepAliveTimeout) == false)
                            {
                                // invalid state
                                this._CleanupRequest();
                                throw new Exception("Bad response, keep-alive value is invalid");
                            }
                        }
                    }
                    else
                    {
                        this._KeepAliveTimeout = 60; // default timeout of 60 seconds if the server does not indicate a limit
                    }
    
                    this._KeepAliveLastRequest = this._UnixTimestamp();
                } else {
                    this._DisconnectSocket();
                }
    
                if (responseCode == "302") {
                    this._302Location = hHeaders["Location"].ToString();
                } else {
                    this._302Location = "";
                }
    
                this._ParseCookies(uri.Host, headers);
    
                this._LastHttpStatusCode = responseCode;
                this._ResponseBody = body;
                this._ResponseHeaders = headers;
                this._RequestInProgress = false;
                this._CancelFlag = false;
                this._Cancelled = false;
    
                OnRequestCompletedEvent(new EventArgs());
            }
    
            protected void _CleanupRequest()
            {
                this._RequestInProgress = false;
                this._DisconnectSocket();
    
                if (this._CancelFlag) {
                    this._Cancelled = true;
                    this._CancelFlag = false;
                    OnRequestCompletedEvent(new EventArgs());
                }
            }
    
            protected void _DisconnectSocket()
            {
                try {
                    this._sock.Shutdown(SocketShutdown.Both);
                    this._sock.Disconnect(false);
                } catch (SocketException e) {
                    Console.WriteLine("Caught socket exception trying to shut down socket: {0}: {1}", e.NativeErrorCode.ToString(), e.Message);
                }
            }
    
            protected int _ParseCookies(string host, string headers)
            {
                CookieContainer cc;
    
                if (this._Cookies.ContainsKey(host)) {
                    cc = (CookieContainer)this._Cookies[host];
                } else {
                    cc = new CookieContainer();
                    this._Cookies[host] = cc;
                }
    
                return cc.ParseHeaders(headers);
            }
    
            protected void _Connect(Uri uri)
            {
                bool connect       = false;
                bool blockingState = this._sock.Blocking;
                
                if (this._LastHost != uri.Host) {
                    connect = true;
                } else if (this._WasKeepAlive == false) {
                    connect = true;
                } else {
                    // check to see if the current socket is still open
                    try {
                        bool part1 = this._sock.Poll(1000, SelectMode.SelectRead);
                        bool part2 = (this._sock.Available == 0);
                        if (part1 && part2) {
                            connect = true;
                        } else {
                            connect = false;
                        }
                    } catch (SocketException e) {
                        if (e.NativeErrorCode.Equals(10035)) {
                            connect = true;
                        } else {
                            connect = true;
                        }
                    } finally {
                        this._sock.Blocking = blockingState;
    
                        if (this._sock.Connected == false) {
                            connect = true;
                        }
    
                        if ( connect == false && (int)(this._UnixTimestamp() - this._KeepAliveLastRequest) >= this._KeepAliveTimeout) {
                            connect = true;
                        }
                    }
                }
    
                if (connect == true) {
                    if (this._sock.Connected) {
                        this._DisconnectSocket();
                    }
    
                    this._sock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
    
                    Console.WriteLine("Connecting.");
    
                    try {
                        this._sock.Connect(uri.Host, uri.Port);
                        OnConnectedEvent(new EventArgs());
                        this._LastHost = uri.Host;
                    } catch (SocketException e) {
                        this._LastErrorCode    = e.NativeErrorCode;
                        this._LastErrorMessage = e.Message;
                        throw new SDHttpClientRequestException("Failed to connect to remote host", e);
                    }
                    
                } else {
                    OnConnectedEvent(new EventArgs());
                    Console.WriteLine("Used keep-alive connection");
                }
            }
    
            protected Byte[] _GetHTTPRequest(string method, Uri uri, string data = "")
            {
                string contentLen = "";
                string cookieHeader = "";
                string refererHeader = "";
                string connection = "";
    
                string req = "{0} {1} HTTP/1.1\r\n" +
                             "Host: {2}\r\n" +
                             "User-Agent: {3}\r\n" +
                             "Accept-Encoding: gzip,deflate\r\n" +
                             "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\n" +
                             "Keep-Alive: 30\r\n" +
                             "Connection: {4}\r\n" +
                             "{5}" + // referer, if set
                             "{6}" + // cookies, if any
                             //"Connection: close\r\n" +
                             "{7}" + // content length
                             "{8}\r\n";
    
                if (method == "POST") {
                    contentLen = "Content-type: application/x-www-form-urlencoded\r\n";
                    contentLen += "Content-Length: " + data.Length.ToString() + "\r\n";
                    data = "\r\n" + data;
                }
    
                if (this._Cookies.ContainsKey(uri.Host)) {
                    CookieContainer cc = (CookieContainer)this._Cookies[uri.Host];
                    cookieHeader = cc.ToString();
                    if (cookieHeader != "") {
                        cookieHeader = "Cookie: " + cookieHeader + "\r\n";
                    }
                }
    
                if (this._HttpReferer != "") {
                    refererHeader = "Referer: " + this._HttpReferer + "\r\n";
                }
    
                if (this._UseKeepAlive == true) {
                    connection = "keep-alive";
                } else {
                    connection = "close";
                }
    
                req = string.Format(req,
                                    method,
                                    uri.PathAndQuery,
                                    uri.Host,
                                    this._UserAgent,
                                    connection,
                                    refererHeader,
                                    cookieHeader,
                                    contentLen,
                                    data);
    
                Byte[] b = Encoding.ASCII.GetBytes(req);
    
                return b;
            }
    
            protected string UrlEncode(string s)
            {
                string encoded = "";
                char c;
    
                for (int i = 0; i < s.Length; ++i) {
                    c = s[i];
    
                    if (c == ' ') {
                        encoded += '+';
                    } else if ((c < '0' && c != '-' && c != '.') ||
                               (c < 'A' && c > '9') ||
                               (c > 'Z' && c < 'a' && c != '_') ||
                               (c > 'z')) {
                        encoded += '%';
                        encoded += ((int)c).ToString("X");
                    } else {
                        encoded += c;
                    }
                }
    
                return encoded;
            }
    
            protected bool _GZInflate(ref byte[] content, ref string decompressed)
            {
                Byte[] outBuf = new Byte[0x4000];
                int read = 0;
                decompressed = "";
    
                System.IO.MemoryStream stream = new System.IO.MemoryStream(content);
                System.IO.Compression.GZipStream gzstream = new System.IO.Compression.GZipStream(stream, System.IO.Compression.CompressionMode.Decompress);
    
                while ((read = gzstream.Read(outBuf, 0, outBuf.Length)) > 0) {
                    decompressed += Encoding.ASCII.GetString(outBuf, 0, read);
                }
    
                outBuf = null;
                stream.Close();
                gzstream.Close();
                stream.Dispose();
                gzstream.Dispose();
    
                return true;
            }
    
            protected bool _IsNumeric(char c)
            {
                if (c >= 48 && c <= 57) {
                    return true;
                } else {
                    return false;
                }
            }
    
            protected bool _IsAlpha(char c)
            {
                if ((c >= 65 && c <= 90) || (c >= 97 && c <= 122)) {
                    return true;
                } else {
                    return false;
                }
            }
    
            protected bool _IsText(char c)
            {
                if (c >= 32 && c < 127) {
                    return true;
                } else {
                    return false;
                }
            }
    
            protected bool _IsCtl(char c)
            {
                if (c < 32 || c == 127) {
                    return true;
                } else {
                    return false;
                }
            }
    
            protected bool _IsHex(char c)
            {
                if ((c >= 65 && c <= 70) || (c >= 97 && c <= 102) || (c >= 48 && c <= 57)) {
                    return true;
                } else {
                    return false;
                }
            }
    
            protected ulong _UnixTimestamp()
            {
                return (ulong)this._UnixTimestampWithMicroseconds();
            }
    
            protected double _UnixTimestampWithMicroseconds()
            {
                return (DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0)).TotalSeconds;
            }
    
            /// <summary>
            /// Get the current time as a Unix timestamp
            /// </summary>
            /// <returns></returns>
            public static double UnixTime()
            {
                return (DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0)).TotalSeconds;
            }
    
            protected virtual void OnDataReceivedEvent(DataReceivedEventArgs e)
            {
                if (DataReceived != null) {
                    DataReceived(this, e);
                }
            }
    
            protected virtual void OnConnectedEvent(EventArgs e)
            {
                if (Connected != null) {
                    Connected(this, e);
                }
            }
    
            protected virtual void OnRequestCompletedEvent(EventArgs e)
            {
                if (RequestCompleted != null) {
                    RequestCompleted(this, e);
                }
            }
        }
    
        /// <summary>
        /// A container of http cookies
        /// </summary>
        public class CookieContainer
        {
            protected Hashtable _cookies;
    
            public CookieContainer()
            {
                this._cookies = new Hashtable(10);
            }
    
            /// <summary>
            /// Parse cookies out of an http response header block
            /// </summary>
            /// <param name="headers">The headers to get cookies out of</param>
            /// <returns>The number of cookies sent</returns>
            public int ParseHeaders(string headers)
            {
                char[]   split  = new char[] { '\r', '\n' };
                string[] lines  = headers.Split(split, StringSplitOptions.RemoveEmptyEntries);
                Regex regCookie = new Regex(@"^set-cookie:\s*([^=]+)=([^;]+);", RegexOptions.IgnoreCase);
                Match m;
                int count = 0;
    
                //Set-Cookie: xt6Yr4e33D=94394812224217313165124; expires=Tue, 22-May-2012 03:44:02 GMT; path=/; domain=.site.com
                foreach (string header in lines) {
                    m = regCookie.Match(header);
                    if (m.Success) {
                        this.SetCookie(m.Groups[1].Value.ToString(), m.Groups[2].Value.ToString());
                        count++;
                    }
                }
    
    
                return count;
            }
    
            /// <summary>
            /// Set an individual cookie
            /// </summary>
            /// <param name="key">The cookie name</param>
            /// <param name="value">The value of the cookie</param>
            public void SetCookie(string key, string value)
            {
                if (this._cookies.ContainsKey(key)) {
                    this._cookies[key] = value;
                } else {
                    this._cookies.Add(key, value);
                }
            }
    
            /// <summary>
            /// Get the content of a cookie by name
            /// </summary>
            /// <param name="key">The cookie to get</param>
            /// <returns>The cookie value</returns>
            public string GetCookie(string key)
            {
                if (this._cookies.ContainsKey(key)) {
                    return this._cookies[key].ToString();
                } else {
                    return "";
                }
            }
    
            /// <summary>
            /// Unset a cookie
            /// </summary>
            /// <param name="key">The cookie to remove</param>
            /// <returns>true if found and removed, false if not found</returns>
            public bool RemoveCookie(string key)
            {
                if (this._cookies.ContainsKey(key)) {
                    this._cookies.Remove(key);
                    return true;
                } else {
                    return false;
                }
            }
    
            /// <summary>
            /// Return the underlying hash table of the cookie container
            /// </summary>
            /// <returns>Hashtable of key value cookie pairs</returns>
            public Hashtable GetCookies()
            {
                return this._cookies;
            }
    
            /// <summary>
            /// Return the cookies as a string
            /// </summary>
            /// <returns></returns>
            public override string ToString()
            {
                string s = "";
    
                foreach (DictionaryEntry d in this._cookies) {
                    s += d.Key + "=" + d.Value + "; ";
                }
    
                if (s.Length > 2) {
                    s = s.Substring(0, s.Length - 1);
                }
    
                return s;
            }
        }
    
        /// <summary>
        /// Thrown when a request fails
        /// </summary>
        public class SDHttpClientRequestException : Exception
        {
            public SDHttpClientRequestException()
            {
            }
    
            public SDHttpClientRequestException(string message)
                : base(message)
            {
            }
    
            public SDHttpClientRequestException(string message, Exception innerException)
                : base(message, innerException)
            {
            }
        }
    
        /// <summary>
        /// Parameters for the DataReceived event
        /// </summary>
        public class DataReceivedEventArgs : EventArgs
        {
            private long bytesReceived;
            private long bytesTotal;
    
            public DataReceivedEventArgs(long received, long total)
            {
                this.bytesReceived = received;
                this.bytesTotal = total;
            }
    
            public long BytesTotal
            {
                get { return this.bytesTotal; }
            }
    
            public long BytesReceived
            {
                get { return this.bytesReceived; }
            }
        }
    }
    This I would leave here for the same purpose, just for learning. I transitioned to this HTTP client when making Stealth Core which was the worst decision ever for someone new to C# as I had to fix and add way too many things. This is untouched and would leave it here for learning purposes. Some functions presented better than the previous wrapper.
    (you need an account to see links)
    (you need an account to see links)(you need an account to see links)

    ------------------------
    [02/24/2013] Stealth CORE is made into the first standalone Neopets auto-player.
    ------------------------


  6. The Following 2 Users Say Thank You to j03 For This Useful Post:

    I_royalty_I (03-19-2014),Rambo (03-19-2014)

  7. #5

    Rambo's Avatar
    Joined
    Sep 2013
    Posts
    136
    Userbars
    1
    Thanks
    19
    Thanked
    29/25
    DL/UL
    11/7
    Mentioned
    25 times
    Time Online
    4d 3h 14m
    Avg. Time Online
    1m
    Thanks a bunch! I am going to look into this, and hopefully gear up for a release soon.

    MaraRumble v0.9.2 will come out soon in Python/TK form,
    Kayak v0.7.2 should come out in a month or less.
    @(you need an account to see links), can you tell me how to use the wrapper? Like a simple example? I am a little new to VC#.

    Code:
    using goodwrap;
    
    ...
    
    string html = wrapper.Request("GET", "http://www.marapets.com", "http://www.marapets.com");
    I get:
    Code:
    "An Object refrence is required for the non static field ..."
    Last edited by Rambo; 03-19-2014 at 05:54 PM.

  8. #6
    Saiyan Race
    j03's Avatar
    Joined
    Dec 2011
    Posts
    13,722
    Userbars
    166
    Thanks
    5,906
    Thanked
    33,077/6,608
    DL/UL
    23/36
    Mentioned
    3,867 times
    Time Online
    563d 5h 25m
    Avg. Time Online
    3h 13m
    Quote Originally Posted by Rambo View Post
    Thanks a bunch! I am going to look into this, and hopefully gear up for a release soon.

    MaraRumble v0.9.2 will come out soon in Python/TK form,
    Kayak v0.7.2 should come out in a month or less.
    @(you need an account to see links), can you tell me how to use the wrapper? Like a simple example? I am a little new to VC#.
    With the first one I showed you, save it as a class, load it in your project then usage as follows:

    Code:
    goodwrap.wrapper w = new goodwrap.wrapper();
    
    string strHTML = null;
    
    w.Request("GET", "http://www.neopets.com", "http://www.jellyneo.net");
    (you need an account to see links)
    (you need an account to see links)(you need an account to see links)

    ------------------------
    [02/24/2013] Stealth CORE is made into the first standalone Neopets auto-player.
    ------------------------


  9. The Following User Says Thank You to j03 For This Useful Post:

    Rambo (03-19-2014)

  10. #7

    Rambo's Avatar
    Joined
    Sep 2013
    Posts
    136
    Userbars
    1
    Thanks
    19
    Thanked
    29/25
    DL/UL
    11/7
    Mentioned
    25 times
    Time Online
    4d 3h 14m
    Avg. Time Online
    1m
    Worked quite well thanks!

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts
  •