C# Socket-Richtlinien-Dateiserver für Low-Level-AS3.0-Socket-Verbindungen?

Question

Wie erstelle ich einen Socket -Richtlinien -Dateiserver in C#? Alles, was es tun muss, ist Port 843 für die Zeichenfolge zuzuhören. "u003Cpolicy-file-request/> "Gefolgt von einem Null -Byte und dann eine XML -Zeichenfolge (die Socket -Richtliniendatei ist).

Ich habe so etwas noch nicht codiert und bin mir nicht sicher, wo ich anfangen soll. Erstelle ich es in einem Windows -Dienst? Alle Tipps oder Links sind willkommen.

Hintergrund:

Um einen Webdienst von Flash zu kontaktieren, verwende ich die Bibliothek "As3httpclient" anstelle der Urlrequest/Urlloader. Dies liegt daran, dass ich die Möglichkeit gibt, benutzerdefinierte Header mit GET -Anfragen zu senden. Diese Bibliothek verwendet Low-Level-Steckdosen, um ihre Sachen zu tun.

Wenn Flash Low -Level -Steckdosen verwendet, um eine Verbindung zu einem Server herzustellen, sucht er nach einer Socket -Richtliniendatei - und dies muss von einem Socket -Richtlinien -Dateiserver bereitgestellt werden.

Artikel über Socket -Richtliniendatei von Adobe

Answer 1

Ein paar Dinge, die Sie über Ihre vorgeschlagene Architektur bewusst sind:

Der Versuch, eine HTTP -Anfrage über Sockets zu senden

Vor allem müssen Sie sich darüber im Klaren sein, dass Sie, obwohl Sie mithilfe von Steckdosen auf einer niedrigeren Ebene chatten können, eine große Anzahl von Fällen gibt, in denen die Kommunikation auf diese Weise fehlschlägt. Hauptsächlich werden diese Fehler auftreten, wenn der Benutzer über einen Proxy -Server in seinem Browser aktiviert ist, da es keine wirksamen Mittel zum Erkennen und anschließenden Verwendung des Proxy beim Anschließen über einen Socket gibt.

Um einen Richtlinienserver zu erstellen, können Sie die verwenden Tcplistener Klasse. Sie würden wie folgt zuhören:

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

Die Methode NewClientHandler hätte die Form:

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

An diesem Punkt möchten Sie möglicherweise das TCPClient -Objekt an eine Klasse Ihrer eigenen Erstellung liefern, um die Validierung der aus dem Socket stammenden Daten zu verarbeiten. Ich werde es remoteclient nennen.

In RemoteClient hätten Sie so etwas:

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

und eine Empfangsmethode:

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

und einige senden Methoden:

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

Das sind all die wichtigen Details, die ich denke. Ich habe das vor einiger Zeit geschrieben ... Die Empfangsmethode sieht mit einer Nacharbeit aus, aber es sollte ausreichen, um Ihnen den Einstieg zu erlangen.

Answer 2

Erstellen Sie eine Hörstecke.

Wenn eine Verbindung geöffnet wird, führen Sie ein Empfang durch und warten Sie auf die erwartete Zeichenfolge. Wenn Sie den Dateiinhalt empfangen und dann den Socket schließen.

Wickeln Sie dies in einen Dienst ein (als ein Konto mit niedrigem Privilegien).

Der größte Teil der Arbeit wird mit dem erledigt System.net.sockets.socket Klasse, die Dokumentation enthält eine Probe, die API ist der BSD -Socket -API insgesamt sehr ähnlich (hauptsächlich gibt es eine 1: 1 -Mapping von der BSD -API zu Socket (oder Hilfetyp), sodass jeder Hintergrund leicht übersetzbar sein sollte.

Answer 3

Ich musste diese Aufgabe mit Java und C#zu dieser Aufgabe mussten, sie sind ziemlich ähnlich.

Sie können sich ansehen Java -Richtliniendatei.

Auf dieser Antwort können einige Probleme sehen: https://stackoverflow.com/a/12854204/1343667