博客园_TianFang

用C#实现MSN客户端（五）

2012-05-06T07:32:00Z

在前文中介绍过，MSN协议中服务器分为NS（NotificationServer）和SB（Switchboard）等几种，其中NS主要用来传输控制命令，而SB则用来传输会话，每个会话对应着一个SB。在一个MSN客户端中，是连接着一个NS和多个SB的。

创建会话

这里以两个客户端ClientA和ClientB和交谈为例，假定ClientA创建一个会话，并邀请ClientB参加会话，则它们之间的交互过程如下：

1. ClientA发送XFR命令创建SessionBoard，服务器返回SessionBoard地址

>>> XFR 15 SB\r\n
<<< XFR 15 SB 207.46.108.37:1863 CKI 17262740.1050826919.32308\r\n

服务器的XFR应答消息中包含三个参数，第一个参数为SB服务器的地址，第二个参数为认证类型，固定为CKI，第三个参数为后面服务器的认证Key值，后面会用到。

2. ClientA连接SessionBoard，并发送USR命令进行身份认证。

    <o> Client Connects to 207.46.108.37 1863 (Switchboard)
    >>> USR 1 example@passport.com17262740.1050826919.32308\r\n
    <<< USR 1 OK example@passport.com Example%20Name\r\n
    <o> Continue SB Session . . .

USR认证时携带两个参数，第一个参数是当前用户，第二个参数即是前面的XFR应答消息中携带的Key值。

3. ClientA发送CAL命令邀请ClientB

>>> CAL 2 name_123@hotmail.com\r\n
<<< CAL 2 RINGING 11752013\r\n

PS：服务器的CAL应答是等成功邀请上ClientB后才回应的，如上图所示。但ClientA感知不到这个过程，故这里就放在一块儿了。

4. NS发送RNG命令通知ClientB参加会话，ClientB根据RNG命令中SessionBoard地址，并发送ANS命令进行身份认证。

    <<< RNG 11752013207.46.108.38:1863 CKI 849102291.520491113 example@passport.com Example%20Name\r\n
    <o> Client Connects to 207.46.108.38 1863 (Switchboard)
    >>> ANS 1 name_123@hotmail.com 849102291.520491113 11752013\r\n
    <<< IRO 1 1 2 example@passport.com Mike\r\n
    <<< IRO 1 2 2 myname@msn.com My%20Name\r\n
    <<< ANS 1 OK\r\n
    <o> Continue SB Session . . .

RNG命令有5个参数，前三个参数和XFR应答的三个参数意义一样，后面两个参数就是邀请方的账户和昵称。
ClientB发送的ANSr认证有三个参数，前两个和发起方的USR认证一样，分别是账户和认证Key值，第三个参数则是RNG通知消息的TrID。
发送认证信息后，会收到SB服务器的IRO通知消息，标明当前会话中的当前用户。

从这个协议中不难看出，MSN协议设计时就考虑了多方通信的支持的，只要重复3,4步即可，要实现多方通信主要这里就不累述了。

从常见会话过程中可以看出，建立一个会话时，客户端分为主动连接和被动连接两种，主动连接方主要完成1、2、3这三步，而被动连接方主要完成第4步。

退出会话

退出会话交互过程如下：

1. 主动退出方对SB发送OUT命令，SB则自动中断连接。

>>> OUT\r\n
<o> Switchboard Closes Connection

2. SB对会话中的其它成员发送BYE命令，通知其它成员会话有成员退出，如果只剩下一个成员，则和该成员的连接也会被中断。

<<< BYE example@passport.com 1\r\n
<o> Switchboard Closes Connection

另外，如果只有两个成员，且他们之间5分钟都没有活动，则服务器会对两个成员都发送BYE命令，此时的交互方式如下。

这时会话双方都是被动退出，交互过程和前面一样，就不累述了。

从前面的交互过程中可以看出，退出时也分为主动方和被动方：主动方需要发送OUT命令，被动方则需要响应BYE通知，还是比较简单的。

开始会话

MSN的对话都是在SB上进行的，并且对话信息都是通过MSG类型的消息发送的，它和我们打电话的过程非常类似。一个简单的对话过程如下：

ClientA把消息发给SB
>>> MSG 4 N 133\r\n
MIME-Version: 1.0\r\n
Content-Type: text/plain; charset=UTF-8\r\n
X-MMS-IM-Format: FN=Arial; EF=I; CO=0; CS=0; PF=22\r\n
\r\n
Hello! How are you?
<<< ACK 4
SB服务器把消息转发给ClientB（如果是多方通话，则转发给其它的每个成员）
<<< MSG example@passport.com Mike 133\r\n
MIME-Version: 1.0\r\n
Content-Type: text/plain; charset=UTF-8\r\n
X-MMS-IM-Format: FN=Arial; EF=I; CO=0; CS=0; PF=22\r\n
\r\n
Hello! How are you?
ClientB把回复消息发给SB
SB把ClientB的回复消息转发给ClientA（如果是多方通话，则转发给其它的每个成员）

从上可以看出，步骤3,4和步骤1,2是完全一样的，也就是说，MSN对话是不区分发送方和接收方的，所有交互都是通过SB转发，发送的消息都是单向的，接收消息都是靠通知而不是应答。这就意味着：发送方只能知道消息是否发送成功，并不能保证一定会应答，接收方收到消息通知时，并不要求要回应答。这一点和我们实际的交谈过程也是一样的。

除了类型为"text/plain"的对话内容通知消息外，另外一个比较常用的通知为那种常见的"xxx 正在输入…"的通知，这个消息的格式为：

    MIME-Version: 1.0\r\n
    Content-Type: text/x-msmsgscontrol\r\n
    TypingUser: example@passport.com\r\n
    \r\n
    \r\n

如果要实现一个较为友好的客户端，需要响应和发送此消息。

由于我最初只打算实现个MSN机器人，除了这两个消息外，其它的消息（如闪屏震动，文件发送等）我都没有实现，它们的处理方式也没有太大难度，如果感兴趣可以参考我前面的参考文献地址自行实现一下，就不要在留言中问我如何实现了。

代码实现：

  1     class Conversation
  2     {
  3         public IObservable<MsnMessage> MessageNotify { get; private set; }
  4         public IObservable<string> StateNotify { get; private set; }
  5         public IObservable<string> LogoutNotify { get; private set; }
  6
  7         MsnServer sb;
  8         private Conversation(MsnServer sb)
  9         {
10             this.sb = sb;
11
12             MessageNotify = from msg in sb.NotifyMsgs
13                             where msg.Headers.ContainsKey("Content-Type") && msg.Headers["Content-Type"].StartsWith("text/plain")
14                             select msg;
15
16             StateNotify = from msg in sb.NotifyMsgs
17                           where msg.Headers.ContainsKey("Content-Type") && msg.Headers["Content-Type"].StartsWith("text/x-msmsgscontrol")
18                           select msg.Paras[0];
19
20             LogoutNotify = from notify in sb.NotifyCmds
21                            where notify.CmdType == "BYE"
22                            select notify.Paras[0];
23
24             MessageNotify.Subscribe(async (msg) =>
25                 {
26                     Debug.WriteLine(ConsoleColor.White, "### Recv: " + msg.Content);
27                     await Send(new string(msg.Content.Reverse().ToArray()), msg.Headers);
28                 });
29
30             StateNotify.Subscribe(account =>
31                 {
32                     Debug.WriteLine(ConsoleColor.White, string.Format("#-# {0} is typing ", account));
33                 });
34
35             //Test();
36         }
37
38         //async void Test()
39         //{
40         //    await Invite("tianfangxyz@msn.com");
41         //    await SendMessage("Hello! How are you?");
42         //}
43
44         public async Task<MsnCommand> Invite(string user)
45         {
46             return await sb.SendAsync("CAL", user);
47         }
48
49
50         public Task<MsnCommand> SendMessage(string content, string font = "Arial", int size = 22)
51         {
52             Contract.Requires(!string.IsNullOrEmpty(content));
53
54             var headers = new Dictionary<string, string>();
55             headers["MIME-Version"] = "1.0";
56             headers["Content-Type"] = "text/plain; charset=UTF-8";
57             headers["X-MMS-IM-Format"] = string.Format("FN={0}; EF=I; CO=0; CS=0; PF={1}", font, size);
58
59             return Send(content, headers);
60         }
61
62         public async Task<MsnCommand> Send(string content, Dictionary<string,string> headers)
63         {
64             Contract.Requires(headers != null);
65
66             var msg = new MsnMessage(MsnServer.NewTransactionId(), headers, content);
67             return await sb.SendAsync(msg);
68         }
69
70         public static async Task<Conversation> CreateAsync(MsnServer ns,string me)
71         {
72             Contract.Requires((ns != null) && (!string.IsNullOrWhiteSpace(me)));
73
74             var reply = await ns.SendAsync("XFR", "SB");
75             var hostAndPort = reply.Paras[1];
76             var key = reply.Paras[3];
77
78             var sb = await MsnServer.CreateAsync(hostAndPort);
79             await sb.SendAsync("USR", me, key);
80
81             return new Conversation(sb);
82         }
83
84         public static IObservable<Conversation> GetInvitations(MsnServer ns, string me)
85         {
86             var conversations = from cmd in ns.NotifyCmds
87                                 where cmd.CmdType == "RNG"
88                                 from conversation in Observable.FromAsync(() => Conversation.CreateAsync(cmd, me))
89                                 select conversation;
90             conversations.Subscribe();
91             return conversations;
92         }
93
94         static async Task<Conversation> CreateAsync(MsnCommand rng, string me)
95         {
96             var hostAndPort = rng.Paras[0];
97             var id = (int)rng.TransactionId;
98             var key = rng.Paras[2];
99
100             Debug.WriteLine(ConsoleColor.White, "ProcessInvitation: " + hostAndPort);
101             var sb = await MsnServer.CreateAsync(hostAndPort);
102             await sb.SendAsync("ANS", me, key, id);
103             return new Conversation(sb);
104         }
105     }

到此我的MSN系列文章基本完结了，由于时间和精力有限，并不打算继续深入研究和完善。相关代码我基本都在文中已经贴出来了，总共也就3百行左右，非常简单。我实现代码只是为了练习Async编程，因此只实现了一个雏形，并不完善，如果在项目中需要实现MSN协议建议使用MSNSharp等开源库，我并不打算放出完整的工程下载，文章写完后相关代码即刻删除，本地也不会保留，请勿留言索取。

如果文中关于MSN协议的说明有误，欢迎留言指正。但如果是使用本文代码中遇到了问题，请不要留言求助，我没有足够的精力来一一指正，望见谅。

本文链接

用C#实现MSN客户端（四）

2012-05-06T01:35:00Z

前面的文章里已经介绍了如何实现用户登录，本文中主要解决目前遗留下的一个问题：看到远端好友状态和让远端好友看到你的状态。

一、联系人同步

要看到远端好友的状态，首先需要进行的一步就是联系人同步。联系人同步主要是通过SYN命令来进行的，SYN命令格式如下：

>>> SYN 1 0\r\n
<<< SYN 1 2 1\r\n

SYN命令只有一个参数，就是当前的同步序号，如果传0即可实现全同步，传大于0的数字时可以实现增量同步，当前同步到的最新序号可以从应答中获取。

服务器收到SYN命令后，然后就会把当前联系人的设置通过通知的方式一一发送过来，一个示例如下：

    >>> SYN 1 0\r\n
    <<< SYN 1 139 5 4\r\n

    <<< GTC A\r\n
    <<< BLP AL\r\n

    <<< PRP PHH 01%20234\r\n
    <<< PRP PHM 56%20789\r\n

    <<< LSG 0 Other%20Contacts 0\r\n
    <<< LSG 1 Coworkers 0\r\n
    <<< LSG 2 Friends 0\r\n
    <<< LSG 3 Family 0\r\n

    <<< LST principal1@passport.com principal1 4\r\n
    <<< LST principal2@passport.com principal2 10\r\n
    <<< LST principal3@passport.com principal3 11 1,3\r\n
    <<< LST principal4@passport.com principal4 11 0\r\n
    <<< BPR PHH 01%20234\r\n
    <<< BPR MOB Y\r\n
    <<< LST principal5@passport.com principal5 12\r\n
    <<< LST principal6@passport.com principal6 11 2\r\n
    <<< BPR PHW 45%206789\r\n

由此可见，这里的通知还是比较多的，有GTC、BLP、LSG、LST等，这里就不一一介绍了，要详细了解的话可以看一下这个网页：http://www.hypothetic.org/docs/msn/index.php

由于通知消息是异步发送的，这里就存在一个不知道什么时候结束的问题。我这里的做法是：在发送SYN命令后，紧跟着发送一个Ping命令PNG，这样，可以简单的认为收到QNG时同步已经完成，此时交互如下：

    >>> SYN 1 0\r\n
    <<< SYN 1 139 5 4\r\n
    >>> PNG/r/n

    <<< GTC A\r\n
    <<< BLP AL\r\n

    <<< PRP PHH 01%20234\r\n
    <<< PRP PHM 56%20789\r\n

    <<< LSG 0 Other%20Contacts 0\r\n
    <<< LSG 1 Coworkers 0\r\n
    <<< LSG 2 Friends 0\r\n
    <<< LSG 3 Family 0\r\n

    <<< LST principal1@passport.com principal1 4\r\n
    <<< LST principal2@passport.com principal2 10\r\n
    <<< LST principal3@passport.com principal3 11 1,3\r\n
    <<< LST principal4@passport.com principal4 11 0\r\n
    <<< BPR PHH 01%20234\r\n
    <<< BPR MOB Y\r\n
    <<< LST principal5@passport.com principal5 12\r\n
    <<< LST principal6@passport.com principal6 11 2\r\n
    <<< BPR PHW 45%206789\r\n
    <<< QNG/r/n

不过MSN协议并没有规定QNG一定会在SYN通知完成后才通知，这种做法并不一定可靠，一般情况下貌似也没有什么大问题。

前面已经介绍过，SYNC的应答通知有许多种类型，要完全实现还是比较麻烦的。另外，要实现完善的话，只靠这个通知有时还不够，往往还需要根据用户人的账户名称获取详细信息。由于时间有限，我只弄了一个同步所有人的简单实现。也没有对同步结果进行任何处理。请看本文的朋友不要进一步询问相关问题，大可自己参考前面提到的那个网页自行实现。

1     class Sync
2     {
3         public static async Task SyncAll(MsnServer server)    //TODO 增量同步
4         {
5             var accounts = server.ReceiveUntilPingBack();
6             accounts.Subscribe(i => Debug.Write(ConsoleColor.Gray, ">>> " + i));
7
8             await server.SendAsync("SYN", 0);
9             await server.SendPingAsync();
10
11             await accounts;
12         }
13

二．接收好友状态变化

同步完联系人后，所有的联系人默认都是离线状态。对于那些非离线状态的联系人，服务器会通过NLN，ILN，FLN命令来通知联系人状态的变化。一个状态通知的示例如下：

<<< ILN AWYexample@passport.comexample%20display%20name268435492

它有四个参数，其中第一个参数表示当前的状态，目前MSN支持如下几种状态：

NLN - 有空(Available)
BSY - 忙碌(Busy)
IDL - 发呆(Idle)
BRB – 马上回来(Be Right Back)
AWY – 离开(Away)
PHN – 电话中(On the Phone)
LUN – 外出就餐(Out to Lunch)
HDN – 隐身(Hidden)

第二个参数是用户账号，第三个参数是昵称（不完整），第四个参数是ClientID。其内容具体参看http://www.hypothetic.org/docs/msn/notification/presence.php的Client Identification numbers一节，这里就不详细介绍了。

除了ILN外，

三. 设置我的状态

设置自己的状态主要通过CHG命令设置，示例如下：

>>> CHG 12 NLN 0\r\n
<<< CHG 12 NLN 0\r\n

CHG命令有两个参数，第一个参数是状态，第二个是ClientID。设置成功后，服务器会回一个CHG应答。如果过于频繁设置状态，则会收到 800错误。

代码附上：

1     enum State
2     {
3         AWY,    //离开
4         NLN,    //可用
5         BSY,    //忙碌
6         IDL,    //发呆
7         BRB,    //马上回来
8         PHN,    //打电话
9         LUN,    //外出就餐
10         HDN,    //隐身
11     }
12
13     class StateMgr
14     {
15         public State State { get; private set; }
16
17         MsnServer server;
18         public StateMgr(MsnServer server, State state = State.NLN)
19         {
20             this.server = server;
21             ProcessStateChgNotify();
22
23             SetState(state);
24         }
25
26         public async void SetState(State value)
27         {
28             if (this.State == value)
29                 return;
30
31             this.State = value;
32             await server.SendAsync("CHG", State ,6);
33         }
34
35         void ProcessStateChgNotify()
36         {
37             var notify = server.NotifyCmds;
38
39             notify.Where(i => (i.CmdType == "FLN") || (i.CmdType == "NLN")).Subscribe(i =>
40                 {
41                     var account = i.Paras[0];
42                     Debug.WriteLine(ConsoleColor.Cyan, ">>> " + account + "离线了");
43                 });
44             notify.Where(i => i.CmdType == "ILN").Subscribe(i =>
45                 {
46                     var state = i.Paras[0];
47                     var account = i.Paras[1];
48                     var name = i.Paras[2];
49                     Debug.WriteLine(ConsoleColor.Cyan, ">>> " + account + "状态变为" + state);
50                 });
51         }
52     }

本文链接

用C#实现MSN客户端（三）

2012-04-25T13:59:00Z

一、MSN中的Ping

在基于TCP的协议中，一般都会都会设计Ping命令来检测并踢掉僵死的连接，从而节省服务器资源。在成功登陆到服务器后，一般立即会收到到服务器发送的Ping命令CHL，如过不进行正确的应答的话，则会被服务器踢掉。为了后面的功能能正常运行，首先我们必须学习一下MSN的Ping命令。

MSN协议中的Ping命令有两种：服务器端发送的和客户端发送的。客户端发送的Ping命令非常简单：客户端发送PNG命令，服务器应答QNG，都不携带任何参数。
>>> PNG/r/n
<<< QNG/r/n

除了客户端Ping服务器外，服务器也会不定时（一般登录后就会收到一次）对客户端发送Ping命令CHL。CHL命令之间没有固定周期，它包含两个参数：第一个总会是0，第二个被称作"Challenge String"，客户端会根据它来生成应答。CHL命令格式如下：
<<< CHL 0 15570131571988941333/r/n

接收Challenge命令后，必须在50秒内发送应答命令QRY到服务器，否则将被断开。应答命令QRY格式如下：

    <<< CHL 0 15570131571988941333/r/n
    >>> QRY 1049 msmsgs@msnmsgr.com 32/r/n
        8f2f5a91b72102cd28355e9fc9000d6e (no newline)

QRY命令主要有三个参数，第一个参数是客户端ID，第二个参数是32，第三个参数是客户端应答字符串。其实前面介绍过：QRY是一个有效载荷命令，它的第二个参数是后面的内容（应答字符串），因为应答字符串长度是32，因此第二个参数也就固定为32。因此需要我们填充的是第一个参数客户端ID和第三个参数应答字符串。下面就介绍一下这两个参数的生成方式。

首先看一张表:

客户端ID	客户端标识码
msmsgs@msnmsgr.com	Q1P7W2E4J9R8U3S5
PROD0038W!61ZTF9	VT6PX?UQTM4WM%YR
PROD0058#7IL2{QD	QHDCY@7R1TB6W?5B
PROD0061VRRZH@4F	JXQ6J@TUOGYV@N0M

其中客户端ID可以取上表中的一个（貌似也不是任取一个就可以的），而应答字符串则是CHL命令的Challenge String参数和客户端标识码的MD5值（这个也是为什么长度总是32的原因）。

例如，对于前面的CHL命令，我们取客户端字符串为msmsgs@msnmsgr.com，对应的客户端标识码为Q1P7W2E4J9R8U3S5，则对应的应答码的为：MD5(15570131571988941333 + Q1P7W2E4J9R8U3S5) = 8f2f5a91b72102cd28355e9fc9000d6e

有了上面的基础后，用C#实现一个客户端的主动Ping命令和对服务器的ping命令自动应答就十分简单了，代码如下：

1     static class Ping
2     {
3         public static async Task SendPingAsync(this MsnServer server)
4         {
5             await server.SendAsync(new MsnCommand("PNG",null));
6         }
7
8         public static IObservable<MsnCommand> ReceiveUntilPingBack(this MsnServer server)
9         {
10             return server.NotifyCmds.TakeWhile(i => i.CmdType != "QNG");
11         }
12
13         /// <summary>
14         /// 应答服务器的ping命令
15         /// </summary>
16         public static void RegistPingReply(this MsnServer server)
17         {
18             var clientId = "PROD0061VRRZH@4F";
19             var clientCode = "JXQ6J@TUOGYV@N0M";
20             var md5 = new System.Security.Cryptography.MD5CryptoServiceProvider();
21
22             server.NotifyCmds.Where(i => i.CmdType == "CHL")
23                 .Subscribe(async (cmd) =>
24                 {
25                     var data = md5.ComputeHash(UnicodeEncoding.UTF8.GetBytes(cmd.Paras[0] + clientCode));
26                     var replyKey = string.Join("", data.Select(i => i.ToString("x2")));
27                     var replyCmd = new MsnCommand("QRY", 0, clientId, "32") { Content = replyKey };
28                     await server.SendAsync(replyCmd);
29                 });
30         }
31     }

二、退出登录

介绍完Ping后，顺带介绍一下上章中忘记介绍的退出登录。

退出登录最简单的方法就是正常关闭socket连接，这种方式也是非常简单有效的。但还有一种方式是对服务器发送OUT指令，服务器受到OUT指令后会主动关闭socket连接。
<<< OUT/r/n
<o> Server closes connection

除了上面介绍的客户端主动退出登录外，服务器有时也会发送OUT指令强制客户端退出登录。主要有如下两种情况：

1. 当服务器要进行维护时，将会发送OUT SSD — server shutting down，发送后就立即关闭连接。
<<< OUT SSD/r/n
<o> Server closes connection

2.当有人在别处用你的账号登录时，原来的连接将被关闭，新连接将被建立。关闭连接前，NS将给客户端发送OUT命令并携带参数OTH

<<< OUT OTH/r/n
<o> Server closes connection

最后附带一下代码的实现。

1     static class Logout
2     {
3         public static async void LogoutAsync(MsnServer server)
4         {
5             await server.SendAsync(new MsnCommand("OUT", null));
6         }
7
8         public static IObservable<string> GetLogoutNotify(MsnServer server)
9         {
10             //CmdType有SSD和OTH两种
11             return server.NotifyCmds.FirstAsync(i => i.CmdType == "OUT")
12                 .Select(i => i.CmdType == "OTH"? "用户在其他地方登陆":  "服务器故障");
13         }
14     }

PS：本来打算在这篇文章中介绍一下如何实现设置和获取联系人的在线状态的，但由于如果不能正确实现对服务器的Ping应答的话，一般刚登上去就会被踢掉的，故先介绍一下。设置和获取联系人的功能待下篇文章中再介绍。

本文链接

用C#实现MSN客户端（二）

2012-04-22T02:09:00Z

上一篇文章里对MSN协议进行了简单的介绍，并实现了消息的解析，今天这里将简单地介绍一下如何实现MSN客户端登陆。

MSN会话的服务器一般称为通知服务器(Notification Server, NS)，但由于MSN用户比较多，因此采用的是分布式结构，通知服务器并不唯一。我们首先需要连接需要连接分派服务器（Dispatch Server, DS），获取通知服务器地址。大致步骤如下：

1. 连接到messenger.hotmail.com:1863(Dispatch Server)，发送VER指令说明版本信息
    <o> Connect: messenger.hotmail.com 1863
    >>> VER 0 MSNP8 CVR0/r/n
    <<< VER 0 MSNP8 CVR0/r/n

2. 发送CVR指令说明当前使用的环境
>>> CVR 2 0x0409 win 4.10 i386 MSNMSGR 5.0.0544 MSMSGS example@passport.com/r/n
<<< CVR 2 6.0.0602 6.0.0602 1.0.0000http://download.microsoft.com/download/8/a/4/8a42bcae-f533-4468-b871-d2bc8dd32e9e/SETUP9x.EXE http://messenger.msn.com/r/n

3. 发送USR命令进行初始认证，获取通知服务器地址发送USR说明身份
    >>> USR 2 TWN I example@passport.com/r/n
    <<< XFR 2 NS 207.46.106.145:1863 0 207.46.104.20:1863/r/n
    <o> Server Closes Connection
    注意，USR命令的第二个参数为I，表示此时为初次认证（Initiating）。此时应答命令的类型是XFR，其中第二个参数（高亮部分）表示的是通知服务器地址。

获取到通知服务器地址后，分派服务器将会自动关闭，客户端开始连接通知服务器。

4. 重复上面的认证过程（注意把高亮的example@passport.com替换成自己的用户名）
    <o> client connects to 207.46.106.35, port 1863
    >>> VER 1 MSNP8 CVR0/r/n
    <<< VER 1 MSNP8 CVR0/r/n
    >>> CVR 2 0x0409 win 4.10 i386 MSNMSGR 5.0.0544 MSMSGS example@passport.com/r/n
    <<< CVR 2 6.0.0602 6.0.0602 1.0.0000http://download.microsoft.com/download/8/a/4/8a42bcae-f533-4468-b871-d2bc8dd32e9e/SETUP9x.EXE http://messenger.msn.com. /r/n
    >>> USR 3 TWN I example@passport.com/r/n
    <<< USR 3 TWN S lc=1033,id=507,tw=40,fs=1,ru=http%3A%2F%2Fmessenger%2Emsn%2Ecom,ct=1062764229,kpp=1,kv=5,ver=2.1.0173.1,tpf=43f8a4c8ed940c04e3740be46c4d1619/r/n
    此时USR的应答命令也是USR了（注意，它可能还是XFR，此时需要再次连接下一个NS了），它的第三个参数lc=1033…就是当前用户的一个标识，一般称作Challenge String，用于后面的SSL 身份验证。

5. 连接https://nexus.passport.com/rdr/pprdr.asp，获取认证服务器
    <o> Client connects to nexus.passport.com, port 443 (Passport Nexus)
    >>> GET /rdr/pprdr.asp HTTP/1.0/r/n
        /r/n
    <<< HTTP/1.1 200 OK/r/n
    <<< Server: Microsoft-IIS/5.0/r/n
    <<< Date: Mon, 02 Jun 2003 11:57:47 GMT/r/n
    <<< Connection: close/r/n
    <<< PassportURLs: DARealm=Passport.Net,DALogin=login.passport.com/login2.srf,DAReg=http://register.passport.net/uixpwiz.srf,Properties=https://register.passport.net/editprof.srf,Privacy=http://www.passport.com/consumer/privacypolicy.asp,GeneralRedir=http://nexusrdr.passport.com/redir.asp,Help=http://memberservices.passport.net/memberservice.srf,ConfigVersion=11/r/n
    <<< Content-Length: 0/r/n
    <<< Content-Type: text/html/r/n
    <<< Cache-control: private/r/n
    <<< /r/n
    <o> nexus.passport.com closes connection

其中应答信息的DALogin=后面的部分就是认证服务器。

6. 连接认证服务器，发送认证信息，获取令牌
    <o> Client connects to login.passport.com, port 443
    >>> GET /login2.srf HTTP/1.1/r/n
    >>> Authorization: Passport1.4 OrgVerb=GET,OrgURL=http%3A%2F%2Fmessenger%2Emsn%2Ecom,sign-in=example%40passport.com,pwd=password,lc=1033,id=507,tw=40,fs=1,ru=http%3A%2F%2Fmessenger%2Emsn%2Ecom,ct=1062764229,kpp=1,kv=5,ver=2.1.0173.1,tpf=43f8a4c8ed940c04e3740be46c4d1619/r/n
    >>> Host: login.passport.com/r/n

注意认证信息中高亮三个部分，前两个分别是用户名和密码，均采用URL编码，第三个是前面获取到的Challenge String

这个http请求一般会有三种结果，一个是302应答，重定向新的认证服务器。
    <<< HTTP/1.1 302 Found/r/n
    <<< Server: Microsoft-IIS/5.0/r/n
    <<< Date: Mon, 02 Jun 2003 11:58:32 GMT/r/n
    <<< PPServer: H: LAWPPLOG5C006/r/n
    <<< Connection: close/r/n
    <<< Content-Type: text/html/r/n
    <<< Expires: Mon, 02 Jun 2003 11:57:32 GMT/r/n
    <<< Cache-Control: no-cache/r/n
    <<< cachecontrol: no-store/r/n
    <<< Pragma: no-cache/r/n
    <<< P3P: CP="DSP CUR OTPi IND OTRi ONL FIN"/r/n
    <<< Authentication-Info: Passport1.4 da-status=redir/r/n
    <<< Location: https://loginnet.passport.com/login2.srf?lc=1033/r/n
    <<< /r/n

此时就要连接到新的认证服务器，重复上面的过程。

另一种是401应答，认证失败。
    <<< HTTP/1.1 401 Unauthorized/r/n
    <<< Server: Microsoft-IIS/5.0/r/n
    <<< Date: Mon, 02 Jun 2003 11:58:15 GMT/r/n
    <<< PPServer: H: LAWPPIIS6B077/r/n
    <<< Connection: close/r/n
    <<< Content-Type: text/html/r/n
    <<< Expires: Mon, 15 Sep 2003 07:57:14 GMT/r/n
    <<< Cache-Control: no-cache/r/n
    <<< cachecontrol: no-store/r/n
    <<< Pragma: no-cache/r/n
    <<< P3P: CP="DSP CUR OTPi IND OTRi ONL FIN"/r/n
    <<< PassportConfig: ConfigVersion=11/r/n
    <<< WWW-Authenticate: Passport1.4 da-status=failed,srealm=Passport.NET,ts=-3,prompt,cburl=http://www.passportimages.com/XPPassportLogo.gif,cbtxt=Type%20your%20e-mail%20address%20and%20password%20correctly.%20If%20you%20haven%E2%80%99t%20registered%20with%20.NET%20Passport%2C%20click%20the%20Get%20a%20.NET%20Passport%20link./r/n
    <<< Content-Length: 390/r/n/r/n

此时就没有继续进行下去的必要了，直接抛异常退出。

最后一种是我们所期望的200应答，认证成功。
    <<< HTTP/1.1 200 OK/r/n
    <<< Server: Microsoft-IIS/5.0/r/n
    <<< Date: Mon, 02 Jun 2003 11:59:00 GMT/r/n
    <<< PPServer: H: LAWPPIIS6B061/r/n
    <<< Connection: close/r/n
    <<< Content-Type: text/html/r/n
    <<< Expires: Mon, 02 Jun 2003 11:58:00 GMT/r/n
    <<< Cache-Control: no-cache/r/n
    <<< cachecontrol: no-store/r/n
    <<< Pragma: no-cache/r/n
    <<< P3P: CP="DSP CUR OTPi IND OTRi ONL FIN"/r/n
    <<< Set-Cookie: MSPSec1= ; expires=Thu, 30-Oct-1980 16:00:00    GMT;domain=.passport.com;path=/;HTTPOnly= ;version=1/r/n
    <<< Set-Cookie: MSPSec=5Cdd1SshOELpwqafsSuYSiDEuEtP1PUaX99YOZcaoJP3vkIn7DXozt868I7eJNjcWG; HTTPOnly= ; domain=.passport.com;path=/;secure=/r/n
    <<< Set-Cookie: MSPAuth=5yDBU0BqvDa7UiY9W9nVEncRXCLD4gjLmtEr2XkunnafkOgdgG5x*CEpqe7MyZEOir*EiA1PbwLKzqCGO671TeTQ$$; HTTPOnly= ; domain=.passport.com;path=//r/n
    <<< Set-Cookie: MSPProf=5a0mKE6PKDsxz!*4apQt0amnQOGLYqcCm78ie!MmHq0KnAiIJM0z0Zajs8NL7ux7Ae0hnH5AAoB!zXIZ9jTA2rcQttC*RKKRsc9k7JflwThB!H0Qa*6ipGcdj5co6taPir; HTTPOnly= ; domain=.passport.com;path=//r/n
    <<< Set-Cookie: MSPVis=507;domain=.passport.com;path=//r/n
    <<< Set-Cookie: MSPPre=esqkk@hotmail.com; HTTPOnly= ; domain=.passport.com;path=/;Expires=Wed, 30-Dec-2037 16:00:00 GMT/r/n
    <<< Set-Cookie: MSPShared= ; HTTPOnly= ; domain=.passport.com;path=/;Expires=Thu, 30-Oct-1980 16:00:00 GMT/r/n
    <<< Authentication-Info: Passport1.4 da-status=success,tname=MSPAuth,tname=MSPProf,tname=MSPSec,from-PP='t=53*1hAu8ADuD3TEwdXoOMi08sD*2!cMrntTwVMTjoB3p6stWTqzbkKZPVQzA5NOt19SLI60PY!b8K4YhC!Ooo5ug$$&p=5eKBBC!yBH6ex5mftp!a9DrSb0B3hU8aqAWpaPn07iCGBw5akemiWSd7t2ot!okPvIR!Wqk!MKvi1IMpxfhkao9wpxlMWYAZ!DqRfACmyQGG112Bp9xrk04!BVBUa9*H9mJLoWw39m63YQRE1yHnYNv08nyz43D3OnMcaCoeSaEHVM7LpR*LWDme29qq2X3j8N',ru=http://messenger.msn.com/r/n
    <<< Content-Length: 0/r/n
    <<< /r/n

其中from-PP=头里面包含的信息即是用户的令牌，一般称为Ticket。

7. 返回到前面的NS服务器，继续发送USR命令进行认证。
    <o> Client authenticates itself with MS Passport
    >>> USR 4 TWN St=53*1hAu8ADuD3TEwdXoOMi08sD*2!cMrntTwVMTjoB3p6stWTqzbkKZPVQzA5NOt19SLI60PY!b8K4YhC!Ooo5ug$$&p=5eKBBC!yBH6ex5mftp!a9DrSb0B3hU8aqAWpaPn07iCGBw5akemiWSd7t2ot!okPvIR!Wqk!MKvi1IMpxfhkao9wpxlMWYAZ!DqRfACmyQGG112Bp9xrk04!BVBUa9*H9mJLoWw39m63YQRE1yHnYNv08nyz43D3OnMcaCoeSaEHVM7LpR*LWDme29qq2X3j8N/r/n
    <<< USR 4 OK example@passport.com example%20display%20name 1 0/r/n

此时USR命令的第二个参数不再是I，而是S；第四个参数也不是用户名，而是前面获取的TICKET。而应答的第一个参数也不是前面的TWN，而是OK，后面两个参数则是当前用户名和昵称。

代码实现

代码实现如下：

1     class Login
2     {
3         public string UserName { get; private set; }
4         public string Password { get; private set; }
5
6         private Login(string userName, string password)
7         {
8             this.UserName = userName;
9             this.Password = password;
10         }
11
12         async Task<MsnServer> Process(string host = "messenger.hotmail.com", int port = 1863)
13         {
14             var session = await MsnServer.CreateAsync(host, port);
15
16             await session.SendAsync("VER", "MSNP8 CVR0");
17             await session.SendAsync("CVR", "0x0804 win 5.1.2600 i386 MSNMSGR 7.0.0813 MSMSGS", UserName);
18             var reply = await session.SendAsync("USR", "TWN I", UserName);
19
20             //加速方法：中间可能会经过XFR重定位一次，保存重定位后的地址，下次直接从它启动，失败后再从messenger.hotmail.com获取
21             Contract.Assume((reply.CmdType == "XFR") || (reply.CmdType == "USR"));
22             if (reply.CmdType == "XFR")
23             {
24                 var xfrEpData = reply.Paras[1].Split(':');
25                 return await Process(xfrEpData[0], int.Parse(xfrEpData[1]));
26             }
27
28             var result = await session.SendAsync("USR", "TWN S", await GetTicket(reply.Paras[2]));
29             Contract.Assume(result.Paras[0] == "OK");
30
31             return session;
32         }
33
34         public static Task<MsnServer> ConnectAsync(string userName, string password)
35         {
36             return new Login(userName, password).Process();
37         }
38
39         async Task<string> GetTicket(string challengeStr)
40         {
41             //加速方法：保存DALoginUrl，下次启动或使用时直接读取保存的数据，失败后再从nexus.passport.com中更新
42             var daLoginUrl = "https://" + await SendRequestAsync("https://nexus.passport.com/rdr/pprdr.asp", "DALogin=(.+?),");
43
44             var authInfo = string.Format("Passport1.4 OrgVerb=GET,OrgURL=http%3A%2F%2Fmessenger.msn.com,sign-in={0},pwd={1},{2}",
45                                         System.Web.HttpUtility.UrlEncode(UserName), System.Web.HttpUtility.UrlEncode(Password), challengeStr);
46
47             return await SendRequestAsync(daLoginUrl, "from-PP='(.+?)'", req => { req.Headers.Add("Authorization", authInfo); });
48         }
49
50         async Task<string> SendRequestAsync(string url, string matchResultExp = null, Action<HttpWebRequest> reqHanlder = null)
51         {
52             var req = WebRequest.Create(url) as HttpWebRequest;
53             if (reqHanlder != null)
54             {
55                 reqHanlder(req);
56             }
57
58             Debug.WriteLine(ConsoleColor.Gray, url + "\r\n" + req.Headers);
59
60             using (var rsp = await req.GetResponseAsync())
61             {
62                 var headers = rsp.Headers.ToString();
63                 Debug.WriteLine(ConsoleColor.Cyan, headers);
64
65                 if (matchResultExp == null)
66                     return headers;
67                 else
68                     return Regex.Match(headers, matchResultExp).Groups[1].Value;
69             }
70         }
71     }

基本上只用几十行就可以实现登陆的主体功能，实现起来所花的时间远比看协议要少得多。它使用起来也非常简单，只有一个人口函数Login.ConnectAsync()，这里就不举例了。

另外，从这个流程可以看出，MSN客户端在认证过程中，经历了多次重定向，这个也是其登陆较慢的原因之一，在代码的注释中我已经列举了两种减少重定向次数，加速登陆的方法，但没有实现，感兴趣的朋友可以试着实现一下。

到此时，我们已经可以实现MSN客户端登陆了，但把这段代码执行后就会发现：即使用户认证成功，远端好友仍然看不到该用户的上线。实际上，完成用户认证只是万里长征的第一步，下一篇文章中将介绍如何改变用户的状态。

本文链接

用C#实现MSN客户端（一）

2012-04-20T15:39:00Z

前言

清明的时候学习一下C# 5.0的新特性async，顺带用它实现了一个C#的MSN客户端，实现了简单的通话功能。

MSN协议还是比较复杂的，不是两三天能完整实现的。由于工作较忙，加上MSN也只是一个小众产品，开发动力不足。本文的主要目的是介绍MSN协议基础和练习async编程，暂时没有打算完善其功能。如果后续有时间的话可能会进一步完善。文中所涉及到的主要流程、思路及关键算法都会在代码中贴出来，我也只实现了简单的通话功能，但还有大部分异常处理工作要做，本身就不是很完善。由于工作较忙，如果是代码实现过程中遇到的问题一般是不会解答的，请见谅。

MSN Messenger 协议

MSN Messenger Network是微软提供的即时通讯会话网，成立于1999年。和它同期即时通讯软件有AOL Instant Messenger，ICQ及Yahoo Messenger等，是老牌IM软件了。虽然国内基本上是腾讯的天下，但MSN还是半死不活的占着一席之地的。和X讯不同的是，MSN的协议是公开的，也就是说，我们可以自己实现一个MSN客户端。MSN Messenger协议是学习网络编程的一个比较好的材料的。

MSN协议是在不断修改演进的，但基本上仍然是保持着向下兼容的，本文主要是参考http://www.hypothetic.org/docs/msn/index.php网站上列举的MSN8协议来的，虽然非常老了，但实现其基本功能还是没有问题的。

基础知识

所有的到MSN服务器连接都是建立在TCP/IP之上的。一般采用1863作为通信端口（其通信服务器可能会由分派服务器重定向，重定向后的端口不一定是1863）。

MSN协议大体上还是基于字符串的，其送和接收的编码为UTF-8编码。另外，由于字符串协议通常采用了空格等作为协议字段的分隔符，因此，使用了空格的昵称，显示名，组名，电话号码等一些地方需要采用URL编码方式转换依次（这些和具体的命令相关，是规定好了的）。

MSN消息格式

MSN之间的应答方式一般称为命令，一个基本的MSN应答消息格式如下：

>>> VER15MSNP8 FOO CVR0 BAR\r\n
<<< VER 15 MSNP8 CVR0\r\n

从上看出，一条MSN命令基本包括如下三个部分，

首三个字符标识命令类型。
随后的一个数字为事务ID，主要用来用于应答方式的交互，通过事务ID来匹配请求和响应命令。（对于那些不需要应答的命令，事务ID不是必须的）
再随后一直到行尾都是命令的参数，参数间通过空格来分割。
最后的\r\n就是命令行标识符了。但需要注意的是，对于四条特殊的命令QRY、PAG、NOT及MSG，它们是可以超过一行的，这些命令（QRY和MSG是这样的，其余的两个暂时还没有用到）的最后一个参数标明了剩余字符的字节数（不是字符长度）。

>>> QRY 1049 msmsgs@msnmsgr.com 32/r/n
8f2f5a91b72102cd28355e9fc9000d6e (no newline)

根据命令格式的语法，则可以大致定义出解析的算法：

首先读一行，解析出命令类型，事务ID，参数等信息
如果命令为MSG等超过一行的格式，根据参数中剩余消息长度来读取剩余消息。

命令次序

MSN命令基本上是一个异步响应的过程，它非常不好解析，主要原因如下：

通常情况下，应答命令会以它们被发送的次序发送。但并不总是这样，有时你可能以1，2，3的次序发送命令，而服务器以2，3，1的次序响应，此时就需要靠事务ID来匹配请求和应答了。
有些命令（如CHG等）会得到服务器的多个应答。这些应答中包含相同的事务ID和原始命令。

另外，它还和没有固定的顺序和时机的通知消息复用了同一个TCP流，解析起来还是十分令人头疼的。

惩罚策略

由于程序不可能一口气完美实现，有时我们可能无意间对MSN服务器进行一些不遵循协议要求的操作（当然，也不排除有人在好心测试MSN服务器的防攻击能力），如发送的不遵循协议格式的消息，对服务器的应答没有正确回复等。

对于这些非法操作，MSN服务器一般会断掉当前连接，有时还会在一定时间内不响应该地址的请求（一般十分钟左右就解封了）。另外，对于服务器的命令不合法回复（或不回复）时，服务器可能在一定时间内不会再次通知该事件，就算重新登录也一样（一般也是十分钟左右就解封了），在开发过程中尤其需要注意一下。

MSN Message对象的实现

首先附上MSN消息的C#实现：

  1     abstract class MsnPacket
  2     {
  3         public int? TransactionId { get; private set; }
  4         public string CmdType { get; private set; }
  5         public string[] Paras { get; private set; }
  6         public virtual bool WaitReply { get { return TransactionId != null; } }
  7         protected virtual string ExtraMessage { get { return null; } }
  8
  9         public MsnPacket(string cmdType, int? transId, string[] paras)
10         {
11             Contract.Requires((cmdType != null) && (paras != null));
12
13             this.CmdType = cmdType;
14             this.TransactionId = transId;
15             this.Paras = string.Join(" ", paras.Select(i => i.Trim())).Split(' ');        //防止有的参数中带空格
16         }
17
18         public override string ToString()
19         {
20             if (!string.IsNullOrEmpty(ExtraMessage))
21             {
22                 Contract.Assume((CmdType == "MSG") || (CmdType == "QRY") || (CmdType == "PAG") || (CmdType == "NOT"));
23
24                 var contentSize = Encoding.UTF8.GetByteCount(ExtraMessage);
25                 Paras[Paras.Length - 1] = contentSize.ToString();
26                 Contract.Assume(contentSize < 1664);        //TODO 如果消息长度超过1664，需要拆分发送，目前不支持这种超长消息的发送
27             }
28
29             return string.Format("{0} {1}{2}\r\n{3}",
30                                 CmdType,
31                                 TransactionId == null ? "" : TransactionId + " ",
32                                 string.Join(" ", Paras),
33                                 ExtraMessage);
34         }
35
36         static Regex regexp = new Regex(@"^(?<cmd>\w{3})(?<id> \d+){0,1}(?<para> .+){0,1}");
37         public static async Task<MsnPacket> ReadAsync(System.IO.StreamReader reader)
38         {
39             Contract.Requires(reader != null);
40
41             try
42             {
43                 var info = await reader.ReadLineAsync();
44                 CheckReadResult(info != null);
45
46                 var groups = regexp.Match(info).Groups;
47                 var cmdType = groups["cmd"].Value;
48                 var actionID = groups["id"].Success ? (int?)int.Parse(groups["id"].Value.Trim()) : null;
49                 var paras = groups["para"].Value.Trim().Split(' ');
50
51                 if (cmdType != MsnMessage.CommandType)                    //其它三种超过一行的命令QRY，PAG，NOT不是应答命令，这里碰不到
52                 {
53                     return new MsnCommand(cmdType, actionID, paras);
54                 }
55
56                 var contentSize = int.Parse(paras.Last());
57                 var extraMsg = await ReadBlockAsync(reader, contentSize);
58                 var headers = MsnMessage.ParseHeaders(extraMsg);
59                 var content = Regex.Match(extraMsg, @".*?\r\n\r\n(.*)", RegexOptions.Singleline).Groups[1].Value;
60
61                 return new MsnMessage(actionID, paras, headers, content);
62             }
63             catch (FormatException)
64             {
65                 return null;
66             }
67         }
68
69         static async Task<string> ReadBlockAsync(System.IO.StreamReader reader, int bytesCount)
70         {
71             Contract.Requires((reader != null) && (bytesCount > 0));
72
73             var currentCount = 0;
74             var content = new StringBuilder();
75             var chBuffer = new char[1];
76
77             while (currentCount < bytesCount)
78             {
79                 var writeCount = await reader.ReadBlockAsync(chBuffer, 0, 1);
80                 CheckReadResult(writeCount == 1);
81
82                 content.Append(chBuffer[0]);
83                 currentCount += reader.CurrentEncoding.GetByteCount(chBuffer);
84             }
85
86             Contract.Assume(currentCount == bytesCount);
87             return content.ToString();
88         }
89
90         static void CheckReadResult(bool isSuccess)
91         {
92             if (isSuccess) return;
93             throw new FormatException();
94         }
95     }
96
97
98     class MsnCommand : MsnPacket
99     {
100         public string Content { get; set; }
101
102         public MsnCommand(string cmdType, int? transId, params string[] paras)
103             : base(cmdType, transId, paras)
104         {
105         }
106
107         protected override string ExtraMessage { get { return Content; } }
108     }
109
110     class MsnMessage : MsnPacket
111     {
112         public Dictionary<string, string> Headers { get; private set; }
113         public string Content { get; set; }
114         public override bool WaitReply { get { return false; } }
115         public const string CommandType = "MSG";
116
117         public MsnMessage(int? transId, string[] paras,Dictionary<string, string> headers, string content)
118             : base(CommandType, transId, paras)
119         {
120             this.Headers = headers;
121             this.Content = content;
122         }
123
124         public MsnMessage(int transId, Dictionary<string, string> headers, string content)
125             : this(transId, new string[] { "N", "0" }, headers, content)
126         {
127             /* 本来有U(不确认)、A（都确认）、N（发送失败时确认）三种类型的。
128              * 这里为了简单，直接选择的是N，但不收应答消息(Message.WaitReply = false)，发送失败作为通知响应 */
129         }
130
131         protected override string ExtraMessage
132         {
133             get
134             {
135                 var headerMsg = string.Join("\r\n", Headers.Select(i => i.Key + ": " + i.Value));
136                 return headerMsg + "\r\n\r\n" + Content;
137             }
138         }
139
140         static internal Dictionary<string, string> ParseHeaders(string extraMsg)
141         {
142             var headers = new Dictionary<string, string>();
143             var match = Regex.Match(extraMsg, @"(.*?)\r\n\r\n", RegexOptions.Singleline);
144             var headerMsg = match.Groups[1].Value;
145             foreach (Match item in Regex.Matches(headerMsg, @"(.+?): (.+)"))
146             {
147                 var key = item.Groups[1].Value;
148                 var value = item.Groups[2].Value.Trim();
149                 headers[key] = value;
150             }
151             return headers;
152         }
153     }

代码非常简单，只有三个类；其中MsnPacket是虚基类，其它两个MsnCommand和MsnMessage是子类。本来三个类可以统一用一个MsnCommand来表示的，但由于MSG类型的消息相对较为复杂和常用，需要单独构造和解析其消息头。因此单独用一个MsnMessage类来表示。

当我们连上MSN服务器时，就可以通过MsnPacket.ReadAsync()函数来读取并解析出MSN消息对象了，具体方法参看下面的MsnServer的实现。

MSN Server对象的实现

在MSN消息里，发送命令和接收应答是一个同步模型，而服务器通知又是一个异步模型，本来很不好处理。但通过C#的TAP和RX两种异步解决方案还是可以很优雅的实现它的解析，方式如下：

发送命令行后，通过TaskCompletionSource对象异步等待服务器通知应答结果
异步接收消息，如果是发送命令的应答则通过等待的TaskCompletionSource对象返回结果，如果是服务器通知则通过Iobservable的数据源分发。

  1     class MsnServer : IDisposable
  2     {
  3         StreamWriter writer;
  4         Subject<MsnCommand> notifyCmds = new Subject<MsnCommand>();
  5         Subject<MsnMessage> notifyMsgs = new Subject<MsnMessage>();
  6
  7         public IObservable<MsnCommand> NotifyCmds { get { return notifyCmds; } }
  8         public IObservable<MsnMessage> NotifyMsgs { get { return notifyMsgs; } }
  9
10         public MsnServer(Stream stream)
11         {
12             this.writer = new StreamWriter(stream, Encoding.UTF8);
13             this.IsConnected = true;
14
15             RecevieAsync(new StreamReader(stream, Encoding.UTF8));
16         }
17
18         //TODO 这儿最好还需要加一个老化处理，删除长期没有应答的命令
19         Dictionary<int, TaskCompletionSource<MsnCommand>> replyList = new Dictionary<int, TaskCompletionSource<MsnCommand>>();
20         public async Task<MsnCommand> SendAsync(MsnPacket cmd)
21         {
22             Contract.Requires(cmd != null);
23
24             if (!cmd.WaitReply)            //不需要等待应答
25             {
26                 await SendAsync(cmd.ToString());
27                 return null;
28             }
29
30             var replySource = new TaskCompletionSource<MsnCommand>();
31             replyList[(int)cmd.TransactionId] = replySource;
32
33             await SendAsync(cmd.ToString());
34
35             if (await Task.WhenAny(replySource.Task, Task.Delay(15000)) != replySource.Task)
36             {
37                 var errMsg = "接收应答超时: " + cmd;
38                 Debug.WriteLine(ConsoleColor.Red, errMsg);
39                 this.Dispose();
40                 replySource.SetException(new TimeoutException(errMsg));
41                 throw new TimeoutException(errMsg);
42             }
43
44             return replySource.Task.Result;
45         }
46
47         async void RecevieAsync(StreamReader reader)
48         {
49             if (!IsConnected)
50                 return;
51
52             try
53             {
54                 var packet = await MsnPacket.ReadAsync(reader);
55                 if (packet == null)
56                 {
57                     Debug.WriteLine(ConsoleColor.Red, "连接中断");
58                     Dispose();
59                     return;
60                 }
61
62                 Debug.Write(ConsoleColor.Yellow, packet);
63
64                 var replySource = null as TaskCompletionSource<MsnCommand>;
65                 if ((packet.TransactionId != null) && (replyList.TryGetValue((int)packet.TransactionId, out replySource)))
66                 {
67                     replySource.SetResult(packet as MsnCommand);
68                     replyList.Remove((int)packet.TransactionId);
69                 }
70                 else
71                 {
72                     if (packet is MsnMessage)
73                         notifyMsgs.OnNext(packet as MsnMessage);
74                     else
75                         notifyCmds.OnNext(packet as MsnCommand);
76                 }
77             }
78             finally
79             {
80                 RecevieAsync(reader);
81             }
82         }
83
84         public Task<MsnCommand> SendAsync(string cmdType, params object[] paras)
85         {
86             var cmd = new MsnCommand(cmdType, NewTransactionId(), paras.Select(i => i.ToString()).ToArray());
87             return SendAsync(cmd);
88         }
89
90         async Task SendAsync(string info)
91         {
92             //await writer.WriteAsync(info);    //不知道为什么这么写发不出去
93             //await writer.FlushAsync();
94
95             var data = writer.Encoding.GetBytes(info);
96             await writer.BaseStream.WriteAsync(data, 0, data.Length);
97             await writer.BaseStream.FlushAsync();
98
99             Debug.Write(ConsoleColor.Gray, info);
100         }
101
102         public async Task SendPing() { await SendAsync("PNG\r\n"); }
103         public IObservable<MsnCommand> ReceiveUntilPingBack() { return notifyCmds.TakeWhile(i => i.CmdType != "QNG"); }
104
105         #region IDisposable 成员
106
107         public bool IsConnected { get; private set; }
108         public void Close() { Dispose(); }
109         public void Dispose()
110         {
111             if (!IsConnected)
112                 return;
113
114             IsConnected = false;
115             writer.Dispose();
116             notifyCmds.OnCompleted();
117             notifyMsgs.OnCompleted();
118         }
119
120         #endregion
121
122         public static Task<MsnServer> CreateAsync(string hostAndPort)
123         {
124             var epData = hostAndPort.Split(':');
125             return CreateAsync(epData[0], int.Parse(epData[1]));
126         }
127
128         public static async Task<MsnServer> CreateAsync(string host, int port)
129         {
130             var client = new System.Net.Sockets.TcpClient();
131             await client.ConnectAsync(host, port);
132
133             return new MsnServer(client.GetStream());
134         }
135
136         static int curTransId = 1;
137         public static int NewTransactionId() { return curTransId++; }
138
139     }

服务器端的实现也不复杂，只有一百行左右代码。它其实就是一个Socket的封装，可以通过构造函数或MsnServer.CreateAsync()异步创建。创建后，通过RecevieAsync()函数异步读取并解析Msn消息并分发。外部对象通过调用SendAsync()发送命令，并异步接收应答。

另外，我这里把MSG类型区分开了单独作为了一个数据源，主要是为了方便后面处理。其它的就不用多介绍了。

后记

由于时间有限，目前只介绍了关于MSN消息的格式及解析部分。下周估计会写篇文章介绍如何实现登陆，具体到收发消息的部分估计只能等到五一后了。主要参考资料可以见我以前的一篇文章--《MSN开发相关资料》。

本文链接

HTML5中的WebSocket

2012-04-02T07:15:00Z

背景

在传统方式下，很多网站为了实现即时通讯，所用的技术都是轮询。轮询是在特定的的时间间隔（如每1秒），由浏览器对伺服器发出HTTP request，然后由伺服器返回最新的数据给客户端的浏览器。这种传统的模式带来很明显的缺点，即浏览器需要不断的向伺服器发出请求，然而HTTP request 的header是非常长的，里面包含的数据可能只是一个很小的值，这样会占用很多的带宽和服务器资源。

而比较新的技术去做轮询的效果是Comet，使用了AJAX。但这种技术虽然可达到双向通信，但依然需要发出请求，而且在Comet中，普遍采用了长链接，这也会大量消耗服务器带宽和资源。

面对这种状况，HTML5定义了WebSocket协议，能更好的节省服务器资源和带宽并达到实时通讯。WebSocket 是HTML5一种新的协议。它是实现了浏览器与伺服器的双向通讯。

简单的讲，通过WebSocket，可以在浏览器和服务器间建立一个TCP长连接，服务器可以实现主动推送数据至客户端。目前为止，Chrome和Safari的最新版本浏览器已经支持WebSockets了（win8测试版中的IE10也是支持的）。

客户端

在支持WebSocket的浏览器中，可以直接在Javascript中通过WebSocket对象来实现通信。WebSocket对象主要通过onopen，onmessage，onclose即onerror四个事件实现对socket消息的异步响应。一个简单的示例如下：

var socket = new WebSocket("ws://localhost:8080/");
socket.onopen = function () {
alert("Socket has been opened!");
}
socket.onmessage = function (msg) {
alert(msg); //Awesome!
}

关于其详细信息可以查看W3网站上的WebSocket API

这里附一个网上找的简单的聊天页面的实现：

1 <html>
2 <head>
3     <title>WebSocket</title>
4     <style>
5         html, body {
6             font: normal 0.9em arial,helvetica;
7         }
8
9         #log {
10             width: 440px;
11             height: 200px;
12             border: 1px solid #7F9DB9;
13             overflow: auto;
14         }
15
16         #msg {
17             width: 330px;
18         }
19     </style>
20     <script>
21         var socket;
22
23         function init() {
24             var host = "ws://localhost:8080/";
25             try {
26                 socket = new WebSocket(host);
27                 socket.onopen = function (msg) {; };
28                 socket.onmessage = function (msg) { log(msg.data); };
29                 socket.onclose = function (msg) { log("connection closed."); };
30             }
31             catch (ex) { log(ex); }
32             $("msg").focus();
33         }
34
35         function send() {
36             var txt, msg;
37             txt = $("msg");
38             msg = txt.value;
39             if (!msg) { alert("Message can not be empty"); return; }
40             txt.value = "";
41             txt.focus();
42             try { socket.send(msg); } catch (ex) { log(ex); }
43         }
44
45         window.onbeforeunload = function () {
46             try {
47                 socket.send('quit');
48                 socket.close();
49                 socket = null;
50             }
51             catch (ex) {
52                 log(ex);
53             }
54         };
55
56
57         function $(id) { return document.getElementById(id); }
58         function log(msg) { $("log").innerHTML += "<br>" + msg; }
59         function onkey(event) { if (event.keyCode == 13) { send(); } }
60 </script>
61 </head>
62 <body onload="init()">
63     <h3>WebSocket</h3>
64     <br>
65     <br>
66     <div id="log"></div>
67     <input id="msg" type="textbox" onkeypress="onkey(event)" />
68     <button onclick="send()">Send</button>
69 </body>
70 </html>

服务器端

在.Net 4.5中，在System.Web.WebSockets和System.Net.WebSocket名字空间实现了对WebSocket的支持，其中前者主要用于Asp.net框架。如下是一个简单的EchoServer的实现。

    classWebSocketServer
    {
        public WebSocketServer()
        {
            Start();
        }

        asyncvoid Start()
        {
            var listener = new HttpListener();
            listener.Prefixes.Add("http://localhost:8080/");
            listener.Start();

            while (true)
            {
                var context = await listener.GetContextAsync();
                Console.WriteLine("connected");

                var websocketContext = await context.AcceptWebSocketAsync(null);
                ProcessClient(websocketContext.WebSocket);
            }
        }

        asyncvoid ProcessClient(WebSocket websocket)
        {
            var data = newbyte[1500];
            var buffer = newArraySegment<byte>(data);

            while (true)
            {
                var result = await websocket.ReceiveAsync(buffer, CancellationToken.None);

                if (result.CloseStatus != null)
                {
                    Console.WriteLine("socket closed");
                    websocket.Abort();
                    return;
                }

                Console.WriteLine(">>> " + Encoding.UTF8.GetString(data, 0, result.Count));
                await websocket.SendAsync(buffer, WebSocketMessageType.Text, true, CancellationToken.None);
            }
        }
    }

得益于C#的async特性，实现WebSocket服务器是非常简洁的，不过我没有找到实现客户端的方法，如果谁知道望指点一下。但令人不解的是这个api只支持win8（虽然从MSDN上来看是支持win7等其它系统的），不知道最后正式版会不会去掉这个操作系统的限制。

要在非win8环境下实现WebSocket，可以试一下SuperWebSocket（服务器端）和WebSocket4Net（客户端）这两个开源库。当然，非.net的实现也是非常多的，常见的就有phpwebsockets，jWebSocket，web-socket-ruby等，这里就不一一列举了。

由于现在这段时间较忙，对于WebSocket也只是处于概念性的学习，浅尝辄止。如果有时间的话后续再写一下关于WebSocket协议和实现的相关文章。

本文链接

WPF中判断是否处于设计模式

2012-03-18T06:45:00Z

在WPF中，有时需要判断当前是否处于设计模式，以屏蔽设计器执行构造函数里面的部分功能

    publicstaticbool IsInDesignMode(thisControl control)
    {
        return System.ComponentModel.DesignerProperties.GetIsInDesignMode(control);
    }

本文链接

.Net 4.5中的HttpClient试用

2012-03-10T12:47:00Z

.Net 4.5中增加了一个新的System.Net.Http.HttpClient名字空间（在 System.Net.Http.dll 中），用于发送 HTTP 请求和接收 HTTP 响应。

基本操作

和以前的HttpWebRequest相比，HttpClient更加简洁，下面就是一个下载www.windows.com页面的示例：

    string uri = "http://www.windows.com/";
    HttpClient client = newHttpClient();
    string body = await client.GetStringAsync(uri);

它支持编码识别和对压缩的http流解压，省去了我们的不少代码。除GetStringAsync()之外，还有GetByteArrayAsync()、GetStreamAsync()、PostAsync ()、DeleteAsync()等函数，非常好用。

HttpClient.GetStringAsync()是一个简化的函数，用这个函数的时候，我们看不到HttpResponse的相关信息，如果需要看到Http响应的信息，可以用如下标准方式：

    HttpResponseMessage response = await client.GetAsync(uri);
    response.EnsureSuccessStatusCode();
    string responseBody = await response.Content.ReadAsStringAsync();

自定义HttpHeader

前面的示例非常简单，但有时我们需要在发送Get请求时在HttpHeader中加入一些额外的信息，常见的的有Refer、Cookie及UserAgent等。这个时候我们就要用到HttpClientHandler了，具体方法如下：

首先自定义一个HttpClienHanlder类，重载SendAsync方法。

    string uri = "http://www.windows.com/";
    HttpClient client = newHttpClient();

    classMyHttpClienHanlder:HttpClientHandler
    {
        protectedoverrideTask<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
        {
            request.Headers.Referrer = newUri("http://www.google.com/");
            request.Headers.Add("UserAgent", "Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 6.1; WOW64; Trident/5.0; SLCC2; .NET CLR 2.0.50727)");

            returnbase.SendAsync(request, cancellationToken);
        }
    }

在HttpClient构造函数中加入自定义的HttpClienHanlder类。

    string uri = "http://www.windows.com/";
    HttpClient client = newHttpClient(newMyHttpClienHanlder());
    string body = await client.GetStringAsync(uri);

可见，HttpClienHanlder其实就是是一个常见的代理模式的设计，它在HttpClient.GetStringAsync()中加了一层封装，拦截了HttpClient的输入和输出，从而实现一些自定义的操作。

常见问题

HttpClient虽然非常简单易用，但并不意味着它任何时候都能照着我们期望的方式工作，常见问题（我这两天试用过程中遇到的）如下：

中文乱码

HttpClient.GetStringAsync()本身支持编码识别，但如果HttpResponse的HttpHeader中不含CharSet信息时，便采用默认编码方式进行字符串解码，它的默认编码方式是无法解析中文的，此时便会出现中文乱码。

一种常见的做法是：如果HttpHeader中不含CharSet信息时，采用GBK方式来解码。要实现这个功能的话，还是需要用到前面提到的HttpClientHandler。

    classMyHttpClienHanlder:HttpClientHandler
    {
        protectedasyncoverrideTask<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
        {
            var rsponse = awaitbase.SendAsync(request, cancellationToken);
            var contentType = rsponse.Content.Headers.ContentType;
            if (string.IsNullOrEmpty(contentType.CharSet))
            {
                contentType.CharSet = "GBK";
            }
            return rsponse;
        }
    }

当然，这么做仍然不是很完善，有的时候如果要更精确的话还需要从Html页面中获取charset信息，甚至通过相应的库函数进行编码猜测。具体实现的方法类似，这里就不一一细述了

响应内容过长导致HttpRequestException

HttpClient有一个属性MaxResponseContentBufferSize，它表示的是读取响应内容时最大字节数缓冲区。它的默认值是64k，当页面内容很多，超过64k的时候，就会抛出一个HttpRequestException，导致Get失败。

这个属性必须是个正整数，也就是说，它是不支持自适应的，这个非常令人费解，不知道MS为什么非要自己估算页面大小，在Get操作前支持为合适的值，这个是个不够好用的地方。

我查了一下MSDN，目前对这个属性的说明比较少，不知道更改这个值的大小会影响什么地方。即使把他设置成int.Max貌似也不会有过多的内存占用。不过为了安全起见，还是把它设置在一个合理的范围吧，像我一般就把它设置为1m。

HttpClient client = newHttpClient() { MaxResponseContentBufferSize = 1024 * 1024 };

最后提一个不是问题的问题：HttpClient全部都是异步方法，没有同步方法，如果要在同步函数中使用，必须通过Task.Wait()来等待任务完成，稍稍有些不便。

本文链接

在C#中模拟大数乘法

2012-03-06T15:58:00Z

今天见一道算法题，要求实现两个不限长度的正整数的乘法。感觉不难，便顺手做了一下。我这里的实现比较简单，基本上就是模拟算术运算，大概分成如下几步

125
x 11
-------
125
125
--------
1375

将乘数每位与乘数相乘，获取到一个m*n的矩阵
将矩阵错位相加，得到输出数组
对输出中数组进行进位运算

一个简单的实现如下

    staticstring Multiplication(string num1, string num2)
    {
        var input1 = num1.Select(i => (int)(i - '0'));
        var input2 = num2.Select(i => (int)(i - '0'));

        //把num1依次和num2每位相乘，获取到一个m*n的矩阵
        var rectangel = input2.Select(i => input1.Select(j => j * i).ToArray()).ToArray();

        //将矩阵错位相加，得到输出数组
        var result = newint[num1.Length + num2.Length];
        for (int row = 0; row < num2.Length; row++)
        {
            for (int column = 0; column < num1.Length; column++)
            {
                result[column + row + 1] += rectangel[row][column];
            }
        }

        //对输出中数组进行进位运算
        for (int i = result.Length - 1; i >= 0; i--)
        {
            if (result[i] < 10)
                continue;

            result[i - 1] += result[i] / 10;
            result[i] %= 10;
        }

        returnnewstring(result.Select(i => (char)(i += '0')).ToArray());
    }

当然，这个只是一个算法练习，真正在实际应用中如果用到了大数运算是没必要用这个重复轮子的，在.net 4.0中引入了System.Numerics.BigInteger结构，可以实现不限长度的大数运算，比我的这个潦草地实现要凶猛得多的。

本文链接

布隆过滤器（Bloom Filter）

2012-03-04T08:29:00Z

网上找的两篇介绍布隆过滤器（Bloom Filter）的文章.

1. 数学之美系列二十一－布隆过滤器（Bloom Filter）

在日常生活中，包括在设计计算机软件时，我们经常要判断一个元素是否在一个集合中。比如在字处理软件中，需要检查一个英语单词是否拼写正确（也就是要判断它是否在已知的字典中）；在 FBI，一个嫌疑人的名字是否已经在嫌疑名单上；在网络爬虫里，一个网址是否被访问过等等。最直接的方法就是将集合中全部的元素存在计算机中，遇到一个新元素时，将它和集合中的元素直接比较即可。一般来讲，计算机中的集合是用哈希表（hash table）来存储的。它的好处是快速准确，缺点是费存储空间。当集合比较小时，这个问题不显著，但是当集合巨大时，哈希表存储效率低的问题就显现出来了。比如说，一个象 Yahoo,Hotmail 和 Gmai 那样的公众电子邮件（email）提供商，总是需要过滤来自发送垃圾邮件的人（spamer）的垃圾邮件。一个办法就是记录下那些发垃圾邮件的 email 地址。由于那些发送者不停地在注册新的地址，全世界少说也有几十亿个发垃圾邮件的地址，将他们都存起来则需要大量的网络服务器。如果用哈希表，每存储一亿个 email 地址，就需要 1.6GB 的内存（用哈希表实现的具体办法是将每一个 email 地址对应成一个八字节的信息指纹 googlechinablog.com/2006/08/blog-post.html，然后将这些信息指纹存入哈希表，由于哈希表的存储效率一般只有 50%，因此一个 email 地址需要占用十六个字节。一亿个地址大约要 1.6GB，即十六亿字节的内存）。因此存贮几十亿个邮件地址可能需要上百 GB 的内存。除非是超级计算机，一般服务器是无法存储的。

今天，我们介绍一种称作布隆过滤器的数学工具，它只需要哈希表 1/8 到 1/4 的大小就能解决同样的问题。

布隆过滤器是由巴顿.布隆于一九七零年提出的。它实际上是一个很长的二进制向量和一系列随机映射函数。我们通过上面的例子来说明起工作原理。

假定我们存储一亿个电子邮件地址，我们先建立一个十六亿二进制（比特），即两亿字节的向量，然后将这十六亿个二进制全部设置为零。对于每一个电子邮件地址 X，我们用八个不同的随机数产生器（F1,F2, ...,F8）产生八个信息指纹（f1, f2, ..., f8）。再用一个随机数产生器 G 把这八个信息指纹映射到 1 到十六亿中的八个自然数 g1, g2, ...,g8。现在我们把这八个位置的二进制全部设置为一。当我们对这一亿个 email 地址都进行这样的处理后。一个针对这些 email 地址的布隆过滤器就建成了。（见下图）

现在，让我们看看如何用布隆过滤器来检测一个可疑的电子邮件地址 Y 是否在黑名单中。我们用相同的八个随机数产生器（F1, F2, ..., F8）对这个地址产生八个信息指纹 s1,s2,...,s8，然后将这八个指纹对应到布隆过滤器的八个二进制位，分别是 t1,t2,...,t8。如果 Y 在黑名单中，显然，t1,t2,..,t8 对应的八个二进制一定是一。这样在遇到任何在黑名单中的电子邮件地址，我们都能准确地发现。

布隆过滤器决不会漏掉任何一个在黑名单中的可疑地址。但是，它有一条不足之处。也就是它有极小的可能将一个不在黑名单中的电子邮件地址判定为在黑名单中，因为有可能某个好的邮件地址正巧对应个八个都被设置成一的二进制位。好在这种可能性很小。我们把它称为误识概率。在上面的例子中，误识概率在万分之一以下。

布隆过滤器的好处在于快速，省空间。但是有一定的误识别率。常见的补救办法是在建立一个小的白名单，存储那些可能别误判的邮件地址。

原文地址：http://www.google.com.hk/ggblog/googlechinablog/2007/07/bloom-filter_7469.html（不定期抽风中）

2. BloomFilter——大规模数据处理利器

这篇文章详细介绍了其原理和实现，写的相当不错。本身就是博客园里的一篇文章，这里就直接贴链接了

http://www.cnblogs.com/heaad/archive/2011/01/02/1924195.html。

本文链接