Sockets

Flash Player 9 et les versions ultérieures, Adobe AIR 1.0 et les versions ultérieures

Un socket est un type de connexion réseau établie entre deux processus informatiques. En règle générale, les processus s’exécutent sur deux ordinateurs distincts connectés au même réseau IP (Internet Protocol). Les processus connectés peuvent toutefois s’exécuter sur le même ordinateur via l’adresse IP spéciale « hôte local ».

Adobe Flash Player prend en charge les sockets TCP (Transport Control Protocol) côté client. Une application Flash Player peut se connecter à un autre processus qui fait office de serveur socket, mais est incapable d’accepter les demandes de connexion entrantes provenant d’autres processus. En d’autres termes, une application Flash Player peut se connecter à un serveur TCP, mais ne peut pas faire office de serveur TCP.

L’API de Flash Player comprend également la classe XMLSocket. La classe XMLSocket utilise un protocole propre à Flash Player, qui permet d’échanger des messages XML avec un serveur qui comprend ce protocole. La classe XMLSocket a été introduite dans ActionScript 1 et continue à être prise en charge à des fins de compatibilité ascendante. En règle générale, réservez la classe Socket aux nouvelles applications, sauf si vous vous connectez à un serveur dédié aux communications avec Flash XMLSockets.

Adobe AIR intègre plusieurs autres classes réservées à la programmation réseau basée sur les sockets. Les applications AIR peuvent agir comme serveurs sockets TCP grâce à la classe ServerSocket, et peuvent se connecter à des serveurs sockets qui requièrent une sécurité SSL ou TLS grâce à la classe SecureSocket. La classe DatagramSocket permet également aux applications AIR d’envoyer et de recevoir des messages UDP (Universal Datagram Protocol).

Sockets TCP

Le protocole TCP (Transmission Control Protocol) permet d’échanger des messages via une connexion réseau permanente. Le protocole TCP assure la réception dans l’ordre correct de tous les messages envoyés (ce qui élimine les principaux problèmes liés au réseau). Les connexions TCP nécessitent un « client » et un « serveur ». Flash Player peut créer des sockets clients. Adobe AIR peut en outre créer des sockets serveur.

Les API ActionScript suivantes assurent des connexions TCP :

  • Socket : permet à une application cliente de se connecter à un serveur. La classe Socket peut écouter les connexions entrantes.

  • SecureSocket (AIR) : permet à une application cliente de se connecter à un serveur approuvé et d’établir des communications chiffrées.

  • ServerSocket (AIR) : permet à une application d’écouter les connexions entrantes et de servir de serveur.

  • XMLSocket : permet à une application cliente de se connecter à un serveur XMLSocket.

Sockets clients binaires

Une connexion socket binaire est semblable à un socket XML, à une différence près : le client et le serveur n’échangent pas uniquement des messages XML. La connexion peut en effet transférer des données au format binaire. Vous pouvez ainsi vous connecter à un plus large éventail de services, notamment des serveurs de messagerie (POP3, SMTP et IMAP) et d’informations (NNTP).

Socket, classe

La classe Socket vous permet d’établir des connexions socket, ainsi que de lire et d’écrire des données binaires brutes. La classe Socket est utile si vous utilisez des serveurs faisant appel à des protocoles binaires. Grâce aux connexions socket binaires, vous pouvez écrire du code qui gère les interactions avec différents protocoles Internet (POP3, SMTP, IMAP et NNTP, par exemple). Ces interactions permettent alors aux applications de se connecter à des serveurs de messagerie et d’informations.

Flash Player peut communiquer directement avec un serveur en utilisant directement le protocole binaire de ce serveur. Certains serveurs utilisent l’ordre d’octets « gros-boutiste », d’autres l’ordre « petit-boutiste ». La plupart des serveurs sur Internet utilisent l’ordre gros-boutiste, car il s’agit de l’ordre d’octets du réseau. L’ordre petit-boutiste s’est répandu en raison de son utilisation par l’architecture Intel® x86. Vous devez utiliser l’ordre d’octets correspondant au serveur qui envoie et reçoit les données. Toutes les opérations sont effectuées par les interfaces IDataInput et IDataOutput, et les classes qui les implémentent (ByteArray, Socket et URLStream) sont par défaut encodées au format gros-boutiste (l’octet le plus significatif en premier). Cet ordre d’octet par défaut a été sélectionné pour correspondre à Java et à l’ordre des octets réseau officiel. Pour modifier l’ordre d’octets à utiliser, vous pouvez définir la propriété endian sur Endian.BIG_ENDIAN ou Endian.LITTLE_ENDIAN .

la classe Socket hérite de toutes les méthodes définies par les interfaces IDataInput et IDataOutput (qui résident dans le package flash.utils). Vous devez impérativement utiliser ces méthodes pour écrire et lire à partir du socket.

Pour plus d’informations, voir :

Sockets de client sécurisés (AIR)

La classe SecureSocket permet d’établir une connexion aux serveurs socket qui utilisent Secure Sockets Layer version 4 (SSLv4) ou Transport Layer Security version 1 (TLSv1). Les avantages que présente un socket sécurisé sont au nombre de trois : authentification du serveur, intégrité des données et confidentialité des messages. Le moteur d’exécution authentifie un serveur par le biais de son certificat et de sa relation aux certificats délivrés par les autorités de certification racine ou intermédiaires dans le magasin d’approbation de l’utilisateur. Le moteur d’exécution se fonde sur les algorithmes de cryptographie utilisés par les implémentations de protocoles SSL et TLS pour assurer l’intégrité des données et la confidentialité des messages.

Lorsque vous vous connectez à un serveur par le biais de l’objet SecureSocket, le moteur d’exécution valide le certificat du serveur via le magasin d’approbation des certificats. Sous Windows et Mac, le système d’exploitation fournit le magasin d’approbation. Sous Linux, le moteur d’exécution fournit son propre magasin d’approbation.

Si le certificat du serveur n’est ni valide, ni fiable, le moteur d’exécution distribue un événement ioError . La propriété serverCertificateStatus de l’objet SecureSocket permet d’identifier le motif de l’échec de la validation. Il est impossible de communiquer avec un serveur qui ne dispose pas d’un certificat valide et fiable.

La classe CertificateStatus définit les constantes de chaîne qui représentent les résultats possibles de la validation :

  • Expired (Expiré) : la date d’expiration du certificat est dépassée.

  • Invalid (Non valide) : diverses raisons expliquent la non-validité d’un certificat. Celui-ci pourrait avoir été modifié, altéré ou son type pourrait être incorrect.

  • Invalid chain (Chaîne non valide) : un ou plusieurs certificats de la chaîne de certificats du serveur ne sont pas valides.

  • Principal mismatch (Non-concordance majeure) : le nom d’hôte du serveur et le nom commun figurant sur le certificat ne sont pas identiques. En d’autres termes, le serveur utilise le certificat d’un autre serveur.

  • Revoked (Révoqué) : l’autorité de certification a révoqué le certificat.

  • Trusted (Fiable) : le certificat est valide et fiable. Pour qu’un objet SecureSocket puisse se connecter à un serveur, ce dernier doit disposer d’un certificat valide et fiable.

  • Unknown (Inconnu) : l’objet SecureSocket n’a pas encore validé le certificat. La propriété serverCertificateStatus possède cet état avant que vous n’appeliez connect() et avant la distribution d’un événement connect ou ioError .

  • Untrusted signers (Signataires non fiables) : le certificat ne fait pas partie d’une « chaîne » de certificats racine fiables dans le magasin d’approbation de l’ordinateur client.

L’établissement de communications avec un objet SecureSocket nécessite un serveur qui utilise un protocole sécurisé et possède un certificat valide et fiable. A d’autres égards, l’utilisation d’un objet SecureSocket s’apparente à celle d’un objet Socket.

L’objet SecureSocket n’est pas pris en charge par toutes les plates-formes. Faites appel à la propriété isSupported de la classe SecureSocket pour vérifier si le moteur d’exécution gère l’utilisation de l’objet SecureSocket sur l’ordinateur client actif.

Pour plus d’informations, voir :

Exemple de socket TCP : création d’un client Telnet

L’exemple Telnet illustre les techniques de connexion à un serveur distant et de transmission des données à l’aide de la classe Socket. Cet exemple étudie les techniques suivantes :

  • Création d’un client Telnet personnalisé à l’aide de la classe Socket

  • Envoi de texte au serveur distant à l’aide de l’objet ByteArray

  • Gestion des données reçues d’un serveur distant

Pour obtenir les fichiers d’application de cet exemple, voir www.adobe.com/go/learn_programmingAS3samples_flash_fr . Les fichiers d’application Telnet se trouvent dans le dossier Samples/Telnet. L’application se compose des fichiers suivants :

Fichier

Description

TelnetSocket.fla

ou

TelnetSocket.mxml

Fichier d’application principal correspondant à l’interface utilisateur de Flex (MXML) ou Flash (FLA).

TelnetSocket.as

Classe Document fournissant la logique de l’interface utilisateur (Flash uniquement).

com/example/programmingas3/Telnet/Telnet.as

Fournit la fonctionnalité client Telnet à l’application, par exemple pour la connexion à un serveur distant et l’envoi, la réception et l’affichage des données.

Présentation de l’application socket Telnet

Le fichier principal TelnetSocket.mxml se charge de créer l’interface utilisateur (IU) de l’application entière.

Outre l’IU, ce fichier définit deux méthodes, login() et sendCommand() , qui permettent la connexion de l’utilisateur au serveur spécifié.

L’exemple suivant répertorie le code ActionScript du fichier d’application principal :

import com.example.programmingas3.socket.Telnet; 
 
private var telnetClient:Telnet; 
private function connect():void 
{ 
    telnetClient = new Telnet(serverName.text, int(portNumber.text), output); 
    console.title = "Connecting to " + serverName.text + ":" + portNumber.text; 
    console.enabled = true; 
} 
private function sendCommand():void 
{ 
    var ba:ByteArray = new ByteArray(); 
    ba.writeMultiByte(command.text + "\n", "UTF-8"); 
    telnetClient.writeBytesToSocket(ba); 
    command.text = ""; 
}

La première ligne de code importe la classe Telnet à partir du package personnalisé com.example.programmingas.socket. La deuxième ligne de code déclare une occurrence de la classe Telnet, telnetClient , qui est initialisée ultérieurement par la méthode connect() . Ensuite, la méthode connect() est déclarée et initialise la variable telnetClient déclarée auparavant. Cette méthode transmet le nom du serveur Telnet spécifié par l’utilisateur, le port de ce serveur et une référence à un composant TextArea dans la liste d’affichage, qui sert à afficher les réponses textuelles reçues du serveur socket. Les deux dernières lignes de la méthode connect() définissent la propriété title du composant Panel et active celui-ci, ce qui permet à l’utilisateur d’envoyer les données au serveur distant. La méthode finale du fichier d’application principal, sendCommand() , permet d’envoyer les commandes de l’utilisateur au serveur distant sous forme d’objet ByteArray.

Présentation de la classe Telnet

La classe Telnet se charge d’établir la connexion au serveur distant Telnet et d’envoyer et de recevoir les données.

La classe Telnet déclare les variables privées suivantes :

private var serverURL:String; 
private var portNumber:int; 
private var socket:Socket; 
private var ta:TextArea; 
private var state:int = 0;

La première variable, serverURL , contient l’adresse du serveur auquel se connecter, spécifiée par l’utilisateur.

La deuxième variable, portNumber , correspond au numéro de port sur lequel le serveur Telnet s’exécute actuellement. Par défaut, le service Telnet utilise le port 23.

La troisième variable, socket , est une occurrence de Socket qui tente d’établir une connexion au serveur défini par les variables serverURL et portNumber .

La quatrième variable, ta , est une référence à l’occurrence du composant TextArea sur la scène. Ce composant sert à afficher les réponses provenant du serveur Telnet distant ou les éventuels messages d’erreur.

La dernière variable, state , est une valeur numérique utilisée pour déterminer les options prises en charge par le client Telnet.

Comme vous l’avez vu précédemment, la fonction constructeur de la classe Telnet est appelée par la méthode connect() dans le fichier d’application principal.

Le constructeur Telnet prend trois paramètres : server , port et output . Les paramètres server et port spécifient le nom et le numéro de port du serveur Telnet. Le dernier paramètre, output , est une référence à une occurrence du composant TextArea sur la scène où s’affichent les résultats du serveur à l’intention de l’utilisateur.

public function Telnet(server:String, port:int, output:TextArea) 
{ 
    serverURL = server; 
    portNumber = port; 
    ta = output; 
    socket = new Socket(); 
    socket.addEventListener(Event.CONNECT, connectHandler); 
    socket.addEventListener(Event.CLOSE, closeHandler); 
    socket.addEventListener(ErrorEvent.ERROR, errorHandler); 
    socket.addEventListener(IOErrorEvent.IO_ERROR, ioErrorHandler); 
    socket.addEventListener(ProgressEvent.SOCKET_DATA, dataHandler); 
    Security.loadPolicyFile("http://" + serverURL + "/crossdomain.xml"); 
    try 
    { 
        msg("Trying to connect to " + serverURL + ":" + portNumber + "\n"); 
        socket.connect(serverURL, portNumber); 
    } 
    catch (error:Error) 
    { 
        msg(error.message + "\n"); 
        socket.close(); 
    } 
}
Ecriture de données dans un socket

Pour écrire des données sur une connexion socket, vous appelez l’une des méthodes d’écriture de la classe Socket. Parmi ces méthodes d’écriture figurent writeBoolean() , writeByte() , writeBytes() , writeDouble() , etc. Purgez ensuite les données dans le tampon de sortie par le biais de la méthode flush() . Sur le serveur Telnet, les données sont écrites sur la connexion Socket à l’aide de la méthode writeBytes() , qui prend comme paramètre le tableau d’octets et l’envoie au tampon de sortie. La méthode writeBytesToSocket() se présente comme suit :

public function writeBytesToSocket(ba:ByteArray):void 
{ 
    socket.writeBytes(ba); 
    socket.flush(); 
}

Cette méthode est appelée par la méthode sendCommand() du fichier d’application principal.

Affichage des messages provenant du serveur socket

Dès qu’un message est reçu du serveur socket ou qu’un événement se produit, la méthode personnalisée msg() est appelée. Cette méthode ajoute une chaîne au composant TextArea sur la scène et appelle une méthode setScroll() personnalisée, qui provoque le défilement vers le bas du composant TextArea. La méthode msg() se présente comme suit :

private function msg(value:String):void 
{ 
    ta.text += value; 
    setScroll(); 
}

Si vous n’appliquez pas le défilement automatique au contenu du composant TextArea, les utilisateurs auront à le faire manuellement pour consulter la dernière réponse du serveur.

Défilement du contenu d’un composant TextArea

La méthode setScroll() contient une seule ligne de code ActionScript qui permet de faire défiler verticalement le contenu du composant TextArea de manière que l’utilisateur puisse voir la dernière ligne de texte renvoyé. L’extrait de code suivant illustre la méthode setScroll() :

public function setScroll():void 
{ 
    ta.verticalScrollPosition = ta.maxVerticalScrollPosition; 
}

Cette méthode définit la propriété verticalScrollPosition , qui correspond au numéro de la ligne de caractère supérieure actuellement affichée, puis lui attribue la valeur de la propriété maxVerticalScrollPosition .

Sockets XML

Un socket XML permet de créer une connexion à un serveur distant qui demeure ouverte jusqu’à ce qu’elle soit explicitement fermée. Vous pouvez échanger des données au format chaîne (XML, par exemple) entre le serveur et le client. L’utilisation d’un serveur socket XML présente l’avantage de ne pas imposer au client de demander explicitement les données. Le serveur peut envoyer des données sans attendre de demande à chaque client connecté.

Dans Flash Player et les contenus Adobe AIR situés hors du sandbox d’application, les connexions socket XML nécessitent la présence d’un fichier de régulation socket sur le serveur cible. Pour plus d’informations, voir Contrôles de site Web (fichiers de régulation) et Connexion aux sockets .

La classe XMLSocket ne peut pas automatiquement tunneler à travers les pare-feux car, contrairement au protocole RTMP (Real-Time Messaging Protocol), le XMLSocket n’a pas de capacité de tunneling HTTP. Si vous devez utiliser le tunneling HTTP, envisagez l’emploi de Flash Remoting ou Flash Media Server (qui prend en charge RTMP).

Les restrictions suivantes indiquent comment et où le contenu situé dans Flash Player ou une application AIR hors du sandbox de sécurité de l’application peut utiliser un objet XMLSocket pour se connecter au serveur :

  • Pour le contenu hors du sandbox de sécurité de l’application, la méthode XMLSocket.connect() peut se connecter uniquement aux numéros de port TCP supérieurs ou égaux à 1024. En conséquence de cette restriction, les serveurs démon qui communiquent avec l’objet XMLSocket doivent également être affectés à des numéros de port supérieurs ou égaux à 1024. Les ports dont le numéro est inférieur à 1024 sont souvent utilisés par des services du système, tels que FTP (21), Telnet (23), SMTP (25), HTTP (80) et POP3 (110), de sorte que les objets XMLSocket ne puissent pas y accéder pour des raisons de sécurité. La restriction du numéro de port limite les possibilités d’accès à ces ressources et leur mauvaise utilisation.

  • Pour le contenu hors du sandbox de sécurité de l’application, la méthode XMLSocket.connect() peut se connecter uniquement aux ordinateurs dans le même domaine de résidence du contenu. (Cette restriction est identique aux règles de sécurité de URLLoader.load() .) Pour se connecter à un serveur démon s’exécutant dans un domaine différent du domaine de résidence du contenu, vous pouvez créer sur le serveur un fichier de régulation interdomaines qui permette un accès à partir de domaines spécifiques. Pour plus d’informations sur les fichiers de régulation interdomaine, voir Sécurité AIR .

Remarque : la configuration d’un serveur en vue de la communication avec un objet XMLSocket peut être difficile à réaliser. Si votre application ne requiert pas d’interactivité en temps réel, utilisez la classe URLLoader, plutôt que la classe XMLSocket.

Vous pouvez utiliser les méthodes XMLSocket.connect() et XMLSocket.send() de la classe XMLSocket pour transférer un objet XML vers et à partir d’un serveur sur une connexion socket. La méthode XMLSocket.connect() établit une connexion socket avec le port d’un serveur Web. La méthode XMLSocket.send() transmet un objet XML au serveur spécifié dans la connexion socket.

Lorsque vous appelez la méthode XMLSocket.connect() , l’application ouvre une connexion TCP/IP avec le serveur et garde cette connexion ouverte jusqu’à ce que l’un des événements suivants se produise :

  • La méthode XMLSocket.close() de la classe XMLSocket est appelée.

  • Il n’existe plus aucune référence à l’objet XMLSocket.

  • Flash Player se ferme.

  • La connexion est interrompue (le modem est déconnecté, par exemple).

Connexion à un serveur par le biais de la classe XMLSocket

Pour créer une connexion socket, vous devez créer une application côté serveur qui attend la demande de connexion socket et envoie une réponse à l’application Flash Player ou AIR. Ce type d’application côté serveur peut être programmé en AIR ou dans tout autre langage de programmation tel que Java, Python ou Perl. Pour utiliser la classe XMLSocket, l’ordinateur serveur doit exécuter un démon capable de lire le protocole simple utilisé par la classe XMLSocket :

  • Les messages XML sont envoyés via une connexion socket à flux TCP/IP bidirectionnel simultané.

  • Chaque message XML est un document XML complet, terminé par un octet nul (0).

  • Un nombre illimité de messages XML peut être envoyé et reçu via une connexion XMLSocket.

Création d’un serveur socket XML Java et connexion à ce serveur

Le code suivant illustre un simple serveur XMLSocket écrit en langage Java qui accepte les connexions entrantes et affichent les messages reçus dans la fenêtre d’invite de commande. Par défaut, un nouveau serveur est créé sur le port 8080 de votre machine locale, mais vous pouvez spécifier un numéro de port différent en lançant le serveur à partir de la ligne de commande.

Créez un document texte et ajoutez-y le code suivant :

import java.io.*; 
import java.net.*; 
 
class SimpleServer 
{ 
    private static SimpleServer server; 
    ServerSocket socket; 
    Socket incoming; 
    BufferedReader readerIn; 
    PrintStream printOut; 
 
    public static void main(String[] args) 
    { 
        int port = 8080; 
 
        try 
        { 
            port = Integer.parseInt(args[0]); 
        } 
        catch (ArrayIndexOutOfBoundsException e) 
        { 
            // Catch exception and keep going. 
        } 
 
        server = new SimpleServer(port); 
    } 
 
    private SimpleServer(int port) 
    { 
        System.out.println(">> Starting SimpleServer"); 
        try 
        { 
            socket = new ServerSocket(port); 
            incoming = socket.accept(); 
            readerIn = new BufferedReader(new InputStreamReader(incoming.getInputStream())); 
            printOut = new PrintStream(incoming.getOutputStream()); 
            printOut.println("Enter EXIT to exit.\r"); 
            out("Enter EXIT to exit.\r"); 
            boolean done = false; 
            while (!done) 
            { 
                String str = readerIn.readLine(); 
                if (str == null) 
                { 
                    done = true; 
                } 
                else 
                { 
                    out("Echo: " + str + "\r"); 
                    if(str.trim().equals("EXIT")) 
                    { 
                        done = true; 
                    } 
                } 
                incoming.close(); 
            } 
        } 
        catch (Exception e) 
        { 
            System.out.println(e); 
        } 
    } 
 
    private void out(String str) 
    { 
        printOut.println(str); 
        System.out.println(str); 
    } 
}

Enregistrez le document sur le disque dur sous le nom SimpleServer.java et compilez-le à l’aide d’un compilateur Java, qui crée un fichier de classe Java nommé SimpleServer.class.

Vous pouvez lancer le serveur XMLSocket via la ligne de commande en tapant java SimpleServer . Le fichier SimpleServer.class peut se situer à tout emplacement sur l’ordinateur local ou le réseau ; il n’est pas nécessaire de le placer dans le répertoire racine du serveur Web.

si vous ne pouvez pas lancer le serveur parce que des fichiers ne se trouvent pas dans le chemin de classe Java, essayez de le faire avec java -classpath. SimpleServer .

Pour établir une connexion au serveur XMLSocket à partir de l’application, vous devez créer une nouvelle occurrence de la classe XMLSocket et appeler la méthode XMLSocket.connect() tout en transférant le nom d’hôte et le numéro de port, comme suit :

var xmlsock:XMLSocket = new XMLSocket(); 
xmlsock.connect("127.0.0.1", 8080);

Dès que vous recevez des données du serveur, l’événement data ( flash.events.DataEvent.DATA ) est distribué :

xmlsock.addEventListener(DataEvent.DATA, onData); 
private function onData(event:DataEvent):void 
{ 
    trace("[" + event.type + "] " + event.data); 
}

Pour envoyer des données au serveur XMLSocket, utilisez la méthode XMLSocket.send() et transmettez un objet XML ou une chaîne. Flash Player convertit le paramètre fourni en objet String et envoie au serveur XMLSocket son contenu suivi d’un octet nul (0) :

xmlsock.send(xmlFormattedData);

La méthode XMLSocket.send() ne renvoie pas de valeur indiquant si les données ont bien été transmises. Si une erreur se produit pendant la tentative d’envoi des données, une erreur IOError est renvoyée.

chaque message que vous envoyez au serveur socket doit se terminer par un caractère de changement de ligne ( \n ).

Pour plus d’informations, voir XMLSocket .

Sockets de serveur

La classe ServerSocket permet d’autoriser d’autres processus à se connecter à l’application par le biais d’un socket TCP (Transport Control Protocol). Le processus de connexion peut s’exécuter sur l’ordinateur local ou un autre ordinateur connecté au réseau. Lorsqu’un objet ServerSocket reçoit une demande de connexion, il distribue un événement connect . L’objet ServerSocketConnectEvent distribué avec l’événement contient un objet Socket. Cet objet permet de communiquer ultérieurement avec l’autre processus.

Pour écouter les connexions socket entrantes :

  1. Créez un objet ServerSocket et liez-le à un port local.

  2. Ajoutez des écouteurs d’événements associés à l’événement connect .

  3. Appelez la méthode listen() .

  4. Répondez à l’événement connect , qui fournit un objet Socket pour chaque connexion entrante.

L’objet ServerSocket continue à écouter les nouvelles connexions jusqu’à ce que vous appeliez la méthode close() .

L’exemple de code suivant illustre la création d’une application de serveur socket. L’exemple écoute les connexions entrantes sur le port 8087. Lorsqu’une connexion est reçue, l’exemple envoie un message (la chaîne « Connected ») au socket client. Le serveur renvoie désormais tout message reçu au client.

package 
{ 
    import flash.display.Sprite; 
    import flash.events.Event; 
    import flash.events.IOErrorEvent; 
    import flash.events.ProgressEvent; 
    import flash.events.ServerSocketConnectEvent; 
    import flash.net.ServerSocket; 
    import flash.net.Socket; 
     
    public class ServerSocketExample extends Sprite 
    { 
        private var serverSocket:ServerSocket; 
        private var clientSockets:Array = new Array(); 
 
        public function ServerSocketExample() 
        { 
            try 
            { 
                // Create the server socket 
                serverSocket = new ServerSocket(); 
                 
                // Add the event listener 
                serverSocket.addEventListener( Event.CONNECT, connectHandler ); 
                serverSocket.addEventListener( Event.CLOSE, onClose ); 
                 
                // Bind to local port 8087 
                serverSocket.bind( 8087, "127.0.0.1" ); 
                 
                // Listen for connections 
                serverSocket.listen(); 
                trace( "Listening on " + serverSocket.localPort ); 
 
            } 
            catch(e:SecurityError) 
            { 
                trace(e); 
            } 
        } 
 
        public function connectHandler(event:ServerSocketConnectEvent):void 
        { 
            //The socket is provided by the event object 
            var socket:Socket = event.socket as Socket; 
            clientSockets.push( socket ); 
             
            socket.addEventListener( ProgressEvent.SOCKET_DATA, socketDataHandler); 
            socket.addEventListener( Event.CLOSE, onClientClose ); 
            socket.addEventListener( IOErrorEvent.IO_ERROR, onIOError ); 
             
            //Send a connect message 
            socket.writeUTFBytes("Connected."); 
            socket.flush(); 
             
            trace( "Sending connect message" ); 
        } 
         
        public function socketDataHandler(event:ProgressEvent):void 
        { 
            var socket:Socket = event.target as Socket 
                 
            //Read the message from the socket 
            var message:String = socket.readUTFBytes( socket.bytesAvailable ); 
            trace( "Received: " + message); 
 
            // Echo the received message back to the sender 
            message = "Echo -- " + message; 
            socket.writeUTFBytes( message ); 
            socket.flush(); 
            trace( "Sending: " + message ); 
        } 
         
        private function onClientClose( event:Event ):void 
        { 
            trace( "Connection to client closed." ); 
            //Should also remove from clientSockets array... 
        } 
 
        private function onIOError( errorEvent:IOErrorEvent ):void 
        { 
            trace( "IOError: " + errorEvent.text ); 
        } 
 
        private function onClose( event:Event ):void 
        { 
            trace( "Server socket closed by OS." ); 
        } 
}}

Pour plus d’informations, voir :

Sockets UDP (AIR)

Le protocole UDP (Universal Datagram Protocol) permet d’échanger des messages via une connexion réseau sans état. Non seulement UDP ne garantit pas la livraison dans l’ordre des messages, mais il ne peut pas se porter garant qu’ils soient livrés. Si UDP est activé, le code réseau du système d’exploitation consacre généralement moins de temps à la mise en ordre, au suivi et à la confirmation des messages. Par conséquent, les messages UDP sont le plus souvent livrés à l’application de destination plus rapidement que les messages TCP.

Les communications de type sockets UDP s’avèrent utiles lorsque vous devez envoyer des informations en temps réel telles qu’une actualisation des positions dans le cadre d’un jeu ou des paquets son dans une application de conversation vocale. Dans les applications de ce type, un certain pourcentage de perte de données est acceptable et une faible latence de transmission prime sur la livraison garantie. Dans quasiment tous les autres cas de figure, il est préférable d’utiliser les sockets TCP.

L’application AIR peut envoyer et recevoir des messages UDP à l’aide des classes DatagramSocket et DatagramSocketDataEvent. Pour envoyer ou recevoir un message UDP :

  1. Créez un objet DatagramSocket.

  2. Ajoutez un écouteur d’événements associé à l’événement data .

  3. Liez le socket à une adresse IP locale et à un port par le biais de la méthode bind() .

  4. Envoyez des messages en appelant la méthode send() et en transmettant l’adresse IP et le port de l’ordinateur cible.

  5. Répondez à l’événement data pour recevoir des messages. L’objet DatagramSocketDataEvent distribué pour cet événement contient un objet ByteArray dans lequel figurent les données du message.

L’exemple de code suivant illustre l’envoi et la réception de messages UDP par une application. L’exemple envoie un message simple contenant la chaîne « Hello. » à l’ordinateur cible. Il effectue également le suivi du contenu de tout message reçu.

package 
{ 
import flash.display.Sprite; 
import flash.events.DatagramSocketDataEvent; 
import flash.events.Event; 
import flash.net.DatagramSocket; 
import flash.utils.ByteArray; 
 
public class DatagramSocketExample extends Sprite 
{ 
    private var datagramSocket:DatagramSocket; 
     
    //The IP and port for this computer 
    private var localIP:String = "192.168.0.1"; 
    private var localPort:int = 55555; 
     
    //The IP and port for the target computer 
    private var targetIP:String = "192.168.0.2"; 
    private var targetPort:int = 55555; 
     
    public function DatagramSocketExample() 
    { 
        //Create the socket 
        datagramSocket = new DatagramSocket(); 
        datagramSocket.addEventListener( DatagramSocketDataEvent.DATA, dataReceived ); 
         
        //Bind the socket to the local network interface and port 
        datagramSocket.bind( localPort, localIP ); 
         
        //Listen for incoming datagrams 
        datagramSocket.receive(); 
         
        //Create a message in a ByteArray 
        var data:ByteArray = new ByteArray(); 
        data.writeUTFBytes("Hello."); 
         
        //Send the datagram message 
        datagramSocket.send( data, 0, 0, targetIP, targetPort); 
    } 
     
    private function dataReceived( event:DatagramSocketDataEvent ):void 
    { 
        //Read the data from the datagram 
        trace("Received from " + event.srcAddress + ":" + event.srcPort + "> " + 
            event.data.readUTFBytes( event.data.bytesAvailable ) ); 
    } 
}}

Tenez compte des considérations suivantes si vous utilisez des sockets UDP :

  • Un paquet unique de données ne doit pas excéder l’unité maximale de transmission gérée par l’interface réseau ou tout nœud réseau entre l’expéditeur et le destinataire. L’intégralité des données de l’objet ByteArray transmise à la méthode send() est envoyée sous forme de paquet unique. (Dans TCP, les messages volumineux sont divisés en plusieurs paquets distincts.)

  • Il ne se produit pas de négociation entre l’expéditeur et la cible. Les messages sont ignorés sans générer d’erreur si la cible n’existe pas ou qu’aucun écouteur actif n’est défini sur le port indiqué.

  • Si vous faites appel à la méthode connect() , les messages issus d’autres sources sont ignorés. Une connexion UDP assure un filtrage des paquets uniquement. Cela ne signifie pas nécessairement qu’un processus d’écoute valide soit déployé à l’adresse et sur le port cibles.

  • Le trafic UDP risque de submerger un réseau. En cas d’encombrement réseau, les administrateurs réseau sont parfois appelés à mettre en œuvre des contrôles de qualité de service. (TCP intègre des fonctions de régulation de la circulation en vue de réduire l’impact de l’encombrement réseau.)

Pour plus d’informations, voir :

Adresses IPv6

Flash Player 9.0.115.0 (et versions ultérieures) prennent en charge IPv6 (Internet Protocol version 6). IPv6 est une version du protocole IP (Internet Protocol) qui prend en charge les adresses 128 bits (amélioration du protocole IPv4 précédent qui prend en charge les adresses 32 bits). Vous devrez peut-être activer IPv6 sur vos interfaces de mise en réseau. Pour plus d’informations, voir l’Aide du système d’exploitation hébergeant les données.

Si IPv6 est pris en charge sur le système hébergeant, vous pouvez spécifier des adresses littérales IPv6 numériques dans les URL entre crochets ([]), comme suit :

[2001:db8:ccc3:ffff:0:444d:555e:666f]

Flash Player renvoie les valeurs IPv6 littérales selon les règles suivantes :

  • Flash Player renvoie la forme complète de la chaîne pour les adresses IPv6.

  • La valeur IP ne possède pas d’abréviations à deux-points redoublés (::).

  • Les chiffres hexadécimaux sont en bas de casse seulement.

  • Les adresses IPv6 sont entourées de crochets ([]).

  • Chaque quatuor d’adresses est représenté par 0 à 4 chiffres hexadécimaux, sans zéros non significatifs.

  • Un quatuor d’adresses de zéros est représenté par un seul zéro (et pas un caractère de deux-points redoublé), sauf dans les cas suivants.

Les valeurs IPv6 que renvoie Flash Player sont soumises aux exceptions suivantes :

  • Une adresse IPv6 non spécifiée (rien que des zéros) est représentée par [::].

  • L’adresse de bouclage (loopback) ou localhost IPv6 est représentée par [::1].

  • Les adresses mappées en IPv4 (converties en IPv6) sont représentées par [::ffff:a.b.c.d], où a.b.c.d constitue une valeur décimale à points (dotted-decimal) IPv4 classique.

  • Les adresses compatibles avec IPv4 sont représentées par [::a.b.c.d], où a.b.c.d est une valeur décimale à points (dotted-decimal) IPv4 classique.