HTTPRequest.cs

using System;
using System.IO;
using System.Net.Sockets;
using System.Text;
using NZlib.Compression;
using NZlib.Streams;
using NZlib.Zip;
using NZlib.Checksums;

namespace Common {
        /*************************************************************************/
        public class HTTPRequest : HTTPObject {
                /*** Properties ***/

                public string Hostname {
                        get { return ((HTTPRequestHeader)headers).requestUri.Host;}
                }

                public int Port {
                        get { return ((HTTPRequestHeader)headers).requestUri.Port; }
                }

                public Uri URI {
                        get { return ((HTTPRequestHeader)headers).requestUri; }
                }
                
                public bool HasPragmaNoCacheSet {
                        get { if (headers.headerCollection["Pragma"] != null) {
                                          return (headers.headerCollection["Pragma"].IndexOf("no-cache") != -1);
                                  } else {
                                          return false;
                                  }
                        }
                }
                /*** Constructors ***/

                public HTTPRequest(Stream src) {
                        StringBuilder sb = new StringBuilder();

                        StreamReader sr = new StreamReader(src, Encoding.ASCII, false, 256);
                        string s = sr.ReadLine();

//                      string s = StreamUtil.ReadLine(ref src);
                        while (s != "" && s != null) {
                                sb.Append(s + "\r\n");
                                s = sr.ReadLine();
//                              s = StreamUtil.ReadLine(ref src);
                        }
                        sb.Append("\r\n");

                        headers = new HTTPRequestHeader(sb.ToString());
                        //Console.WriteLine(">>> CLIENT REQUEST: " + this.URI);
                        // if we have data to receive, we can receive "Content-length" number of bits!
                        if (this.headers.headerCollection["Content-Length"] != null) {
                                int bodySize = Int32.Parse(this.headers.headerCollection["Content-Length"]);
                                byte[] bodyBuffer = StreamUtil.ReadBody(ref src, bodySize);
                                this.body = new HTTPBody(bodyBuffer);
                        } // otherwise, we could be in a case where connection is terminating determines size
                        else if ((this.headers.headerCollection["Connection"] == "Close") || ((HTTPRequestHeader)this.headers).method == "POST") {
                                // TODO: find more conditions for having a body
                                        byte[] bodyBuffer = StreamUtil.ReadBody(ref src);
                                        this.body = new HTTPBody(bodyBuffer);
                                // throw any exceptions up the ladder.
                        } 
//                      Console.WriteLine("HTTP Request constructor finished");
                }

                public HTTPRequest(byte[] src) : base(src) {
                        // calling base(src) should have set up bodyBytes and headerBytes
                        if (headerBytes != null) {
                                headers = new HTTPRequestHeader(headerBytes);
                        }
                        if (bodyBytes != null) {
                                body = new HTTPBody(bodyBytes);
                        }
                }

                public HTTPRequest(HTTPRequest req) {
                        this.headers = new HTTPRequestHeader(req.headers.rawString);
                        this.headerBytes = req.headerBytes;
                        this.body = req.body;
                        this.bodyBytes = req.bodyBytes;
                }

                public HTTPRequest(HTTPRequest baseRequest, Uri newUri) : this(baseRequest) {
                        try {
                                int i1 = 0;
                                int i2 = headers.rawString.IndexOf("\r\n");
                                int i3;
                                string s = headers.rawString.Substring(i1, i2-i1);
                                // extract method
                                i3 = s.IndexOf(' ');
                                //                      parseHTTPMethod(s.Substring(i1, i3-i1));
                                i1=i3+1;
                                // extract URI
                                i3 = s.IndexOf(' ', i1);
                                string newRawHeaders = s.Remove(i1, i3-i1);
                                newRawHeaders = newRawHeaders.Insert(i1, newUri.ToString());
                                string s1 = headers.rawString.Replace(s, newRawHeaders);
                                s1 = s1.Replace(headers.headerCollection["Host"], newUri.Host + ":" + newUri.Port);
                                headers.rawString = s1;
                                headers.parseRaw();
                        } catch (Exception ex) {
                                string errorMessage = String.Format("*** Error creating HTTP Request for {0} ***\n{1}", newUri, ex.Message);
                                Console.WriteLine(errorMessage);
                                throw new Exception(errorMessage, ex);
                        }
                }
        }

        /*************************************************************************/
        public class HTTPRequestHeader : HTTPHeader {
                // deals differently with HTTP/1.0 GET foo.html header
                public Uri requestUri;
                public string method; // TODO: Convert to ENUM

                /*** Constructors ***/
                public HTTPRequestHeader(string source) : base(source) {}

                public HTTPRequestHeader(byte[] src) : this(Encoding.ASCII.GetString(src)) {

                }
                /*** Methods ***/
                protected override void parseHTTP() {
                        string CRLF = "\r\n";
                        int i1 = rawStringPos;
                        int i2 = rawString.IndexOf(CRLF);
                        int i3;
                        string s = rawString.Substring(i1, i2-i1);
                        // do parsing work
                        // extract method
                        i3 = s.IndexOf(' ');
                        parseHTTPMethod(s.Substring(i1, i3-i1));
                        i1=i3+1;
                        // extract URI
                        i3 = s.IndexOf(' ', i1);
                        parseRequestUri(s.Substring(i1, i3-i1));
                        i1 = i3 + 1;
                        // extract version info
//                      parseVersionInfo(s.Substring(i1, s.Length-i1)); // get to the end of the string
                        rawStringPos = i2 + CRLF.Length; // step over the newline char
                }
                public void parseHTTPMethod(string s) {
                        method = s;
                }

                protected void parseRequestUri(string s) {
                        requestUri = new Uri(s);
                }
        }
        /*************************************************************************/
        // used to go in a queue
        public class HTTPRequestQueueObject : HTTPRequest {
                public ushort sourceDeviceID;
                // callback ID
                public int callbackReceipt;             
                // chk of origianl document. if != null, use it to create a delta
                public byte[] originalChk; 
                // parent constructors
                public HTTPRequestQueueObject(System.Net.Sockets.NetworkStream s) : base(s) {}
                public HTTPRequestQueueObject(HTTPRequest req) : base(req) {}
        }
        /*************************************************************************/
        public class EncodedHTTPRequest {
                byte[] compressedData;
                public EncodedHTTPRequest(HTTPRequest req) {
                        byte[] srcData = req.Serialise();
                        MemoryStream deflatedMem = new MemoryStream();
                        DeflaterOutputStream defOutStr = new DeflaterOutputStream(deflatedMem);
                        defOutStr.Write(srcData, 0, srcData.Length);
                        defOutStr.Flush();
                        defOutStr.Finish();
                        compressedData = new byte[deflatedMem.Position];
                        Array.Copy(deflatedMem.GetBuffer(), compressedData, compressedData.Length);
                        defOutStr.Close();
                }
                public EncodedHTTPRequest(byte[] src, int start, int length) {
                        compressedData = new byte[length];
                        Array.Copy(src, start, compressedData, 0, length);
                }

                public byte[] ToByteArray() {
                        return compressedData;
                }

                public HTTPRequest Decode() {
                        MemoryStream baseInflationStream = new MemoryStream(compressedData);
                        MemoryStream deflatedOutput = new MemoryStream();
                        byte[] buffer = new byte[512];
                        int bytesRead;
                        InflaterInputStream inflateStream = new InflaterInputStream(baseInflationStream);
                        bytesRead = inflateStream.Read(buffer, 0, buffer.Length);
                        while (bytesRead > 0) {
                                deflatedOutput.Write(buffer, 0, bytesRead);
                                bytesRead = inflateStream.Read(buffer, 0, buffer.Length);
                        }
                        inflateStream.Flush();
                        inflateStream.Close();
                        deflatedOutput.Flush();
                        HTTPRequest result = new HTTPRequest(deflatedOutput.GetBuffer());
                        deflatedOutput.Close();
                        return result;
                }
        }
        
}

---