中国联通SGIP接口

雨点打透心脏的1/2处 2022-08-04 15:47 219阅读 0赞

下载参考程序 ：[http://download.csdn.net/detail/adama119/4189313][http_download.csdn.net_detail_adama119_4189313]

短信行业已经很成熟了，到处可以找到资料。本人在这个行业干过几年，做过3套短信平台都在省级单位省用，做的最复杂的自然是SP的应用，曾经在广电集团工作时做的内容确实非常复杂自己都觉得头疼，当然也和水平有限有关。

2010年底给江苏某国企做了一套行业应用的短信系统，做短信平台大量工作还是围绕业务开发WEB方面内容。这次网关客户端的是用C\#开发的，目标为50条/秒，性能上应该没什么问题,支持普通短信但是长短信对方没要就没写，需要的朋友可以自行修改开发。以下贴出SGIP1.2源代码给各位需要的朋友做个参考，运行到现在没有发现任何问题。这里只贴出sgip接口，至于程序就自己做吧，如果需要也可以联系我。

//------------------------------------------------------------------------------

//文件Client.cs

//------------------------------------------------------------------------------

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

namespace AsiaINFO.SMS.SGIP  
\{

/// <summary>  
/// @Description：SGIP1.2 短消息联通网关SP客户端  
/// @Author：Adama SUN  
/// @Mail：[spf193@gmail.com][spf193_gmail.com]

/// @Copyright (C) 2010 AsiaINFO. All rights reserved.  
/// </summary>  
public class SGIPClient : SGIPBase  
\{

public SGIPClient(Queue<byte\[\]> queue, SyncEvents syncEvents)  
: base(queue, syncEvents)  
\{

\#region private field

private string \_CorpId; //企业代码

private static object \_SyncLockObject = new object(); //锁  
private TcpClient tc;  
private NetworkStream \_NetworkStream;

\#endregion

\#region public methos

/// <summary>  
/// 连接  
/// </summary>  
/// <param name="Host">主机地址</param>  
/// <param name="Port">端口</param>  
/// <param name="UserID">用户名</param>  
/// <param name="Password">密码</param>  
/// <param name="CorpId">企业代码</param>  
/// <param name="SequenceId">序列号</param>  
/// <returns></returns>  
public void Connect(string Host, int Port, string UserID, string Password,string CorpId, uint SequenceId)  
\{  
this.\_CorpId = CorpId;

SGIP\_Bind connect = new SGIP\_Bind((uint)LoginTypes.SpToSmg,UserID, Password, SequenceId);

if (!IsConnected || tc == null || !tc.Connected)  
\{  
tc = new TcpClient();  
tc.Connect(Host, Port);  
if (this.\_NetworkStream != null)  
\{  
try  
\{  
this.\_NetworkStream.Close();  
this.\_NetworkStream = null;  
\}  
catch (Exception) \{ \}  
\}  
\}

this.\_NetworkStream = tc.GetStream();  
this.WriteToStreamWithLock(connect.ToBytes(), this.\_NetworkStream);  
  
this.StartRun();  
\}

/// <summary>  
/// 中断  
/// </summary>  
/// <param name="SequenceId"></param>  
public void Terminate(uint SequenceId)  
\{  
MessageHeader terminate = new MessageHeader(MessageHeader.Length,SGIP\_Command\_Id.SGIP\_UNBIND, SequenceId);  
this.WriteToStreamWithLock(terminate.ToBytes(), this.\_NetworkStream);  
\}

/// <summary>  
/// 发送短信  
/// </summary>  
/// <param name="SPNumber">SP号码</param>  
/// <param name="feeMobile">计费手机号码</param>  
/// <param name="mobile">手机号码</param>  
/// <param name="MessageContent">短消息的内容</param>  
/// <param name="LinkID">LinkID</param>  
/// <param name="SequenceId">序列号</param>  
public void Submit(string SPNumber,string feeMobile, string mobile, string MessageContent, string LinkID, uint SequenceId)  
\{  
Submit(SPNumber, feeMobile, mobile, "HELP", (uint)FeeTypes.Free, "0", (uint)SubmitMorelatetoMTFlags.NormalFirst, (uint)SubmitReportFlag.Always, MessageContent, LinkID, SequenceId);  
\}

/// <summary>  
/// 发送短信  
/// </summary>  
/// <param name="SPNumber">SP的接入号码</param>  
/// <param name="ChargeNumber">付费号码</param>  
/// <param name="UserNumber">接收该短消息的手机号</param>  
/// <param name="ServiceType">业务代码</param>  
/// <param name="FeeType">计费类型</param>  
/// <param name="FeeValue">费率，单位分</param>  
/// <param name="MorelatetoMTFlag">引起MT消息的原因</param>  
/// <param name="ReportFlag">状态报告标记</param>  
/// <param name="MessageContent">短消息的内容</param>  
/// <param name="LinkID">LinkID</param>  
/// <param name="SequenceId">序列号</param>  
public void Submit(string SPNumber, string ChargeNumber, string UserNumber, string ServiceType, uint FeeType, string FeeValue  
, uint MorelatetoMTFlag,uint ReportFlag, string MessageContent, string LinkID, uint SequenceId)  
\{  
if (ChargeNumber != null && ChargeNumber.Length == 11)  
ChargeNumber = "86" + ChargeNumber;  
if (UserNumber != null && UserNumber.Length == 11)  
UserNumber = "86" + UserNumber;

SGIP\_SUBMIT submit = new SGIP\_SUBMIT(SequenceId);  
submit.SPNumber = SPNumber;  
submit.ChargeNumber = ChargeNumber;  
// submit.ChargeNumber = "";  
submit.UserCount = 1;  
submit.UserNumber = UserNumber;  
submit.CorpId = this.\_CorpId;  
submit.ServiceType = ServiceType;  
submit.FeeType = FeeType;  
submit.FeeValue = FeeValue;  
submit.GivenValue = "0";  
submit.AgentFlag = (uint)SubmitAgentFlag.RealIncome;  
submit.MorelatetoMTFlag = MorelatetoMTFlag;  
submit.Priority = 0;  
submit.ExpireTime = "";  
submit.ScheduleTime = "";  
submit.ReportFlag = ReportFlag;  
submit.TP\_pid = 0;  
submit.TP\_udhi = 0;  
submit.MessageCoding = 15;  
submit.MessageType = 0;  
submit.MessageContent = MessageContent;  
submit.LinkID = LinkID;

this.WriteToStreamWithLock(submit.ToBytes(), this.\_NetworkStream);  
\}

/// <summary>  
/// 断开回复  
/// </summary>  
/// <param name="SrcNodeSequence"></param>  
/// <param name="DateSequence"></param>  
/// <param name="Sequence\_Id"></param>  
public void UnbindResp(uint SrcNodeSequence, uint DateSequence, uint Sequence\_Id)  
\{  
SGIP\_Unbind\_Resp response = new SGIP\_Unbind\_Resp(SrcNodeSequence, DateSequence, Sequence\_Id);  
this.WriteToStreamWithLock(response.ToBytes(), this.\_NetworkStream);  
\}

/// <summary>  
/// 退出  
/// </summary>  
public void Exit()  
\{  
try  
\{  
StopReceive();  
this.\_NetworkStream.Close();  
this.\_NetworkStream = null;  
\}  
catch (Exception) \{ \}  
\}

\#endregion

\#region private method

private void CloseClient()  
\{  
try  
\{  
try  
\{  
IsConnected = false;  
this.tc.Client.Shutdown(SocketShutdown.Both);  
\}  
catch  
\{  
\}  
\}  
finally  
\{  
this.tc.Close();  
\}  
\}

/// <summary>  
/// 写入流  
/// </summary>  
/// <param name="data"></param>  
/// <param name="Stream"></param>  
private void WriteToStreamWithLock(byte\[\] data, NetworkStream Stream)  
\{  
try  
\{  
lock (\_SyncLockObject)  
\{  
Util.WriteToStream(data, Stream);  
\}  
\}  
catch (Exception ex)  
\{

CloseClient();  
OnError(ex.Message);  
\}  
\}

/// <summary>  
/// 读取流  
/// </summary>  
/// <param name="Length"></param>  
/// <param name="Stream"></param>  
/// <returns></returns>  
private byte\[\] ReadFromStreamWithLock(int Length, NetworkStream Stream)  
\{  
try  
\{  
lock (\_SyncLockObject)  
\{  
return Util.ReadFromStream(Length, Stream);  
\}  
\}  
catch (Exception ex)  
\{  
CloseClient();  
OnError(ex.Message);  
\}  
return null;  
\}

protected override void Run()  
\{  
try  
\{  
while (!\_syncEvents.ExitThreadEvent.WaitOne(2, false))  
\{  
if (this.\_NetworkStream.CanRead)  
\{  
if (this.\_NetworkStream.DataAvailable)  
\{  
byte\[\] buffer = new byte\[MessageHeader.Length\]; //Header  
buffer = this.ReadFromStreamWithLock(MessageHeader.Length, this.\_NetworkStream);

MessageHeader header = new MessageHeader(buffer);  
byte\[\] bytes = new byte\[header.Total\_Length\];  
Buffer.BlockCopy(buffer, 0, bytes, 0, buffer.Length);

int l = (int)header.Total\_Length - MessageHeader.Length;  
if (l > 0)  
\{  
buffer = this.ReadFromStreamWithLock(l, this.\_NetworkStream);  
Buffer.BlockCopy(buffer, 0, bytes, MessageHeader.Length, buffer.Length);  
\}  
lock (((ICollection)\_receiveQueue).SyncRoot)  
\{  
\_receiveQueue.Enqueue(bytes);  
\}  
\_syncEvents.NewItemEvent.Set();

\}  
\}  
\}  
\}  
catch (Exception ex)  
\{  
CloseClient();  
OnError("SGIPClient接收错误："+ex.Message);  
\}  
OnThreadState(ThreadState.Stopped);  
  
\}  
\#endregion

\}  
\}

//------------------------------------------------------------------------------

//文件MessageEventArgs.cs

//------------------------------------------------------------------------------

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

namespace AsiaINFO.SMS.SGIP  
\{  
  
/// <summary>  
/// 消息包  
/// </summary>  
public class MessageEventArgs : EventArgs  
\{  
private byte\[\] \_HeaderData;  
private MessageHeader \_Header;  
private byte\[\] \_BodyData;

public byte\[\] BodyData  
\{  
get  
\{  
return this.\_BodyData;  
\}  
\}

public MessageHeader Header  
\{  
get  
\{  
return this.\_Header;  
\}  
\}

public byte\[\] HeaderData  
\{  
get  
\{  
return this.\_HeaderData;  
\}  
\}

public MessageEventArgs(byte\[\] bytes)  
\{  
this.\_HeaderData = new byte\[MessageHeader.Length\];  
Buffer.BlockCopy(bytes, 0, this.\_HeaderData, 0, MessageHeader.Length);  
this.\_Header = new MessageHeader(this.\_HeaderData);  
this.\_BodyData = new byte\[this.\_Header.Total\_Length - MessageHeader.Length\];  
Buffer.BlockCopy(bytes, MessageHeader.Length, this.\_BodyData, 0, this.\_BodyData.Length);  
\}

\}  
\}

//------------------------------------------------------------------------------

//文件Server.cs

//------------------------------------------------------------------------------

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

namespace AsiaINFO.SMS.SGIP  
\{  
/// <summary>  
/// @Description：SGIP1.2 短消息联通网关SP服务端  
/// @Author：Adama SUN  
/// @Mail：[spf193@gmail.com][spf193_gmail.com]  
/// @Copyright (C) 2010 AsiaINFO. All rights reserved.  
/// </summary>  
public class SGIPServer : SGIPBase  
\{  
// private Socket \_Server;  
private TcpListener \_tcpListener;  
private string \_LoginName;  
private string \_LoginPassowrd;  
private string \_Host;  
private int \_Port;  
private byte\[\] \_Buffer = new byte\[0x10000\];  
private ManualResetEvent \_MySet = new ManualResetEvent(false);  
private BaseSortedList<string, ClientQueue> m\_ClientInfo;  
private bool m\_IsRun;  
/// <summary>  
/// 空闲间隔  
/// </summary>  
private int \_TerminateFreeInterval;  
/// <summary>  
/// 源节点编号  
/// </summary>  
internal static uint \_SrcNodeSequence = 3057199999;

public event NetEventDelegate RecvDataEvent;

public SGIPServer(Queue<byte\[\]> queue, SyncEvents syncEvents, string Host, int Port, string LoginName, string LoginPassowrd, uint SrcNodeSequence, int rerminateFreeInterval)  
: base(queue, syncEvents)  
\{  
this.\_Host = Host;  
this.\_Port = Port;  
this.\_LoginName = LoginName;  
this.\_LoginPassowrd = LoginPassowrd;  
SGIPServer.\_SrcNodeSequence = SrcNodeSequence;  
this.m\_IsRun = true;  
this.\_TerminateFreeInterval = rerminateFreeInterval;  
\}

protected override void Run()  
\{  
try  
\{  
OnMsg("正在启动监听...");  
this.m\_ClientInfo = new BaseSortedList<string, ClientQueue>();  
  
// this.\_Server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);  
IPEndPoint localEP = new IPEndPoint(IPAddress.Parse(this.\_Host), this.\_Port);  
if (this.\_Host == null || this.\_Host == "127.0.0.1" || this.\_Host=="")  
this.\_tcpListener = new TcpListener(\_Port);  
else  
this.\_tcpListener = new TcpListener(localEP);

this.\_tcpListener.Start();  
//this.\_Server.Bind(localEP);  
//this.\_Server.Listen(50);  
this.IsConnected = true;  
OnMsg("启动监听成功");  
while (!\_syncEvents.ExitThreadEvent.WaitOne(2, false))  
\{  
this.\_MySet.Reset();  
this.\_tcpListener.BeginAcceptTcpClient(new AsyncCallback(this.AcceptCallBack), this.\_tcpListener);  
this.\_MySet.WaitOne();  
\}  
\}  
catch (Exception ex)  
\{  
OnError("SGIPServer监听错误：" + ex.Message);  
\}  
finally  
\{  
Stop();  
\}  
\}

public void Stop()  
\{  
if (!this.IsConnected)  
return;  
try  
\{  
try  
\{  
StopReceive();  
this.\_tcpListener.Server.Shutdown(SocketShutdown.Both);  
\}  
catch  
\{  
\}  
\}  
finally  
\{  
this.\_tcpListener.Server.Close();  
this.IsConnected = false;  
\}  
\}

private void AcceptCallBack(IAsyncResult ia)  
\{  
this.\_MySet.Set();  
try  
\{  
TcpClient tc = ((TcpListener)ia.AsyncState).EndAcceptTcpClient(ia);  
ClientQueue queue = new ClientQueue(tc, DateTime.Now);  
this.m\_ClientInfo.Add(this.GetSocketIP(tc), queue);  
int msgCount = tc.Client.Receive(this.\_Buffer);  
if (msgCount > 0)  
\{  
uint BindResult = 0;  
if (Util.bytes2Uint(this.\_Buffer, 0) == msgCount)  
\{  
if (Util.bytes2Uint(this.\_Buffer, 4) == 1)  
\{  
SGIP\_Bind bind = new SGIP\_Bind(this.\_Buffer);  
if (bind.LoginType == (uint)LoginTypes.SmgToSp || bind.LoginType == (uint)LoginTypes.SpToSmg)  
\{  
if ((bind.LoginName == this.\_LoginName) && (bind.LoginPassword == this.\_LoginPassowrd))  
\{  
BindResult = 0;  
\}  
else  
\{  
BindResult = 1;  
\}  
\}  
else  
\{  
BindResult = 4;  
\}  
SGIP\_Bind\_Resp resp = new SGIP\_Bind\_Resp(BindResult, bind.Header.SrcNodeSequence, bind.Header.DateSequence, bind.Header.Sequence\_Id);  
this.SendMSG(resp.ToBytes(), tc);  
if (BindResult == 0)  
\{  
ThreadPool.UnsafeQueueUserWorkItem(new WaitCallback(this.Recv), tc);  
\}  
else  
\{  
string msg = string.Format("网关登录SP服务端失败 Result=\{0\} LoginType=\{1\} LoginName=\{2\} Passowrd=\{3\} ", BindResult, bind.LoginType, bind.LoginName, bind.LoginPassword);  
OnMsg(msg);  
\}

\}  
\}  
else  
\{  
this.CloseClient(tc);  
\}  
\}  
\}  
catch (SocketException ex)  
\{  
OnError("AcceptCallBack\_SocketException错误：" + ex.Message);  
\}  
catch \{ \}  
\}

public void SendMSG(byte\[\] bs, TcpClient tc)  
\{  
try  
\{  
if (tc.Client.Send(bs) == 0)  
\{  
this.CloseClient(tc);  
\}  
\}  
catch (SocketException)  
\{  
this.CloseClient(tc);  
\}  
catch \{ \}  
\}

protected void Recv(object client)  
\{

string msg = string.Format("网关登录SP服务端成功 ,监听线程池分配线程ID=\{0\}", AppDomain.GetCurrentThreadId());  
OnMsg(msg);

TcpClient tc = null;  
NetworkStream networkStream = null;  
try  
\{  
tc = (TcpClient)client;  
networkStream = tc.GetStream();  
object syncLockObject = new object(); //锁  
DateTime startTime = DateTime.Now;  
while (!\_syncEvents.ExitThreadEvent.WaitOne(2, false))  
\{  
if (networkStream.CanRead)  
\{  
if (networkStream.DataAvailable)  
\{  
startTime = DateTime.Now;  
byte\[\] buffer = new byte\[MessageHeader.Length\]; //Header  
buffer = this.ReadFromStreamWithLock(syncLockObject, MessageHeader.Length, networkStream);

MessageHeader header = new MessageHeader(buffer);  
byte\[\] bytes = new byte\[header.Total\_Length\];  
Buffer.BlockCopy(buffer, 0, bytes, 0, buffer.Length);

int l = (int)header.Total\_Length - MessageHeader.Length;  
if (l > 0)  
\{  
buffer = this.ReadFromStreamWithLock(syncLockObject, l, networkStream);  
Buffer.BlockCopy(buffer, 0, bytes, MessageHeader.Length, buffer.Length);  
\}

if (this.RecvDataEvent != null)  
\{  
this.RecvDataEvent(bytes, 0, tc);  
\}

\}  
else  
\{  
///计算空闲时间  
TimeSpan ts = DateTime.Now - startTime;  
if (ts.TotalSeconds > this.\_TerminateFreeInterval)  
\{  
Terminate(syncLockObject, 1, networkStream);  
CloseClient(tc);  
msg = string.Format("超时：监听线程池 线程ID=\{0\}", AppDomain.GetCurrentThreadId());  
OnMsg(msg);  
break;  
\}  
\}  
\}  
else  
break;  
\}  
\}  
catch (Exception)  
\{  
CloseClient(tc);  
msg = string.Format("接收错误：监听线程池 线程ID=\{0\}", AppDomain.GetCurrentThreadId());  
OnMsg(msg);  
\}  
finally  
\{  
msg = string.Format("退出：监听线程池 线程ID=\{0\}", AppDomain.GetCurrentThreadId());  
OnMsg(msg);  
\}  
  
  
  
\}

/// <summary>  
/// 中断  
/// </summary>  
/// <param name="SequenceId"></param>  
public void Terminate(object syncLockObject,uint SequenceId, NetworkStream stream)  
\{  
MessageHeader terminate = new MessageHeader(MessageHeader.Length, SGIP\_Command\_Id.SGIP\_UNBIND, SequenceId);  
this.WriteToStreamWithLock(syncLockObject,terminate.ToBytes(), stream);  
\}

/// <summary>  
/// 读取流  
/// </summary>  
/// <param name="Length"></param>  
/// <param name="Stream"></param>  
/// <returns></returns>  
private byte\[\] ReadFromStreamWithLock(object syncLockObject,int Length, NetworkStream Stream)  
\{  
try  
\{  
lock (syncLockObject)  
\{  
return Util.ReadFromStream(Length, Stream);  
\}  
\}  
catch (Exception)\{\}  
return null;  
\}

/// <summary>  
/// 写入流  
/// </summary>  
/// <param name="data"></param>  
/// <param name="Stream"></param>  
private void WriteToStreamWithLock(object syncLockObject, byte\[\] data, NetworkStream Stream)  
\{  
try  
\{  
lock (syncLockObject)  
\{  
Util.WriteToStream(data, Stream);  
\}  
\}  
catch (Exception)\{\}  
\}

private void CloseClient(TcpClient tc)  
\{  
try  
\{  
try  
\{  
tc.Client.Shutdown(SocketShutdown.Both);  
\}  
catch  
\{  
\}  
\}  
finally  
\{  
tc.Close();  
\}  
\}

private string GetSocketIP(TcpClient tc)  
\{  
try  
\{  
IPEndPoint remoteEndPoint = (IPEndPoint)tc.Client.RemoteEndPoint;  
return (remoteEndPoint.Address.ToString() + ":" + remoteEndPoint.Port.ToString());  
\}  
catch  
\{  
return "";  
\}  
\}

private BaseSortedList<string, ClientQueue> ClientInfo  
\{  
get  
\{  
return this.m\_ClientInfo;  
\}  
\}

/// <summary>  
/// 发送SGIP\_DELIVER\_RESP  
/// </summary>  
/// <param name="Result"></param>  
/// <param name="SrcNodeSequence"></param>  
/// <param name="DateSequence"></param>  
/// <param name="SequenceId"></param>  
/// <param name="soc"></param>  
public void DeliverResp(uint Result, uint SrcNodeSequence, uint DateSequence, uint SequenceId, TcpClient tc)  
\{  
SGIP\_DELIVER\_RESP deliverResp = new SGIP\_DELIVER\_RESP(Result, "", SrcNodeSequence, DateSequence, SequenceId);  
this.SendMSG(deliverResp.ToBytes(), tc);  
\}

/// <summary>  
/// 发送SGIP\_Report\_Resp  
/// </summary>  
/// <param name="Result"></param>  
/// <param name="SrcNodeSequence"></param>  
/// <param name="DateSequence"></param>  
/// <param name="SequenceId"></param>  
/// <param name="soc"></param>  
public void ReportResp(uint Result, uint SrcNodeSequence, uint DateSequence, uint SequenceId, TcpClient tc)  
\{  
SGIP\_Report\_Resp reportResp = new SGIP\_Report\_Resp(Result, "", SrcNodeSequence, DateSequence, SequenceId);  
this.SendMSG(reportResp.ToBytes(), tc);  
\}

/// <summary>  
/// 发送SGIP\_Unbind\_Resp  
/// </summary>  
/// <param name="SrcNodeSequence"></param>  
/// <param name="DateSequence"></param>  
/// <param name="SequenceId"></param>  
/// <param name="soc"></param>  
public void UnbindResp(uint SrcNodeSequence, uint DateSequence, uint SequenceId, TcpClient tc)  
\{  
SGIP\_Unbind\_Resp unbindResp = new SGIP\_Unbind\_Resp(SrcNodeSequence, DateSequence, SequenceId);  
this.SendMSG(unbindResp.ToBytes(), tc);  
CloseClient(tc);  
\}

public delegate void NetEventDelegate(byte\[\] bs, int recvCount, TcpClient tc);  
\}

//------------------------------------------------------------------------------

//文件SGIPBase.cs

//------------------------------------------------------------------------------

using System;  
using System.Collections.Generic;  
using System.Text;  
using System.Threading;  
using System.Net.Sockets;  
using System.Collections;  
namespace AsiaINFO.SMS.SGIP  
\{  
public class SGIPBase  
\{  
public delegate void MsgEventDelegate(string msg);  
/// <summary>  
/// 线程状态通知  
/// </summary>  
/// <param name="sender">线程</param>  
/// <param name="state">线程状态</param>  
public delegate void ThreadStateDelegate(object sender, ThreadState state);

/// <summary>  
/// 构造  
/// </summary>  
/// <param name="queue">接收数据队列</param>  
/// <param name="syncEvents">接口信号：检查是否需要退出线程，接口新数据到达（通知）</param>  
public SGIPBase(Queue<byte\[\]> queue, SyncEvents syncEvents)  
\{  
if (queue == null || syncEvents == null)  
throw new Exception("参数不能为空！");  
\_receiveQueue = queue;  
\_syncEvents = syncEvents;  
\}

\#region public property

/// <summary>  
/// 监听或连接状态  
/// </summary>  
public bool IsConnected  
\{  
get  
\{  
lock (\_syncIsConnectedObject)  
\{  
return this.\_IsConnected;  
\}  
\}  
set  
\{  
lock (\_syncIsConnectedObject)  
\{  
this.\_IsConnected = value;  
\}  
\}  
\}

\#endregion

\#region protected field

protected Queue<byte\[\]> \_receiveQueue;//接收队列  
protected SyncEvents \_syncEvents;//信号  
protected Thread \_thread;  
private object \_syncIsConnectedObject = new object();  
private bool \_IsConnected = false; //监听或连接状态  
\#endregion

\#region public event

/// <summary>  
/// 信息事件  
/// </summary>  
public event MsgEventDelegate MsgEvent;  
/// <summary>  
/// 错误事件  
/// </summary>  
public event MsgEventDelegate ErrorEvent;

/// <summary>  
/// 退出事件  
/// </summary>  
public event ThreadStateDelegate ThreadStateEvent;

/// <summary>  
/// 信息通知  
/// </summary>  
protected void OnMsg(string msg)  
\{  
if (MsgEvent != null)  
\{  
MsgEvent(msg);  
\}  
\}

/// <summary>  
/// 错误通知  
/// </summary>  
/// <param name="type"></param>  
/// <param name="err"></param>  
protected void OnError(string err)  
\{  
if (ErrorEvent != null)  
\{  
ErrorEvent(err);  
\}  
\}  
/// <summary>  
/// 退出  
/// </summary>  
protected void OnThreadState(ThreadState state)  
\{  
if (ThreadStateEvent != null)  
\{  
ThreadStateEvent(this, state);  
\}  
\}

\#endregion

\#region public method

public void StartRun()  
\{

try  
\{  
if (this.\_thread == null)  
\{  
this.\_thread = new Thread(new ThreadStart(this.Run));  
\}

if (this.\_thread.ThreadState == ThreadState.Unstarted)  
\{  
OnThreadState(ThreadState.Running);  
this.\_thread.Start();  
\}  
else if (this.\_thread.ThreadState == ThreadState.Suspended)  
\{  
OnThreadState(ThreadState.Running);  
this.\_thread.Resume();  
\}  
else if (this.\_thread.ThreadState == ThreadState.Stopped)  
\{  
OnThreadState(ThreadState.Running);  
this.\_thread = null;  
this.\_thread = new Thread(new ThreadStart(this.Run));  
this.\_thread.Start();  
\}

\}  
catch (Exception ex)  
\{  
OnError("SGIP启动错误：" + ex.Message);  
\}  
\}

/// <summary>  
/// 暂停线程  
/// </summary>  
public void Suspend()  
\{  
try  
\{  
if (this.\_thread != null && \_thread.ThreadState != ThreadState.Stopped && \_thread.ThreadState != ThreadState.Suspended)  
\{  
OnThreadState(ThreadState.Suspended);  
this.\_thread.Suspend();  
\}  
\}  
catch (Exception) \{ \}  
\}

/// <summary>  
/// 是否已经停止  
/// </summary>  
/// <returns></returns>  
public bool IsStop()  
\{  
if (\_thread == null || \_thread.ThreadState == ThreadState.Stopped || \_thread.ThreadState == ThreadState.Aborted || \_thread.ThreadState == ThreadState.AbortRequested)  
return true;  
return false;  
\}

/// <summary>  
/// 立刻停止  
/// </summary>  
/// <returns></returns>  
public void StopImmediately()  
\{  
try  
\{  
if (\_thread != null)  
\_thread.Abort();  
\}  
catch (ThreadAbortException) \{ \}  
catch (Exception) \{ \}  
finally  
\{  
OnThreadState(ThreadState.Stopped);  
\}

/// <summary>  
/// 停止接收数据  
/// </summary>  
public void StopReceive()  
\{  
\_syncEvents.ExitThreadEvent.Set();  
\}

\#endregion

\#region protected method

protected virtual void Run()  
\{

\#endregion  
\}  
\}

//------------------------------------------------------------------------------

//文件SGIPMessages.cs

//------------------------------------------------------------------------------

using System;  
using System.Text;  
using System.Security.Cryptography;

namespace AsiaINFO.SMS.SGIP  
\{  
//SGIP 消息定义  
public enum SGIP\_Command\_Id : uint  
\{  
SGIP\_BIND = 0x1,  
SGIP\_BIND\_RESP = 0x80000001,  
SGIP\_UNBIND = 0x2,  
SGIP\_UNBIND\_RESP = 0x80000002,  
SGIP\_SUBMIT = 0x3,  
SGIP\_SUBMIT\_RESP = 0x80000003,  
SGIP\_DELIVER = 0x4,  
SGIP\_DELIVER\_RESP = 0x80000004,  
SGIP\_REPORT = 0x5,  
SGIP\_REPORT\_RESP = 0x80000005,  
//SGIP\_ADDSP = 0x6,  
//SGIP\_ADDSP\_RESP = 0x80000006,  
//SGIP\_MODIFYSP = 0x7,  
//SGIP\_MODIFYSP\_RESP = 0x80000007,  
//SGIP\_DELETESP = 0x8,  
//SGIP\_DELETESP\_RESP = 0x80000008,  
//SGIP\_QUERYROUTE = 0x9,  
//SGIP\_QUERYROUTE\_RESP = 0x80000009,  
//SGIP\_ADDTELESEG = 0xa,  
//SGIP\_ADDTELESEG\_RESP = 0x8000000a,  
//SGIP\_MODIFYTELESEG = 0xb,  
//SGIP\_MODIFYTELESEG\_RESP = 0x8000000b,  
//SGIP\_DELETETELESEG = 0xc,  
//SGIP\_DELETETELESEG\_RESP = 0x8000000c,  
//SGIP\_ADDSMG = 0xd,  
//SGIP\_ADDSMG\_RESP = 0x8000000d,  
//SGIP\_MODIFYSMG = 0xe,  
//SGIP\_MODIFYSMG\_RESP = 0x0000000e,  
//SGIP\_DELETESMG = 0xf,  
//SGIP\_DELETESMG\_RESP = 0x8000000f,  
//SGIP\_CHECKUSER = 0x10,  
//SGIP\_CHECKUSER\_RESP = 0x80000010,  
//SGIP\_USERRPT = 0x11,  
//SGIP\_USERRPT\_RESP = 0x80000011,  
//SGIP\_TRACE = 0x1000,  
//SGIP\_TRACE\_RESP = 0x80001000,  
\}

/// <summary>  
/// 消息头  
/// </summary>  
public class MessageHeader  
\{  
public const int Length = 4 + 4 + 4 + 4 + 4;

/// <summary>  
/// 获取命令类型  
/// </summary>  
public SGIP\_Command\_Id Command\_Id  
\{  
get  
\{  
return this.\_Command\_Id;  
\}  
\}

/// <summary>  
/// 获取序列号  
/// </summary>  
public uint Sequence\_Id  
\{  
get  
\{  
return this.\_Sequence\_Id;  
\}  
\}

/// <summary>  
/// 获取原节点  
/// </summary>  
public uint SrcNodeSequence  
\{  
get \{ return \_SrcNodeSequence; \}  
\}

/// <summary>  
/// 获取命令产生的日期和时间  
/// </summary>  
public uint DateSequence  
\{  
get \{ return \_DateSequence; \}  
\}

/// <summary>  
/// 获取总长度  
/// </summary>  
public uint Total\_Length  
\{  
get  
\{  
return this.\_Total\_Length;  
\}  
\}

private uint \_Total\_Length; // 4 Unsigned Integer 消息总长度(含消息头及消息体)  
private SGIP\_Command\_Id \_Command\_Id; // 4 Unsigned Integer 命令或响应类型  
private uint \_SrcNodeSequence = 3057199999; //4 Unsigned Integer 源节点的编号  
private uint \_DateSequence = 0; //4 Unsigned Integer 格式为十进制的mmddhhmmss  
private uint \_Sequence\_Id; // 4 Unsigned Integer 消息流水号,顺序累加,步长为1,循环使用(一对请求和应答消息的流水号必须相同)

public MessageHeader  
(  
uint Total\_Length  
, SGIP\_Command\_Id Command\_Id  
, uint Sequence\_Id  
) //发送前  
\{  
this.\_Total\_Length = Total\_Length;  
this.\_Command\_Id = Command\_Id;  
this.\_SrcNodeSequence = SGIPServer.\_SrcNodeSequence;  
this.\_DateSequence = uint.Parse(Util.Get\_MMDDHHMMSS\_String(DateTime.Now));  
this.\_Sequence\_Id = Sequence\_Id;  
\}

public MessageHeader  
(  
uint Total\_Length  
, SGIP\_Command\_Id Command\_Id  
, uint SrcNodeSequence  
, uint DateSequence  
, uint Sequence\_Id  
) //发送前  
\{  
this.\_Total\_Length = Total\_Length;  
this.\_Command\_Id = Command\_Id;  
this.\_SrcNodeSequence = SrcNodeSequence;  
this.\_DateSequence = DateSequence;  
this.\_Sequence\_Id = Sequence\_Id;  
\}

public MessageHeader(byte\[\] bytes)  
\{  
int i = 0;  
byte\[\] buffer = new byte\[4\];  
Buffer.BlockCopy(bytes, i, buffer, 0, buffer.Length);  
Array.Reverse(buffer);  
this.\_Total\_Length = BitConverter.ToUInt32(buffer, 0);

i += 4;  
Buffer.BlockCopy(bytes, 4, buffer, 0, buffer.Length);  
Array.Reverse(buffer);  
this.\_Command\_Id = (SGIP\_Command\_Id)BitConverter.ToUInt32(buffer, 0);

i += 4;  
Buffer.BlockCopy(bytes, i, buffer, 0, buffer.Length);  
Array.Reverse(buffer);  
this.\_SrcNodeSequence = BitConverter.ToUInt32(buffer, 0);

i += 4;  
Buffer.BlockCopy(bytes, i, buffer, 0, buffer.Length);  
Array.Reverse(buffer);  
this.\_DateSequence = BitConverter.ToUInt32(buffer, 0);

i += 4;  
Buffer.BlockCopy(bytes, i, buffer, 0, buffer.Length);  
Array.Reverse(buffer);  
this.\_Sequence\_Id = BitConverter.ToUInt32(buffer, 0);

public byte\[\] ToBytes()  
\{  
int i = 0;  
byte\[\] bytes = new byte\[MessageHeader.Length\];

byte\[\] buffer = BitConverter.GetBytes(this.\_Total\_Length);  
Array.Reverse(buffer);  
Buffer.BlockCopy(buffer, 0, bytes, i, 4);

i += 4;  
buffer = BitConverter.GetBytes((uint)this.\_Command\_Id);  
Array.Reverse(buffer);  
Buffer.BlockCopy(buffer, 0, bytes, i, 4);  
i += 4;

buffer = BitConverter.GetBytes(this.\_SrcNodeSequence);  
Array.Reverse(buffer);  
Buffer.BlockCopy(buffer, 0, bytes, i, 4);

i += 4;  
buffer = BitConverter.GetBytes(this.\_DateSequence);  
Array.Reverse(buffer);  
Buffer.BlockCopy(buffer, 0, bytes, i, 4);

i += 4;  
buffer = BitConverter.GetBytes(this.\_Sequence\_Id);  
Array.Reverse(buffer);  
Buffer.BlockCopy(buffer, 0, bytes, i, 4);

return bytes;  
\}  
public override string ToString()  
\{  
return string.Format("MessageHeader: tCommand\_Id=\{0\} tSequence\_Id=\{1\} tTotal\_Length=\{2\}"  
, this.\_Command\_Id  
, this.\_Sequence\_Id  
, this.\_Total\_Length  
);

public class SGIP\_Bind // 双向  
\{  
public const int BodyLength = 1 + 16 + 16 + 8;

private uint \_LoginType; // 1 Unsigned Integer 登录类型。  
private string \_LoginName; // 16 Octet String 服务器端给客户端分配的登录名  
private string \_LoginPassword; // 16 Octet String 服务器端和Login Name对应的密码  
private string \_Reserve; // 8 Octet String 保留，扩展用

private MessageHeader \_Header;

public SGIP\_Bind  
(  
uint LoginType  
, string LoginName  
, string LoginPassword  
, uint Sequence\_Id  
)  
\{  
this.\_Header = new MessageHeader(MessageHeader.Length + BodyLength, SGIP\_Command\_Id.SGIP\_BIND, Sequence\_Id);

this.\_LoginType = LoginType;  
this.\_LoginName = LoginName;  
this.\_LoginPassword = LoginPassword;  
this.\_Reserve = "";  
\}

//public SGIP\_Bind  
// (  
// uint LoginType  
// , string LoginName  
// , string LoginPassword  
// , uint SrcNodeSequence  
// , uint DateSequence  
// , uint Sequence\_Id  
// )  
//\{  
// this.\_Header = new MessageHeader(MessageHeader.Length + BodyLength, SGIP\_Command\_Id.SGIP\_BIND,SrcNodeSequence,DateSequence, Sequence\_Id);

// this.\_LoginType = LoginType;  
// this.\_LoginName = LoginName;  
// this.\_LoginPassword = LoginPassword;  
// this.\_Reserve = "";  
//\}

public SGIP\_Bind(byte\[\] bytes)  
\{  
int i = 0;  
string s = null;  
byte\[\] buffer = new byte\[MessageHeader.Length\];  
Buffer.BlockCopy(bytes, 0, buffer, 0, MessageHeader.Length);  
this.\_Header = new MessageHeader(buffer);

//LoginType 1  
i += MessageHeader.Length;  
this.\_LoginType = (uint)bytes\[i++\];

//LoginName 16  
buffer = new byte\[16\];  
Buffer.BlockCopy(bytes, i, buffer, 0, buffer.Length);  
s = Encoding.ASCII.GetString(buffer).Trim();  
if (s.IndexOf('/0') > 0)  
s = s.Substring(0, s.IndexOf('/0'));  
this.\_LoginName = s;

//LoginPassword 16  
i += 16;  
buffer = new byte\[16\];  
Buffer.BlockCopy(bytes, i, buffer, 0, buffer.Length);  
s = Encoding.ASCII.GetString(buffer).Trim();  
if (s.IndexOf('/0') > 0)  
s = s.Substring(0, s.IndexOf('/0'));  
this.\_LoginPassword = s;

//LoginPassword 16  
i += 16;  
buffer = new byte\[8\];  
Buffer.BlockCopy(bytes, i, buffer, 0, buffer.Length);  
s = Encoding.ASCII.GetString(buffer).Trim();  
if (s.IndexOf('/0') > 0)  
s = s.Substring(0, s.IndexOf('/0'));  
this.\_Reserve = s;  
\}

public byte\[\] ToBytes()  
\{  
int i = 0;  
byte\[\] bytes = new byte\[MessageHeader.Length + BodyLength\];

//header 20  
byte\[\] buffer = this.\_Header.ToBytes();  
Buffer.BlockCopy(buffer, 0, bytes, i, buffer.Length);

//LoginType 1  
i += MessageHeader.Length;  
bytes\[i++\] = (byte)this.\_LoginType;

//LoginName 16  
buffer = Encoding.ASCII.GetBytes(this.\_LoginName);  
Buffer.BlockCopy(buffer, 0, bytes, i, buffer.Length);

//LoginPassword 16  
i += 16;  
buffer = Encoding.ASCII.GetBytes(this.\_LoginPassword);  
Buffer.BlockCopy(buffer, 0, bytes, i, buffer.Length);

//Reserve 8  
i += 16;  
buffer = Encoding.ASCII.GetBytes(this.\_Reserve);  
Buffer.BlockCopy(buffer, 0, bytes, i, buffer.Length);  
return (bytes);  
\}

public override string ToString()  
\{  
return string.Format("Header=\{0\} LoginType=\{1\} LoginName=\{2\} LoginPassword=\{3\} Reserve=\{4\}"  
, this.\_Header.ToString()  
, this.\_LoginType  
, this.\_LoginName  
, this.\_LoginPassword  
, this.\_Reserve);  
\}

/// <summary>  
/// 获取 登录类型  
/// </summary>  
public uint LoginType  
\{  
get \{ return \_LoginType; \}  
\}

/// <summary>  
/// 获取登陆用户名  
/// </summary>  
public string LoginName  
\{  
get \{ return \_LoginName; \}  
\}

/// <summary>  
/// 获取登陆密码  
/// </summary>  
public string LoginPassword  
\{  
get \{ return \_LoginPassword; \}  
\}

/// <summary>  
/// 获取保留信息  
/// </summary>  
public string Reserve  
\{  
get \{ return \_Reserve; \}  
\}

public MessageHeader Header  
\{  
get  
\{  
return this.\_Header;  
\}  
\}

public class SGIP\_Bind\_Resp // 双向  
\{  
private MessageHeader \_Header;  
public const int BodyLength = 1 + 8;

private uint \_Result; // 1 Unsigned Integer 执行命令是否成功 0：执行成功 其它：错误码  
private string \_Reserve; // 8 Octet String 保留，扩展用

public SGIP\_Bind\_Resp  
(  
uint Result  
, uint SrcNodeSequence  
, uint DateSequence  
, uint Sequence\_Id  
)  
\{  
this.\_Header = new MessageHeader(MessageHeader.Length + BodyLength, SGIP\_Command\_Id.SGIP\_BIND\_RESP, SrcNodeSequence, DateSequence, Sequence\_Id);

this.\_Result = Result;  
this.\_Reserve = "null";  
\}

public SGIP\_Bind\_Resp(byte\[\] bytes)  
\{  
//header 20  
int i = 0;  
string s = null;  
byte\[\] buffer = new byte\[MessageHeader.Length\];  
Buffer.BlockCopy(bytes, 0, buffer, 0, buffer.Length);  
this.\_Header = new MessageHeader(buffer);

//Result 1  
i += MessageHeader.Length;  
this.\_Result = (uint)bytes\[i++\];

//Result 8  
buffer = new byte\[8\];  
Buffer.BlockCopy(bytes, i, buffer, 0, buffer.Length);  
s = Encoding.ASCII.GetString(buffer).Trim();  
if (s.IndexOf('/0') > 0)  
s = s.Substring(0, s.IndexOf('/0'));  
this.\_Reserve = s;

public byte\[\] ToBytes()  
\{  
int i = 0;  
byte\[\] bytes = new byte\[MessageHeader.Length + BodyLength\];

//header 20  
byte\[\] buffer = this.\_Header.ToBytes();  
Buffer.BlockCopy(buffer, 0, bytes, i, buffer.Length);

//Result 1  
i += MessageHeader.Length;  
bytes\[i++\] = (byte)this.\_Result;

//Result 8  
buffer = Encoding.ASCII.GetBytes(this.\_Reserve);  
Buffer.BlockCopy(buffer, 0, bytes, i, buffer.Length);  
return (bytes);

public override string ToString()  
\{  
return string.Format("Header=\{0\} Result=\{1\} Reserve=\{2\}"  
, this.\_Header.ToString()  
, this.\_Result  
, this.\_Reserve);

/// <summary>  
/// 获取结果  
/// </summary>  
public uint Result  
\{  
get \{ return \_Result; \}  
\}

/// <summary>  
/// 获取保留信息  
/// </summary>  
public string Reserve  
\{  
get \{ return \_Reserve; \}  
\}

public MessageHeader Header  
\{  
get  
\{  
return this.\_Header;  
\}  
\}

public class SGIP\_SUBMIT  
\{  
private int \_BodyLength;

public const int FixedBodyLength = 21 //SPNumber  
\+ 21 //ChargeNumber  
\+ 1 //UserCount  
\+21 //UserNumber  
\+ 5 //CorpId  
\+ 10 //ServiceType  
\+ 1 //FeeType  
\+ 6 //FeeValue  
\+ 6 //GivenValue  
\+ 1 //AgentFlag  
\+ 1 //MorelatetoMTFlag  
\+ 1 //Priority  
\+ 16 //ExpireTime  
\+ 16 //ScheduleTime  
\+ 1 //ReportFlag  
\+ 1 //TP\_pid  
\+ 1 //TP\_udhi  
\+ 1 //MessageCoding  
\+ 1 //MessageType  
\+ 4 //MessageLength  
//+ Message Length //MessageContent  
\+ 8 ; //Reserve

private string \_SPNumber; //21 Octet String SP的接入号码  
private string \_ChargeNumber; //21 Octet String 付费号码，手机号码前加“86”国别标志  
private uint \_UserCount; //1 Unsigned Integer 接收短消息的手机数量，取值范围1至100  
private string \_UserNumber; //21 Octet String 接收该短消息的手机号 手机号码前加“86”国别标志  
private string \_CorpId; //5 Octet String 企业代码，取值范围0-99999  
private string \_ServiceType; //10 Octet String 业务代码，由SP定义  
private uint \_FeeType; //1 Unsigned Integer 计费类型  
private string \_FeeValue; //6 Octet String 取值范围0-99999，该条短消息的收费值，单位为分，由SP定义对于包月制收费的用户，该值为月租费的值  
private string \_GivenValue; //6 Octet String 赠送用户的话费，单位为分  
private uint \_AgentFlag; //1 Unsigned Integer 代收费标志，0：应收；1：实收  
private uint \_MorelatetoMTFlag; //1 Unsigned Integer 引起MT消息的原因  
private uint \_Priority; //1 Unsigned Integer 优先级0-9从低到高，默认为0  
private string \_ExpireTime; //16 Octet String 短消息寿命的终止时间，如果为空，表示使用短消息中心的缺省值  
private string \_ScheduleTime; //16 Octet String 短消息定时发送的时间，如果为空，表示立刻发送该短消息  
private uint \_ReportFlag; //1 Unsigned Integer 状态报告标记  
private uint \_TP\_pid; //1 Unsigned Integer  
private uint \_TP\_udhi; //1 Unsigned Integer  
private uint \_MessageCoding; //1 Unsigned Integer 短消息的编码格式  
private uint \_MessageType; //1 Unsigned Integer 信息类型：0-短消息信息 其它：待定  
private uint \_MessageLength; //4 Unsigned Integer 短消息的长度  
private string \_MessageContent; // MessageLength Octet String 信息内容。  
private string \_LinkID;  
  
private MessageHeader \_Header;  
private uint \_Sequence\_Id;

public SGIP\_SUBMIT(uint Sequence\_Id)  
\{  
this.\_Sequence\_Id = Sequence\_Id;  
\}

private byte\[\] \_Msg\_Content\_Bytes;  
private void SetHeader()  
\{  
//byte\[\] buf;  
switch (this.\_MessageCoding)  
\{  
case 8:  
\_Msg\_Content\_Bytes = Encoding.BigEndianUnicode.GetBytes(this.\_MessageContent);  
break;  
case 15: //gb2312  
\_Msg\_Content\_Bytes = Encoding.GetEncoding("gb2312").GetBytes(this.\_MessageContent);  
break;  
case 0: //ascii  
case 3: //短信写卡操作  
case 4: //二进制信息  
default:  
\_Msg\_Content\_Bytes = Encoding.ASCII.GetBytes(this.\_MessageContent);  
break;  
\}

this.\_MessageLength = (uint)\_Msg\_Content\_Bytes.Length;  
this.\_BodyLength = (int)(FixedBodyLength + this.\_MessageLength);  
this.\_Header = new MessageHeader((uint)(MessageHeader.Length + this.\_BodyLength), SGIP\_Command\_Id.SGIP\_SUBMIT, this.\_Sequence\_Id);  
\}

public byte\[\] ToBytes()  
\{  
//Msg\_Length Msg\_Content  
int i = 0;  
byte\[\] bytes = new byte\[MessageHeader.Length + this.\_BodyLength\];  
byte\[\] buffer = this.\_Header.ToBytes();  
Buffer.BlockCopy(buffer, 0, bytes, 0, buffer.Length);  
i += MessageHeader.Length;

//SPNumber //21  
buffer = Encoding.ASCII.GetBytes(this.\_SPNumber);  
Buffer.BlockCopy(buffer, 0, bytes, i, buffer.Length);

//ChargeNumber //21  
i += 21;  
buffer = Encoding.ASCII.GetBytes(this.\_ChargeNumber);  
Buffer.BlockCopy(buffer, 0, bytes, i, buffer.Length);

//UserCount //1  
i += 21;  
bytes\[i++\] = (byte)this.\_UserCount;

//UserNumber //21  
buffer = Encoding.ASCII.GetBytes(this.\_UserNumber);  
Buffer.BlockCopy(buffer, 0, bytes, i, buffer.Length);

//CorpId //5  
i += 21;  
buffer = Encoding.ASCII.GetBytes(this.\_CorpId);  
Buffer.BlockCopy(buffer, 0, bytes, i, buffer.Length);

//ServiceType; //10  
i += 5;  
buffer = Encoding.ASCII.GetBytes(this.\_ServiceType);  
Buffer.BlockCopy(buffer, 0, bytes, i, buffer.Length);

//FeeType //1  
i += 10;  
bytes\[i++\] = (byte)this.\_FeeType;

//FeeValue //6  
buffer = Encoding.ASCII.GetBytes(this.\_FeeValue);  
Buffer.BlockCopy(buffer, 0, bytes, i, buffer.Length);

//GivenValue //6  
i += 6;  
buffer = Encoding.ASCII.GetBytes(this.\_GivenValue);  
Buffer.BlockCopy(buffer, 0, bytes, i, buffer.Length);

i += 6;  
bytes\[i++\] = (byte)this.\_AgentFlag;  
bytes\[i++\] = (byte)this.\_MorelatetoMTFlag;  
bytes\[i++\] = (byte)this.\_Priority;

//ExpireTime; //16  
buffer = Encoding.ASCII.GetBytes(this.\_ExpireTime);  
Buffer.BlockCopy(buffer, 0, bytes, i, buffer.Length);

//ScheduleTime; //16  
i += 16;  
buffer = Encoding.ASCII.GetBytes(this.\_ScheduleTime);  
Buffer.BlockCopy(buffer, 0, bytes, i, buffer.Length);

i += 16;  
bytes\[i++\] = (byte)this.\_ReportFlag;  
bytes\[i++\] = (byte)this.\_TP\_pid;  
bytes\[i++\] = (byte)this.\_TP\_udhi;  
bytes\[i++\] = (byte)this.\_MessageCoding;  
bytes\[i++\] = (byte)this.\_MessageType;

//MessageLength //4  
buffer = BitConverter.GetBytes(this.\_MessageLength);  
Array.Reverse(buffer);  
Buffer.BlockCopy(buffer, 0, bytes, i, buffer.Length);

//Msg\_Content  
i += 4;  
Buffer.BlockCopy(this.\_Msg\_Content\_Bytes, 0, bytes, i, this.\_Msg\_Content\_Bytes.Length);

//LinkID  
i += (int)this.\_MessageLength;  
buffer = Encoding.ASCII.GetBytes(this.\_LinkID);  
Buffer.BlockCopy(buffer, 0, bytes, i, buffer.Length);  
return bytes;  
\}

public MessageHeader Header  
\{  
get  
\{  
return \_Header;  
\}  
set  
\{  
\_Header = value;  
\}  
\}

/// <summary>  
/// SP的接入号码  
/// </summary>  
public string SPNumber  
\{  
get \{ return \_SPNumber; \}  
set \{ \_SPNumber = value; \}  
\}  
/// <summary>  
/// 付费号码,设置时自动在号码前加“86”  
/// </summary>  
public string ChargeNumber  
\{  
get \{ return \_ChargeNumber; \}  
set \{ \_ChargeNumber = value; \}  
\}  
/// <summary>  
/// 接收短消息的手机数量 ，必须为1  
/// </summary>  
public uint UserCount  
\{  
get \{ return \_UserCount; \}  
set \{ \_UserCount = value; \}  
\}  
/// <summary>  
/// 接收该短消息的手机号,设置时自动在号码前加“86”  
/// </summary>  
public string UserNumber  
\{  
get \{ return \_UserNumber; \}  
set \{  
  
\_UserNumber =value;  
\}  
\}  
/// <summary>  
/// 企业代码  
/// </summary>  
public string CorpId  
\{  
get \{ return \_CorpId; \}  
set \{ \_CorpId = value; \}  
\}  
/// <summary>  
/// 业务代码，由SP定义  
/// </summary>  
public string ServiceType  
\{  
get \{ return \_ServiceType; \}  
set \{ \_ServiceType = value; \}  
\}  
/// <summary>  
/// 计费类型  
/// </summary>  
public uint FeeType  
\{  
get \{ return \_FeeType; \}  
set \{ \_FeeType = value; \}  
\}  
/// <summary>  
/// 该条短消息的收费值，单位为分  
/// </summary>  
public string FeeValue  
\{  
get \{ return \_FeeValue; \}  
set \{ \_FeeValue = value; \}  
\}

public string GivenValue  
\{  
get \{ return \_GivenValue; \}  
set \{ \_GivenValue = value; \}  
\}  
/// <summary>  
/// 代收费标志，0：应收；1：实收  
/// </summary>  
public uint AgentFlag  
\{  
get \{ return \_AgentFlag; \}  
set \{ \_AgentFlag = value; \}  
\}  
/// <summary>  
/// 引起MT消息的原因  
/// </summary>  
public uint MorelatetoMTFlag  
\{  
get \{ return \_MorelatetoMTFlag; \}  
set \{ \_MorelatetoMTFlag = value; \}  
\}  
/// <summary>  
/// 优先级  
/// </summary>  
public uint Priority  
\{  
get \{ return \_Priority; \}  
set \{ \_Priority = value; \}  
\}

/// <summary>  
/// 短消息寿命的终止时间  
/// </summary>  
public string ExpireTime  
\{  
get \{ return \_ExpireTime; \}  
set \{ \_ExpireTime = value; \}  
\}

/// <summary>  
/// 短消息定时发送的时间  
/// </summary>  
public string ScheduleTime  
\{  
get \{ return \_ScheduleTime; \}  
set \{ \_ScheduleTime = value; \}  
\}

/// <summary>  
/// 状态报告标记  
/// </summary>  
public uint ReportFlag  
\{  
get \{ return \_ReportFlag; \}  
set \{ \_ReportFlag = value; \}  
\}

public uint TP\_pid  
\{  
get \{ return \_TP\_pid; \}  
set \{ \_TP\_pid = value; \}  
\}

public uint TP\_udhi  
\{  
get \{ return \_TP\_udhi; \}  
set \{ \_TP\_udhi = value; \}  
\}

/// <summary>  
/// 短消息的编码格式  
/// </summary>  
public uint MessageCoding  
\{  
get \{ return \_MessageCoding; \}  
set \{  
\_MessageCoding = value;  
if (this.\_MessageContent != null)  
\{  
this.SetHeader();  
\}  
\}  
\}

/// <summary>  
/// 信息类型：0-短消息信息 其它：待定  
/// </summary>  
public uint MessageType  
\{  
get \{ return \_MessageType; \}  
set \{ \_MessageType = value; \}  
\}

/// <summary>  
/// 短消息的长度  
/// </summary>  
public uint MessageLength  
\{  
get \{ return \_MessageLength; \}  
set \{ \_MessageLength = value; \}  
\}  
/// <summary>  
/// 短消息的内容  
/// </summary>  
public string MessageContent  
\{  
get  
\{  
return this.\_MessageContent;  
\}  
set  
\{  
this.\_MessageContent = value;  
this.SetHeader();  
\}  
\}

public string LinkID  
\{  
get \{ return \_LinkID; \}  
set \{ \_LinkID = value; \}  
\}

public override string ToString()  
\{  
return "\[/r/n"  
\+ this.\_Header.ToString() + "/r/n"  
\+ string.Format  
(  
"/tMessageBody:"  
\+ "/r/n/t/tSPNumber: \{0\}"  
\+ "/r/n/t/tChargeNumber: \{1\}"  
\+ "/r/n/t/tUserCount: \{2\}"  
\+ "/r/n/t/tUserNumber: \{3\}"  
\+ "/r/n/t/tCorpId: \{4\}"  
\+ "/r/n/t/tServiceType \{5\}"  
\+ "/r/n/t/tFeeType: \{6\}"  
\+ "/r/n/t/tFeeValue: \{7\}"  
\+ "/r/n/t/tGivenValue: \{8\}"  
\+ "/r/n/t/tAgentFlag: \{9\}"  
\+ "/r/n/t/tMorelatetoMTFlag \{10\}"  
\+ "/r/n/t/tPriority: \{11\}"  
\+ "/r/n/t/tExpireTime: \{12\}"  
\+ "/r/n/t/tScheduleTime: \{13\}"  
\+ "/r/n/t/tReportFlag: \{14\}"  
\+ "/r/n/t/tTP\_pid: \{15\}"  
\+ "/r/n/t/tTP\_udhi: \{16\}"  
\+ "/r/n/t/tMessageCoding: \{17\}"  
\+ "/r/n/t/tMessageType: \{18\}"  
\+ "/r/n/t/tMessageLength: \{19\}"  
\+ "/r/n/t/tMessageContent: \{20\}"  
\+ "/r/n/t/tlinkID: \{21\}"  
\+ "/r/n/t/tSequence\_Id: \{22\}"  
, this.\_SPNumber  
, this.\_ChargeNumber  
, this.\_UserCount  
, this.\_UserNumber  
, this.\_CorpId  
, this.\_ServiceType  
, this.\_FeeType  
, this.\_FeeValue  
, this.\_GivenValue  
, this.\_AgentFlag  
, this.\_MorelatetoMTFlag  
, this.\_Priority  
, this.\_ExpireTime  
, this.\_ScheduleTime  
, this.\_ReportFlag  
, this.\_TP\_pid  
, this.\_TP\_udhi  
, this.\_MessageCoding  
, this.\_MessageType  
, this.\_MessageLength  
, this.\_MessageContent  
, this.\_LinkID  
, this.\_Sequence\_Id  
)  
\+ "/r/n\]";  
\}

public class SGIP\_SUBMIT\_RESP  
\{  
private MessageHeader \_Header;  
private uint \_Result;  
private string \_Reserve;

public const int BodyLength = 1 + 8;

public uint Result  
\{  
get  
\{  
return this.\_Result;  
\}  
\}

public string Reserve  
\{  
get  
\{  
return this.\_Reserve;  
\}  
\}

public MessageHeader Header  
\{  
get  
\{

return this.\_Header;  
\}  
\}

public SGIP\_SUBMIT\_RESP(byte\[\] bytes)  
\{  
int i = 0;  
byte\[\] buffer = new byte\[MessageHeader.Length\];  
Buffer.BlockCopy(bytes, 0, buffer, 0, buffer.Length);  
this.\_Header = new MessageHeader(buffer);

//Result  
i += MessageHeader.Length;  
this.\_Result = (uint)bytes\[i++\];

//Reserve;  
buffer = new byte\[4\];  
Buffer.BlockCopy(bytes, i, buffer, 0, buffer.Length);  
string s = Encoding.ASCII.GetString(buffer).Trim();  
if (s.IndexOf('/0') > 0)  
s = s.Substring(0, s.IndexOf('/0'));  
this.\_Reserve = s;

\}  
public override string ToString()  
\{  
return "\[/r/n"  
\+ this.\_Header.ToString() + "/r/n"  
\+ string.Format  
(  
"/tMessageBody:"  
\+ "/r/n/t/tResult: \{0\}"  
\+ "/r/n/t/tReserve: \{1\}"

, this.\_Result  
, this.\_Reserve  
)  
\+ "/r/n\]";  
\}  
\}

public class SGIP\_DELIVER  
\{

private MessageHeader \_Header;

private string \_UserNumber; //发送短消息的用户手机号，手机号码前加“86”国别标志  
private string \_SPNumber; //SP的接入号码  
private uint \_TP\_pid; // 1 Unsigned Integer GSM协议类型。详细解释请参考GSM03.40中的9.2.3.9。  
private uint \_TP\_udhi; // 1 Unsigned Integer GSM协议类型。详细解释请参考GSM03.40中的9.2.3.23,仅使用1位,右对齐。  
private uint \_MessageCoding;  
private uint \_MessageLength;  
private string \_MessageContent;  
private string \_LinkID;

public const int FixedBodyLength = 21 // UserNumber Octet String 信息标识。  
\+ 21 // SPNumber Octet String SP的接入号码  
\+ 1 // TP\_pid Unsigned Integer GSM协议类型。详细解释请参考GSM03.40中的9.2.3.9。  
\+ 1 // TP\_udhi Unsigned Integer GSM协议类型。详细解释请参考GSM03.40中的9.2.3.23,仅使用1位,右对齐。  
\+ 1 // MessageCoding Unsigned Integer  
\+ 4 // MessageLength Unsigned Integer  
//+Message Length // MessageLength Octet String 消息内容。  
\+ 8; //LinkID Octet String  
  
private int \_BodyLength;  
public int BodyLength  
\{  
get\{return this.\_BodyLength;\}  
\}

public SGIP\_DELIVER(byte\[\] bytes)  
\{  
int i = 0;  
string s = null;

byte\[\] buffer = new byte\[MessageHeader.Length\];  
Buffer.BlockCopy(bytes, 0, buffer, 0, MessageHeader.Length);  
this.\_Header = new MessageHeader(buffer);

//UserNumber 21  
i += MessageHeader.Length;  
buffer = new byte\[21\];  
Buffer.BlockCopy(bytes, i, buffer, 0, buffer.Length);  
s = Encoding.ASCII.GetString(buffer).Trim();  
if (s.IndexOf('/0') > 0)  
s = s.Substring(0, s.IndexOf('/0'));  
if (s != null && s.Length > 11 && s.Substring(0, 2) == "86")  
s = s.Substring(2, s.Length - 2);  
this.\_UserNumber = s;

//SPNumber 21  
i += 21;  
buffer = new byte\[21\];  
Buffer.BlockCopy(bytes, i, buffer, 0, buffer.Length);  
s = Encoding.ASCII.GetString(buffer).Trim();  
if (s.IndexOf('/0') > 0)  
s = s.Substring(0, s.IndexOf('/0'));  
this.\_SPNumber = s;

//  
i += 21;  
this.\_TP\_pid = (uint)bytes\[i++\];  
this.\_TP\_udhi = (uint)bytes\[i++\];  
this.\_MessageCoding = (uint)bytes\[i++\];

//MessageLength 4  
buffer = new byte\[4\];  
Buffer.BlockCopy(bytes, i, buffer, 0, buffer.Length);  
Array.Reverse(buffer);  
this.\_MessageLength = BitConverter.ToUInt32(buffer, 0);

//MessageContent  
i += 4;  
buffer = new byte\[this.\_MessageLength\];  
Buffer.BlockCopy(bytes, i, buffer, 0, buffer.Length);  
switch (this.\_MessageCoding)  
\{  
case 8:  
this.\_MessageContent = Encoding.BigEndianUnicode.GetString(buffer).Trim();  
break;  
case 15: //gb2312  
this.\_MessageContent = Encoding.GetEncoding("gb2312").GetString(buffer).Trim();  
break;  
case 0: //ascii  
case 3: //短信写卡操作  
case 4: //二进制信息  
default:  
this.\_MessageContent = Encoding.ASCII.GetString(buffer).ToString();  
break;  
\}

//Linkid 8  
i += (int)this.\_MessageLength;  
buffer = new byte\[8\];  
Buffer.BlockCopy(bytes, i, buffer, 0, buffer.Length);  
s = Encoding.ASCII.GetString(buffer).Trim();  
if(s.IndexOf('/0')>0)  
s = s.Substring(0, s.IndexOf('/0'));  
this.\_LinkID = s;

public MessageHeader Header  
\{  
get  
\{  
return this.\_Header;  
\}  
\}

public string UserNumber  
\{  
get \{ return \_UserNumber; \}  
\}

public string SPNumber  
\{  
get \{ return \_SPNumber; \}  
\}

public uint TP\_pid  
\{  
get \{ return \_TP\_pid; \}  
\}

public uint TP\_udhi  
\{  
get \{ return \_TP\_udhi; \}  
set \{ \_TP\_udhi = value; \}  
\}

public uint MessageCoding  
\{  
get \{ return \_MessageCoding; \}  
\}

public uint MessageLength  
\{  
get \{ return \_MessageLength; \}  
\}

public string MessageContent  
\{  
get \{ return \_MessageContent; \}  
\}

public string LinkID  
\{  
get \{ return \_LinkID; \}  
\}

public override string ToString()  
\{  
return "\[/r/n"  
\+ this.\_Header.ToString() + "/r/n"  
\+ string.Format  
(  
"/tMessageBody:"  
\+ "/r/n/t/tBodyLength: \{0\}"  
\+ "/r/n/t/tUserNumber: \{1\}"  
\+ "/r/n/t/tTP\_pid: \{2\}"  
\+ "/r/n/t/tTP\_udhi: \{3\}"  
\+ "/r/n/t/tMessageCoding: \{4\}"  
\+ "/r/n/t/tMessageLength: \{5\}"  
\+ "/r/n/t/tMessageContent: \{6\}"  
\+ "/r/n/t/tLinkID: \{7\}"  
, this.\_BodyLength  
, this.\_SPNumber  
, this.\_TP\_pid  
, this.\_TP\_udhi  
, this.\_MessageCoding  
, this.\_MessageLength  
, this.\_MessageContent  
, this.\_LinkID  
)  
\+ "/r/n\]";  
\}

public class SGIP\_DELIVER\_RESP  
\{  
public const int Bodylength = 1 + 8;  
private MessageHeader \_Header;

private uint \_Result;  
private string \_Reserve;

public SGIP\_DELIVER\_RESP  
(  
uint Result  
, string Reserve  
, uint SrcNodeSequence  
, uint DateSequence  
, uint Sequence\_Id  
)  
\{  
this.\_Header = new MessageHeader(MessageHeader.Length + Bodylength, SGIP\_Command\_Id.SGIP\_DELIVER\_RESP,SrcNodeSequence,DateSequence,Sequence\_Id);  
this.\_Result = Result;  
this.\_Reserve = Reserve;  
\}

public byte\[\] ToBytes()  
\{  
int i = 0;  
byte\[\] bytes = new byte\[MessageHeader.Length + Bodylength\];

byte\[\] buffer = this.\_Header.ToBytes();  
Buffer.BlockCopy(buffer, 0, bytes, 0, buffer.Length);  
i += MessageHeader.Length;

//Result 1  
bytes\[i++\] = (byte)this.\_Result;

//Reserve 8  
buffer = Encoding.ASCII.GetBytes(this.\_Reserve);  
Buffer.BlockCopy(buffer, 0, bytes, i, buffer.Length);  
return bytes;

public override string ToString()  
\{  
return this.\_Header.ToString() + "/r/n"  
\+ string.Format  
(  
"\[/r/nMessageBody:"  
\+ "/r/n/tResult: \{0\}"  
\+ "/r/n/tReserve: \{1\}"  
\+ "/r/n\]"  
, this.\_Result  
, this.\_Reserve  
);  
\}

public class SGIP\_Report  
\{  
public const int BodyLength = 12 + 1 + 21 + 1 + 1 + 8;  
private MessageHeader \_Header;

private uint \_SrcNodeSequence; //4 Unsigned Integer 源节点的编号  
private uint \_DateSequence; //4 Unsigned Integer 格式为十进制的mmddhhmmss  
private uint \_Sequence\_Id; // 4 Unsigned Integer 消息流水号,顺序累加,步长为1,循环使用(一对请求和应答消息的流水号必须相同)

private uint \_ReportType; //1 Unsigned Integer Report命令类型 0：对先前一条Submit命令的状态报告 1：对先前一条前转Deliver命令的状态报告  
private string \_UserNumber; //21 Octet String 接收短消息的手机号，手机号码前加“86”国别标志  
private uint \_State; //1 Unsigned Integer 该命令所涉及的短消息的当前执行状态 0：发送成功 1：等待发送 2：发送失败  
private uint \_ErrorCode; //1 Unsigned Integer 当State=2时为错误码值，否则为0  
private string \_Reserve; //8 Octet String保留，扩展用

public SGIP\_Report(byte\[\] bytes)  
\{  
int i = 0;  
string s = null;

byte\[\] buffer = new byte\[MessageHeader.Length\];  
Buffer.BlockCopy(bytes, 0, buffer, 0, MessageHeader.Length);  
this.\_Header = new MessageHeader(buffer);

//SrcNodeSequence 4  
i += MessageHeader.Length;  
buffer = new byte\[4\];  
Buffer.BlockCopy(bytes, i, buffer, 0, buffer.Length);  
Array.Reverse(buffer);  
this.\_SrcNodeSequence = BitConverter.ToUInt32(buffer, 0);

//DateSequence 4  
i += 4;  
buffer = new byte\[4\];  
Buffer.BlockCopy(bytes, i, buffer, 0, buffer.Length);  
Array.Reverse(buffer);  
this.\_DateSequence = BitConverter.ToUInt32(buffer, 0);

//Sequence\_Id 4  
i += 4;  
buffer = new byte\[4\];  
Buffer.BlockCopy(bytes, i, buffer, 0, buffer.Length);  
Array.Reverse(buffer);  
this.\_Sequence\_Id = BitConverter.ToUInt32(buffer, 0);

//ReportType 1  
i += 4;  
this.\_ReportType = (uint)bytes\[i++\];

//UserNumber 21  
buffer = new byte\[21\];  
Buffer.BlockCopy(bytes, i, buffer, 0, buffer.Length);  
s = Encoding.ASCII.GetString(buffer).Trim();  
if (s.IndexOf('/0') > 0)  
s = s.Substring(0, s.IndexOf('/0'));  
if (s != null && s.Length > 11 && s.Substring(0, 2) == "86")  
s = s.Substring(2, s.Length - 2);  
this.\_UserNumber = s;

//State 1  
i += 21;  
this.\_State = (uint)bytes\[i++\];  
this.\_ErrorCode = (uint)bytes\[i++\];

//Linkid 8  
buffer = new byte\[8\];  
Buffer.BlockCopy(bytes, i, buffer, 0, buffer.Length);  
s = Encoding.ASCII.GetString(buffer).Trim();  
if (s.IndexOf('/0') > 0)  
s = s.Substring(0, s.IndexOf('/0'));  
this.\_Reserve = s;  
\}

public MessageHeader Header  
\{  
get  
\{  
return this.\_Header;  
\}  
\}

/// <summary>  
/// 获取原节点  
/// </summary>  
public uint SrcNodeSequence  
\{  
get \{ return \_SrcNodeSequence; \}  
\}

/// <summary>  
/// 获取命令产生的日期和时间  
/// </summary>  
public uint DateSequence  
\{  
get \{ return \_DateSequence; \}  
\}

/// <summary>  
/// 获取序列号  
/// </summary>  
public uint Sequence\_Id  
\{  
get\{return this.\_Sequence\_Id;\}  
\}

/// <summary>  
/// Report命令类型  
/// </summary>  
public uint ReportType  
\{  
get \{ return \_ReportType; \}  
\}

/// <summary>  
/// 接收短消息的手机号，手机号码前加“86”国别标志  
/// </summary>  
public string UserNumber  
\{  
get \{ return \_UserNumber; \}  
\}

/// <summary>  
/// 该命令所涉及的短消息的当前执行状态 0：发送成功 1：等待发送 2：发送失败  
/// </summary>  
public uint State  
\{  
get \{ return \_State; \}  
\}

/// <summary>  
/// 当State=2时为错误码值，否则为0  
/// </summary>  
public uint ErrorCode  
\{  
get \{ return \_ErrorCode; \}  
\}

public string Reserve  
\{  
get \{ return \_Reserve; \}  
\}

public override string ToString()  
\{  
return string.Format  
(  
"\[/r/nMessageBody:"  
\+ "/r/n/tBodyLength: \{0\}"  
\+ "/r/n/tSrcNodeSequence: \{1\}"  
\+ "/r/n/tDateSequence: \{2\}"  
\+ "/r/n/tSequence\_Id: \{3\}"  
\+ "/r/n/tReportType: \{4\}"  
\+ "/r/n/tUserNumber: \{5\}"  
\+ "/r/n/tState \{6\}"  
\+ "/r/n/tErrorCode \{7\}"  
\+ "/r/n/tReserve \{8\}"  
\+ "/r/n\]"  
, SGIP\_Report.BodyLength  
, this.\_SrcNodeSequence  
, this.\_DateSequence  
, this.\_Sequence\_Id  
, this.\_ReportType  
, this.\_UserNumber  
, this.\_State  
, this.\_ErrorCode  
, this.\_Reserve  
);  
\}  
\}

public class SGIP\_Report\_Resp  
\{  
public const int Bodylength = 1 + 8;  
private MessageHeader \_Header;

private uint \_Result;  
private string \_Reserve;

public SGIP\_Report\_Resp  
(  
uint Result  
, string Reserve  
, uint SrcNodeSequence  
, uint DateSequence  
, uint Sequence\_Id  
)  
\{  
this.\_Header = new MessageHeader(MessageHeader.Length + Bodylength, SGIP\_Command\_Id.SGIP\_REPORT\_RESP, SrcNodeSequence, DateSequence, Sequence\_Id);  
this.\_Result = Result;  
this.\_Reserve = Reserve;  
\}

public byte\[\] ToBytes()  
\{  
int i = 0;  
byte\[\] bytes = new byte\[MessageHeader.Length + Bodylength\];

byte\[\] buffer = this.\_Header.ToBytes();  
Buffer.BlockCopy(buffer, 0, bytes, 0, buffer.Length);  
i += MessageHeader.Length;

//Result 1  
bytes\[i++\] = (byte)this.\_Result;

//Reserve 8  
buffer = Encoding.ASCII.GetBytes(this.\_Reserve);  
Buffer.BlockCopy(buffer, 0, bytes, i, buffer.Length);  
return bytes;

\}  
public override string ToString()  
\{  
return this.\_Header.ToString() + "/r/n"  
\+ string.Format  
(  
"\[/r/nMessageBody:"  
\+ "/r/n/tResult: \{0\}"  
\+ "/r/n/tReserve: \{1\}"  
\+ "/r/n\]"  
, this.\_Result  
, this.\_Reserve  
);  
\}

public class SGIP\_Unbind\_Resp  
\{  
private MessageHeader \_Header;

public MessageHeader Header  
\{  
get  
\{  
return this.\_Header;  
\}  
\}

public SGIP\_Unbind\_Resp  
(  
uint SrcNodeSequence  
, uint DateSequence  
, uint Sequence\_Id  
)  
\{  
this.\_Header = new MessageHeader(MessageHeader.Length, SGIP\_Command\_Id.SGIP\_UNBIND\_RESP,SrcNodeSequence,DateSequence,Sequence\_Id);  
\}

public byte\[\] ToBytes()  
\{  
return this.\_Header.ToBytes();  
\}  
public override string ToString()  
\{  
return this.\_Header.ToString();  
\}

\}  
\}

//------------------------------------------------------------------------------

//文件StateDictionary.cs

//------------------------------------------------------------------------------

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

namespace AsiaINFO.SMS.SGIP  
\{

/// <summary>  
/// 状态字典  
/// </summary>  
public class StateDictionary  
\{  
  
/// <summary>  
/// Status 请求返回结果。响应包用来向请求包返回成功信息或者失败原因。  
/// </summary>  
/// <param name="state"></param>  
/// <returns></returns>  
public static string stateRespDictionary(uint state)  
\{  
string result = "结果：";  
switch (state)  
\{  
case 0: result += "无错误，命令正确接收"; break;  
case 1: result += "非法登录，如登录名、口令出错、登录名与口令不符等。"; break;  
case 2: result += "重复登录，如在同一TCP/IP连接中连续两次以上请求登录。"; break;  
case 3: result += "连接过多，指单个节点要求同时建立的连接数过多。"; break;  
case 4: result += "登录类型错，指bind命令中的logintype字段出错。"; break;

case 5: result += "参数格式错，指命令中参数值与参数类型不符或与协议规定的范围不符。"; break;  
case 6: result += "非法手机号码，协议中所有手机号码字段出现非86130号码或手机号码前未加“86”时都应报错。"; break;  
case 7: result += "消息ID错"; break;  
case 8: result += "信息长度错"; break;  
case 9: result += "非法序列号，包括序列号重复、序列号格式错误等"; break;  
case 10: result += "非法操作GNS"; break;  
case 11: result += "节点忙，指本节点存储队列满或其他原因，暂时不能提供服务的情况"; break;

case 21: result += "目的地址不可达，指路由表存在路由且消息路由正确但被路由的节点暂时不能提供服务的情况"; break;  
case 22: result += "路由错，指路由表存在路由但消息路由出错的情况，如转错SMG等"; break;  
case 23: result += "路由不存在，指消息路由的节点在路由表中不存在"; break;  
case 24: result += "计费号码无效，鉴权不成功时反馈的错误信息"; break;  
case 25: result += "用户不能通信（如不在服务区、未开机等情况）"; break;  
case 26: result += "手机内存不足"; break;  
case 27: result += "手机不支持短消息"; break;  
case 28: result += "手机接收短消息出现错误"; break;  
case 29: result += "不知道的用户"; break;  
case 30: result += "不提供此功能"; break;  
case 31: result += "非法设备"; break;  
case 32: result += "系统失败"; break;  
case 33: result += "短信中心队列满"; break;

default: result = "其它错误码" + state.ToString(); break;  
\}  
return result;  
\}

/// <summary>  
/// 计费类别定义  
/// </summary>  
public enum FeeTypes : byte  
\{  
/// <summary>  
/// 0 “短消息类型”为“发送”，对“计费用户号码”不计信息费，此类话单仅用于核减SP对称的信道费  
/// </summary>  
FreeSend = 0,  
/// <summary>  
/// 1 对“计费用户号码”免费  
/// </summary>  
Free = 1,  
/// <summary>  
/// 2 对“计费用户号码”按条计信息费  
/// </summary>  
RowNumFee = 2,  
/// <summary>  
/// 3 对“计费用户号码”按包月收取信息费  
/// </summary>  
MonthFee = 3,  
/// <summary>  
/// 4 对“计费用户号码”的收费是由SP实现  
/// </summary>  
SpFee = 4,  
\}  
/// <summary>  
/// Report 状态与短消息状态的映射  
/// </summary>  
public enum ReportStatus : uint  
\{  
/// <summary>  
/// 0，发送成功 DELIVERED  
/// </summary>  
Delivered = 0,  
/// <summary>  
/// 1，等待发送 ENROUTE，ACCEPTED  
/// </summary>  
Accepted = 1,  
/// <summary>  
/// 2，发送失败 EXPIRED，DELETED，UNDELIVERABLE，UNKNOWN，REJECTED  
/// </summary>  
Error = 2,  
\}  
public enum ErrorCodes : byte  
\{

/// <summary>  
/// 0 无错误，命令正确接收  
/// </summary>  
Success = 0,  
/// <summary>  
/// 1 非法登录，如登录名、口令出错、登录名与口令不符等。  
/// </summary>  
LoginError = 1,  
/// <summary>  
/// 2 重复登录，如在同一TCP/IP连接中连续两次以上请求登录。  
/// </summary>  
Relogon = 2,  
/// <summary>  
/// 3 连接过多，指单个节点要求同时建立的连接数过多。  
/// </summary>  
ConnectionFull = 3,  
/// <summary>  
/// 4 登录类型错，指bind命令中的logintype字段出错。  
/// </summary>  
ErrorLoginType = 4,  
/// <summary>  
/// 5 参数格式错，指命令中参数值与参数类型不符或与协议规定的范围不符。  
/// </summary>  
ParameterError = 5,  
/// <summary>  
/// 6 非法手机号码，协议中所有手机号码字段出现非86130号码或手机号码前未加“86”时都应报错。  
/// </summary>  
TelnumberError = 6,  
/// <summary>  
/// 7 消息ID错  
/// </summary>  
MsgIDError = 7,  
/// <summary>  
/// 8 信息长度错  
/// </summary>  
PackageLengthError = 8,  
/// <summary>  
/// 9 非法序列号，包括序列号重复、序列号格式错误等  
/// </summary>  
SequenceError = 9,  
/// <summary>  
/// 10 非法操作GNS  
/// </summary>  
GnsOperationError = 10,  
/// <summary>  
/// 11 节点忙，指本节点存储队列满或其他原因，暂时不能提供服务的情况  
/// </summary>  
NodeBusy = 11,  
/// <summary>  
/// 21 目的地址不可达，指路由表存在路由且消息路由正确但被路由的节点暂时不能提供服务的情况  
/// </summary>  
NodeCanNotReachable = 21,  
/// <summary>  
/// 22 路由错，指路由表存在路由但消息路由出错的情况，如转错SMG等  
/// </summary>  
RouteError = 22,  
/// <summary>  
/// 23 路由不存在，指消息路由的节点在路由表中不存在  
/// </summary>  
RoutNodeNotExisted = 23,  
/// <summary>  
/// 24 计费号码无效，鉴权不成功时反馈的错误信息  
/// </summary>  
FeeNumberError = 24,  
/// <summary>  
/// 25 用户不能通信（如不在服务区、未开机等情况）  
/// </summary>  
UserCanNotReachable = 25,  
/// <summary>  
/// 26 手机内存不足  
/// </summary>  
HandsetFull = 26,  
/// <summary>  
/// 27 手机不支持短消息  
/// </summary>  
HandsetCanNotRecvSms = 27,  
/// <summary>  
/// 28 手机接收短消息出现错误  
/// </summary>  
HandsetReturnError = 28,  
/// <summary>  
/// 29 不知道的用户  
/// </summary>  
UnknownUser = 29,  
/// <summary>  
/// 30 不提供此功能  
/// </summary>  
NoDevice = 30,  
/// <summary>  
/// 31 非法设备  
/// </summary>  
InvalidateDevice = 31,  
/// <summary>  
/// 32 系统失败  
/// </summary>  
SystemError = 32,  
/// <summary>  
/// 33 短信中心队列满  
/// </summary>  
FullSequence = 33,  
/// <summary>  
/// 未知错误  
/// </summary>  
OtherError = 99,  
\}  
/// <summary>  
/// Bind操作，登录类型。  
/// </summary>  
public enum LoginTypes : byte  
\{  
/// <summary>  
/// 1：SP向SMG建立的连接，用于发送命令  
/// </summary>  
SpToSmg = 1,  
/// <summary>  
/// 2：SMG向SP建立的连接，用于发送命令  
/// </summary>  
SmgToSp = 2,  
/// <summary>  
/// 3：SMG之间建立的连接，用于转发命令  
/// </summary>  
SmgToSmg = 3,  
/// <summary>  
/// 4：SMG向GNS建立的连接，用于路由表的检索和维护  
/// </summary>  
SmgToGns = 4,  
/// <summary>  
/// 5：GNS向SMG建立的连接，用于路由表的更新  
/// </summary>  
GnsToSmg = 5,  
/// <summary>  
/// 6：主备GNS之间建立的连接，用于主备路由表的一致性  
/// </summary>  
GnsToGns = 6,  
/// <summary>  
/// 11：SP与SMG以及SMG之间建立的测试连接，用于跟踪测试  
/// </summary>  
Test = 11,  
/// <summary>  
/// 其它：保留  
/// </summary>  
Unknown = 0,  
\}  
/// <summary>  
/// 短消息的编码格式。  
/// </summary>  
public enum MessageCodings : byte  
\{  
/// <summary>  
/// 0：纯ASCII字符串  
/// </summary>  
Ascii = 0,  
/// <summary>  
/// 3：写卡操作  
/// </summary>  
WriteCard = 3,  
/// <summary>  
/// 4：二进制编码  
/// </summary>  
Binary = 4,  
/// <summary>  
/// 8：UCS2编码  
/// </summary>  
Ucs2 = 8,  
/// <summary>  
/// 15: GBK编码  
/// </summary>  
Gbk = 15,  
/// <summary>  
/// 其它参见GSM3.38第4节：SMS Data Coding Scheme  
/// </summary>  
Others = 99,  
\}  
/// <summary>  
/// 引起MT消息的原因  
/// </summary>  
public enum SubmitMorelatetoMTFlags : byte  
\{  
/// <summary>  
/// 0-MO点播引起的第一条MT消息；  
/// </summary>  
VoteFirst = 0,  
/// <summary>  
/// 1-MO点播引起的非第一条MT消息；  
/// </summary>  
VoteNonFirst = 1,  
/// <summary>  
/// 2-非MO点播引起的MT消息；  
/// </summary>  
NormalFirst = 2,  
/// <summary>  
/// 3-系统反馈引起的MT消息。  
/// </summary>  
NormalNonFirst = 3,  
\}  
/// <summary>  
/// Report命令类型  
/// </summary>  
public enum ReportTypes : byte  
\{  
/// <summary>  
/// 0：对先前一条Submit命令的状态报告  
/// </summary>  
Submit = 0,  
/// <summary>  
/// 1：对先前一条前转Deliver命令的状态报告  
/// </summary>  
Deliver = 1,  
\}  
/// <summary>  
/// 该命令所涉及的短消息的当前执行状态  
/// </summary>  
public enum ReportStates : byte  
\{  
/// <summary>  
/// 0：发送成功  
/// </summary>  
Success = 0,  
/// <summary>  
/// 1：等待发送  
/// </summary>  
Accepted = 1,  
/// <summary>  
/// 2：发送失败  
/// </summary>  
Error = 2,  
\}  
/// <summary>  
/// 代收费标志，0：应收；1：实收  
/// </summary>  
public enum SubmitAgentFlag : byte  
\{  
/// <summary>  
/// 0：应收  
/// </summary>  
SouldIncome = 0,  
/// <summary>  
/// 1：实收  
/// </summary>  
RealIncome = 1,  
\}  
/// <summary>  
/// 状态报告标记  
/// </summary>  
public enum SubmitReportFlag : byte  
\{  
/// <summary>  
/// 0-该条消息只有最后出错时要返回状态报告  
/// </summary>  
ErrorReport = 0,  
/// <summary>  
/// 1-该条消息无论最后是否成功都要返回状态报告  
/// </summary>  
Always = 1,  
/// <summary>  
/// 2-该条消息不需要返回状态报告  
/// </summary>  
NoReport = 2,  
/// <summary>  
/// 3-该条消息仅携带包月计费信息，不下发给用户，要返回状态报告  
/// </summary>  
MonthReport = 3,  
\}  
\}

//------------------------------------------------------------------------------

//文件SyncEvents.cs

//------------------------------------------------------------------------------

using System;  
using System.Collections.Generic;  
using System.Text;  
using System.Threading;

namespace AsiaINFO.SMS.SGIP  
\{  
/// <summary>  
/// 同步信号量  
/// </summary>  
public class SyncEvents  
\{  
public SyncEvents()  
\{  
\_newItemEvent = new AutoResetEvent(false);  
\_exitThreadEvent = new ManualResetEvent(false);  
\_eventArray = new WaitHandle\[2\];  
\_eventArray\[0\] = \_newItemEvent;  
\_eventArray\[1\] = \_exitThreadEvent;  
\}

/// <summary>  
/// 退出信号  
/// </summary>  
public EventWaitHandle ExitThreadEvent  
\{  
get \{ return \_exitThreadEvent; \}  
\}

/// <summary>  
/// 收到数据信号  
/// </summary>  
public EventWaitHandle NewItemEvent  
\{  
get \{ return \_newItemEvent; \}  
\}

public WaitHandle\[\] EventArray  
\{  
get \{ return \_eventArray; \}  
\}

private EventWaitHandle \_newItemEvent;

private EventWaitHandle \_exitThreadEvent;  
private WaitHandle\[\] \_eventArray;  
\}  
\}

//------------------------------------------------------------------------------

//文件Util.cs

//------------------------------------------------------------------------------

using System;  
using System.Net.Sockets;

namespace AsiaINFO.SMS.SGIP  
\{  
public class Util  
\{  
//private static object \_SyncLockObject = new object();

public static string Get\_MMDDHHMMSS\_String(DateTime dt)  
\{  
string s = dt.Month.ToString().PadLeft(2, '0');  
s += dt.Day.ToString().PadLeft(2, '0');  
s += dt.Hour.ToString().PadLeft(2, '0');  
s += dt.Minute.ToString().PadLeft(2, '0');  
s += dt.Second.ToString().PadLeft(2, '0');  
return s;  
\}

public static string Get\_YYYYMMDD\_String(DateTime dt)  
\{  
string s = dt.Year.ToString().PadLeft(4, '0');  
s += dt.Month.ToString().PadLeft(2, '0');  
s += dt.Day.ToString().PadLeft(2, '0');  
return s;  
\}

internal static void WriteToStream(byte\[\] bytes, NetworkStream Stream)  
\{  
if (Stream.CanWrite)  
\{  
//lock (\_SyncLockObject)  
//\{  
Stream.Write(bytes, 0, bytes.Length);  
//\}  
\}  
\}

internal static byte\[\] ReadFromStream(int Length, NetworkStream Stream)  
\{  
byte\[\] bytes = null;  
if (Stream.CanRead)  
\{  
if (Stream.DataAvailable)  
\{  
bytes = new byte\[Length\];  
int r = 0;  
int l = 0;  
//lock (\_SyncLockObject)  
\{  
while (l < Length)  
\{  
r = Stream.Read(bytes, l, Length - l);  
l += r;  
\}  
\}  
\}  
\}  
return bytes;  
\}

public static uint bytes2Uint(byte\[\] bs, int index)  
\{  
byte\[\] dst = new byte\[4\];  
Buffer.BlockCopy(bs, index, dst, 0, 4);  
byte num = dst\[0\];  
dst\[0\] = dst\[3\];  
dst\[3\] = num;  
num = dst\[1\];  
dst\[1\] = dst\[2\];  
dst\[2\] = num;  
return BitConverter.ToUInt32(dst, 0);  
\}

public static byte\[\] uint2Bytes(uint u)  
\{  
byte\[\] bytes = BitConverter.GetBytes(u);  
byte num = bytes\[0\];  
bytes\[0\] = bytes\[3\];  
bytes\[3\] = num;  
num = bytes\[1\];  
bytes\[1\] = bytes\[2\];  
bytes\[2\] = num;  
return bytes;  
\}  
\}  
\}

//------------------------------------------------------------------------------

//文件BaseSortedList.cs

//------------------------------------------------------------------------------

using System;  
using System.Collections.Generic;  
using System.Reflection;

namespace AsiaINFO.SMS.SGIP  
\{  
public class BaseSortedList<K, V>  
\{  
protected SortedList<K, V> m\_List;  
protected object m\_Lock;

public BaseSortedList()  
\{  
this.m\_List = new SortedList<K, V>();  
this.m\_Lock = new object();  
\}

public void Add(K key, V Obj)  
\{  
if (!this.m\_List.ContainsKey(key))  
\{  
lock (this.m\_Lock)  
\{  
this.m\_List.Add(key, Obj);  
\}  
\}  
\}

public void Remove(K key)  
\{  
if (this.m\_List.ContainsKey(key))  
\{  
lock (this.m\_Lock)  
\{  
this.m\_List.Remove(key);  
\}  
\}  
\}

public int Count  
\{  
get  
\{  
return this.m\_List.Count;  
\}  
\}

public V this\[K key\]  
\{  
get  
\{  
if (this.m\_List.ContainsKey(key))  
\{  
return this.m\_List\[key\];  
\}  
return default(V);  
\}  
set  
\{  
lock (this.m\_Lock)  
\{  
if (this.m\_List.ContainsKey(key))  
\{  
this.m\_List\[key\] = value;  
\}  
\}  
\}  
\}

public SortedList<K, V> List  
\{  
get  
\{  
return this.m\_List;  
\}  
\}  
\}  
\}

//------------------------------------------------------------------------------

//文件ClientQueue.cs

//------------------------------------------------------------------------------

using System;  
using System.Net.Sockets;

namespace AsiaINFO.SMS.SGIP  
\{  
public class ClientQueue  
\{  
private TcpClient m\_tc;  
private DateTime m\_Time;

public ClientQueue(TcpClient tc, DateTime time)  
\{  
this.m\_tc = tc;  
this.m\_Time = time;  
\}

public TcpClient Soc  
\{  
get  
\{  
return this.m\_tc;  
\}  
\}

public DateTime Time  
\{  
get  
\{  
return this.m\_Time;  
\}  
set  
\{  
this.m\_Time = value;  
\}  
\}  
\}  
\}

[http_download.csdn.net_detail_adama119_4189313]: http://download.csdn.net/detail/adama119/4189313
[spf193_gmail.com]: mailto:spf193@gmail.com