Silverlight Working with Sockets

Silverlight和服务端进行通信前会向服务端请求一个安全策略文件，在Silverlight 3.0中这个请求端口为943、Silverlight 4.0也可以是80。请求的模式取决于你的应用程序中SocketAsyncEventArgs.SocketClientAccessPolicyProtocol所指的值为Http或Tcp。如果是Http，需要在IIS中为80的站点添加net.tcp类型的绑定，并指明端口（4502 - 4530）。Tcp则需要一个应用程序负责监听943端口，当请求为时返回你的策略文件内容。策略文件的格式可以如下：

<?xml version="1.0" encoding="utf-8"?>
<access-policy>
  <cross-domain-access>
    <policy>
      <allow-from http-request-headers="*">
        <domain uri="*" />
      </allow-from>
      <grant-to>
    <socket-resource port="4530" protocol="tcp" />
      </grant-to>
    </policy>
  </cross-domain-access>
</access-policy>

详细的内容可以参考Network Security Access Restrictions in Silverlight这篇文章：

http://msdn.microsoft.com/en-us/library/cc645032(v=VS.95).aspx

如果你编写的服务端需要和Silverlight进行Tcp通信，请准备一个策略服务端监听943端口。当Silverlight应用创建和服务端连接时，它会先请求你的PolicyServer并获取允许使用的端口。

关于WCF NET.TCP请参考WCF NET.TCP Protocol in Silverlight这篇文章：

http://www.silverlightshow.net/items/WCF-NET.TCP-Protocol-in-Silverlight-4.aspx

using System;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;

namespace SLPolicyServer
{
    class Program
    {
        /// <summary>
        /// 主程序入口
        /// </summary>
        /// <param name="args">参数</param>
        static void Main(String[] args)
        {
            String policyFile = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "clientaccesspolicy.xml");

            if (args.Length == 1)
            {
                policyFile = args[0];

                Console.WriteLine(args[0]);
            }

            new Thread(() =>
            {
                new PolicyServer(policyFile);
                Thread.Sleep(Timeout.Infinite);
            }).Start();

            Console.ReadKey();
        }
    }

    /// <summary>
    /// 策略连接
    /// </summary>
    class PolicyConnection
    {
        /// <summary>
        /// 策略请求字符串
        /// </summary>
        private static readonly String PolicyRequestString = "<policy-file-request/>";

        private Socket m_connection;
        private Byte[] m_buffer;
        private Byte[] m_policy;
        private Int32 m_received;

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="client">客户端套接字</param>
        /// <param name="policy">策略数据</param>
        public PolicyConnection(Socket client, Byte[] policy)
        {
            m_connection = client;
            m_policy = policy;
            m_buffer = new Byte[PolicyRequestString.Length];
            m_received = 0;

            try
            {
                m_connection.BeginReceive(m_buffer, 0, PolicyRequestString.Length, SocketFlags.None, new AsyncCallback(OnReceive), null);
            }
            catch (SocketException)
            {
                m_connection.Close();
            }
        }

        /// <summary>
        /// 接收数据
        /// </summary>
        /// <param name="ar">异步结果</param>
        private void OnReceive(IAsyncResult ar)
        {
            try
            {
                m_received += m_connection.EndReceive(ar);

                // 发送字符不足则继续接收
                if (m_received < PolicyRequestString.Length)
                {
                    m_connection.BeginReceive(m_buffer, m_received, PolicyRequestString.Length - m_received, SocketFlags.None, new AsyncCallback(OnReceive), null);

                    return;
                }

                String request = Encoding.UTF8.GetString(m_buffer, 0, m_received);

                if (StringComparer.InvariantCultureIgnoreCase.Compare(request, PolicyRequestString) != 0)
                {
                    m_connection.Close();

                    return;
                }

                // 发送策略文件
                m_connection.BeginSend(m_policy, 0, m_policy.Length, SocketFlags.None, new AsyncCallback(OnSend), null);
            }
            catch (SocketException)
            {
                m_connection.Close();
            }
        }

        /// <summary>
        /// 发送数据
        /// </summary>
        /// <param name="ar">异步结果</param>
        private void OnSend(IAsyncResult ar)
        {
            try
            {
                m_connection.EndSend(ar);
            }
            finally
            {
                m_connection.Close();
            }
        }
    }

    /// <summary>
    /// 策略服务
    /// </summary>
    class PolicyServer
    {
        private Socket m_listener;
        private Byte[] m_policy;

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="policyFile">策略文件</param>
        public PolicyServer(String policyFile)
        {
            // 读取策略文件
            FileStream policyStream = new FileStream(policyFile, FileMode.Open);
            m_policy = new byte[policyStream.Length];

            policyStream.Read(m_policy, 0, m_policy.Length);
            policyStream.Close();

            // 监听943端口
            m_listener = new Socket(AddressFamily.InterNetworkV6, SocketType.Stream, ProtocolType.Tcp);
            m_listener.SetSocketOption(SocketOptionLevel.IPv6, (SocketOptionName)27, 0);
            m_listener.Bind(new IPEndPoint(IPAddress.IPv6Any, 943));
            m_listener.Listen(10);
            m_listener.BeginAccept(new AsyncCallback(OnConnection), null);
        }

        /// <summary>
        /// 关闭
        /// </summary>
        public void Close()
        {
            m_listener.Close();
        }

        /// <summary>
        /// 连接
        /// </summary>
        /// <param name="ar">异步结果</param>
        private void OnConnection(IAsyncResult ar)
        {
            Socket client = null;

            try
            {
                client = m_listener.EndAccept(ar);
            }
            catch (SocketException)
            {
                return;
            }

            // 建立策略连接
            PolicyConnection pc = new PolicyConnection(client, m_policy);

            m_listener.BeginAccept(new AsyncCallback(OnConnection), null);
        }
    }
}