public bool OnInvalidCertificate(BaseSocket sock,
     System.Security.Cryptography.X509Certificates.X509Certificate certificate,
     System.Security.Cryptography.X509Certificates.X509Chain chain,
     System.Net.Security.SslPolicyErrors sslPolicyErrors)
 {
     return false;
 }

 public void OnError(BaseSocket sock, Exception ex)
 {
     lock (done)
     {
         succeeded = false;
         errorMessage = ex.Message;
         Monitor.Pulse(done);
     }
 }

            public bool OnRead(BaseSocket sock, byte[] buf, int offset, int length)
            {
                string str = ENC.GetString(buf, offset, length);
                Console.WriteLine("SR: " + str);
                if (str.Contains("11111"))
                {
                sock.Write(ENC.GetBytes(@"HTTP/1.1 200 OK
Content-Length: 10
Content-Type: text/plain

1234567890"));
                }
                else if (str.Contains("22222"))
                {
                    sock.Write(ENC.GetBytes(@"HTTP/1.1 200 OK
Content-Length: 10
Content-Type: text/plain

12345"));
                    sock.Write(ENC.GetBytes("67890"));
                }
                else if (str.Contains("33333"))
                {
                    sock.Write(ENC.GetBytes(@"HTTP/1.1 200 OK
Content-Length: 20
Content-Type: text/plain

12345"));
                    // Turning off Nagle didn't fix this.  Mrmph.
                    Thread.Sleep(300);
                    sock.Write(ENC.GetBytes("67890"));
                    Thread.Sleep(300);
                    sock.Write(ENC.GetBytes("12345"));
                    Thread.Sleep(300);
                    sock.Write(ENC.GetBytes("67890"));
                }
                return true;
            }

 /// <summary>
 /// Outbound connection was connected.
 /// </summary>
 /// <param name="sock">Connected socket.</param>
 public virtual void OnConnect(BaseSocket sock)
 {
 }

 /// <summary>
 /// An error happened in processing.  The socket is no longer open.
 /// </summary>
 /// <param name="sock">Socket in error</param>
 /// <param name="ec">Exception that caused the error</param>
 public virtual void OnError(BaseSocket sock, System.Exception ec)
 {
 }

 /// <summary>
 ///
 /// </summary>
 /// <param name="sock"></param>
 /// <param name="buf"></param>
 /// <param name="offset"></param>
 /// <param name="length"></param>
 public virtual void OnWrite(BaseSocket sock, byte[] buf, int offset, int length)
 {
     m_listener.OnWrite(sock, buf, offset, length);
 }

 void ISocketEventListener.OnInit(BaseSocket newSock)
 {
 }

 public void OnWrite(BaseSocket sock, byte[] buf, int offset, int length)
 {
     System.Diagnostics.Debug.WriteLine(ENC.GetString(buf, offset, length));
     sock.Close();
 }

 /// <summary>
 ///
 /// </summary>
 /// <param name="sock"></param>
 /// <param name="ex"></param>
 public virtual void OnError(BaseSocket sock, System.Exception ex)
 {
     m_listener.OnError(sock, ex);
 }

 public void OnInit(BaseSocket new_sock)
 {
 }

 /// <summary>
 /// Bytes were written to the socket.
 /// </summary>
 /// <param name="sock">The socket that was written to.</param>
 /// <param name="buf">The bytes that were written.</param>
 /// <param name="offset">Offset into the buffer to start at</param>
 /// <param name="length">Number of bytes to use out of the buffer</param>
 public virtual void OnWrite(BaseSocket sock, byte[] buf, int offset, int length)
 {
 }

 public void OnConnect(BaseSocket sock)
 {
     sock.Write(sbuf, 5, 10);
 }

        bool ISocketEventListener.OnRead(BaseSocket sock, byte[] buf, int offset, int length)
        {
            int tim = (int)m_listener[Options.KEEP_ALIVE];
            if (tim > 0)
                m_timer.Change(tim, tim);

            m_listener.BytesRead(buf, offset, length);
            try
            {
                m_elements.Push(buf, offset, length);
            }
            catch (Exception e)
            {
                ((ISocketEventListener)this).OnError(sock, e);
                sock.Close();
                return false;
            }
            return true;
        }

 public void OnClose(BaseSocket sock)
 {
 }

 public bool OnAccept(BaseSocket newsocket)
 {
     newsocket.RequestRead();
     return false;
 }

 public ISocketEventListener GetListener(BaseSocket new_sock)
 {
     return this;
 }

 /// <summary>
 /// An accept socket is about to be bound, or a connect socket is about to connect,
 /// or an incoming socket just came in.  Use this as an opportunity to
 /// </summary>
 /// <param name="newSock">The new socket that is about to be connected.</param>
 public virtual void OnInit(BaseSocket newSock)
 {
 }

 /// <summary>
 ///
 /// </summary>
 /// <param name="newSock"></param>
 /// <returns></returns>
 public virtual ISocketEventListener GetListener(BaseSocket newSock)
 {
     return m_listener.GetListener(newSock);
 }

 /// <summary>
 /// Bytes were read from the socket.
 /// </summary>
 /// <param name="sock">The socket that was read from.</param>
 /// <param name="buf">The bytes that were read.</param>
 /// <returns>true if RequestRead() should be called automatically again</returns>
 /// <param name="offset">Offset into the buffer to start at</param>
 /// <param name="length">Number of bytes to use out of the buffer</param>
 public virtual bool OnRead(BaseSocket sock, byte[] buf, int offset, int length)
 {
     return true;
 }

        /// <summary>
        ///
        /// </summary>
        /// <param name="sock"></param>
        public virtual void OnConnect(BaseSocket sock)
        {
            if (m_ssl)
            {
#if !NO_SSL
                m_sock.StartTLS();
#else
                throw new NotImplementedException("SSL not compiled in");
#endif
            }
            m_listener.OnConnect(sock);
        }