public SocketStream(SocketInfo info, IOLoop ioloop)
            : base(ioloop)
        {
            state = SocketState.Open;

            port = info.port;
            address = info.Address;
        }

    // --

    public Client(IClientListener listener)
    {
        this.listeners = new List<IClientListener>();
        this.listeners.Add(listener);
        this.username = User.Instance.username;
        this.id = User.Instance.id;
        this.state = SocketState.DISCONNECTED;
    }

        public SocketStream(Socket socket, IOLoop ioloop)
            : base(ioloop)
        {
            this.socket = socket;

            if (socket != null) {
                socket.Blocking = false;
                SetHandle (IOWatcher.GetHandle (socket));
                state = SocketState.Open;
            }
        }

        public SocketStream(SocketInfo info, IOLoop ioloop)
            : base(ioloop)
        {
            fd = info.fd;

            if (fd > 0) {
                SetHandle (fd);
                state = SocketState.Open;
            }

            port = info.port;
        }

 public void CloseAbortively()
 {
     try
     {
         ClientSocket.AbortiveClose();
         ClientSocket = null;
         ClientSocketState = SocketState.Closed;
         Console.WriteLine("Abortively closed socket");
     }
     catch (Exception ex)
     {
         ResetSocket();
         Console.WriteLine("Error aborting socket: [" + ex.GetType().Name + "] " + ex.Message);
     }
     finally
     {
         RefreshDisplay();
     }
 }

    /// <summary>
    /// Connexion au serveur
    /// </summary>
    /// <param name="host">Localisation du serveur</param>
    /// <param name="port">Id of friend</param>
    /// <param name="authenticate">Authentification automatique</param>
    public void Connect(string host = HOST, int port = PORT, bool authenticate = true)
    {
        this._sock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        try
        {
            _sock.Connect(host, port);
            this.state = SocketState.CONNECTED;

            run = new Thread(new ThreadStart(ReceiveLoop));
            run.Name = "ReceiveThread";
            run.IsBackground = true;
            run.Start();

            if (authenticate)
                this.Authenticate();
        }
        catch (Exception e)
        {
            Debug.Log("Erreur de connexion : " + e.Message);
        }
    }

        private void SendToClient(SocketState state, byte[] data)
        {
            if (state == null)
                return;

            if (state.Socket == null || !state.Socket.Connected) {
                state.Dispose();
                state = null;
                return;
            }

            if (_socketSendCallback == null)
                _socketSendCallback = OnSent;

            try {
                state.Socket.BeginSend(data, 0, data.Length, SocketFlags.None, _socketSendCallback, state);
            } catch (SocketException e) {
                LogError(Category, "Error sending data");
                LogError(Category, String.Format("{0} {1}", e.SocketErrorCode, e));
            }
        }

        private void AcceptCallback(IAsyncResult ar)
        {
            _reset.Set();

            Socket listener = (Socket)ar.AsyncState;
            Socket handler = listener.EndAccept(ar);

            SocketState state = new SocketState() {
                Socket = handler
            };

            WaitForData(state);
        }

        private void SendRemainingBytes(int offset, int count)
        {
            lock (this)
            {
                if (socketState == SocketState.Idle)
                {
                    socketState = SocketState.Sending;

                    this.eventArgs.SetBuffer(offset, count);
                    bool asynchronous = this.socket.SendAsync(this.eventArgs);
                    if (!asynchronous)
                    {
                        this.IOCompleted(this, this.eventArgs);
                    }
                }
                else
                {
                    Console.WriteLine("Error: we shouldn't have come here 2");
                }
            }
        }

        private void TrySend()
        {
            lock (this)
            {
                if (socketState == SocketState.Idle)
                {
                    var messageToSend = outgoingMessages.Dequeue();

                    socketState = SocketState.Sending;

                    this.eventArgs.SetBuffer(messageToSend, 0, messageToSend.Length);
                    bool asynchronous = this.socket.SendAsync(this.eventArgs);
                    if (!asynchronous)
                    {
                        this.IOCompleted(this, this.eventArgs);
                    }
                }
            }
        }

          private void beginAcceptCallback_forStartListening(IAsyncResult result)
          {
                  Console.WriteLine("TransportLayerCommunicator::beginAcceptCallback_forStartListening ENTER");
          
      SocketUtility.SocketListener.SocketListenState socketListenState = (SocketUtility.SocketListener.SocketListenState) result.AsyncState;
      // Signal the listener thread to continue.
      socketListenState.allDone.Set();
      Socket listener = socketListenState.sock;
      Socket handler = listener.EndAccept(result);
        
      TransportLayerCommunicator transportLayerCommunicator = (TransportLayerCommunicator)(socketListenState.obj);
                 
          SockMsgQueue sockMsgQueue = new SockMsgQueue(handler, transportLayerCommunicator );
          IPAddress IP = ((IPEndPoint)(handler.RemoteEndPoint)).Address;
          SocketState socketState = new SocketState();
          socketState.transportLayerCommunicator = transportLayerCommunicator;
                     
          try
                  {
                          transportLayerCommunicator.commRegistry.Add(IP, sockMsgQueue);
                          socketState.sock = handler;
                  handler.BeginReceive( socketState.buffer, 0, socketState.buffer.Length, new SocketFlags(), new AsyncCallback(beginReceiveCallBack), socketState);      
                          Console.WriteLine("TransportLayerCommunicator::beginAcceptCallback_forStartListening EXIT");
          }
                  catch(System.ArgumentException)
                  {
                          socketState.sock = handler;
                  handler.BeginReceive( socketState.buffer, 0, socketState.buffer.Length, new SocketFlags(), new AsyncCallback(beginReceiveCallBack), socketState);      
                  Console.WriteLine("TransportLayerCommunicator::beginAcceptCallback_forStartListening EXIT");
                  }
                  Console.WriteLine("TransportLayerCommunicator::beginAcceptCallback_forStartListening EXIT");
 
          }

		protected void OnChangeState(SocketState newState)
		{
			SocketState prev = this.state;
			this.state = newState;
			if (this.StateChanged != null)
				this.StateChanged(new NetSockStateChangedEventArgs(this.state, prev));

			if (this.state == SocketState.Connected)
				this.connectionTimer.Change(0, this.ConnectionCheckInterval);
			else if (this.state == SocketState.Closed)
				this.connectionTimer.Change(Timeout.Infinite, Timeout.Infinite);
		}

        /// <summary>
        /// Close the socket.  This is NOT async.  .Net doesn't have
        /// async closes.  But, it can be *called* async, particularly
        /// from GotData.  Attempts to do a shutdown() first.
        /// </summary>
        public override void Close()
        {
            Debug.WriteLine("Close");
            lock (this)
            {
                /*
                switch (State)
                {
                case State.Closed:
                    throw new InvalidOperationException("Socket already closed");
                case State.Closing:
                    throw new InvalidOperationException("Socket already closing");
                }
                */

                SocketState oldState = State;

                if (m_sock.Connected)
                {
                    State = SocketState.Closing;
                }

                if (m_stream != null)
                    m_stream.Close();
                else
                {
                    try
                    {
                        m_sock.Close();
                    }
                    catch { }
                }

                if (oldState <= SocketState.Connected)
                    m_listener.OnClose(this);

                if (m_watcher != null)
                    m_watcher.CleanupSocket(this);

                State = SocketState.Closed;
            }
        }

        /// <summary>
        /// Prepare to start accepting inbound requests.  Call
        /// RequestAccept() to start the async process.
        /// </summary>
        /// <param name="addr">Address to listen on</param>
        /// <param name="backlog">The Maximum length of the queue of
        /// pending connections</param>
        public override void Accept(Address addr, int backlog)
        {
            lock (this)
            {
                m_addr = addr;

                m_sock = new Socket(AddressFamily.InterNetwork,
                                    SocketType.Stream,
                                    ProtocolType.Tcp);

                // Always reuse address.
                m_sock.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, 1);
                m_sock.Bind(m_addr.Endpoint);
                m_sock.Listen(backlog);
                State = SocketState.Listening;

                if (m_watcher != null)
                    m_watcher.RegisterSocket(this);
            }
        }

        /// <summary>
        /// Address resolution finished.  Try connecting.
        /// </summary>
        /// <param name="addr"></param>
        private void OnConnectResolved(Address addr)
        {
            // Debug.WriteLine("connectresolved: " + addr.ToString());
            lock (this)
            {
                if (State != SocketState.Resolving)
                {
                    // closed in the mean time.   Probably not an error.
                    return;
                }
                if ((addr == null) || (addr.IP == null) || (addr.Endpoint == null))
                {
                    FireError(new AsyncSocketConnectionException("Bad host: " + addr.Hostname));
                    return;
                }

                if (m_watcher != null)
                    m_watcher.RegisterSocket(this);

                m_addr = addr;
                State = SocketState.Connecting;

                if (Socket.OSSupportsIPv6 && (m_addr.Endpoint.AddressFamily == AddressFamily.InterNetworkV6))
                {
                    // Debug.WriteLine("ipv6");
                    m_sock = new Socket(AddressFamily.InterNetworkV6,
                        SocketType.Stream,
                        ProtocolType.Tcp);
                }
                else
                {
                    // Debug.WriteLine("ipv4");
                    m_sock = new Socket(AddressFamily.InterNetwork,
                        SocketType.Stream,
                        ProtocolType.Tcp);
                }

                // well, of course this isn't right.
                m_sock.SetSocketOption(SocketOptionLevel.Socket,
                    SocketOptionName.ReceiveBuffer,
                    4 * m_buf.Length);
            }

            if (m_synch)
            {
                try
                {
                    m_sock.Connect(m_addr.Endpoint);
                }
                catch (SocketException ex)
                {
                    FireError(ex);
                    return;
                }

                if (m_sock.Connected)
                {
                    // TODO: check to see if this Mono bug is still valid
            #if __MonoCS__
                    m_sock.Blocking = true;
                    m_stream = new NetworkStream(m_sock);
                    m_sock.Blocking = false;
            #else
                    m_stream = new NetworkStream(m_sock);
            #endif
                    if (m_secureProtocol != SslProtocols.None)
                        StartTLS();

                    lock (this)
                    {
                        State = SocketState.Connected;
                    }
                    m_listener.OnConnect(this);
                }
                else
                {
                    AsyncClose();
                    FireError(new AsyncSocketConnectionException("could not connect"));
                }
            }
            else
            {
            #if __MonoCS__
                m_sock.Blocking = false;
            #endif
                m_sock.BeginConnect(m_addr.Endpoint, new AsyncCallback(ExecuteConnect), null);
            }
        }

        private async void Send(byte[] data)
        {

            var cts = new CancellationTokenSource();
            ConnectionClosing += (sender, args) => cts.Cancel();

            var state = new SocketState() { Buffer = data, Socket = _client };

            try
            {
                var t = await SendAsync(state, cts.Token);
                if (!t) throw new Exception("Data not send");
                OnSendComplete();
            }
            catch (OperationCanceledException e)
            {
                Debug.WriteLine("Sending cancelled");
            }

            catch (Exception e)
            {
                var mes = "Error sending data: " + e;
                Debug.WriteLine(mes);
                _netStates.Fire(NetEvent.Error, e);
            }
            Debug.WriteLine("Net: Send Data");
        }

        private static Task<bool> SendAsync(SocketState state, CancellationToken ct)
        {
            var tcs = new TaskCompletionSource<bool>(state);

            state.Socket.BeginSend(state.Buffer, 0, state.Buffer.Length, SocketFlags.None, (iar) =>
            {
                var t = (TaskCompletionSource<bool>)iar.AsyncState;
                var s = (SocketState)t.Task.AsyncState;
                using (ct.Register(() => t.TrySetCanceled()))
                {
                    try
                    {
                        s.Socket.EndSend(iar);
                        t.TrySetResult(true);
                    }
                    catch (Exception exc)
                    {
                        t.TrySetException(exc);
                    }
                }
            }, tcs);
            return tcs.Task;
        }

 /// <summary>
 /// Outbound connection.  Eventually calls Listener.OnConnect() when
 /// the connection comes up.  Don't forget to call RequestRead() in
 /// OnConnect()!
 /// </summary>
 /// <param name="addr"></param>
 public override void Connect(Address addr)
 {
     // Debug.WriteLine("starting connect to " + addr.ToString());
     State = SocketState.Resolving;
     if (m_synch)
     {
         addr.Resolve();
         OnConnectResolved(addr);
     }
     else
     {
         addr.Resolve(new AddressResolved(OnConnectResolved));
     }
 }

		public NetSockStateChangedEventArgs(SocketState newState, SocketState prevState)
		{
			this.NewState = newState;
			this.PrevState = prevState;
		}

 /// <summary>
 /// Error occurred in the class.  Send to Listener.
 /// </summary>
 /// <param name="e"></param>
 protected void FireError(Exception e)
 {
     lock (this)
     {
         State = SocketState.Error;
     }
     if (e is SocketException)
     {
         Debug.WriteLine("Sock errno: " + ((SocketException) e).ErrorCode);
     }
     if (m_watcher != null)
         m_watcher.CleanupSocket(this);
     m_listener.OnError(this, e);
 }