public unsafe void ReceiveChunk(string endpoint, bool isAlive, int bytesReceived, SocketError status)
		{
			if (IsEnabled())
			{
				fixed (char* pEndpoint = endpoint)
				{
					var data = stackalloc EventData[4];

					data[0].DataPointer = (IntPtr)(pEndpoint);
					data[0].Size = (endpoint.Length + 1) * 2;

					var alive = isAlive ? 1 : 0;
					data[1].DataPointer = (IntPtr)(&alive);
					data[1].Size = sizeof(int);

					data[2].DataPointer = (IntPtr)(&bytesReceived);
					data[2].Size = sizeof(int);

					data[3].Size = sizeof(int);
					data[3].DataPointer = (IntPtr)(&status);

					WriteEventCore(22, 4, data);
				}
			}
		}

 private void InitOption(MailStatus status, MailCause cause)
 {
     this.mStatus = status;
     this.mCause = cause;
     this.mSocketErrorCode = 0;
     this.mSocketErrorCodeType = SocketError.Success;
 }

 private void OnConnectionFailed(ITcpConnection connection, SocketError socketError)
 {
     if (Interlocked.CompareExchange(ref _isClosed, 1, 0) == 0)
     {
         Console.WriteLine("Connection '{0}' ({1:B}) to [{2}] failed: {3}.", _connectionName, _connectionId, connection.RemoteEndPoint, socketError);
     }
 }

        public void InCompleted(SocketError socketError, int bytesTransferred)
        {
            if (socketError != SocketError.Success)
            {
                m_socket.EventAcceptFailed(m_address.ToString(), ErrorHelper.SocketErrorToErrorCode(socketError));

                // dispose old object
                m_acceptedSocket.Handle.Dispose();

                Accept();
            }
            else
            {
                m_acceptedSocket.InitOptions();

                var pgmSession = new PgmSession(m_acceptedSocket, m_options);

                IOThread ioThread = ChooseIOThread(m_options.Affinity);

                SessionBase session = SessionBase.Create(ioThread, false, m_socket, m_options, new Address(m_handle.LocalEndPoint));

                session.IncSeqnum();
                LaunchChild(session);
                SendAttach(session, pgmSession, false);
                m_socket.EventAccepted(m_address.ToString(), m_acceptedSocket.Handle);

                Accept();
            }
        }

 private void OnClientDisconnect(ServerClient arg1, SocketError arg2)
 {
     Console.WriteLine("Disconnected");
     _timeSyncCompleted = false;
     _completedEvent.Set();
     _batchCounter = 0;
 }

 private void OnConnectionClosed(ITcpConnection connection, SocketError socketError)
 {
     if (Interlocked.CompareExchange(ref _isClosed, 1, 0) == 0)
     {
         Console.WriteLine("Connection '{0}' [{1:B}] closed: {2}.", connection.ConnectionId, connection.RemoteEndPoint, socketError);
     }
 }

        /// <summary>
        /// Connect TCP socket to a server.
        /// </summary>
        /// <param name="serverAddr">IP or hostname of server.</param>
        /// <param name="port">Port that TCP should use.</param>
        /// <returns>True if connection is successful otherwise false</returns>
        internal bool Connect(string serverAddr, int port)
        {
            try
            {
                IPAddress[] serverIP = Dns.GetHostAddresses(serverAddr);
                if (serverIP.Length <= 0)
                {
                    mErrorString = "Error looking up host name";
                    return false;
                }

                mTCPClient = new TcpClient();
                mTCPClient.Connect(serverIP[0], port);
                // Disable Nagle's algorithm
                mTCPClient.NoDelay = true;
            }
            catch (SocketException e)
            {
                mErrorString = e.Message;
                mErrorCode = e.SocketErrorCode;

                if (mTCPClient != null)
                {
                    mTCPClient.Close();
                }

                return false;
            }

            return true;
        }

 internal SocketError CheckAsyncCallOverlappedResult(SocketError errorCode)
 {
     if (this.m_UseOverlappedIO)
     {
         switch (errorCode)
         {
             case SocketError.Success:
             case SocketError.IOPending:
                 ThreadPool.UnsafeRegisterWaitForSingleObject(this.m_OverlappedEvent, new WaitOrTimerCallback(this.OverlappedCallback), this, -1, true);
                 return SocketError.Success;
         }
         base.ErrorCode = (int) errorCode;
         base.Result = -1;
         this.ReleaseUnmanagedStructures();
         return errorCode;
     }
     this.ReleaseUnmanagedStructures();
     switch (errorCode)
     {
         case SocketError.Success:
         case SocketError.IOPending:
             return SocketError.Success;
     }
     base.ErrorCode = (int) errorCode;
     base.Result = -1;
     if (this.m_Cache != null)
     {
         this.m_Cache.Overlapped.AsyncResult = null;
     }
     this.ReleaseUnmanagedStructures();
     return errorCode;
 }

        private void OnConnectionClosed(ITcpConnection connection, SocketError socketError)
        {
            connection.ConnectionClosed -= OnConnectionClosed;

            var handler = ConnectionClosed;
            if (handler != null)
                handler(this, socketError);
        }

        private void AcceptCompletionCallback(IntPtr acceptedFileDescriptor, byte[] socketAddress, int socketAddressSize, SocketError socketError)
        {
            _acceptedFileDescriptor = acceptedFileDescriptor;
            Debug.Assert(socketAddress == null || socketAddress == _acceptBuffer, $"Unexpected socketAddress: {socketAddress}");
            _acceptAddressBufferCount = socketAddressSize;

            CompletionCallback(0, socketError);
        }

        internal SocketException(SocketError errorCode, uint platformError) : base((int)platformError)
        {
            _errorCode = errorCode;

            if (GlobalLog.IsEnabled)
            {
                GlobalLog.Print($"SocketException::.ctor(SocketError={errorCode}, uint={platformError}):{Message}");
            }
        }

        /// <summary>Creates a new instance of the <see cref='System.Net.Sockets.SocketException'/> class with the specified error code as SocketError.</summary>
        internal SocketException(SocketError socketError) : base(GetNativeErrorForSocketError(socketError))
        {
            _errorCode = socketError;

            if (GlobalLog.IsEnabled)
            {
                GlobalLog.Print($"SocketException::.ctor(SocketError={socketError}):{Message}");
            }
        }

 public override bool Close () {
     try {
         socket.Close();
         return true;
     } catch (SocketException exn) {
         socketError = exn.SocketErrorCode;
         return false;
     }
 }

 internal CompletionStatus(AsyncSocket asyncSocket, object state, OperationType operationType, SocketError socketError, int bytesTransferred) : 
     this()
 {
     AsyncSocket = asyncSocket;
     State = state;
     OperationType = operationType;
     SocketError = socketError;
     BytesTransferred = bytesTransferred;
 }

        public void CompletionCallback(int numBytes, byte[] socketAddress, int socketAddressSize, SocketFlags receivedFlags, SocketError errorCode)
        {
            if (_socketAddress != null)
            {
                Debug.Assert(socketAddress == null || _socketAddress.Buffer == socketAddress);
                _socketAddressSize = socketAddressSize;
            }

            base.CompletionCallback(numBytes, errorCode);
        }

        private void AcceptCompletionCallback(int acceptedFileDescriptor, byte[] socketAddress, int socketAddressSize, SocketError socketError)
        {
            // TODO: receive bytes on socket if requested

            _acceptedFileDescriptor = acceptedFileDescriptor;
            Debug.Assert(socketAddress == null || socketAddress == _acceptBuffer);
            _acceptAddressBufferCount = socketAddressSize;

            CompletionCallback(0, socketError);
        }

        public static string GetDesc(SocketError e)
        {
            switch(e)
            {
                case SocketError.Success: return "The Socket operation succeeded.";
                case SocketError.SocketError: return "An unspecified Socket error has occurred.";
                case SocketError.Interrupted: return "A blocking Socket call was canceled.";
                case SocketError.AccessDenied: return "An attempt was made to access a Socket in a way that is forbidden by its access permissions.";
                case SocketError.Fault: return "An invalid pointer address was detected by the underlying socket provider.";
                case SocketError.InvalidArgument: return "An invalid argument was supplied to a Socket member.";
                case SocketError.TooManyOpenSockets: return "There are too many open sockets in the underlying socket provider.";
                case SocketError.WouldBlock: return "An operation on a nonblocking socket cannot be completed immediately.";
                case SocketError.InProgress: return "A blocking operation is in progress.";
                case SocketError.AlreadyInProgress: return "The nonblocking Socket already has an operation in progress.";
                case SocketError.NotSocket: return "A Socket operation was attempted on a non-socket.";
                case SocketError.DestinationAddressRequired: return "A required address was omitted from an operation on a Socket.";
                case SocketError.MessageSize: return "The datagram is too long.";
                case SocketError.ProtocolType: return "The protocol type is incorrect for this Socket.";
                case SocketError.ProtocolOption: return "An unknown, invalid, or unsupported option or level was used with a Socket.";
                case SocketError.ProtocolNotSupported: return "The protocol is not implemented or has not been configured.";
                case SocketError.SocketNotSupported: return "The support for the specified socket type does not exist in this address family.";
                case SocketError.OperationNotSupported: return "The address family is not supported by the protocol family.";
                case SocketError.ProtocolFamilyNotSupported: return "The protocol family is not implemented or has not been configured.";
                case SocketError.AddressFamilyNotSupported: return "The address family specified is not supported. This error is returned if the IPv6 address family was specified and the IPv6 stack is not installed on the local machine. This error is returned if the IPv4 address family was specified and the IPv4 stack is not installed on the local machine.";
                case SocketError.AddressAlreadyInUse: return "Only one use of an address is normally permitted.";
                case SocketError.AddressNotAvailable: return "The selected IP address is not valid in this context.";
                case SocketError.NetworkDown: return "The network is not available.";
                case SocketError.NetworkUnreachable: return "No route to the remote host exists.";
                case SocketError.NetworkReset: return "The application tried to set KeepAlive on a connection that has already timed out.";
                case SocketError.ConnectionAborted: return "The connection was aborted by the .NET Framework or the underlying socket provider.";
                case SocketError.ConnectionReset: return "The connection was reset by the remote peer.";
                case SocketError.NoBufferSpaceAvailable: return "No free buffer space is available for a Socket operation.";
                case SocketError.IsConnected: return "The Socket is already connected.";
                case SocketError.NotConnected: return "The application tried to send or receive data, and the Socket is not connected.";
                case SocketError.Shutdown: return "A request to send or receive data was disallowed because the Socket has already been closed.";
                case SocketError.TimedOut: return "The connection attempt timed out, or the connected host has failed to respond.";
                case SocketError.ConnectionRefused: return "The remote host is actively refusing a connection.";
                case SocketError.HostDown: return "The operation failed because the remote host is down.";
                case SocketError.HostUnreachable: return "There is no network route to the specified host.";
                case SocketError.ProcessLimit: return "Too many processes are using the underlying socket provider.";
                case SocketError.SystemNotReady: return "The network subsystem is unavailable.";
                case SocketError.VersionNotSupported: return "The version of the underlying socket provider is out of range.";
                case SocketError.NotInitialized: return "The underlying socket provider has not been initialized.";
                case SocketError.Disconnecting: return "A graceful shutdown is in progress.";
                case SocketError.TypeNotFound: return "The specified class was not found.";
                case SocketError.HostNotFound: return "No such host is known. The name is not an official host name or alias.";
                case SocketError.TryAgain: return "The name of the host could not be resolved. Try again later.";
                case SocketError.NoRecovery: return "The error is unrecoverable or the requested database cannot be located.";
                case SocketError.NoData: return "The requested name or IP address was not found on the name server.";
                case SocketError.IOPending: return "The application has initiated an overlapped operation that cannot be completed immediately.";
                case SocketError.OperationAborted: return "The overlapped operation was aborted due to the closure of the Socket.";
            }

            return "Unknown Socket Error";
        }

 // http://msdn.microsoft.com/ko-kr/library/vstudio/system.net.sockets.socketerror(v=vs.100).aspx
 public static bool IsIgnorableError(SocketError error)
 {
     if (error == SocketError.Interrupted
         || error == SocketError.ConnectionAborted
         || error == SocketError.ConnectionReset
         || error == SocketError.OperationAborted)
     {
         return true;
     }
     return false;
 }

        public void CompletionCallback(int numBytes, byte[] socketAddress, int socketAddressSize, SocketFlags receivedFlags, IPPacketInformation ipPacketInformation, SocketError errorCode)
        {
            Debug.Assert(_socketAddress != null);
            Debug.Assert(socketAddress == null || _socketAddress.Buffer == socketAddress);

            _socketAddressSize = socketAddressSize;
            _socketFlags = receivedFlags;
            _ipPacketInformation = ipPacketInformation;

            base.CompletionCallback(numBytes, errorCode);
        }

 void Handle( SocketError se )
 {
     switch ( se ) {
     case SocketError.Success:
         return; // not an error
     case SocketError.ConnectionReset:
         if (AutoReconnect) BeginReconnect();
         break;
     }
     if ( OnSocketError != null ) OnSocketError(se);
 }