HTTPObject.cs

using System;
using System.Threading;
using System.Collections;
using System.Collections.Specialized;
using System.Text;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Security.Cryptography;

namespace Common
{
        public abstract class HTTPObject
        {
                protected HTTPHeader headers;
                protected HTTPBody body;

                public HTTPObject() {}

                public byte[] Serialise() {
                        /* produces byte array in the following format:
                         * 0..3: Header Length (int bytes, -1 if no header);
                         * 4..7: Body Length (int bytes, -1 if no body)
                         * [8..n: Header Data]
                         * [n..m; Body Data]
                         */ 
                        byte[] result;
                        byte[] headerBuffer = null;
                        byte[] intSizeByteBuffer;
                        int resultLength = 0;
                        int headerLength = 0;
                        int bodyLength = 0;
                        if (headers != null) { 
                                headerBuffer = Encoding.ASCII.GetBytes(headers.rawString);
                                headerLength = headerBuffer.Length;
                                resultLength += headerLength;
                        } else {
                                headerLength = -1;
                        }
                        if (body != null) { 
                                bodyLength = body.data.Length;
                                resultLength += bodyLength; 
                        } else {
                                bodyLength = -1;
                        }
                        result = new byte[resultLength + 8]; // add 8 for header length, body length at start
                        intSizeByteBuffer = BitConverter.GetBytes(headerLength);
                        Array.Copy(intSizeByteBuffer, 0, result, 0, intSizeByteBuffer.Length);
                        intSizeByteBuffer = BitConverter.GetBytes(bodyLength);
                        Array.Copy(intSizeByteBuffer, 0, result, 4, intSizeByteBuffer.Length);
                        if (headers != null) { Array.Copy(headerBuffer, 0, result, 8, headerBuffer.Length); }
                        if (body != null) { Array.Copy(body.data, 0, result, 8 + headerBuffer.Length, body.data.Length); }
                        return result;
                }

                public byte[] ToHTTPByteArray() {
                        /* produces byte array in the following format:
                         * 0..3: Header Length (int bytes, -1 if no header);
                         * 4..7: Body Length (int bytes, -1 if no body)
                         * [8..n: Header Data]
                         * [n..m; Body Data]
                         */ 
                        byte[] result;
                        byte[] headerBuffer = null;
                        int resultLength = 0;
                        if (headers != null) { 
                                headerBuffer = Encoding.ASCII.GetBytes(headers.rawString);
                                resultLength += headerBuffer.Length;
                        }
                        if (body != null) { 
                                resultLength += body.data.Length; 
                        } 
                        result = new byte[resultLength];
                        if (headers != null) { Array.Copy(headerBuffer, 0, result, 0, headerBuffer.Length); }
                        if (body != null) { Array.Copy(body.data, 0, result, headerBuffer.Length, body.data.Length); }
                        return result;
                }


                public HTTPObject(byte[] src) {
                        int headerLength = BitConverter.ToInt32(src, 0);
                        int bodyLength = BitConverter.ToInt32(src, 4);
                        if (headerLength != -1 ) {
                                headerBytes = new byte[headerLength];
                                Array.Copy(src, 8, headerBytes, 0, headerLength);
                        } else { 
                                headerBytes = null;
                        }
                        if (bodyLength != -1) {
                                bodyBytes = new byte[bodyLength];
                                Array.Copy(src, 8 + headerLength, bodyBytes, 0, bodyLength);
                        } else {
                                bodyBytes = null;
                        }
                }


                // Used in creation of object from byte array. 
                protected byte[] headerBytes;
                protected byte[] bodyBytes;

                public void AppendBody(HTTPBody newBody) {
                        body = newBody;
                }

                public byte[] GetCHK() {
                        return body.GetCHK();
                }
        }

        /*****************************************************************************************/
        public class HTTPBody {
                public byte[] data;

                public HTTPBody(byte[] data) {
                        this.data = data;
                }

                public byte[] GetCHK() {
                        SHA1Managed sha1 = new SHA1Managed();
                        return sha1.ComputeHash(data);
                }
        }

        /*****************************************************************************************/
        public abstract class HTTPHeader {
                public string rawString;
                protected int rawStringPos = -1; // at proc exit, points to next readable char (or last)
//              protected string VersionInfo;
                public WebHeaderCollection headerCollection;

                /*** Constructors ***/

                public HTTPHeader(string source) {
                        rawString = source;
                        parseRaw();
                }

                /*** Methods ***/

                // Parses the raw data string
                public void parseRaw() {
                        rawStringPos = 0;
                        this.parseHTTP();
                        this.populateRawHeaders();
                }

                protected abstract void parseHTTP();
//
//              protected void parseVersionInfo(string src) {
//              }

//              protected void parseResponseText(string src) {
//              }

                public void populateRawHeaders() {
                        string CRLF = "\r\n";
                        headerCollection = new WebHeaderCollection();
                        // keep on looping until we hit a blank line.
                        int i1 = rawStringPos;
                        int i2 = rawString.IndexOf(CRLF, i1);
                        string s = rawString.Substring(i1, i2-i1);
                        while (s != "") {
                                headerCollection.Add(s);
                                i1 = i2 + CRLF.Length;
                                i2 = rawString.IndexOf(CRLF, i1);
                                s = rawString.Substring(i1, i2-i1);
                        }
                        rawStringPos = i1;
                }
        }


        /**************************************************************************************************/
        public class HTTPObjectQueue: Queue {
                //TODO: Comment
                //TODO: Search Client for calls to Enqueue and Dequeue

                public void EnqueueBlocking(HTTPObject obj) {
                        lock(this) {
                                Enqueue(obj);
                                Monitor.Pulse(this);
                        }
                }

                public HTTPObject DequeueBlocking() {
                        HTTPObject result;
                        lock(this) {
                                while (Count == 0) { Monitor.Wait(this); }
                                result = (HTTPObject)Dequeue();
                                Monitor.Pulse(this);
                        }
                        return result;
                }

                
        }

        public class StreamUtil {
                public static string ReadLine(ref Stream ns) {
                        const byte CR = 13;
                        const byte LF = 10;
                        byte[] bBuffer = new byte[8 * 1024]; // 8kB Buffer
                        int elementCount = 0;
                        bool endOfStream = false;
                        bool endOfLine = false;

                        string sBuffer;
                        int readByteResult;
                        byte currentByte;

                        while (!endOfStream && !endOfLine) {
                                readByteResult = ns.ReadByte();
                                if (readByteResult == -1) {
                                        endOfStream = true;
                                } else {
                                        currentByte = (byte)readByteResult;
                                        if (currentByte == CR) {
                                                readByteResult = ns.ReadByte();
                                                if (readByteResult == -1) {
                                                        endOfStream = true;
                                                } else { // if CR & 2nd char is not end of stream
                                                        currentByte = (byte)readByteResult;
                                                        if (currentByte == LF) { // if second char is LF
                                                                endOfLine = true; // exit search loop
                                                        } else { // second char was not LF
                                                                append(ref bBuffer, ref elementCount, CR);
                                                                append(ref bBuffer, ref elementCount, currentByte);
                                                        }
                                                } // end 2nd char switch
                                        } else if (currentByte == LF) { // else if 1st char was LF
                                                endOfLine = true; // exit the search loop
                                        } else { // 1st char was not CR or LF
                                                append(ref bBuffer, ref elementCount, currentByte);
                                        }
                                }
                        }
                        if (endOfStream) {
                                // do fancy end of stream processing
                                sBuffer = null;
                        } else {
                                // convert bBuffer into sBuffer
                                sBuffer = Encoding.ASCII.GetString(bBuffer, 0, elementCount);
                        }
                        return sBuffer; 
                }

                private static byte[] ReadBody(ref Stream ns, bool haveTarget, int targetBytes) {
                        // init variables
                        byte[] readBuffer = new byte[8*1024];
                        byte[] bBuffer = new byte[8*1024];
                        bool endOfStream = false;
                        int readByteResult;
                        byte currentByte;

                        int totalBytesRead = 0;

                        // read the stream
                        while (!endOfStream && (haveTarget ? totalBytesRead < targetBytes : true)) {
                                readByteResult = ns.ReadByte();
                                if (readByteResult != -1) {
                                        currentByte = (byte)readByteResult;
                                        append(ref bBuffer, ref totalBytesRead, currentByte);
                                        //append(ref bBuffer, ref totalBytesRead, readBuffer);
                                } else { // end of stream?
                                        endOfStream = true;
                                }
                        }
                        
                        // return the trimmed result
                        byte[] result = new byte[totalBytesRead];
                        Array.Copy(bBuffer, result, totalBytesRead);
                        return result;
                }

                public static byte[] ReadBody(ref Stream ns, int targetBytes) {
                        return ReadBody(ref ns, true, targetBytes);
                }
                public static byte[] ReadBody(ref Stream ns) {
                        return ReadBody(ref ns, false, 0);
                }

                private static void append(ref byte[] buffer, ref int elementCount,  byte data) {
                        if (elementCount + 1 > buffer.Length) {
                                byte[] newBuffer = new byte[buffer.Length * 2];
                                Array.Copy(buffer, 0, newBuffer, 0, buffer.Length);
                                buffer = newBuffer;
                        }
                        buffer[elementCount] = data;
                        elementCount++;
                }

        }
}

---