sgip.cs

用C#编写的的中国联通Sgip协议

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

namespace UnicomSgip
{
	/// <summary>
	/// SgipBlock 的摘要说明。
	/// </summary>

	//
	// 用于队列的基本数据结构，包含一个字符串和发送它的网络连接
	//
	public class MessageAndSocket
	{
		Socket _sck;
		NetworkStream _ns;

		private string _number;
		private string _messageInput;
		private string _messageOutput;


		public NetworkStream ns
		{
			set { _ns = value; }
			get { return _ns;  }
		}

		public MessageAndSocket()
		{
		}

		public MessageAndSocket( Socket sck,  NetworkStream ns )
		{
			_sck = sck;
			_ns = ns;

			_number = string.Empty;
		}

		public bool IsTestData
		{
			get
			{
				return _ns != null;
			}
		}

		public void SendOutputMessage()
		{
			byte[] data = Encoding.Default.GetBytes(  _messageOutput + "\r\n" );
			_ns.Write(  data, 0, data.Length );
		}

		public string Number
		{
			set { _number = value; }
			get { return _number; }
		}

		public string MessageInput
		{
			set { _messageInput = value; }
			get { return _messageInput; }
		}

		public string MessageOutput
		{
			set { _messageOutput = value; }
			get { return _messageOutput; }
		}
	}


	public class SgipBlock
	{
		public static string[] ErrorMessage = new string[]
			{
				"无错误，命令正确接收",
				"非法登录，如登录名、口令出错、登录名与口令不符等。",
				"重复登录，如在同一TCP/IP连接中连续两次以上请求登录。",
				"连接过多，指单个节点要求同时建立的连接数过多。",
				"登录类型错，指bind命令中的logintype字段出错。",
				"参数格式错，指命令中参数值与参数类型不符或与协议规定的范围不符。",
				"非法手机号码，协议中所有手机号码字段出现非86130号码或手机号码前未加“86”时都应报错。",
				"消息ID错",
				"信息长度错",
				"非法序列号，包括序列号重复、序列号格式错误等",
				"非法操作GNS",
				"节点忙，指本节点存储队列满或其他原因，暂时不能提供服务的情况",
				"未定义(12)", "未定义(13)", "未定义(14)", "未定义(15)", "未定义(16)",
				"未定义(17)", "未定义(18)", "未定义(19)", "未定义(20)",  
				"目的地址不可达，指路由表存在路由且消息路由正确但被路由的节点暂时不能提供服务的情况",
				"路由错，指路由表存在路由但消息路由出错的情况，如转错SMG等",
				"路由不存在，指消息路由的节点在路由表中不存在",
				"计费号码无效，鉴权不成功时反馈的错误信息",
				"用户不能通信（如不在服务区、未开机等情况）",
				"手机内存不足",
				"手机不支持短消息",
				"手机接收短消息出现错误",
				"不知道的用户",
				"不提供此功能",
				"非法设备",
				"系统失败",
				"短信中心队列满"
			};

		protected int _totalLength;
		protected CommandID _commandID;

		private static uint _sequenceNumber1;
		private static uint _sequenceNumber2;
		private static uint _sequenceNumber3;

		protected uint _sequenceNumberGot1;
		protected uint _sequenceNumberGot2;
		protected uint _sequenceNumberGot3;

		public static Encoding gbk = Encoding.GetEncoding( 936 );

		public SgipBlock()
		{
		}

		public int BufferLength( byte[] byteBuffer )
		{
			int i = byteBuffer.Length - 1;

			while( byteBuffer[i] == 0 && i > 0 )
				i --;

			return i + 1;
		}

		public static void SetSequenceNumber
			(
			uint sequenceNumber1
			)
		{
			_sequenceNumber1 = sequenceNumber1;
			_sequenceNumber3 = 0;
		}

		protected void SendSameHead( BinaryWriter bw )
		{
			int netValue;
			uint sequenceNumber2, sequenceNumber3;

			DateTime sendTime = DateTime.Now;

			netValue = IPAddress.HostToNetworkOrder( _totalLength );
			bw.Write( netValue );

			netValue = IPAddress.HostToNetworkOrder( unchecked( (int)_commandID ));
			bw.Write( netValue );

			netValue = IPAddress.HostToNetworkOrder( unchecked( (int)_sequenceNumber1 ) );
			bw.Write( netValue );

			sequenceNumber2 = (uint)11 * 100000000 + (uint)11 * 1000000 + 
				(uint)11 * 10000 + (uint)11 * 100 + (uint)11;
			netValue = IPAddress.HostToNetworkOrder( unchecked( (int)sequenceNumber2 ) );
			bw.Write( netValue );

			sequenceNumber3 = 0;

			netValue = IPAddress.HostToNetworkOrder( unchecked( (int)sequenceNumber3 ) );
			bw.Write( netValue );

		}


		protected void SendHeadGot( BinaryWriter bw )
		{
			int netValue;

			netValue = IPAddress.HostToNetworkOrder( _totalLength );
			bw.Write( netValue );
			
			netValue = IPAddress.HostToNetworkOrder( unchecked( (int)_commandID ));
			bw.Write( netValue );

			netValue = IPAddress.HostToNetworkOrder( unchecked( (int)_sequenceNumberGot1 ) );
			bw.Write( netValue );

			netValue = IPAddress.HostToNetworkOrder( unchecked( (int)_sequenceNumberGot2 ) );
			bw.Write( netValue );

			netValue = IPAddress.HostToNetworkOrder( unchecked( (int)_sequenceNumberGot3 ) );
			bw.Write( netValue );

		}

		protected void SendHead( BinaryWriter bw )
		{
			int netValue;
			DateTime sendTime = DateTime.Now;

			netValue = IPAddress.HostToNetworkOrder( _totalLength );
			bw.Write( netValue );

			netValue = IPAddress.HostToNetworkOrder( unchecked( (int)_commandID ));
			bw.Write( netValue );

			netValue = IPAddress.HostToNetworkOrder( unchecked( (int)_sequenceNumber1 ) );
			bw.Write( netValue );

			_sequenceNumber2 = (uint)sendTime.Month * 100000000 + (uint)sendTime.Day * 1000000 + 
				(uint)sendTime.Hour * 10000 + (uint)sendTime.Minute * 100 + (uint)sendTime.Second;
			netValue = IPAddress.HostToNetworkOrder( unchecked( (int)_sequenceNumber2 ) );
			bw.Write( netValue );

			_sequenceNumber3 ++;
			if( _sequenceNumber3 == uint.MaxValue )
				_sequenceNumber3 = 0;
			netValue = IPAddress.HostToNetworkOrder( unchecked( (int)_sequenceNumber3 ) );
			bw.Write( netValue );

		}

		protected void GetHead
			(
			BinaryReader br
			)
		{
			int netValue;

			netValue = br.ReadInt32();
			_totalLength = IPAddress.NetworkToHostOrder( netValue );

			netValue = br.ReadInt32();
			_commandID = unchecked( (CommandID) IPAddress.NetworkToHostOrder( netValue ) );

			netValue = br.ReadInt32();
			_sequenceNumberGot1 = unchecked( (uint) IPAddress.NetworkToHostOrder( netValue ) );

			netValue = br.ReadInt32();
			_sequenceNumberGot2 = unchecked( (uint) IPAddress.NetworkToHostOrder( netValue ) );

			netValue = br.ReadInt32();
			_sequenceNumberGot3 = unchecked( (uint) IPAddress.NetworkToHostOrder( netValue ) );
		}

		public static CommandID GetRespCommandID
			(
			Socket sck
			)
		{
			CommandID commandID;

			byte[] respBuffer = new byte[8];
			int netValue;

			sck.Receive( respBuffer, 0, 8, SocketFlags.Peek );
			MemoryStream ms = new MemoryStream( respBuffer, false );
			BinaryReader br = new BinaryReader( ms );

			netValue = br.ReadInt32();
			netValue = br.ReadInt32();
			commandID = unchecked( (CommandID) IPAddress.NetworkToHostOrder( netValue ) );

			return commandID;
		}

		public virtual void Get( BinaryReader br )
		{
			GetHead( br );
		}

		public virtual void Send( BinaryWriter bw )
		{
			SendHead( bw );
		}

		public virtual void SendResponse( BinaryWriter bw, ErrorCode err )
		{
		}

		public CommandID CommandID 
		{
			get { return _commandID; }
			set { _commandID = value; }
		}

		public int TotalLength
		{
			get { return _totalLength; }
			set { _totalLength = value; }
		}

		public uint SeqNumGot1
		{
			get{ return _sequenceNumberGot1; }
		}

		public uint SeqNumGot2
		{
			get{ return _sequenceNumberGot2; }
		}

		public uint SeqNumGot3
		{
			get{ return _sequenceNumberGot3; }
		}
	}

	
	class SgipBind : SgipBlock
	{
		LoginType _loginType;

		byte[] _loginName;
		byte[] _loginPassword;
		byte[] _reserve;

		public SgipBind()
		{
			_totalLength = 61;
			_commandID = CommandID.SGIP_BIND;

			_loginName = new byte[16] {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
			_loginPassword = new byte[16] {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
			_reserve = new byte[8]{0,0,0,0,0,0,0,0};
		}

		public string LoginName
		{
			get
			{
				return gbk.GetString( _loginName, 0,  BufferLength( _loginName ) );
			}
		}

		public string LoginPassword
		{
			get
			{
				return gbk.GetString( _loginPassword, 0, BufferLength( _loginPassword ) );
			}
		}

		public SgipBind
			(
			LoginType loginType,
			string userName,
			string loginPassword
			)
		{
			_totalLength = 61;
			_commandID = CommandID.SGIP_BIND;
			_loginType = loginType;

			_loginName = new byte[16] {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
			_loginPassword = new byte[16] {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
			_reserve = new byte[8]{0,0,0,0,0,0,0,0};

			
			Encoding.ASCII.GetBytes( userName, 0, userName.Length, _loginName, 0 );
			Encoding.ASCII.GetBytes( loginPassword, 0, loginPassword.Length, _loginPassword, 0 );
		}

		public override	void Send
			(
			BinaryWriter bw
			)
		{
			SendHead( bw );
			bw.Write( (byte)_loginType );
			bw.Write( _loginName, 0, 16 );
			bw.Write( _loginPassword, 0, 16 );
			bw.Write( _reserve, 0, 8 );
		}

		public override void Get
			(
			BinaryReader br
			)
		{
			GetHead( br );
			_loginType = (LoginType)br.ReadByte();
			br.Read( _loginName, 0, 16 );
			br.Read( _loginPassword, 0, 16 );
			br.Read( _reserve, 0, 8 );
		}

		public override void SendResponse( BinaryWriter bw, ErrorCode err )
		{
			SgipBindResp bindResp = new SgipBindResp
				(
				_sequenceNumberGot1,
				_sequenceNumberGot2,
				_sequenceNumberGot3,
				(byte)err
				);

			bindResp.Send( bw );
		}

	}

	class SgipBindResp : SgipBlock
	{
		byte _result;
		byte[] _reserve = new byte[8] { 0, 0, 0, 0, 0, 0, 0, 0 };

		public SgipBindResp( )
		{
			_totalLength = 29;
			_commandID = CommandID.SGIP_BIND_RESP;
		}

		public SgipBindResp( uint s1, uint s2, uint s3, byte result )
		{
			_sequenceNumberGot1 = s1;
			_sequenceNumberGot2 = s2;
			_sequenceNumberGot3 = s3;

			_totalLength = 29;
			_commandID = CommandID.SGIP_BIND_RESP;
			_result = result;
		}

		public override void Send
			(
			BinaryWriter bw
			)
		{

			byte[] data = new byte[ _totalLength ];
			MemoryStream ms = new MemoryStream( data );
			BinaryWriter bbw = new BinaryWriter( ms );

			SendHeadGot( bbw );
			bbw.Write( _result );
			bbw.Write( _reserve, 0, 8 );

			bw.Write( data, 0, data.Length );
		}

		public override void Get
			(
			BinaryReader br
			)
		{
			GetHead( br );
			_result = br.ReadByte();
			br.Read( _reserve, 0, 8 );
		}

		public ErrorCode Result
		{
			get 
			{
				return (ErrorCode)_result;
			}

			set
			{
				_result = (byte)value;
			}
		}
	}

	class SgipUnBind : SgipBlock
	{
		public SgipUnBind()
		{
			_totalLength = 20;
			_commandID = CommandID.SGIP_UNBIND;
		}

		public override void SendResponse( BinaryWriter bw, ErrorCode err )
		{
			SgipUnBindResp unBindResp = new SgipUnBindResp
				(
				_sequenceNumberGot1,
				_sequenceNumberGot2,
				_sequenceNumberGot3
				);

			unBindResp.Send( bw );
		}
	}

	class SgipUnBindResp : SgipBlock
	{



		public SgipUnBindResp()
		{
			_totalLength = 20;
			_commandID = CommandID.SGIP_UNBIND_RESP;
		}


		public SgipUnBindResp( uint s1, uint s2, uint s3 )
		{
			_sequenceNumberGot1 = s1;
			_sequenceNumberGot2 = s2;
			_sequenceNumberGot3 = s3;

			_totalLength = 20;
			_commandID = CommandID.SGIP_UNBIND_RESP;
		}

		public override void Send(  BinaryWriter bw )
		{
			SendHeadGot( bw );
		}
	}

	class SgipSubmit : SgipBlock
	{
		byte[] _spNumber;
		byte[] _chargeNumber;

		byte _userCount;
		byte[][]  _userNumber;

		byte[] _corpId;
		byte[] _serviceType;

		FeeType _feeType;
		byte[] _feeValue;
		byte[] _givenValue;

		AgentFlag _agentFlag;
		MorelatetoMTFlag _morelatetoMTFlag;
		byte _priority;

		byte[] _expireTime;
		byte[] _scheduleTime;

		ReportFlag _reportFlag;
		byte _tp_pid;
		byte _tp_udhi;
		MessageCoding _messageCoding;
		MessageType _messageType;

		int _messageLength;
		byte[] _messageContent;

		byte[] _reserve;

		public SgipSubmit()
		{
			_commandID = CommandID.SGIP_SUBMIT;
			_reserve = new byte[8] { 0,0,0,0,0,0,0,0 };
		}

		public SgipSubmit
			(
			string corpId,
			string serviceType,

			FeeType feeType,
			string feeValue,
			string givenValue,