runtime/bin/socket_impl.dart - sdk.git - Git at Google

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.


 class _SocketBase extends NativeFieldWrapperClass1 {
   // Bit flags used when communicating between the eventhandler and
   // dart code. The EVENT flags are used to indicate events of
   // interest when sending a message from dart code to the
   // eventhandler. When receiving a message from the eventhandler the
   // EVENT flags indicate the events that actually happened. The
   // COMMAND flags are used to send commands from dart to the
   // eventhandler. COMMAND flags are never received from the
   // eventhandler. Additional flags are used to communicate other
   // information.
   static const int _IN_EVENT = 0;
   static const int _OUT_EVENT = 1;
   static const int _ERROR_EVENT = 2;
   static const int _CLOSE_EVENT = 3;

   static const int _CLOSE_COMMAND = 8;
   static const int _SHUTDOWN_READ_COMMAND = 9;
   static const int _SHUTDOWN_WRITE_COMMAND = 10;

   // Flag send to the eventhandler providing additional information on
   // the type of the file descriptor.
   static const int _LISTENING_SOCKET = 16;
   static const int _PIPE = 17;

   static const int _FIRST_EVENT = _IN_EVENT;
   static const int _LAST_EVENT = _CLOSE_EVENT;

   static const int _FIRST_COMMAND = _CLOSE_COMMAND;
   static const int _LAST_COMMAND = _SHUTDOWN_WRITE_COMMAND;

   _SocketBase () {
     _handlerMap = new List(_LAST_EVENT + 1);
     _handlerMask = 0;
     _canActivateHandlers = true;
     _closed = true;
     _EventHandler._start();
     _hashCode = _nextHashCode;
     _nextHashCode = (_nextHashCode + 1) & 0xFFFFFFF;
   }

   // Multiplexes socket events to the socket handlers.
   void _multiplex(int event_mask) {
     _canActivateHandlers = false;
     for (int i = _FIRST_EVENT; i <= _LAST_EVENT; i++) {
       if (((event_mask & (1 << i)) != 0)) {
         if ((i == _CLOSE_EVENT) && this is _Socket && !_closed) {
           _closedRead = true;
           if (_closedWrite) _close();
         }

         var eventHandler = _handlerMap[i];
         if (eventHandler != null || i == _ERROR_EVENT) {
           // Unregister the out handler before executing it.
           if (i == _OUT_EVENT) _setHandler(i, null);

           // Don't call the in handler if there is no data available
           // after all.
           if ((i == _IN_EVENT) && (this is _Socket) && (available() == 0)) {
             continue;
           }
           if (i == _ERROR_EVENT) {
             _reportError(_getError(), "");
             close();
           } else {
             eventHandler();
           }
         }
       }
     }
     _canActivateHandlers = true;
     _activateHandlers();
   }

   void _setHandler(int event, Function callback) {
     if (callback == null) {
       _handlerMask &= ~(1 << event);
     } else {
       _handlerMask |= (1 << event);
     }
     _handlerMap[event] = callback;
     // If the socket is only for writing then close the receive port
     // when not waiting for any events.
     if (this is _Socket &&
         _closedRead &&
         _handlerMask == 0 &&
         _handler != null) {
       _handler.close();
       _handler = null;
     } else {
       _activateHandlers();
     }
   }

   OSError _getError() native "Socket_GetError";
   int _getPort() native "Socket_GetPort";

   void set onError(void callback(e)) {
     _setHandler(_ERROR_EVENT, callback);
   }

   void _activateHandlers() {
     if (_canActivateHandlers && !_closed) {
       if (_handlerMask == 0) {
         if (_handler != null) {
           _handler.close();
           _handler = null;
         }
         return;
       }
       int data = _handlerMask;
       if (_isListenSocket()) {
         data |= (1 << _LISTENING_SOCKET);
       } else {
         if (_closedRead) { data &= ~(1 << _IN_EVENT); }
         if (_closedWrite) { data &= ~(1 << _OUT_EVENT); }
         if (_isPipe()) data |= (1 << _PIPE);
       }
       _sendToEventHandler(data);
     }
   }

   int get port {
     if (_port === null) {
       _port = _getPort();
     }
     return _port;
   }

   void close([bool halfClose = false]) {
     if (!_closed) {
       if (halfClose) {
         _closeWrite();
       } else {
         _close();
       }
     } else if (_handler != null) {
       // This is to support closing sockets created but never assigned
       // any actual socket.
       _handler.close();
       _handler = null;
     }
   }

   void _closeWrite() {
     if (!_closed) {
       if (_closedRead) {
         _close();
       } else {
         _sendToEventHandler(1 << _SHUTDOWN_WRITE_COMMAND);
       }
       _closedWrite = true;
     }
   }

   void _closeRead() {
     if (!_closed) {
       if (_closedWrite) {
         _close();
       } else {
         _sendToEventHandler(1 << _SHUTDOWN_READ_COMMAND);
       }
       _closedRead = true;
     }
   }

   void _close() {
     if (!_closed) {
       _sendToEventHandler(1 << _CLOSE_COMMAND);
       _handler.close();
       _handler = null;
       _closed = true;
     }
   }

   void _sendToEventHandler(int data) {
     if (_handler === null) {
       _handler = new ReceivePort();
       _handler.receive((var message, ignored) { _multiplex(message); });
     }
     assert(!_closed);
     _EventHandler._sendData(this, _handler, data);
   }

   bool _reportError(error, String message) {
     void doReportError(Exception e) {
       // Invoke the socket error callback if any.
       bool reported = false;
       if (_handlerMap[_ERROR_EVENT] != null) {
         _handlerMap[_ERROR_EVENT](e);
         reported = true;
       }
       // Propagate the error to any additional listeners.
       reported = reported || _propagateError(e);
       if (!reported) throw e;
     }

     // For all errors we close the socket, call the error handler and
     // disable further calls of the error handler.
     close();
     if (error is OSError) {
       doReportError(new SocketIOException(message, error));
     } else if (error is List) {
       assert(_isErrorResponse(error));
       switch (error[0]) {
         case _ILLEGAL_ARGUMENT_RESPONSE:
           doReportError(new ArgumentError());
           break;
         case _OSERROR_RESPONSE:
           doReportError(new SocketIOException(
               message, new OSError(error[2], error[1])));
           break;
         default:
           doReportError(new Exception("Unknown error"));
           break;
       }
     } else {
       doReportError(new SocketIOException(message));
     }
   }

   int hashCode() => _hashCode;

   bool _propagateError(Exception e) => false;

   abstract bool _isListenSocket();
   abstract bool _isPipe();

   // Is this socket closed.
   bool _closed;

   // Dedicated ReceivePort for socket events.
   ReceivePort _handler;

   // Poll event to handler map.
   List _handlerMap;

   // Indicates for which poll events the socket registered handlers.
   int _handlerMask;

   // Indicates if native interrupts can be activated.
   bool _canActivateHandlers;

   // Holds the port of the socket, null if not known.
   int _port;

   // Hash code for the socket. Currently this is just a counter.
   int _hashCode;
   static int _nextHashCode = 0;
   bool _closedRead = false;
   bool _closedWrite = false;
 }


 class _ServerSocket extends _SocketBase implements ServerSocket {
   // Constructor for server socket. First a socket object is allocated
   // in which the native socket is stored. After that _createBind
   // is called which creates a file descriptor and binds the given address
   // and port to the socket. Null is returned if file descriptor creation or
   // bind failed.
   factory _ServerSocket(String bindAddress, int port, int backlog) {
     _ServerSocket socket = new _ServerSocket._internal();
     var result = socket._createBindListen(bindAddress, port, backlog);
     if (result is OSError) {
       socket.close();
       throw new SocketIOException("Failed to create server socket", result);
     }
     socket._closed = false;
     assert(result);
     if (port != 0) {
       socket._port = port;
     }
     return socket;
   }

   _ServerSocket._internal();

   _accept(Socket socket) native "ServerSocket_Accept";

   _createBindListen(String bindAddress, int port, int backlog)
       native "ServerSocket_CreateBindListen";

   void set onConnection(void callback(Socket connection)) {
     _clientConnectionHandler = callback;
     _setHandler(_SocketBase._IN_EVENT,
                 _clientConnectionHandler != null ? _connectionHandler : null);
   }

   void _connectionHandler() {
     if (!_closed) {
       _Socket socket = new _Socket._internal();
       var result = _accept(socket);
       if (result is OSError) {
         _reportError(result, "Accept failed");
       } else if (result) {
         socket._closed = false;
         _clientConnectionHandler(socket);
       } else {
         // Temporary failure accepting the connection. Ignoring
         // temporary failures lets us retry when we wake up with data
         // on the listening socket again.
       }
     }
   }

   bool _isListenSocket() => true;
   bool _isPipe() => false;

   var _clientConnectionHandler;
 }


 class _Socket extends _SocketBase implements Socket {
   static const HOST_NAME_LOOKUP = 0;

   // Constructs a new socket. During the construction an asynchronous
   // host name lookup is initiated. The returned socket is not yet
   // connected but ready for registration of callbacks.
   factory _Socket(String host, int port) {
     Socket socket = new _Socket._internal();
     _ensureSocketService();
     List request = new List(2);
     request[0] = HOST_NAME_LOOKUP;
     request[1] = host;
     _socketService.call(request).then((response) {
       if (socket._isErrorResponse(response)) {
         socket._reportError(response, "Failed host name lookup");
       } else{
         var result = socket._createConnect(response, port);
         if (result is OSError) {
           socket.close();
           socket._reportError(result, "Connection failed");
         } else {
           socket._closed = false;
           socket._activateHandlers();
         }
       }
     });
     return socket;
   }

   _Socket._internal();
   _Socket._internalReadOnly() : _pipe = true { super._closedWrite = true; }
   _Socket._internalWriteOnly() : _pipe = true { super._closedRead = true; }

   int available() {
     if (!_closed) {
       var result = _available();
       if (result is OSError) {
         _reportError(result, "Available failed");
         return 0;
       } else {
         return result;
       }
     }
     throw new
         SocketIOException("Error: available failed - invalid socket handle");
   }

   _available() native "Socket_Available";

   int readList(List<int> buffer, int offset, int bytes) {
     if (!_closed) {
       if (bytes == 0) {
         return 0;
       }
       if (offset < 0) {
         throw new IndexOutOfRangeException(offset);
       }
       if (bytes < 0) {
         throw new IndexOutOfRangeException(bytes);
       }
       if ((offset + bytes) > buffer.length) {
         throw new IndexOutOfRangeException(offset + bytes);
       }
       var result = _readList(buffer, offset, bytes);
       if (result is OSError) {
         _reportError(result, "Read failed");
         return -1;
       }
       return result;
     }
     throw new
         SocketIOException("Error: readList failed - invalid socket handle");
   }

   _readList(List<int> buffer, int offset, int bytes) native "Socket_ReadList";

   int writeList(List<int> buffer, int offset, int bytes) {
     if (buffer is! List || offset is! int || bytes is! int) {
       throw new ArgumentError(
           "Invalid arguments to writeList on Socket");
     }
     if (!_closed) {
       if (bytes == 0) {
         return 0;
       }
       if (offset < 0) {
         throw new IndexOutOfRangeException(offset);
       }
       if (bytes < 0) {
         throw new IndexOutOfRangeException(bytes);
       }
       if ((offset + bytes) > buffer.length) {
         throw new IndexOutOfRangeException(offset + bytes);
       }
       _BufferAndOffset bufferAndOffset =
           _ensureFastAndSerializableBuffer(buffer, offset, bytes);
       var result =
           _writeList(bufferAndOffset.buffer, bufferAndOffset.offset, bytes);
       if (result is OSError) {
         _reportError(result, "Write failed");
         // If writing fails we return 0 as the number of bytes and
         // report the error on the error handler.
         result = 0;
       }
       return result;
     }
     throw new SocketIOException("writeList failed - invalid socket handle");
   }

   _writeList(List<int> buffer, int offset, int bytes)
       native "Socket_WriteList";

   bool _isErrorResponse(response) {
     return response is List && response[0] != _SUCCESS_RESPONSE;
   }

   bool _createConnect(String host, int port) native "Socket_CreateConnect";

   void set onWrite(void callback()) {
     if (_outputStream != null) throw new StreamException(
             "Cannot set write handler when output stream is used");
     _clientWriteHandler = callback;
     _updateOutHandler();
   }

   void set onConnect(void callback()) {
     if (_seenFirstOutEvent || _outputStream != null) {
       throw new StreamException(
           "Cannot set connect handler when already connected");
     }
     if (_outputStream != null) {
       throw new StreamException(
           "Cannot set connect handler when output stream is used");
     }
     _clientConnectHandler = callback;
     _updateOutHandler();
   }

   void set onData(void callback()) {
     if (_inputStream != null) throw new StreamException(
             "Cannot set data handler when input stream is used");
     _onData = callback;
   }

   void set onClosed(void callback()) {
     if (_inputStream != null) throw new StreamException(
            "Cannot set close handler when input stream is used");
     _onClosed = callback;
   }

   bool _isListenSocket() => false;

   bool _isPipe() => _pipe;

   InputStream get inputStream {
     if (_inputStream == null) {
       if (_handlerMap[_SocketBase._IN_EVENT] !== null ||
           _handlerMap[_SocketBase._CLOSE_EVENT] !== null) {
         throw new StreamException(
             "Cannot get input stream when socket handlers are used");
       }
       _inputStream = new SocketInputStream(this);
     }
     return _inputStream;
   }

   OutputStream get outputStream {
     if (_outputStream == null) {
       if (_handlerMap[_SocketBase._OUT_EVENT] !== null) {
         throw new StreamException(
             "Cannot get input stream when socket handlers are used");
       }
       _outputStream = new SocketOutputStream(this);
     }
     return _outputStream;
   }

   void set _onWrite(void callback()) {
     _setHandler(_SocketBase._OUT_EVENT, callback);
   }

   void set _onData(void callback()) {
     _setHandler(_SocketBase._IN_EVENT, callback);
   }

   void set _onClosed(void callback()) {
     _setHandler(_SocketBase._CLOSE_EVENT, callback);
   }

   bool _propagateError(Exception e) {
     bool reported = false;
     if (_inputStream != null) {
       reported = reported || _inputStream._onSocketError(e);
     }
     if (_outputStream != null) {
       reported = reported || _outputStream._onSocketError(e);
     }
     return reported;
   }

   void _updateOutHandler() {
     void firstWriteHandler() {
       assert(!_seenFirstOutEvent);
       _seenFirstOutEvent = true;

       // From now on the write handler is only the client write
       // handler (connect handler cannot be called again). Change this
       // before calling any handlers as handlers can change the
       // handlers.
       if (_clientWriteHandler === null) _onWrite = _clientWriteHandler;

       // First out event is socket connected event.
       if (_clientConnectHandler !== null) _clientConnectHandler();
       _clientConnectHandler = null;

       // Always (even for the first out event) call the write handler.
       if (_clientWriteHandler !== null) _clientWriteHandler();
     }

     if (_clientConnectHandler === null && _clientWriteHandler === null) {
       _onWrite = null;
     } else {
       if (_seenFirstOutEvent) {
         _onWrite = _clientWriteHandler;
       } else {
         _onWrite = firstWriteHandler;
       }
     }
   }

   int get remotePort {
     if (_remotePort === null) {
       remoteHost;
     }
     return _remotePort;
   }

   String get remoteHost {
     if (_remoteHost === null) {
       List peer = _getRemotePeer();
       _remoteHost = peer[0];
       _remotePort = peer[1];
     }
     return _remoteHost;
   }

   List _getRemotePeer() native "Socket_GetRemotePeer";

   static SendPort _newServicePort() native "Socket_NewServicePort";

   static void _ensureSocketService() {
     if (_socketService == null) {
       _socketService = _Socket._newServicePort();
     }
   }

   bool _seenFirstOutEvent = false;
   bool _pipe = false;
   Function _clientConnectHandler;
   Function _clientWriteHandler;
   SocketInputStream _inputStream;
   SocketOutputStream _outputStream;
   String _remoteHost;
   int _remotePort;
   static SendPort _socketService;
 }
	// Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file
	// for details. All rights reserved. Use of this source code is governed by a
	// BSD-style license that can be found in the LICENSE file.


	class _SocketBase extends NativeFieldWrapperClass1 {
	// Bit flags used when communicating between the eventhandler and
	// dart code. The EVENT flags are used to indicate events of
	// interest when sending a message from dart code to the
	// eventhandler. When receiving a message from the eventhandler the
	// EVENT flags indicate the events that actually happened. The
	// COMMAND flags are used to send commands from dart to the
	// eventhandler. COMMAND flags are never received from the
	// eventhandler. Additional flags are used to communicate other
	// information.
	static const int _IN_EVENT = 0;
	static const int _OUT_EVENT = 1;
	static const int _ERROR_EVENT = 2;
	static const int _CLOSE_EVENT = 3;

	static const int _CLOSE_COMMAND = 8;
	static const int _SHUTDOWN_READ_COMMAND = 9;
	static const int _SHUTDOWN_WRITE_COMMAND = 10;

	// Flag send to the eventhandler providing additional information on
	// the type of the file descriptor.
	static const int _LISTENING_SOCKET = 16;
	static const int _PIPE = 17;

	static const int _FIRST_EVENT = _IN_EVENT;
	static const int _LAST_EVENT = _CLOSE_EVENT;

	static const int _FIRST_COMMAND = _CLOSE_COMMAND;
	static const int _LAST_COMMAND = _SHUTDOWN_WRITE_COMMAND;

	_SocketBase () {
	_handlerMap = new List(_LAST_EVENT + 1);
	_handlerMask = 0;
	_canActivateHandlers = true;
	_closed = true;
	_EventHandler._start();
	_hashCode = _nextHashCode;
	_nextHashCode = (_nextHashCode + 1) & 0xFFFFFFF;
	}

	// Multiplexes socket events to the socket handlers.
	void _multiplex(int event_mask) {
	_canActivateHandlers = false;
	for (int i = _FIRST_EVENT; i <= _LAST_EVENT; i++) {
	if (((event_mask & (1 << i)) != 0)) {
	if ((i == _CLOSE_EVENT) && this is _Socket && !_closed) {
	_closedRead = true;
	if (_closedWrite) _close();
	}

	var eventHandler = _handlerMap[i];
	if (eventHandler != null \|\| i == _ERROR_EVENT) {
	// Unregister the out handler before executing it.
	if (i == _OUT_EVENT) _setHandler(i, null);

	// Don't call the in handler if there is no data available
	// after all.
	if ((i == _IN_EVENT) && (this is _Socket) && (available() == 0)) {
	continue;
	}
	if (i == _ERROR_EVENT) {
	_reportError(_getError(), "");
	close();
	} else {
	eventHandler();
	}
	}
	}
	}
	_canActivateHandlers = true;
	_activateHandlers();
	}

	void _setHandler(int event, Function callback) {
	if (callback == null) {
	_handlerMask &= ~(1 << event);
	} else {
	_handlerMask \|= (1 << event);
	}
	_handlerMap[event] = callback;
	// If the socket is only for writing then close the receive port
	// when not waiting for any events.
	if (this is _Socket &&
	_closedRead &&
	_handlerMask == 0 &&
	_handler != null) {
	_handler.close();
	_handler = null;
	} else {
	_activateHandlers();
	}
	}

	OSError _getError() native "Socket_GetError";
	int _getPort() native "Socket_GetPort";

	void set onError(void callback(e)) {
	_setHandler(_ERROR_EVENT, callback);
	}

	void _activateHandlers() {
	if (_canActivateHandlers && !_closed) {
	if (_handlerMask == 0) {
	if (_handler != null) {
	_handler.close();
	_handler = null;
	}
	return;
	}
	int data = _handlerMask;
	if (_isListenSocket()) {
	data \|= (1 << _LISTENING_SOCKET);
	} else {
	if (_closedRead) { data &= ~(1 << _IN_EVENT); }
	if (_closedWrite) { data &= ~(1 << _OUT_EVENT); }
	if (_isPipe()) data \|= (1 << _PIPE);
	}
	_sendToEventHandler(data);
	}
	}

	int get port {
	if (_port === null) {
	_port = _getPort();
	}
	return _port;
	}

	void close([bool halfClose = false]) {
	if (!_closed) {
	if (halfClose) {
	_closeWrite();
	} else {
	_close();
	}
	} else if (_handler != null) {
	// This is to support closing sockets created but never assigned
	// any actual socket.
	_handler.close();
	_handler = null;
	}
	}

	void _closeWrite() {
	if (!_closed) {
	if (_closedRead) {
	_close();
	} else {
	_sendToEventHandler(1 << _SHUTDOWN_WRITE_COMMAND);
	}
	_closedWrite = true;
	}
	}

	void _closeRead() {
	if (!_closed) {
	if (_closedWrite) {
	_close();
	} else {
	_sendToEventHandler(1 << _SHUTDOWN_READ_COMMAND);
	}
	_closedRead = true;
	}
	}

	void _close() {
	if (!_closed) {
	_sendToEventHandler(1 << _CLOSE_COMMAND);
	_handler.close();
	_handler = null;
	_closed = true;
	}
	}

	void _sendToEventHandler(int data) {
	if (_handler === null) {
	_handler = new ReceivePort();
	_handler.receive((var message, ignored) { _multiplex(message); });
	}
	assert(!_closed);
	_EventHandler._sendData(this, _handler, data);
	}

	bool _reportError(error, String message) {
	void doReportError(Exception e) {
	// Invoke the socket error callback if any.
	bool reported = false;
	if (_handlerMap[_ERROR_EVENT] != null) {
	_handlerMap[_ERROR_EVENT](e);
	reported = true;
	}
	// Propagate the error to any additional listeners.
	reported = reported \|\| _propagateError(e);
	if (!reported) throw e;
	}

	// For all errors we close the socket, call the error handler and
	// disable further calls of the error handler.
	close();
	if (error is OSError) {
	doReportError(new SocketIOException(message, error));
	} else if (error is List) {
	assert(_isErrorResponse(error));
	switch (error[0]) {
	case _ILLEGAL_ARGUMENT_RESPONSE:
	doReportError(new ArgumentError());
	break;
	case _OSERROR_RESPONSE:
	doReportError(new SocketIOException(
	message, new OSError(error[2], error[1])));
	break;
	default:
	doReportError(new Exception("Unknown error"));
	break;
	}
	} else {
	doReportError(new SocketIOException(message));
	}
	}

	int hashCode() => _hashCode;

	bool _propagateError(Exception e) => false;

	abstract bool _isListenSocket();
	abstract bool _isPipe();

	// Is this socket closed.
	bool _closed;

	// Dedicated ReceivePort for socket events.
	ReceivePort _handler;

	// Poll event to handler map.
	List _handlerMap;

	// Indicates for which poll events the socket registered handlers.
	int _handlerMask;

	// Indicates if native interrupts can be activated.
	bool _canActivateHandlers;

	// Holds the port of the socket, null if not known.
	int _port;

	// Hash code for the socket. Currently this is just a counter.
	int _hashCode;
	static int _nextHashCode = 0;
	bool _closedRead = false;
	bool _closedWrite = false;
	}


	class _ServerSocket extends _SocketBase implements ServerSocket {
	// Constructor for server socket. First a socket object is allocated
	// in which the native socket is stored. After that _createBind
	// is called which creates a file descriptor and binds the given address
	// and port to the socket. Null is returned if file descriptor creation or
	// bind failed.
	factory _ServerSocket(String bindAddress, int port, int backlog) {
	_ServerSocket socket = new _ServerSocket._internal();
	var result = socket._createBindListen(bindAddress, port, backlog);
	if (result is OSError) {
	socket.close();
	throw new SocketIOException("Failed to create server socket", result);
	}
	socket._closed = false;
	assert(result);
	if (port != 0) {
	socket._port = port;
	}
	return socket;
	}

	_ServerSocket._internal();

	_accept(Socket socket) native "ServerSocket_Accept";

	_createBindListen(String bindAddress, int port, int backlog)
	native "ServerSocket_CreateBindListen";

	void set onConnection(void callback(Socket connection)) {
	_clientConnectionHandler = callback;
	_setHandler(_SocketBase._IN_EVENT,
	_clientConnectionHandler != null ? _connectionHandler : null);
	}

	void _connectionHandler() {
	if (!_closed) {
	_Socket socket = new _Socket._internal();
	var result = _accept(socket);
	if (result is OSError) {
	_reportError(result, "Accept failed");
	} else if (result) {
	socket._closed = false;
	_clientConnectionHandler(socket);
	} else {
	// Temporary failure accepting the connection. Ignoring
	// temporary failures lets us retry when we wake up with data
	// on the listening socket again.
	}
	}
	}

	bool _isListenSocket() => true;
	bool _isPipe() => false;

	var _clientConnectionHandler;
	}


	class _Socket extends _SocketBase implements Socket {
	static const HOST_NAME_LOOKUP = 0;

	// Constructs a new socket. During the construction an asynchronous
	// host name lookup is initiated. The returned socket is not yet
	// connected but ready for registration of callbacks.
	factory _Socket(String host, int port) {
	Socket socket = new _Socket._internal();
	_ensureSocketService();
	List request = new List(2);
	request[0] = HOST_NAME_LOOKUP;
	request[1] = host;
	_socketService.call(request).then((response) {
	if (socket._isErrorResponse(response)) {
	socket._reportError(response, "Failed host name lookup");
	} else{
	var result = socket._createConnect(response, port);
	if (result is OSError) {
	socket.close();
	socket._reportError(result, "Connection failed");
	} else {
	socket._closed = false;
	socket._activateHandlers();
	}
	}
	});
	return socket;
	}

	_Socket._internal();
	_Socket._internalReadOnly() : _pipe = true { super._closedWrite = true; }
	_Socket._internalWriteOnly() : _pipe = true { super._closedRead = true; }

	int available() {
	if (!_closed) {
	var result = _available();
	if (result is OSError) {
	_reportError(result, "Available failed");
	return 0;
	} else {
	return result;
	}
	}
	throw new
	SocketIOException("Error: available failed - invalid socket handle");
	}

	_available() native "Socket_Available";

	int readList(List<int> buffer, int offset, int bytes) {
	if (!_closed) {
	if (bytes == 0) {
	return 0;
	}
	if (offset < 0) {
	throw new IndexOutOfRangeException(offset);
	}
	if (bytes < 0) {
	throw new IndexOutOfRangeException(bytes);
	}
	if ((offset + bytes) > buffer.length) {
	throw new IndexOutOfRangeException(offset + bytes);
	}
	var result = _readList(buffer, offset, bytes);
	if (result is OSError) {
	_reportError(result, "Read failed");
	return -1;
	}
	return result;
	}
	throw new
	SocketIOException("Error: readList failed - invalid socket handle");
	}

	_readList(List<int> buffer, int offset, int bytes) native "Socket_ReadList";

	int writeList(List<int> buffer, int offset, int bytes) {
	if (buffer is! List \|\| offset is! int \|\| bytes is! int) {
	throw new ArgumentError(
	"Invalid arguments to writeList on Socket");
	}
	if (!_closed) {
	if (bytes == 0) {
	return 0;
	}
	if (offset < 0) {
	throw new IndexOutOfRangeException(offset);
	}
	if (bytes < 0) {
	throw new IndexOutOfRangeException(bytes);
	}
	if ((offset + bytes) > buffer.length) {
	throw new IndexOutOfRangeException(offset + bytes);
	}
	_BufferAndOffset bufferAndOffset =
	_ensureFastAndSerializableBuffer(buffer, offset, bytes);
	var result =
	_writeList(bufferAndOffset.buffer, bufferAndOffset.offset, bytes);
	if (result is OSError) {
	_reportError(result, "Write failed");
	// If writing fails we return 0 as the number of bytes and
	// report the error on the error handler.
	result = 0;
	}
	return result;
	}
	throw new SocketIOException("writeList failed - invalid socket handle");
	}

	_writeList(List<int> buffer, int offset, int bytes)
	native "Socket_WriteList";

	bool _isErrorResponse(response) {
	return response is List && response[0] != _SUCCESS_RESPONSE;
	}

	bool _createConnect(String host, int port) native "Socket_CreateConnect";

	void set onWrite(void callback()) {
	if (_outputStream != null) throw new StreamException(
	"Cannot set write handler when output stream is used");
	_clientWriteHandler = callback;
	_updateOutHandler();
	}

	void set onConnect(void callback()) {
	if (_seenFirstOutEvent \|\| _outputStream != null) {
	throw new StreamException(
	"Cannot set connect handler when already connected");
	}
	if (_outputStream != null) {
	throw new StreamException(
	"Cannot set connect handler when output stream is used");
	}
	_clientConnectHandler = callback;
	_updateOutHandler();
	}

	void set onData(void callback()) {
	if (_inputStream != null) throw new StreamException(
	"Cannot set data handler when input stream is used");
	_onData = callback;
	}

	void set onClosed(void callback()) {
	if (_inputStream != null) throw new StreamException(
	"Cannot set close handler when input stream is used");
	_onClosed = callback;
	}

	bool _isListenSocket() => false;

	bool _isPipe() => _pipe;

	InputStream get inputStream {
	if (_inputStream == null) {
	if (_handlerMap[_SocketBase._IN_EVENT] !== null \|\|
	_handlerMap[_SocketBase._CLOSE_EVENT] !== null) {
	throw new StreamException(
	"Cannot get input stream when socket handlers are used");
	}
	_inputStream = new SocketInputStream(this);
	}
	return _inputStream;
	}

	OutputStream get outputStream {
	if (_outputStream == null) {
	if (_handlerMap[_SocketBase._OUT_EVENT] !== null) {
	throw new StreamException(
	"Cannot get input stream when socket handlers are used");
	}
	_outputStream = new SocketOutputStream(this);
	}
	return _outputStream;
	}

	void set _onWrite(void callback()) {
	_setHandler(_SocketBase._OUT_EVENT, callback);
	}

	void set _onData(void callback()) {
	_setHandler(_SocketBase._IN_EVENT, callback);
	}

	void set _onClosed(void callback()) {
	_setHandler(_SocketBase._CLOSE_EVENT, callback);
	}

	bool _propagateError(Exception e) {
	bool reported = false;
	if (_inputStream != null) {
	reported = reported \|\| _inputStream._onSocketError(e);
	}
	if (_outputStream != null) {
	reported = reported \|\| _outputStream._onSocketError(e);
	}
	return reported;
	}

	void _updateOutHandler() {
	void firstWriteHandler() {
	assert(!_seenFirstOutEvent);
	_seenFirstOutEvent = true;

	// From now on the write handler is only the client write
	// handler (connect handler cannot be called again). Change this
	// before calling any handlers as handlers can change the
	// handlers.
	if (_clientWriteHandler === null) _onWrite = _clientWriteHandler;

	// First out event is socket connected event.
	if (_clientConnectHandler !== null) _clientConnectHandler();
	_clientConnectHandler = null;

	// Always (even for the first out event) call the write handler.
	if (_clientWriteHandler !== null) _clientWriteHandler();
	}

	if (_clientConnectHandler === null && _clientWriteHandler === null) {
	_onWrite = null;
	} else {
	if (_seenFirstOutEvent) {
	_onWrite = _clientWriteHandler;
	} else {
	_onWrite = firstWriteHandler;
	}
	}
	}

	int get remotePort {
	if (_remotePort === null) {
	remoteHost;
	}
	return _remotePort;
	}

	String get remoteHost {
	if (_remoteHost === null) {
	List peer = _getRemotePeer();
	_remoteHost = peer[0];
	_remotePort = peer[1];
	}
	return _remoteHost;
	}

	List _getRemotePeer() native "Socket_GetRemotePeer";

	static SendPort _newServicePort() native "Socket_NewServicePort";

	static void _ensureSocketService() {
	if (_socketService == null) {
	_socketService = _Socket._newServicePort();
	}
	}

	bool _seenFirstOutEvent = false;
	bool _pipe = false;
	Function _clientConnectHandler;
	Function _clientWriteHandler;
	SocketInputStream _inputStream;
	SocketOutputStream _outputStream;
	String _remoteHost;
	int _remotePort;
	static SendPort _socketService;
	}