sgip.cs

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

	class SgipReport : SgipBlock
	{
		uint _sequenceNumberRpt1;
		uint _sequenceNumberRpt2;
		uint _sequenceNumberRpt3;

		ReportType _reportType;
		byte[] _userNumber;
		ReportState _state;
		byte _errorCode;
		byte[] _reserve;

		public SgipReport()
		{
			_totalLength = 64;
			_commandID = CommandID.SGIP_REPORT;
			_reserve = new byte[8] {0,0,0,0,0,0,0,0};
		}

		public string UserNumber
		{
			get { return Encoding.ASCII.GetString( _userNumber, 0, 11 ); }
		}

		public ReportState ReportState
		{
			get { return _state; }
		}

		public ErrorCode ReportErrorCode
		{
			get { return (ErrorCode)_errorCode; }
		}

		public ReportType ReportType
		{
			get { return _reportType; }
		}

		public uint SequenceNumber1
		{
			get { return _sequenceNumberRpt1; }
		}

		public uint SequenceNumber2
		{
			get { return _sequenceNumberRpt2; }
		}

		public uint SequenceNumber3
		{
			get { return _sequenceNumberRpt3; }
		}

		public void UpdateReport
			(
			uint sequenceNumberRpt1,
			uint sequenceNumberRpt2,
			uint sequenceNumberRpt3,
			ReportType reportType,
			string userNumber,
			ReportState state,
			byte errorCode
			)
		{
			_sequenceNumberRpt1 = sequenceNumberRpt1;
			_sequenceNumberRpt2 = sequenceNumberRpt1;
			_sequenceNumberRpt3 = sequenceNumberRpt1;

			_reportType = reportType;

			_userNumber = new byte[21] {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
			Encoding.ASCII.GetBytes( userNumber, 0, userNumber.Length, _userNumber, 0 );

			_state = state;
			_errorCode = errorCode;

		}

		public override void Send
			(
			BinaryWriter bw
			)
		{
			int netValue;

			SendHead( bw );

			netValue = IPAddress.HostToNetworkOrder( unchecked( (int)_sequenceNumberRpt1 ) );
			bw.Write( netValue );
			netValue = IPAddress.HostToNetworkOrder( unchecked( (int)_sequenceNumberRpt2 ) );
			bw.Write( netValue );
			netValue = IPAddress.HostToNetworkOrder( unchecked( (int)_sequenceNumberRpt3 ) );
			bw.Write( netValue );

			bw.Write( (byte)_reportType );
			bw.Write( _userNumber, 0, 21 );
			bw.Write( (byte)_state );
			bw.Write( _errorCode );
			bw.Write( _reserve, 0, 8 );
		}

		public override void Get
			(
			BinaryReader br
			)
		{
			int netValue;

			GetHead( br );

			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 ) );

			_reportType = ( ReportType )br.ReadByte();

			_userNumber = new byte[21] {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
			br.Read( _userNumber, 0, 21 );

			_state = ( ReportState )br.ReadByte();
			_errorCode = br.ReadByte();

			br.Read( _reserve, 0, 8 );
		}

		public override void SendResponse( BinaryWriter bw, ErrorCode err )
		{
			SgipReportResp reportResp = new SgipReportResp( (byte)err );
			reportResp.Send( bw );
		}
	}

	class SgipReportResp : SgipBlock
	{
		byte _result;
		byte[] _reserve = new byte[8];

		public SgipReportResp()
		{
			_totalLength = 29;
			_commandID = CommandID.SGIP_REPORT_RESP;
		}

		public SgipReportResp( byte result )
		{
			_totalLength = 29;
			_commandID = CommandID.SGIP_REPORT_RESP;
			_result = result;
		}

		public override void Send
			(
			BinaryWriter bw
			)
		{
			SendHead( bw );
			bw.Write( _result );
			bw.Write( _reserve, 0, 8 );
		}

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

	public class SgipManager
	{
		private  Socket _sck;
		private IPEndPoint sgipHost;

		private string _userName;
		private string _loginPassword;

		private SgipSubmit _submit;
		private NetworkStream ns;
		private BinaryWriter bw;


		public SgipManager
			(
			Socket sck,
			string userName,
			string loginPassword,
			uint areaCode,
			string corpId
			)
		{
			_sck = sck;
			_userName = userName;
			_loginPassword = loginPassword;

			ns = new NetworkStream( _sck );
			bw = new BinaryWriter( ns );

			if( areaCode < 100 )
				areaCode = areaCode * 10;

			SgipBlock.SetSequenceNumber
				(
				(uint)3 * 1000000000 + (uint)areaCode * 100000 + uint.Parse(corpId)
				);
		}

		public SgipManager
			(
			string hostName,
			int port,
			string userName,
			string loginPassword,

			uint areaCode,
			string corpId,
			string serviceType,

			FeeType feeType,
			string feeValue,
			string givenValue,
			AgentFlag agentFlag,
			MorelatetoMTFlag morelatetoMTFlag,

			byte tp_pid,
			byte tp_udhi
			)
		{
			_userName = userName;
			_loginPassword = loginPassword;

			_submit = new SgipSubmit
				(
				corpId,
				serviceType,
	
				feeType,
				feeValue,
				givenValue,
				agentFlag,
				morelatetoMTFlag,

				tp_pid,
				tp_udhi
				);

			if( areaCode < 100 )
				areaCode = areaCode * 10;

			SgipBlock.SetSequenceNumber
				(
				(uint)3 * 1000000000 + (uint)areaCode * 100000 + uint.Parse(corpId)
				);


			IPHostEntry he = Dns.GetHostByName( hostName );
			sgipHost = new IPEndPoint( he.AddressList[0], port );
		}

		public bool WakeSmg
			(
			string spNumber,
			string chargeNumber,
			string  userNumbers,
			string messageContent
			)
		{
			bool sendStatus = false;

			SgipSubmitResp sbResp = new SgipSubmitResp();

			_submit.UpdateSms
				(
				spNumber,
				chargeNumber,
				userNumbers,
				messageContent,
				0,
				DateTime.MinValue,
				DateTime.MinValue,
				ReportFlag.NoReport,
				MessageCoding.Gbk,
				MessageType.ShortMessage
				);
			_submit.WakeSmg( bw );

			SgipBlock respBlock = GetSgipBlock( _sck );
			if( Object.ReferenceEquals( respBlock.GetType(), sbResp.GetType()) )
			{
				sbResp = ( SgipSubmitResp )respBlock;
				if( sbResp.Result == ErrorCode.SGIP_ERRSEQUENCE )
				{
					sendStatus = true;
				}
			}

			return sendStatus;
		}

		private bool SendSms
			(
			string spNumber,
			string chargeNumber,
			string  userNumbers,
			string messageContent
			)
		{
			bool sendStatus = false;

			SgipSubmitResp sbResp = new SgipSubmitResp();

			_submit.UpdateSms
				(
				spNumber,
				chargeNumber,
				userNumbers,
				messageContent,
				0,
				DateTime.MinValue,
				DateTime.MinValue,
				ReportFlag.NoReport,
				MessageCoding.Gbk,
				MessageType.ShortMessage
				);
			_submit.Send( bw );

			SgipBlock respBlock = GetSgipBlock( _sck );
			if( Object.ReferenceEquals( respBlock.GetType(), sbResp.GetType()) )
			{
				sbResp = ( SgipSubmitResp )respBlock;
				if( sbResp.Result == ErrorCode.SGIP_OK )
				{
					sendStatus = true;
				}
			}


			return sendStatus;
		}


		private byte[] SendGroupSms
			(
			string spNumber,
			string chargeNumber,
			string userNumbers,
			string messageContent
			)
		{
			byte[] result;

			SgipSubmitResp sbResp = new SgipSubmitResp();

			string[] numbers = userNumbers.Split( new char[] { '：','，','；','、',':',',',';',' ' } );

			result = new byte[ numbers.Length ];
			for( int i = 0; i < numbers.Length; i ++ )
				result[i] = ( byte )ErrorCode.SGIP_NOTSEND;

			for( int i = 0; i < numbers.Length; i ++ )
			{
				_submit.UpdateSms
					(
					spNumber,
					chargeNumber,
					numbers[i],
					messageContent,
					0,
					DateTime.MinValue,
					DateTime.MinValue,
					ReportFlag.NoReport,
					MessageCoding.Gbk,
					MessageType.ShortMessage
					);
				_submit.Send( bw );

				SgipBlock respBlock = GetSgipBlock( _sck );
				if( Object.ReferenceEquals( respBlock.GetType(), sbResp.GetType()) )
				{
					sbResp = ( SgipSubmitResp )respBlock;
					result[i] = ( byte )sbResp.Result;
				}
			}

			return result;
		}

	
		private SgipBlock GetSgipBlock
			(
			Socket sck
			)
		{
			SgipBlock respBlock = new SgipBlock();

			NetworkStream ns = new NetworkStream( sck );
			BinaryReader br = new BinaryReader( ns );
			CommandID cmdID;

			cmdID = SgipBlock.GetRespCommandID( sck );
			switch( cmdID )
			{
				case CommandID.SGIP_BIND:
					respBlock = new SgipBind();
					break;

				case CommandID.SGIP_BIND_RESP:
					respBlock = new SgipBindResp();
					break;

				case CommandID.SGIP_UNBIND:
					respBlock = new SgipUnBind();
					break;

				case CommandID.SGIP_UNBIND_RESP:
					respBlock = new SgipUnBindResp();
					break;

				case CommandID.SGIP_SUBMIT:
					respBlock = new SgipSubmit();
					break;

				case CommandID.SGIP_SUBMIT_RESP:
					respBlock = new SgipSubmitResp();
					break;

				case CommandID.SGIP_DELIVER:
					respBlock = new SgipDeliver();
					break;

				case CommandID.SGIP_DELIVER_RESP:
					respBlock = new SgipDeliverResp();
					break;

				case CommandID.SGIP_REPORT:
					respBlock = new SgipReport();
					break;

				case CommandID.SGIP_REPORT_RESP:
					respBlock = new SgipReportResp();
					break;
			}
			
			if( respBlock != null )
			{
				respBlock.Get( br );
			}

			return respBlock;
		}


		public void  ProcessSmgBlock( ref MessageAndSocket ms )
		{

			SgipBlock smgBlock = GetSgipBlock( _sck );
			smgBlock.SendResponse( bw, ErrorCode.SGIP_OK );

			switch( smgBlock.CommandID )
			{
				case CommandID.SGIP_BIND:

					SgipBind sb = ( SgipBind )smgBlock;					
					break;

				case CommandID.SGIP_DELIVER:

					SgipDeliver sd = ( SgipDeliver )smgBlock;

					ms.Number = sd.UserNumber.Substring( 2 );
					ms.MessageInput = sd.MessageContent.ToLower().Trim();

					break;

				case CommandID.SGIP_REPORT:

					SgipReport sr = ( SgipReport )smgBlock;
					break;

				case CommandID.SGIP_UNBIND:

					break;
			}
		}

		private bool SgipLogin()
		{
			SgipBindResp bindResp = new SgipBindResp();
			bool loginStatus = false;

			SgipBind bind = new SgipBind( LoginType.SpConnectSmg, _userName, _loginPassword );
			bind.Send( bw );

			SgipBlock respBlock = GetSgipBlock( _sck );
			if(  Object.ReferenceEquals( respBlock.GetType(), bindResp.GetType() ) )
			{
				bindResp = ( SgipBindResp )respBlock;
				if( bindResp.Result == ErrorCode.SGIP_OK )
					loginStatus = true;
			}

			return loginStatus;
		}

		public bool ConnectAndLogin()
		{
			bool result = false;

			_sck = new Socket
				(
				AddressFamily.InterNetwork,
				SocketType.Stream,
				ProtocolType.Tcp
				);
/*
			_sck.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.SendTimeout, 10000 );
			_sck.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReceiveTimeout, 10000 );
*/
			_sck.Connect( sgipHost );

			ns = new NetworkStream( _sck );
			bw = new BinaryWriter( ns );

			if( SgipLogin() )
				result = true;
			else
			{
				_sck.Shutdown( SocketShutdown.Both );
				_sck.Close();
			}

			return result;
		}


		public void Close()
		{
			_sck.Shutdown( SocketShutdown.Both );
			_sck.Close();
		}

		public byte[] Send
			(
			string spNumber,
			string chargeNumber,
			string mobileNumber,
			string sms
			)
		{
			byte[] result = new byte[1] { (byte) ErrorCode.SGIP_NOTSEND };

			result = SendGroupSms( spNumber, chargeNumber, mobileNumber, sms );
			return result;
		}
	}
}