C # Socket Policy File Server pour les connexions de socket AS3.0 de bas niveau?

Question

Comment créer un serveur de fichiers de stratégie de socket en C #. Il suffit d'écouter sur le port 843 la chaîne & "; & Lt; policy-file-request / & Gt; &"; suivi d'un octet NULL puis retourne une chaîne XML (qui est le fichier de règles de socket).

Je n'ai pas codé ce genre de chose auparavant et je ne sais pas par où commencer. Est-ce que je le crée dans un service Windows? Tous les conseils ou liens sont les bienvenus.

Arrière-plan:

Pour contacter un service Web à partir de Flash, j'utilise la bibliothèque 'as3httpclient' à la place de URLRequest / URLLoader. En effet, cela me permet d'envoyer des en-têtes personnalisés avec des requêtes GET. Cette bibliothèque utilise des sockets de bas niveau pour faire son travail.

Lorsque Flash utilise des sockets de bas niveau pour se connecter à un serveur, il recherche un fichier de stratégie de socket, qui doit être servi par un serveur de fichiers de stratégie de socket.

Article du fichier de règles de socket de Adobe

Answer 1

Quelques éléments à prendre en compte lors de l'utilisation de votre architecture suggérée:

Essayer d'envoyer une demande HTTP via des sockets

Essentiellement, vous devez savoir que même si vous pouvez discuter avec http à un niveau inférieur à l'aide de sockets, il existe un grand nombre de cas où la communication échouera de cette manière. Ces pannes se produiront principalement si l'utilisateur a un serveur proxy activé dans son navigateur, car il n'existe aucun moyen efficace de détecter et d'utiliser ultérieurement le proxy lors d'une connexion via un socket.

Pour créer un serveur de règles, vous pouvez utiliser le TcpListener . Vous commenceriez à écouter comme suit:

var tcpListener = new TcpListener(IPAddress.Any, 843 );
tcpListener.start();
tcpListener.BeginAcceptTcpClient(new AsyncCallback(NewClientHandler), null);

La méthode NewClientHandler aurait la forme suivante:

    private void NewClientHandler(IAsyncResult ar)
    {
        TcpClient tcpClient = tcpListener.EndAcceptTcpClient(ar);
        ...

Vous pouvez alors vouloir fournir l'objet tcpClient à une classe de votre propre création pour gérer la validation des données provenant du socket. Je vais l'appeler RemoteClient.

Dans RemoteClient, vous obtiendrez quelque chose comme ceci:

    var buffer=new byte[BUFFER_SIZE];
    tcpClient.GetStream().BeginRead(buffer, 0, buffer.Length, Receive, null);

et une méthode de réception:

    private void Receive(IAsyncResult ar)
    {
        int bytesRead;
        try
        {
            bytesRead = tcpClient.GetStream().EndRead(ar);
        }
        catch (Exception e)
        {

            //something bad happened. Cleanup required
            return;
        }

        if (bytesRead != 0)
        {
            char[] charBuffer = utf8Encoding.GetChars(buffer, 0, bytesRead);
            try
            {
                tcpClient.GetStream().BeginRead(buffer, 0, buffer.Length, Receive, null);
            }
            catch (Exception e)
            {
                //something bad happened. Cleanup required
            }
        }
        else
        {
            //socket closed, I think?
            return;
        }
    }

et certaines méthodes d'envoi:

    public void Send(XmlDocument doc)
    {
        Send(doc.OuterXml);
    }
    private void Send(String str)
    {

        Byte[] sendBuf = utf8Encoding.GetBytes(str);
        Send(sendBuf);
    }
    private void Send(Byte[] sendBuf)
    {
        try
        {
            tcpClient.GetStream().Write(sendBuf, 0, sendBuf.Length);
            tcpClient.GetStream().WriteByte(0);
            tcpClient.GetStream().WriteByte(13); //very important to terminate XmlSocket data in this way, otherwise Flash can't read it.

        }
        catch (Exception e)
        {
            //something bad happened. cleanup?
            return;
        }
    }

C'est tous les détails importants, je pense. J'ai écrit ceci il y a quelque temps ... la méthode de réception semble pouvoir être reprise, mais elle devrait suffire à vous aider à démarrer.

Answer 2

Créer une socket d'écoute.

Quand une connexion est ouverte, effectuez une réception et attendez la chaîne attendue. Une fois reçu, envoyez le contenu du fichier, puis fermez le socket.

Emballez ceci dans un service (fonctionnant sous un compte à privilèges faibles).

La majeure partie du travail est effectuée avec le System.Net.Sockets.Socket. , la documentation contient un exemple. L’API est très similaire à l’API de socket BSD (il existe en grande partie un mappage 1: 1 de l’API BSD à la méthode Socket (ou type d’aide)), de sorte que tout arrière-plan doit être facile traduisible.

Answer 3

Je devais faire cette tâche avec Java et C #, ils sont assez similaires.

Vous pouvez consulter fichier de règles Java .

Certains problèmes peuvent apparaître dans cette réponse: https://stackoverflow.com/a/12854204/1343667