sgip.cs

联通的SGIP发送代码

/* jll(2005)版权所有，保留所有权力
 * 文件名：SGIP.cs
 * 用  途：这个文件提供了好些个类，封装了Sgip 1.2版本的一些结构
 * 作  者：jll
 * 完成日期：2005年8月2日
 * 修订记录：
 */

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.CompilerServices;

using System.Net;

namespace JLL.SGIP
{
    /// <summary>
    /// 序列号, 参见： 3.4序列号的定义, 12字节
    /// </summary>
    public class SequenceNumber
    {
        //保存的值将是网络字节顺序的值
        private uint _part1;
        private uint _part2;
        private uint _part3;
        private static uint _Sequence = 0; //用于第3部分，序号计数

        public uint Part1
        {
            get
            {
                return (uint)IPAddress.NetworkToHostOrder((int)_part1);
            }
            set
            {
                _part1 = (uint)IPAddress.HostToNetworkOrder((int)value);
            }
        }

        public uint Part2
        {
            get
            {
                return (uint)IPAddress.NetworkToHostOrder((int)_part2);
            }
            set
            {
                _part2 = (uint)IPAddress.HostToNetworkOrder((int)value);
            }
        }

        public uint Part3
        {
            get
            {
                return (uint)IPAddress.NetworkToHostOrder((int)_part3);
            }
            set
            {
                _part3 = (uint)IPAddress.HostToNetworkOrder((int)value);
            }
        }

        /// <summary>
        /// 将另一个序列号赋值给自已， 这在消息应答时用
        /// </summary>
        /// <param name="r"></param>
        public void Assign(SequenceNumber r)
        {
            this._part1 = r._part1;
            this._part2 = r._part2;
            this._part3 = r._part3;
        }

        /// <summary>
        /// 返回所占用的字节数
        /// </summary>
        /// <returns></returns>
        public int GetLength()
        {
            return 12;
        }

        public override string ToString()
        {
            return string.Format("{0}{1}{2}", Part1, Part2, Part3);
        }

        /*
           public override bool Equals(object obj)
           {
               SequenceNumber r = obj as SequenceNumber;
               if (r != null)
               {
                   return (this._part1 == r._part1) && (this._part2 == r._part2) && (this._part3 == r._part3);
               }
               return false;
           }

           public static bool operator ==(SequenceNumber x, SequenceNumber y)
           {
               return (x._part1 == y._part1) && (x._part2 == y._part2) && (x._part3 == y._part3);
           }

           public static bool operator !=(SequenceNumber x, SequenceNumber y)
           {
               return !(x == y);
           }
         */

        /// <summary>
        /// 转换成byte[]类型，以便发送到socket
        /// </summary>
        /// <returns></returns>
        public byte[] GetBytes()
        {
            byte[] result = new byte[12];
            Buffer.BlockCopy(BitConverter.GetBytes(_part1), 0, result, 0, 4);
            Buffer.BlockCopy(BitConverter.GetBytes(_part2), 0, result, 4, 4);
            Buffer.BlockCopy(BitConverter.GetBytes(_part3), 0, result, 8, 4);
            return result;
        }

        /// <summary>
        /// 从一个内存块中读取数据
        /// </summary>
        /// <param name="buffer"></param>
        /// <param name="startIndex"></param>
        internal void ReadFromBytes(byte[] buffer, int startIndex)
        {
            _part1 = BitConverter.ToUInt32(buffer, startIndex);
            _part2 = BitConverter.ToUInt32(buffer, startIndex + 4);
            _part3 = BitConverter.ToUInt32(buffer, startIndex + 8);
        }

        /// <summary>
        /// 从一个byte[]数组中读取序列号对象
        /// </summary>
        /// <param name="buffer"></param>
        /// <param name="startIndex"></param>
        /// <returns></returns>
        public static SequenceNumber ToSequenceNumber(byte[] buffer, int startIndex)
        {
            SequenceNumber sn = new SequenceNumber();
            sn.ReadFromBytes(buffer, startIndex);
            return sn;
        }

        /// <summary>
        /// 生成一个序列号对象
        /// </summary>
        /// <returns></returns>
        public static SequenceNumber CreateSequenceNumber()
        {
            SequenceNumber sn = new SequenceNumber();
            sn.Part1 = SgipConfig.SP.NodeID;
            sn.Part2 = Convert.ToUInt32(DateTime.Now.ToString("MMddhhmmff"));
            sn.Part3 = _Sequence++;
            return sn;
        }
    }

    public class UserNumber : List<string>
    {
        public new void Add(string strPhoneNumber)
        {
            base.Add(SgipHelper.Prefix86ForMobilbeNumber(strPhoneNumber));
        }

        public override string ToString()
        {
            StringBuilder sbResult = new StringBuilder();
            for (int i = 0; i < this.Count; ++i)
            {
                sbResult.Append(this[i] + ",");
            }
            return sbResult.ToString().Substring(0, sbResult.Length - 1);
        }
    }

    /// <summary>
    /// 消息头的定义，20字节
    /// </summary>
    public class Head
    {
        private uint _messageLength; // 4
        private uint _commandID;    // 4
        private SequenceNumber _sequenceNumber = new SequenceNumber(); //12, 注意：尚未进行正确的赋值

        public uint MessageLength
        {
            get
            {
                return (uint)IPAddress.NetworkToHostOrder((int)_messageLength);
            }
            set
            {
                _messageLength = (uint)IPAddress.HostToNetworkOrder((int)value);
            }
        }

        public uint CommandID
        {
            get
            {
                return (uint)IPAddress.NetworkToHostOrder((int)_commandID);
            }
            set
            {
                _commandID = (uint)IPAddress.HostToNetworkOrder((int)value);
            }
        }

        public SequenceNumber SequenceNumber
        {
            get { return _sequenceNumber; }
            set { _sequenceNumber = value; }
        }

        public Head()
        {
        }

        /// <summary>
        /// 返回byte[], 用于socket发送
        /// </summary>
        /// <returns></returns>
        public byte[] GetBytes()
        {
            byte[] result = new byte[this.GetLength()];
            int nIndex = 0;
            BitConverter.GetBytes(_messageLength).CopyTo(result, nIndex);
            nIndex += 4;
            BitConverter.GetBytes(_commandID).CopyTo(result, nIndex);
            nIndex += 4;
            _sequenceNumber.GetBytes().CopyTo(result, nIndex);
            return result;
        }

        /// <summary>
        /// 从byte[]中读取数据
        /// </summary>
        /// <param name="buffer"></param>
        /// <param name="startIndex"></param>
        internal void ReadFromBytes(byte[] buffer, int startIndex)
        {
            _messageLength = BitConverter.ToUInt32(buffer, startIndex);
            _commandID = BitConverter.ToUInt32(buffer, startIndex + 4);
            _sequenceNumber.ReadFromBytes(buffer, startIndex + 8);
        }

        public static Head ToHead(byte[] buffer, int startIndex)
        {
            Head head = new Head();
            head.ReadFromBytes(buffer, startIndex);
            return head;
        }

        /// <summary>
        /// 返回head这一结构所占用的字节数
        /// </summary>
        /// <returns></returns>
        public int GetLength()
        {
            return 20;
        }
    };

    public class Body
    {
        public virtual uint GetCommandID()
        {
            return 0;
        }

        public virtual int GetLength()
        {
            return 0;
        }

        public virtual byte[] GetBytes()
        {
            return new byte[0];
        }

        internal virtual void ReadFromBytes(byte[] buffer, int startIndex)
        {
        }
    };

    /// <summary>
    /// 几个消息应答的格式基本一致，故将其作为一个基类以减少重复代码
    /// </summary>
    public class ResponseBody : Body
    {
        private byte _result;
        private byte[] _reserved = new byte[8];

        /// <summary>
        /// Bind执行命令是否成功。0：执行成功, 其它：错误码
        /// </summary>
        public byte Result
        {
            get
            {
                return _result;
            }
            set
            {
                _result = value;
            }
        }

        /// <summary>
        /// 保留，最多8个字节
        /// </summary>
        public byte[] Reserved
        {
            get { return _reserved; }
            set
            {
                SgipHelper.CheckMaxBytes(value, 8);
                _reserved = value;
            }
        }

        public override int GetLength()
        {
            return 9;
        }

        public override byte[] GetBytes()
        {
            byte[] buffer = new byte[this.GetLength()];
            buffer[0] = _result;
            _reserved.CopyTo(buffer, 1);
            return buffer;
        }

        internal override void ReadFromBytes(byte[] buffer, int startIndex)
        {
            _result = buffer[startIndex];
            Buffer.BlockCopy(buffer, 1, _reserved, 0, 8);
        }

    };

    public class Bind: Body
    {
        public override uint GetCommandID()
        {
            return Command.SGIP_BIND;
        }

        private byte _loginType; //1
        private string _loginName = ""; //16;
        private string _loginPassword = ""; //16
        private byte[] _reserved = new byte[8]; //8

        /// <summary>
        /// 1：SP向SMG建立的连接，用于发送命令