ConnectionManager.cs

using System;
using System.Net;
using System.Threading;
using System.Net.Sockets;
using System.Text;
using System.IO;
using System.Collections;
using Common;

namespace Client {
        public class ConnectionManager {
                ClientControl clientControl; // parent client control object

                public TcpListener listener; // listens for incoming connections
                Thread processingThread; // thread to listen for connections
                
                //Logger myLogger; // logs client-processed requests
                ArrayList connectionList; 

                public ConnectionManager(ClientControl clientControl) {
                        this.clientControl = clientControl;
                        this.listener = new TcpListener(new IPEndPoint(IPAddress.Any, clientControl.settings.ProxyListenPort)); 
//                      myLogger = new Logger(clientControl.settings);
                        connectionList = new ArrayList();
                }

                public void Start() {
                        processingThread = new Thread(new ThreadStart(Run));
                        listener = new TcpListener(clientControl.settings.ProxyListenIP, clientControl.settings.ProxyListenPort);
                        processingThread.Start();
                }

                void Run() {
                        TcpClient currentClient;
                        Connection currentConnection;
                        listener.Start();
                        try {
                                while(true) { // main listening loop
                                        currentClient = listener.AcceptTcpClient();
                                        // create connection to handle it
                                        currentConnection = new Connection(currentClient, clientControl.userRequests,  connectionList); 
                                        // start the connection processing it
                                        ArrayList.Synchronized(connectionList).Add(currentConnection);
                                        currentConnection.Process();
                                }
                        } catch (ThreadAbortException) {
                                //Console.WriteLine("[Received Listener shutdown command]");
                        }
                        listener.Stop();
                }

                public void Stop() {
                        Console.WriteLine("+++ Stopping Connection Manager +++");
                        if (processingThread != null && processingThread.IsAlive) {
                                processingThread.Abort();
                        }
                        // close all connections
                        try {
                                while (ArrayList.Synchronized(connectionList).Count > 0) {
                                        Connection con = (Connection)connectionList[0];
                                        if (con != null) {
                                                con.Close();
                                        } else {
                                                ArrayList.Synchronized(connectionList).Remove(null);
                                        }
                                }
                                foreach (object o in connectionList) {
                                        if (o != null) {
                                                ((Connection)o).Close();
                                        }
                                }
                        } catch (Exception ex) {
                                Console.Error.WriteLine("*** Error closing open connections ***\n{0}", ex);
                        }
                        if (processingThread != null) {
                                processingThread.Join();}
                        Console.WriteLine("+++ Connection Manager Stopped +++");
                }
        }

        /******************************************************************************************/
        public class Connection  {
                TcpClient connection;
                NetworkStream netStream;
                bool haveRequest = false;

                Thread processingThread;
                ClientHTTPRequestQueueObject currentRequest;
                HTTPObjectQueue requestOutputQueue;
//              DateTime startTime;
//              DateTime endTime;
                ArrayList connections;
                        
                public Connection(TcpClient newClient, HTTPObjectQueue requestOutputQueue, ArrayList connections) {
                        this.connections = connections;
                        processingThread = new Thread(new ThreadStart(this.Run));
                        this.connection = newClient;
                        this.requestOutputQueue = requestOutputQueue;
                        netStream = connection.GetStream();
                }

                public void Process() {
                        processingThread.Start();
                }

        
                void Run() {
//                      startTime = DateTime.Now;
                        try {
                                currentRequest = new ClientHTTPRequestQueueObject(netStream); // create HTTP Request from the socket
                                // holds socket open for response later. 
                                haveRequest = true;
                                currentRequest.connection = this;
                                requestOutputQueue.EnqueueBlocking(currentRequest);
                        } catch (Exception ex) {
                                Console.Error.WriteLine("*** Unable to process connection from browser ***\n{0}", ex);
                                Close(); // shut down the connection.
                        }
                }

                public HTTPRequest Request {
                        get {
                                if (haveRequest) { return currentRequest; }
                                else { throw new ApplicationException("Unable to fetch request on callback - no request stored"); }
                        }
                }

                public void SendResponse(HTTPResponse resp) {
                        try {
                                byte[] outputBuffer = resp.ToHTTPByteArray();
                                if (netStream != null && netStream.CanWrite) { // order of eval important, so is short-circuit eval. 
                                        netStream.Write(outputBuffer, 0, outputBuffer.Length);
                                        //Console.WriteLine("<<< Sent {0} to broswer", currentRequest.URI);
                                } else {
                                        throw new ApplicationException("Bad or missing network stream to send response over");
                                } 
//                              if (myLogger != null) {
//                                      endTime = DateTime.Now;
//                                      //myLogger.Log(currentRequest.URI, startTime, endTime);
//                              }
                        } catch (Exception ex) {
                                Console.Error.WriteLine("*** Unable to write HTTP Response to client, terminating browser connection ***\n{0}", ex);
                        } finally {
                                Close();
                        }
                }

                public void Close() {
                        if (netStream != null) { netStream.Close(); }
                        if (connection != null) { connection.Close(); }
                        ArrayList.Synchronized(connections).Remove(this);
                }
                
        }
        
}

---