和飞秋的通讯实现

飞秋是什么？

飞秋(FeiQ)是一款局域网聊天传送文件的绿色软件，它参考了飞鸽传书(IPMSG)和QQ,
完全兼容飞鸽传书(IPMSG)协议,具有局域网传送方便，速度快，操作简单的优点，同
时具有QQ中的一些功能。

功能说明：
- 飞秋(FeiQ)是一款局域网内即时通信软件, 基于 TCP/IP(UDP).
- 完全兼容网上广为流传的飞鸽传书并比原来飞鸽功能更加强大.
- 不需要服务器支持.
- 支持文件/文件夹的传送 (支持大文件传送[4G以上]), 发送方和接收方

先给飞秋做下广告。以上的说明简介转自华军软件园：http://www.newhua.com/soft/66046.htm

下面转入正题，我们公司同时之间习惯使用飞秋来进行通讯，同时也用QQ，他们各有各的好处的特点，飞秋的好处就是，不需要注册帐号，简单方便。但是飞秋在windows2003系统下经常会卡死，不知道是公司网络问题，还是其他什么问题。后来也考虑使用其他的即时im来取代它，尝试过，后来放弃了，毕竟习惯难以改变。既然如此，我们就继续用吧，不过我们想为飞秋增加一些功能，或者想使用飞秋做提醒，那么原来的飞秋就不那么方便了。于是我考虑写个客户端和它来通讯。

 

飞秋支持ipmsg协议，那就好办了。我们只需要遵守协议和消息机制，就能和其他飞秋客户端互发消息了。

ipmsg协议的内容，参考文档http://www.cnblogs.com/hnrainll/archive/2011/05/07/2039567.html，同时对译者感谢。飞秋的消息发送使用的是udp，消息的格式为：

1:100:shirouzu:Jupiter:32:Hello，以冒号作为分割，分为6短。各段的意思为：

版本号：消息编号：发送人姓名：发送人机器名：命令字：附加内容。

 

那么我依靠这些就能互发消息了。然后还要知道“命令字”的内容。这些命令字的常量定义，我没有找到官方文档。不过协议里提到的指令（命令字）对应的数字（int)是多少？却没有找到，而且到处找不到。后来在一篇文章里见到作者写的代码里有包含一些代码中提到了这些常量的定义，就拿来用了。该文章的地址找不到了，对作者表示歉意。

 

/*  ----------------------------------------------------------
* @名称    :    
* @描述    :    
* @创建人  :    张云飞
* @创建日期:    2011/7/11 13:27:24
* @修改记录:
* ---------------------------------------------------------- */

using  System;
using  System.Collections.Generic;
using  System.Linq;
using  System.Text;

namespace  FeiQAPI
{
     public   enum  IPMSG_Header
    {
         /*  header  */
        IPMSG_VERSION  =   0x0001 ,
        IPMSG_DEFAULT_PORT  =   0x0979 ,
    }

     public   enum  IPMSG_FileattachCommand
    {
         /*  file types for fileattach command  */
        IPMSG_FILE_REGULAR  =   0x00000001 ,
        IPMSG_FILE_DIR  =   0x00000002 ,
        IPMSG_LISTGET_TIMER  =   0x0104 ,
        IPMSG_LISTGETRETRY_TIMER  =   0x0105
    }

     public   enum  IPMSG_COMMAND :  int
    {
         /*  command  */
        IPMSG_NOOPERATION  =   0x00000000 ,

        IPMSG_BR_ENTRY  =   0x00000001 ,
        IPMSG_BR_EXIT  =   0x00000002 ,
        IPMSG_ANSENTRY  =   0x00000003 ,
        IPMSG_BR_ABSENCE  =   0x00000004 ,

        IPMSG_BR_ISGETLIST  =   0x00000010 ,
        IPMSG_OKGETLIST  =   0x00000011 ,
        IPMSG_GETLIST  =   0x00000012 ,
        IPMSG_ANSLIST  =   0x00000013 ,
        IPMSG_FILE_MTIME  =   0x00000014 ,
        IPMSG_FILE_CREATETIME  =   0x00000016 ,
        IPMSG_BR_ISGETLIST2  =   0x00000018 ,

        IPMSG_SENDMSG  =   0x00000020 ,
        IPMSG_RECVMSG  =   0x00000021 ,
        IPMSG_READMSG  =   0x00000030 ,
        IPMSG_DELMSG  =   0x00000031 ,

         /*  option for all command  */
        IPMSG_ABSENCEOPT  =   0x00000100 ,
        IPMSG_SERVEROPT  =   0x00000200 ,
        IPMSG_DIALUPOPT  =   0x00010000 ,
        IPMSG_FILEATTACHOPT  =   0x00200000 ,
    }
}

 

有了命令字，然后就是消息对象的MODEL了。我们构建一个消息类的实体，以便在使用中传递消息对象。

 

/*  ----------------------------------------------------------
* @名称    :    
* @描述    :    
* @创建人  :    张云飞
* @创建日期:    2011/7/11 13:35:37
* @修改记录:
* ---------------------------------------------------------- */

using  System;
using  System.Collections.Generic;
using  System.Linq;
using  System.Text;

namespace  FeiQAPI
{
     ///   <summary>
     ///  版本号(1):包编号:发送者姓名:发送者主机名:命令字:附加信息
     ///   </summary>
     public   class  IPMSG
    {
         string  _Version;

         ///   <summary>
         ///  版本号(1)
         ///   </summary>
         public   string  Version
        {
             get  {  return  _Version; }
             set  { _Version  =  value; }
        }

         string  _PackageID;

         ///   <summary>
         ///  包编号
         ///   </summary>
         public   string  PackageID
        {
             get  {  return  _PackageID; }
             set  { _PackageID  =  value; }
        }

         string  _SenderName;

         ///   <summary>
         ///  发送者姓名
         ///   </summary>
         public   string  SenderName
        {
             get  {  return  _SenderName; }
             set  { _SenderName  =  value; }
        }

         string  _SenderHostName;

         ///   <summary>
         ///  发送者主机名
         ///   </summary>
         public   string  SenderHostName
        {
             get  {  return  _SenderHostName; }
             set  { _SenderHostName  =  value; }
        }
        IPMSG_COMMAND _Msg_Command;

         ///   <summary>
         ///  命令字
         ///   </summary>
         public  IPMSG_COMMAND Msg_Command
        {
             get  {  return  _Msg_Command; }
             set  { _Msg_Command  =  value; }
        }

         string  _Option_Data;

         ///   <summary>
         ///  附加信息
         ///   </summary>
         public   string  Option_Data
        {
             get  {  return  _Option_Data; }
             set  { _Option_Data  =  value; }
        }

         ///   <summary>
         ///  转换
         ///   </summary>
         public   static  IPMSG Parse(Byte[] bytes,  int  index,  int  count)
        {
             return  Parse(Encoding.Default.GetString(bytes,index,count));
        }

         ///   <summary>
         ///  转换
         ///   </summary>
         ///   <param name="msgStr"></param>
         ///   <returns></returns>
         public   static  IPMSG Parse( string  msgStr)
        {
             if  ( string .IsNullOrEmpty(msgStr))
            {
                 throw   new  ArgumentNullException();
            }

             ///  版本号(1):包编号:发送者姓名:发送者主机名:命令字:附加信息
             string [] strArr  =  msgStr.Split( new   char [] {  ' : '  }, StringSplitOptions.None);
            Console.WriteLine( " Receive:{0} ,Split array length={1} " , msgStr, strArr.Length);
             if  (strArr.Length  ==   6 )
            {
                IPMSG msg  =   new  IPMSG();
                msg.Version  =  strArr[ 0 ];
                msg.PackageID  =  strArr[ 1 ];
                msg.SenderName  =  strArr[ 2 ];
                msg.SenderHostName  =  strArr[ 3 ];
                msg.Msg_Command  =  (IPMSG_COMMAND)Enum.Parse( typeof (IPMSG_COMMAND), strArr[ 4 ]);
                msg.Option_Data  =  strArr[ 5 ];
                 return  msg;
            }
             return   null ;

        }

         ///   <summary>
         ///  转化到消息
         ///   </summary>
         ///   <returns></returns>
         public   string  ToMsgStr()
        {
             return   string .Format( " {0}:{1}:{2}:{3}:{4}:{5} " ,
                Version  ??   " 1 " ,
                PackageID  ??  DateTime.Now.Ticks.ToString(),
                SenderName  ??   "" ,
                SenderHostName  ??   "" ,
                (( int )Msg_Command).ToString(),
                Option_Data  ??   "" );
        }

         public   byte [] ToBytes()
        {
             string  str  =  ToMsgStr();
            Console.WriteLine( " send Msg:  "   +  str);
             return  Encoding.Default.GetBytes(str);
        }
    }
}

 

上面的实体基本 包含了6个属性，对应协议里的6个部分。同时写了 转换的方法

ToBytes，ToMsgStr，Parse等。实现了消息对象和 字节 之间的转换，便于传输。

 

好了，现在我们构建Socket对象。

 

               _socket  =   new  Socket(AddressFamily.InterNetwork, SocketType.Dgram,
                     ProtocolType.Udp);

                IPEndPoint ip  =   new  IPEndPoint(IPAddress.Any, _Port);
                _socket.Bind(ip);

 

标准的构建socket的代码。端口我们指定为：         int _Port = 2425;

 

现在尝试发送消息，如下代码所示Dns.GetHostName是获得本级机器名的方法。 在下面的方法里，构建里一个IPMSG 对象，并对该对象的各个部分赋值，然后调用socket.SendTo方法，将数据包发送出去。

        public   void  SendMsg( string  targetIP,  string  msgText)
        {
             byte [] byts  =   null ;
            IPMSG msg  =   new  IPMSG();
            msg.SenderName  =  MyName;
            msg.SenderHostName  =  Dns.GetHostName();
            msg.Msg_Command  =  IPMSG_COMMAND.IPMSG_SENDMSG; // IPMSG_SENDMSG
            msg.Option_Data  =  msgText;
            byts  =  msg.ToBytes();

            EndPoint ep  =  (EndPoint) new  IPEndPoint(IPAddress.Parse(targetIP), _Port);
            _socket.SendTo(byts, ep);
        }

 

那么如何接收消息呢？

 

                 byte [] buf  =   new   byte [ 1024 ];
                 while  (_Running)
                {
                     // Socket socketClient = socket.Accept();
                    EndPoint remote  =  (EndPoint)( new  IPEndPoint(IPAddress.Any,  0 ));

                     int  len  =  _socket.ReceiveFrom(buf,  ref  remote);
                     if  (len  >   0 )
                    {
                         string  msg  =  Encoding.Default.GetString(buf,  0 , len);
                        Console.WriteLine(msg);
                        IPMSG msg1  =  IPMSG.Parse(buf,  0 , len);
                        Action < IPMSG >  act  =   new  Action < IPMSG > (ProcessMessage);
                         if  (msg  !=   null )
                        {
                            act.BeginInvoke(msg1,  null ,  null );
                        }
                         // Println(msg + Environment.NewLine);

                        len  =   0 ;
                    }
                }

 

调用socket.ReceiveFrom方法接受到网络发来的数据包，使用我们写好的解析法方法，我们的解析方法遵守了ipmsg协议。

                     string msg = Encoding.Default.GetString(buf, 0, len);
                     IPMSG msg1 = IPMSG.Parse(buf, 0, len);
这样我们就拿到一个IPMSG对象了，该消息对象包含了其他客户机发来的消息内容，这些内容可能是，文本消息，上线消息，回复消息，文件消息等。根据消息里的 指令类型 我们需要对接受到的消息做不同的处理。

注意上面的代码中：

                       Action<IPMSG> act = new Action<IPMSG>(ProcessMessage);
                        if (msg != null)
                        {
                            act.BeginInvoke(msg1, null, null);
                        }
我是使用了一个异步委托。代码执行到这里的时候不至于阻塞。

 

我们接收到了消息后，根据消息的内容做不同的处理，下面的处理消息的代码：

         private   void  ProcessMessage(IPMSG msg)
        {
            Console.WriteLine(msg.Msg_Command);

            IPMSG_COMMAND mode  =  msg.Msg_Command;

             if  ((IPMSG_COMMAND.IPMSG_ANSENTRY  &  mode)  ==  IPMSG_COMMAND.IPMSG_ANSENTRY)
            {
                 // 让用户上线
                ProcessUseOnLine(msg);
                 return ;
            }
             if  ((IPMSG_COMMAND.IPMSG_BR_ENTRY  &  mode)  ==  IPMSG_COMMAND.IPMSG_BR_ENTRY)
            {
                 // 让用户上线
                 // ReceiveMsg(msg);
                 return ;
            }
             if  ((IPMSG_COMMAND.IPMSG_SENDMSG  &  mode)  ==  IPMSG_COMMAND.IPMSG_SENDMSG)
            {
                 // 让用户上线
                ReceiveMsg(msg);
                 return ;
            }
             // if ((IPMSG_COMMAND.IPMSG_RECVMSG & mode) == IPMSG_COMMAND_SENDCHECKOPT)
             // {
             //      // 让用户上线
             //     ReceiveMsg(msg);
             // }
        }

 

我们是如何通知 我们上线了呢？ 向局域网内的其他用户发送广播消息。收到这些消息的客户端就会将我们加入到他们的好友列表，同时各个客户端会回复一个消息给我们，籍此，我们就知道了网络上那些客户端，我们把这些客户端加入到我们的好友列表中。

 

        //发送广播，通知我上线了

        public   void  SendMyOnline()
        {
             byte [] byts  =   null ;
            IPMSG msg  =   new  IPMSG();
            msg.SenderName  =  MyName;
            msg.SenderHostName  =  Dns.GetHostName();
            msg.Msg_Command  =  IPMSG_COMMAND.IPMSG_BR_ENTRY;
            msg.Option_Data  =   string .Format( " {0}\0{1}\0{1}{2} " , MyName, MyGroup,  "" );
            byts  =  msg.ToBytes();

            EndPoint ep  =  (EndPoint) new  IPEndPoint(IPAddress.Parse( " 192.168.3.255 " ), _Port);
            _socket.SendTo(byts, ep);
        }

然后要处理收到的 其他客户机 给我们的回复，该回复了包含了 其他各个客户机的位置信息

 

             if  ((IPMSG_COMMAND.IPMSG_ANSENTRY  &  mode)  ==  IPMSG_COMMAND.IPMSG_ANSENTRY)
            {
                 // 让用户上线
                ProcessUseOnLine(msg);
                 return ;
            }

 

        //处理其他人 的上线消息，就是把这些消息内包含的用户地址等，加入到我们的好友列表中去。

        public   void  ProcessUseOnLine(IPMSG msg)
        {
             string  optionData  =  msg.Option_Data;
             string [] arr  =  optionData.Split( new   char [ ' / ' ], StringSplitOptions.None);
             string  displayName  =   "" ;
             string  group  =   "" ;
             if  (arr  !=   null   &&  arr.Length  >   0 )
            {
                 if  (arr.Length  >   0 )
                {
                    displayName  =  arr[ 0 ];
                }
                 if  (arr.Length  >   1 )
                {
                    group  =  arr[ 1 ];

                }
            }

            _UserList.AddUser(msg.SenderName, msg.SenderHostName, displayName, group);
        }

 

下面是我的好友类，和好友列表类：

 

/*  ----------------------------------------------------------
* @名称    :    
* @描述    :    
* @创建人  :    张云飞
* @创建日期:    2011/7/11 14:27:48
* @修改记录:
* ---------------------------------------------------------- */

using  System;
using  System.Collections.Generic;
using  System.Linq;
using  System.Text;

namespace  FeiQAPI
{
     ///   <summary>
     ///  用户
     ///   </summary>
     public   struct  User
    {
         public   string  UserName;    // 用户名
         public   string  HostName;   // 机器名

         // public string id;                // 节点ID。
         public   string  HostIp;      // 存储IP信息，避免重复添加

         public   string  Displayname;
         public   string  Group;

         // public object Inet;   // 存储网络信息

    }
}

/*  ----------------------------------------------------------
* @名称    :    
* @描述    :    
* @创建人  :    张云飞
* @创建日期:    2011/7/11 14:35:45
* @修改记录:
* ---------------------------------------------------------- */

using  System;
using  System.Collections.Generic;
using  System.Linq;
using  System.Text;
using  System.Net;
using  System.Net.Sockets;

namespace  FeiQAPI
{
     ///   <summary>
     ///  用户列表
     ///   </summary>
     public   class  UserList
    {
        Dictionary < string , User >  _lstUsers  =   new  Dictionary < string , User > ();
         public   event  EventHandler < UserEventArgs >  OnUserAdded;


         public   void  AddUser( string  userName,  string  hostName,  string  displayName,  string  group)
        {
             string  ip  =   null ;
             try
            {
                 if  (Dns.GetHostEntry(hostName)  !=   null   &&  Dns.GetHostEntry(hostName).AddressList  !=   null   &&  Dns.GetHostEntry(hostName).AddressList.Length  >   0 )
                {
                    ip  =  Dns.GetHostEntry(hostName).AddressList.Last().ToString();
                    User user  =   new  User();
                    user.UserName  =  userName;
                    user.HostName  =  hostName;
                    user.HostIp  =  ip;
                    user.Displayname  =  displayName;
                    user.Group  =  group;

                    AddUser(user);
                }
            }
             catch  (SocketException)
            {

            }
             catch  (Exception)
            {

                 throw ;
            }

        }

         public   void  AddUser(User user)
        {
             if  ( ! _lstUsers.ContainsKey(user.HostIp))
            {
                _lstUsers.Add(user.HostIp, user);
                 if  (OnUserAdded  !=   null )
                {
                    OnUserAdded( this ,  new  UserEventArgs(user));
                }
            }
        }

         ///   <summary>
         ///  获得用户
         ///   </summary>
         ///   <param name="senderName"></param>
         ///   <param name="hostName"></param>
         ///   <returns></returns>
         public  User ?  GetUser( string  senderName,  string  hostName)
        {
             return  _lstUsers.Values.SingleOrDefault(p  =>  p.UserName  ==  senderName  &&  p.HostName  ==  hostName);
        }
    }
}

 

最后贴出我的完整的处理 消息 的服务器类：

 

/*  ----------------------------------------------------------
* @名称    :    
* @描述    :    
* @创建人  :    张云飞
* @创建日期:    2011/7/11 14:01:32
* @修改记录:
* ---------------------------------------------------------- */

using  System;
using  System.Collections.Generic;
using  System.Linq;
using  System.Text;
using  System.Net;
using  System.Net.Sockets;
using  System.Threading;

namespace  FeiQAPI
{
     ///   <summary>
     ///  消息服务器
     ///   </summary>
     public   class  MsgServer
    {
         ///   <summary>
         ///  当接受的消息时
         ///   </summary>
         public   event  EventHandler < IpMsg_EventArgs >  OnReceiveMsg;

         int  _Port  =   2425 ;
         bool  _Running  =   false ;

         private   string  _MyName;
         private   string  _MyGroup;

         ///   <summary>
         ///  分组
         ///   </summary>
         public   string  MyGroup
        {
             get  {  return  _MyGroup; }
             set  { _MyGroup  =  value; }
        }

         public   string  MyName
        {
             get  {  return  _MyName; }
             set  { _MyName  =  value; }
        }

         public   bool  Running
        {
             get  {  return  _Running; }
        }

        Socket _socket;

        UserList _UserList  =   new  UserList();

         ///   <summary>
         ///  用户列表
         ///   </summary>
         public  UserList UserList
        {
             get  {  return  _UserList; }
        }

         // public void Send
         public   void  ProcessUseOnLine(IPMSG msg)
        {
             string  optionData  =  msg.Option_Data;
             string [] arr  =  optionData.Split( new   char [ ' / ' ], StringSplitOptions.None);
             string  displayName  =   "" ;
             string  group  =   "" ;
             if  (arr  !=   null   &&  arr.Length  >   0 )
            {
                 if  (arr.Length  >   0 )
                {
                    displayName  =  arr[ 0 ];
                }
                 if  (arr.Length  >   1 )
                {
                    group  =  arr[ 1 ];

                }
            }

            _UserList.AddUser(msg.SenderName, msg.SenderHostName, displayName, group);
        }

         public   void  Start()
        {
            ThreadPool.QueueUserWorkItem( new  WaitCallback( delegate
            {
                Run();

            }));
        }

         private   void  Run()
        {
             if  (_Running  ==   false )
            {
                _socket  =   new  Socket(AddressFamily.InterNetwork, SocketType.Dgram,
                     ProtocolType.Udp);

                IPEndPoint ip  =   new  IPEndPoint(IPAddress.Any, _Port);
                _socket.Bind(ip);
                 // socket.Listen(10);

                _Running  =   true ;
                SendMyOnline();

                 byte [] buf  =   new   byte [ 1024 ];
                 while  (_Running)
                {
                     // Socket socketClient = socket.Accept();
                    EndPoint remote  =  (EndPoint)( new  IPEndPoint(IPAddress.Any,  0 ));

                     int  len  =  _socket.ReceiveFrom(buf,  ref  remote);
                     if  (len  >   0 )
                    {
                         string  msg  =  Encoding.Default.GetString(buf,  0 , len);
                        Console.WriteLine(msg);
                        IPMSG msg1  =  IPMSG.Parse(buf,  0 , len);
                        Action < IPMSG >  act  =   new  Action < IPMSG > (ProcessMessage);
                         if  (msg  !=   null )
                        {
                            act.BeginInvoke(msg1,  null ,  null );
                        }
                         // Println(msg + Environment.NewLine);

                        len  =   0 ;
                    }
                }
            }
        }

         private   void  ProcessMessage(IPMSG msg)
        {
            Console.WriteLine(msg.Msg_Command);

            IPMSG_COMMAND mode  =  msg.Msg_Command;

             if  ((IPMSG_COMMAND.IPMSG_ANSENTRY  &  mode)  ==  IPMSG_COMMAND.IPMSG_ANSENTRY)
            {
                 // 让用户上线
                ProcessUseOnLine(msg);
                 return ;
            }
             if  ((IPMSG_COMMAND.IPMSG_BR_ENTRY  &  mode)  ==  IPMSG_COMMAND.IPMSG_BR_ENTRY)
            {
                 // 让用户上线
                 // ReceiveMsg(msg);
                 return ;
            }
             if  ((IPMSG_COMMAND.IPMSG_SENDMSG  &  mode)  ==  IPMSG_COMMAND.IPMSG_SENDMSG)
            {
                 // 让用户上线
                ReceiveMsg(msg);
                 return ;
            }
             // if ((IPMSG_COMMAND.IPMSG_RECVMSG & mode) == IPMSG_COMMAND_SENDCHECKOPT)
             // {
             //      // 让用户上线
             //     ReceiveMsg(msg);
             // }
        }

         private   void  ReceiveMsg(IPMSG msg)
        {
             if  (OnReceiveMsg  !=   null )
            {
                OnReceiveMsg( this ,  new  IpMsg_EventArgs(msg));
            }
        }

         public   void  SendMyOnline()
        {
             byte [] byts  =   null ;
            IPMSG msg  =   new  IPMSG();
            msg.SenderName  =  MyName;
            msg.SenderHostName  =  Dns.GetHostName();
            msg.Msg_Command  =  IPMSG_COMMAND.IPMSG_BR_ENTRY;
            msg.Option_Data  =   string .Format( " {0}\0{1}\0{1}{2} " , MyName, MyGroup,  "" );
            byts  =  msg.ToBytes();

            EndPoint ep  =  (EndPoint) new  IPEndPoint(IPAddress.Parse( " 192.168.3.255 " ), _Port);
            _socket.SendTo(byts, ep);
        }

         public   void  Stop()
        {
            _Running  =   false ;
        }

         public   void  SendMsg(User _CurrentUser,  string  msgText)
        {
            SendMsg(_CurrentUser.HostIp, msgText);
        }

         public   void  SendMsg( string  targetIP,  string  msgText)
        {
             byte [] byts  =   null ;
            IPMSG msg  =   new  IPMSG();
            msg.SenderName  =  MyName;
            msg.SenderHostName  =  Dns.GetHostName();
            msg.Msg_Command  =  IPMSG_COMMAND.IPMSG_SENDMSG; // IPMSG_SENDMSG
            msg.Option_Data  =  msgText;
            byts  =  msg.ToBytes();

            EndPoint ep  =  (EndPoint) new  IPEndPoint(IPAddress.Parse(targetIP), _Port);
            _socket.SendTo(byts, ep);
        }
    }
}

 

同时提供完整的源代码下载