C # Socket Policy File Server per connessioni socket AS3.0 di basso livello?

Question

Come posso fare per creare un file server di criteri socket in C #. Tutto quello che deve fare è ascoltare sulla porta 843 per la stringa & Quot; & Lt; policy-file-request / & Gt; & Quot; seguito da un byte NULL e quindi restituire una stringa XML (che è il file dei criteri socket).

Non ho mai codificato questo genere di cose prima e non sono sicuro di dove iniziare. Lo creo in un servizio Windows? Eventuali suggerimenti o collegamenti sono benvenuti.

Sfondo:

Per contattare un servizio web da flash sto usando la libreria 'as3httpclient' invece di URLRequest / URLLoader. Questo perché mi dà la possibilità di inviare intestazioni personalizzate con richieste GET. Questa libreria utilizza socket di basso livello per fare le sue cose.

Quando flash utilizza socket di basso livello per connettersi a un server, cerca un file di criteri socket e questo deve essere servito da un file server di criteri socket.

Articolo sul file delle norme sui socket da Adobe

Answer 1

Alcune cose da sapere sull'utilizzo dell'architettura suggerita:

Tentativo di inviare una richiesta HTTP tramite socket

Principalmente, devi essere consapevole che anche se puoi chattare http a un livello inferiore usando i socket, ci sono molti casi in cui la comunicazione in questo modo fallirà. Principalmente questi errori si verificano se l'utente ha un server proxy abilitato nel proprio browser, in quanto non esiste alcun mezzo efficace per rilevare e successivamente utilizzare il proxy durante la connessione tramite un socket.

Per creare un server delle politiche, è possibile utilizzare TcpListener classe. Inizieresti ad ascoltare come segue:

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

Il metodo NewClientHandler avrebbe la forma:

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

A quel punto potresti voler fornire l'oggetto tcpClient a una classe di tua creazione per gestire la validazione dei dati provenienti dal socket. Lo chiamerò RemoteClient.

In RemoteClient, avresti qualcosa del genere:

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

e un metodo di ricezione:

    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;
        }
    }

e alcuni metodi di invio:

    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;
        }
    }

Questi sono tutti i dettagli importanti che penso. L'ho scritto qualche tempo fa ... il metodo di ricezione sembra che potrebbe fare con una rielaborazione, ma dovrebbe essere sufficiente per iniziare.

Answer 2

Crea un socket di ascolto.

Quando viene aperta una connessione, eseguire una ricezione e attendere la stringa prevista. Quando ricevuto, invia il contenuto del file e quindi chiudi il socket.

Avvolgi questo in un servizio (eseguito come account con privilegi limitati).

Gran parte del lavoro viene svolto con il System.Net.Sockets.Socket , la documentazione contiene un esempio, l'API è molto simile all'API del socket BSD nel suo complesso (in gran parte esiste un mapping 1: 1 dall'API BSD al metodo Socket (o tipo di aiuto)), quindi qualsiasi sfondo dovrebbe essere facilmente traducibile.

Answer 3

Ho dovuto svolgere questo compito sia con Java che con C #, sono abbastanza simili.

Puoi dare un'occhiata a file delle politiche java .

Alcuni problemi possono vedere a questa risposta: https://stackoverflow.com/a/12854204/1343667