HTTPResponse.cs

using System;
using System.IO;
using System.Text;
using System.Net.Sockets;
using System.Collections;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using NZlib.Streams;

namespace Common {

        /**************************************************************************************************/
        public class HTTPResponse : HTTPObject {
                /*** Properties ***/
                public String ContentType {
                        get {
                                return headers.headerCollection["Content-Type"];
                        }
                }

                public String ContentLength {
                        get { return headers.headerCollection["Content-Length"]; }
                        set {
                                try {
                                        string oldLength = "Content-Length: " + headers.headerCollection["Content-length"];
                                        string newLength = "Content-Length: " + value;
                                        headers.rawString.Replace(oldLength, newLength); 
                                } catch (Exception ex) {
                                        Console.WriteLine("*** Error occured trying to set new Content Length value for response: {0} ***", ex.Message);
                                }
                                this.headers.parseRaw();
                        }
                }
                public string Headers {
                        get { return headers.rawString; }
                }

                public int StatusCode {
                        get { return Int32.Parse(((HTTPResponseHeader)headers).statusCode); }
                }

                public HTTPBody Body {
                        get { return body; }
                }
                /*** Constructors ***/
                public HTTPResponse(HTTPResponseHeader headers) {
                        this.headers = headers;
                }

                public HTTPResponse(ref Stream nwstream) {
                        StringBuilder sb = new StringBuilder();
                        string s1 = StreamUtil.ReadLine(ref nwstream);                  
                        while (s1 != "") { // the blank line is a marker
                                sb.Append(s1 + "\r\n");
                                s1 = StreamUtil.ReadLine(ref nwstream);
                        } 
                        sb.Append("\r\n");
                        // parse the response and see what kind of message it was
                        this.headers = new HTTPResponseHeader(sb.ToString());
                        // 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 nwstream, 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") || ((HTTPResponseHeader)this.headers).statusCode == "200") {
                                // TODO: find more conditions for having a body
                                try {
                                        byte[] bodyBuffer = StreamUtil.ReadBody(ref nwstream);
                                        this.body = new HTTPBody(bodyBuffer);
                                } catch (Exception ex) {
                                        // TODO: better exception handling here,and all round
                                        Console.WriteLine(ex);
                                }
                        }
                }

                public HTTPResponse() {}

                public HTTPResponse(byte[] src) : base(src) {
                        if (headerBytes != null) {
                                headers = new HTTPResponseHeader(headerBytes);
                        }
                        if (bodyBytes != null) {
                                body = new HTTPBody(bodyBytes);
                        }
                }
        }

        /**************************************************************************************************/
        public class HTTPResponseHeader : HTTPHeader {
                // deals differently with HTTP nnn xxxxxx header
                public string statusCode;
                /*** Constructors ***/
                public HTTPResponseHeader(string source) : base(source) {}
                public HTTPResponseHeader(byte[] src) : base(Encoding.ASCII.GetString(src)) {}

                /*** Methods ***/
                protected override void parseHTTP() {
                        int i1 = rawStringPos;
                        int i2 = rawString.IndexOf("\r\n");
                        int i3;
                        string s = rawString.Substring(i1,i2-i1);
                        // do parsing work
                        // extract HTML version
                        i3 = s.IndexOf(' ');
                        //                      this.parseVersionInfo(s.Substring(i1, i3-i1));
                        i1 = i3 + 1;
                        // extract status code
                        i3 = s.IndexOf(' ', i1);
                        this.parseStatusCode(s.Substring(i1, i3-i1));
                        rawStringPos = i2 + "\r\n".Length;
                }

                protected void parseStatusCode(string src) {
                        statusCode = src;       
                }
        }
        /**************************************************************************************************/
        public class HTTPResponseQueueObject : HTTPResponse {
                public ushort destinationDeviceID;
                // additional property 1
                // additional property 2

                public HTTPResponseQueueObject() : base() {             }
                public HTTPResponseQueueObject(ref Stream nwstream) : base(ref nwstream) {}
                public HTTPResponseQueueObject(HTTPResponseHeader headers) : base(headers) {}
        
        }
        /**************************************************************************************************/
        public class EncodedHTTPResponse : EncodedData {
                byte[] compressedData;
                bool isDeltaEncoded;
                public EncodedHTTPResponse(HTTPResponse response) : this(response, null, null) {}

                public EncodedHTTPResponse(HTTPResponse resp, byte[] originalCHk, CacheManager cacheManager) {
                        MemoryStream uncompressedDataStream = new MemoryStream();
                        if (originalCHk != null && cacheManager != null && resp.ContentType.StartsWith("text")) { // then delta encode
                                byte[] oldBodyBytes = cacheManager.GetByChk(originalCHk).data;
                                if (Math.Abs(oldBodyBytes.Length - resp.Body.data.Length) <= (16 * 1024)) {
                                        isDeltaEncoded = true;
                                        MemoryStream oldBodyData = new MemoryStream(oldBodyBytes);
                                        MemoryStream newBodyData = new MemoryStream(resp.Body.data);
                                        ArrayList changeHunks = CacheManager.Diff(oldBodyData, newBodyData);
                                        // serialise the change hunks
                                        IFormatter formatter = new BinaryFormatter();

                                        resp.AppendBody(null); // cancel out the body of this response
                                        byte[] serilaisedHeaders = resp.Serialise();

                                        // start to write the uncompressed data stream
                                        uncompressedDataStream.Write(BitConverter.GetBytes(serilaisedHeaders.Length), 0, BitConverter.GetBytes(serilaisedHeaders.Length).Length);
                                        uncompressedDataStream.Write(serilaisedHeaders, 0, serilaisedHeaders.Length);
                                        uncompressedDataStream.Write(originalCHk, 0, originalCHk.Length);
                                        formatter.Serialize(uncompressedDataStream, changeHunks);
                                } else { // too much difference to delta encode?
                                        isDeltaEncoded = false;
                                        byte[] serialisedResponse = resp.Serialise();
                                        uncompressedDataStream.Write(serialisedResponse, 0, serialisedResponse.Length);
                                }
                        } else {
                                isDeltaEncoded = false;
                                byte[] serialisedResponse = resp.Serialise();
                                uncompressedDataStream.Write(serialisedResponse, 0, serialisedResponse.Length);
                        }
                        // even if it IS delata encoded, zip the encoded stuff.
                        compressedData = Zip(uncompressedDataStream);
                        uncompressedDataStream.Close();
                        // the IS delta Encoded bit will be written before the compressed data
                }

                public EncodedHTTPResponse(byte[] src, int start, int length) {
                        Deserialise(src, start, length);
                }

                public byte[] Serialise() {
                        MemoryStream buffer = new MemoryStream();
                        buffer.Write(BitConverter.GetBytes(isDeltaEncoded), 0, BitConverter.GetBytes(isDeltaEncoded).Length);
                        buffer.Write(compressedData, 0, compressedData.Length);
                        byte[] result = new byte[buffer.Length];
                        buffer.Seek(0, SeekOrigin.Begin);
                        buffer.Read(result, 0, result.Length);
                        buffer.Close();
                        return result;
                }

                public void Deserialise(byte[] src, int start, int length) {
                        int currentPos = start;
                        isDeltaEncoded = BitConverter.ToBoolean(src, currentPos);
                        currentPos += 1;
                        compressedData = new byte[(length - currentPos) + start];
                        Array.Copy(src, currentPos, compressedData, 0, compressedData.Length);
                }


                public HTTPResponse Decode(CacheManager cacheManager) {
                        MemoryStream compressedDataStream = new MemoryStream(compressedData);
                        HTTPResponse result;
                        if (isDeltaEncoded) {
                                byte[] uncompressedData = Unzip(ref compressedDataStream);
                                int currentPos = 0;
                                // get headers
                                int headerLength = BitConverter.ToInt32(uncompressedData, currentPos);
                                currentPos += 4;
                                byte[] headerBytes = new byte[headerLength];
                                Array.Copy(uncompressedData, currentPos, headerBytes, 0, headerLength);
                                currentPos += headerLength;
                                // start HTTPResponse creation
                                result = new HTTPResponse(headerBytes);
                                // get original chk
                                byte[] originalChk = new byte[20];
                                Array.Copy(uncompressedData, currentPos, originalChk, 0, originalChk.Length);
                                currentPos += 20;
                                // get hunk list
                                MemoryStream partialUncompressedStream = new MemoryStream(uncompressedData, currentPos, uncompressedData.Length - currentPos);
                                IFormatter formatter = new BinaryFormatter();
                                ArrayList hunkList = (ArrayList) formatter.Deserialize(partialUncompressedStream);
                                /*************** WHAT HAPPENS IF DOCUMENT NOT IN CACHE WHEN WE TRY AND FETCH IT ***********/
                                /**************** THROW EXCEPTION UPWARDS AND RE-ISSUE AT CALLER */
                                HTTPBody oldDocBody = cacheManager.GetByChk(originalChk);
                                byte[] newDocBytes = CacheManager.Patch(oldDocBody.data, hunkList);
                                result.AppendBody(new HTTPBody(newDocBytes));
                        } else {
                                result = new HTTPResponse(Unzip(ref compressedDataStream));
                        }
                        compressedDataStream.Close();
                        return result;
                }
                /*
                 *                      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();
                        HTTPResponse result = new HTTPResponse(deflatedOutput.GetBuffer());
                        deflatedOutput.Close();
                        return result;
                        */


        }

        public class EncodedData {
                protected byte[] Unzip(ref MemoryStream compressedStream) {
                        MemoryStream deflatedOutput = new MemoryStream();
                        byte[] buffer = new byte[512];
                        int bytesRead;
                        InflaterInputStream inflateStream = new InflaterInputStream(compressedStream);
                        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();
                        byte[] result = new byte[deflatedOutput.Length];
                        deflatedOutput.Seek(0, SeekOrigin.Begin);
                        deflatedOutput.Read(result, 0, result.Length);
                        deflatedOutput.Close();
                        return result;
                }

                protected byte[] Zip(MemoryStream uncompressedDataStream) {
                        MemoryStream compressedDataStream = new MemoryStream();
                        DeflaterOutputStream deflaterStream = new DeflaterOutputStream(compressedDataStream);
                        uncompressedDataStream.WriteTo(deflaterStream);
                        deflaterStream.Flush();
                        deflaterStream.Finish();
                        byte[] result = new byte[compressedDataStream.Length];
                        compressedDataStream.Seek(0, SeekOrigin.Begin);
                        compressedDataStream.Read(result, 0, result.Length);
                        deflaterStream.Close();
                        compressedDataStream.Close();
                        return result;
                }

                public static byte[] StaticUnzip(ref MemoryStream compressedStream) {
                        EncodedData instance = new EncodedData();
                        return instance.Unzip(ref compressedStream);
                }

                public static byte[] StaticZip(MemoryStream uncompressedDataStream) {
                        EncodedData instance = new EncodedData();
                        return instance.Zip(uncompressedDataStream);
                }
        }
}

---