C# Servidor de arquivos de política de soquete para conexões de soquete AS3.0 de baixo nível?

Question

Como faço para criar um servidor de arquivos de política de soquete em C#. Tudo o que precisa fazer é ouvir na porta 843 para a corda "u003Cpolicy-file-request/> "Seguido por um byte nulo e retorne uma string XML (que é o arquivo de política de soquete).

Eu não codifiquei esse tipo de coisa antes e não tenho certeza de por onde começar. Eu o crio em um serviço do Windows? Quaisquer dicas ou links são bem -vindos.

Fundo:

Para entrar em contato com um serviço da Web do Flash, estou usando a biblioteca 'AS3HTTPCLIENT' em vez do URLRequest/UrlLoader. Isso ocorre porque me dá a capacidade de enviar cabeçalhos personalizados com solicitações GET. Esta biblioteca usa soquetes de baixo nível para fazer suas coisas.

Quando o Flash usa soquetes de baixo nível para se conectar a um servidor, ele procura um arquivo de política de soquete - e isso precisa ser servido por um servidor de arquivos de política de soquete.

Artigo de Política de Socket de Adobe

Answer 1

Algumas coisas a serem cientes de usar sua arquitetura sugerida:

Tentando enviar uma solicitação HTTP por soquetes

Principalmente, você precisa estar ciente de que, embora possa conversar com HTTP em um nível mais baixo usando soquetes, há um grande número de casos em que a comunicação dessa maneira falhará. Principalmente, essas falhas ocorrerão se o usuário tiver um servidor proxy ativado em seu navegador, pois não há meios eficazes de descobrir e subsequentemente usando o proxy ao se conectar através de um soquete.

Para fazer um servidor de políticas, você pode usar o TcPlistener classe. Você começaria a ouvir da seguinte maneira:

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

O método NewClientHandler teria o formulário:

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

Nesse ponto, você pode fornecer o objeto TCPClient a uma classe de sua própria criação para lidar com a validação dos dados provenientes do soquete. Vou chamá -lo de remoção.

No remotecliente, você teria algo assim:

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

e um método de recebimento:

    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 alguns métodos enviados:

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

Acho que são todos os detalhes importantes. Eu escrevi isso há algum tempo ... o método de recebimento parece que poderia fazer com um retrabalho, mas deve ser suficiente para você começar.

Answer 2

Crie um soquete de escuta.

Quando uma conexão for aberta, faça um recebimento e aguarde a string esperada. Quando recebido, envie o conteúdo do arquivo e feche o soquete.

Enrole isso em um serviço (executando como uma conta de baixo privilégio).

A maior parte do trabalho é feita com o System.net.sockets.socket Classe, a documentação contém uma amostra, a API é muito semelhante à API do soquete BSD em geral (em grande parte há um mapeamento 1: 1 da API BSD para o método de soquete (ou tipo de ajuda)) para que qualquer plano de fundo seja facilmente traduzível.

Answer 3

Eu tive que essa tarefa com Java e C#, eles são bastante semelhantes.

Você pode dar uma olhada Arquivo de Política Java.

Alguns problemas podem ver nesta resposta: https://stackoverflow.com/a/12854204/1343667