Sockets

A binary socket connection is similar to an XML socket except that the client and server are not limited to exchanging XML messages. Instead, the connection can transfer data as binary information. Thus, you can connect to a wider range of services, including mail servers (POP3, SMTP, and IMAP), and news servers (NNTP).

An XML socket lets you create a connection to a remote server that remains open until explicitly closed. You can exchange string data, such as XML, between the server and client. A benefit of using an XML socket server is that the client does not need to explicitly request data. The server can send data without waiting for a request and can send data to every connected client connected.

In Flash Player, and in Adobe AIR content outside the application sandbox, XML socket connections require the presence of a socket policy file on the target server. For more information, see Website controls (policy files) and Connecting to sockets .

The XMLSocket class cannot tunnel through firewalls automatically because, unlike the Real-Time Messaging Protocol (RTMP), XMLSocket has no HTTP tunneling capability. If you need to use HTTP tunneling, consider using Flash Remoting or Flash Media Server (which supports RTMP) instead.

The following restrictions apply to how and where content in Flash Player or in an AIR application outside of the application security sandbox can use an XMLSocket object to connect to the server:

• For content outside of the application security sandbox, the XMLSocket.connect() method can connect only to TCP port numbers greater than or equal to 1024. One consequence of this restriction is that the server daemons that communicate with the XMLSocket object must also be assigned to port numbers greater than or equal to 1024. Port numbers below 1024 are often used by system services such as FTP (21), Telnet (23), SMTP (25), HTTP (80), and POP3 (110), so XMLSocket objects are barred from these ports for security reasons. The port number restriction limits the possibility that these resources will be inappropriately accessed and abused.

• For content outside of the application security sandbox, the XMLSocket.connect() method can connect only to computers in the same domain where the content resides. (This restriction is identical to the security rules for URLLoader.load() .) To connect to a server daemon running in a domain other than the one where the content resides, you can create a cross-domain policy file on the server that allows access from specific domains. For details on cross-domain policy files, see AIR security .

You can use the XMLSocket.connect() and XMLSocket.send() methods of the XMLSocket class to transfer XML to and from a server over a socket connection. The XMLSocket.connect() method establishes a socket connection with a web server port. The XMLSocket.send() method passes an XML object to the server specified in the socket connection.

When you invoke the XMLSocket.connect() method, the application opens a TCP/IP connection to the server and keeps that connection open until one of the following occurs:

• The XMLSocket.close() method of the XMLSocket class is called.

• No more references to the XMLSocket object exist.

• The connection is broken (for example, the modem disconnects).

Use the ServerSocket class to allow other processes to connect to your application using a Transport Control Protocol (TCP) socket. The connecting process can be running on the local computer or on another network-connected computer. When a ServerSocket object receives a connection request, it dispatches a connect event. The ServerSocketConnectEvent object dispatched with the event contains a Socket object. You can use this Socket object for subsequent communication with the other process.

To listen for incoming socket connections:

1. Create a ServerSocket object and bind it to a local port

2. Add event listeners for the connect event

3. Call the listen() method

4. Respond to the connect event, which provides a Socket object for each incoming connection

The ServerSocket object continues to listen for new connections until you call the close() method.

The following code example illustrates how to create a socket server application. The example listens for incoming connections on port 8087. When a connection is received, the example sends a message (the string “Connected.”) to the client socket. Thereafter, the server echoes any messages received back to the client.

<html> 
<head> 
<script src="AIRAliases.js"></script> 
<script language="javascript"> 
        var serverSocket; 
        var clientSockets = new Array(); 
        function startServer() 
        { 
            try 
            { 
                // Create the server socket 
                serverSocket = new air.ServerSocket(); 
                 
                // Add the event listener 
                serverSocket.addEventListener( air.Event.CONNECT, connectHandler ); 
                serverSocket.addEventListener( air.Event.CLOSE, onClose ); 
                 
                // Bind to local port 8087 
                serverSocket.bind( 8087, "127.0.0.1" ); 
                 
                // Listen for connections 
                serverSocket.listen(); 
                air.trace( "Listening on " + serverSocket.localPort ); 
            } 
            catch( e ) 
            { 
                air.trace( e ); 
            } 
        } 
        function connectHandler( event ) 
        { 
            //The socket is provided by the event object 
            var socket = event.socket; 
            clientSockets.push( socket ); 
             
            socket.addEventListener( air.ProgressEvent.SOCKET_DATA, socketDataHandler); 
            socket.addEventListener( air.Event.CLOSE, onClientClose ); 
            socket.addEventListener( air.IOErrorEvent.IO_ERROR, onIOError ); 
             
            //Send a connect message 
            socket.writeUTFBytes("Connected."); 
            socket.flush(); 
             
            air.trace( "Sending connect message" ); 
        } 
         
        function socketDataHandler( event ) 
        { 
            var socket = event.target 
                 
            //Read the message from the socket 
            var message = socket.readUTFBytes( socket.bytesAvailable ); 
            air.trace( "Received: " + message); 
            // Echo the received message back to the sender 
            message = "Echo -- " + message; 
            socket.writeUTFBytes( message ); 
            socket.flush(); 
            air.trace( "Sending: " + message ); 
        } 
         
        function onClientClose( event ) 
        { 
            air.trace( "Connection to client closed." ); 
            //Should also remove from clientSockets array... 
        } 
        function onIOError( errorEvent ) 
        { 
            air.trace( "IOError: " + errorEvent.text ); 
        } 
        function onClose( event ) 
        { 
            air.trace( "Server socket closed by OS." ); 
        } 
</script> 
</head> 
<body onload="startServer()"> 
</body> 
</html>

For more information, see:

• ServerSocket

• ServerSocketConnectEvent

• Socket