中国移动CMPP接口

Bertha 。 2022-08-04 15:47 197阅读 0赞

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

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

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

邮箱 spf193@gmail.com

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

//文件Client.cs

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

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

namespace AsiaINFO.SMS.CMPP2  
\{

/// <summary>  
/// @Description：CMPP2 短消息移动网关客户端  
/// @Author：Adama SUN  
/// @Mail：[spf193@gmail.com][spf193_gmail.com]

/// @Copyright (C) 2010 AsiaINFO. All rights reserved.  
/// </summary>  
public class CMPPClient  
\{  
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">CMPP接口 接收数据队列</param>  
/// <param name="cmppSyncEvents">CMPP接口信号：检查是否需要退出线程，CMPP接口新数据到达（通知）</param>  
public CMPPClient(Queue<byte\[\]> queue, SyncEvents cmppSyncEvents)  
\{  
if (queue == null || cmppSyncEvents == null)  
throw new Exception("参数不能为空！");  
\_receiveQueue = queue;  
\_syncEvents = cmppSyncEvents;  
\}

\#region private field

private Queue<byte\[\]> \_receiveQueue;//接收队列  
private SyncEvents \_syncEvents;//信号

// private string \_Host; //主机  
// private int \_Port; //端口  
private string \_Source\_Addr;  
// private string \_Password; //密码  
private bool \_IsConnected=false; //连接状态  
private static object \_SyncLockObject = new object(); //锁  
private TcpClient tc;  
private NetworkStream \_NetworkStream;  
private Thread \_ReadResponseThread;

private object \_syncIsConnectedObject = new object();

\#endregion

\#region public property

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

\#endregion

\#region public event

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

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

\#endregion

\#region public methos

/// <summary>  
/// 连接  
/// </summary>  
/// <param name="Host">主机地址</param>  
/// <param name="Port">端口</param>  
/// <param name="UserID">用户名</param>  
/// <param name="Password">密码</param>  
/// <param name="SequenceId">序列好</param>  
/// <returns></returns>  
public void Connect(string Host, int Port, string UserID, string Password, uint SequenceId)  
\{  
// this.\_Host = Host;  
// this.\_Port = Port;  
this.\_Source\_Addr = UserID;  
// this.\_Password = Password;  
// DateTime ts = DateTime.Now;  
//CMPP\_CONNECT connect = new CMPP\_CONNECT(this.\_Source\_Addr, this.\_Password, ts, 1, SequenceId);  
CMPP\_CONNECT connect = new CMPP\_CONNECT(this.\_Source\_Addr, Password, DateTime.Now, 0x20, SequenceId);

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, CMPP\_Command\_Id.CMPP\_TERMINATE, SequenceId);  
// OnMsg(terminate.ToString());  
this.WriteToStreamWithLock(terminate.ToBytes(), this.\_NetworkStream);  
\}

/// <summary>  
/// CMPP\_ACTIVE\_TEST  
/// </summary>  
/// <param name="SequenceId"></param>  
public void ActiveTest(uint SequenceId)  
\{  
MessageHeader activeTest = new MessageHeader(MessageHeader.Length, CMPP\_Command\_Id.CMPP\_ACTIVE\_TEST, SequenceId);  
//byte\[\] activeTest = activeTest.ToBytes();  
//OnShowMsg(activeTest.ToString());  
// Console.WriteLine("Request:/r/n\{0\}", activeTest.ToString());  
this.WriteToStreamWithLock(activeTest.ToBytes(), this.\_NetworkStream);  
// this.StartRun();  
\}

/// <summary>  
/// CMPP\_ACTIVE\_TEST\_RESP  
/// </summary>  
/// <param name="SequenceId"></param>  
public void ActiveResp(uint SequenceId)  
\{  
CMPP\_ACTIVE\_TEST\_RESP response = new CMPP\_ACTIVE\_TEST\_RESP(SequenceId);  
this.WriteToStreamWithLock(response.ToBytes(), this.\_NetworkStream);  
\}

/// <summary>  
/// 发送CMPP\_DELIVER\_RESP  
/// </summary>  
/// <param name="Msg\_Id"></param>  
/// <param name="Result"></param>  
public void DeliverResp(ulong Msg\_Id, uint Result,uint SequenceId)  
\{  
CMPP\_DELIVER\_RESP deliverResp = new CMPP\_DELIVER\_RESP(Msg\_Id, Result, SequenceId);  
this.WriteToStreamWithLock(deliverResp.ToBytes(), this.\_NetworkStream);  
\}

/// <summary>  
/// 查询发送短信状态  
/// </summary>  
/// <param name="Time"></param>  
/// <param name="QueryType"></param>  
/// <param name="QueryCode"></param>  
/// <param name="Reserve"></param>  
/// <param name="SequenceId"></param>  
public void Query(DateTime Time, uint QueryType, string QueryCode, string Reserve, uint SequenceId)  
\{  
CMPP\_QUERY query = new CMPP\_QUERY(Time, QueryType, QueryCode, Reserve, SequenceId);  
this.WriteToStreamWithLock(query.ToBytes(), this.\_NetworkStream);  
\}

/// <summary>  
/// 发送短信  
/// </summary>  
/// <param name="MsgId">信息标识</param>  
/// <param name="mobile">接收短信的号码与计费号码</param>  
/// <param name="MsgContent">短信内容</param>  
/// <param name="SequenceId">序列号</param>  
/// <param name="Service\_Id">业务代码</param>  
/// <param name="FeeType">资费类别</param>  
/// <param name="FeeCode">资费代码(以分为单位)</param>  
/// <param name="Src\_Id">源号码</param>  
/// <param name="LinkId"></param>  
public void Submit(ulong MsgId, string mobile, string MsgContent, uint SequenceId, string Service\_Id, string FeeType, string FeeCode, string Src\_Id, string WapURL)  
\{  
if (mobile != null && mobile.Length == 11)  
mobile = "86" + mobile;  
Submit(MsgId, mobile, new string\[\] \{ mobile \}, MsgContent, SequenceId, Service\_Id, FeeType, FeeCode, Src\_Id, WapURL);  
\}

/// <summary>  
/// 发送短信  
/// </summary>  
/// <param name="MsgId">信息标识</param>  
/// <param name="FeeTerminalId">被计费用户的号码</param>  
/// <param name="DestTerminalId">接收短信的MSISDN号码\_多个号码</param>  
/// <param name="MsgContent">短信内容</param>  
/// <param name="SequenceId">序列号</param>  
/// <param name="Service\_Id">业务代码</param>  
/// <param name="FeeType">资费类别</param>  
/// <param name="FeeCode">资费代码(以分为单位)</param>  
/// <param name="Src\_Id">源号码</param>  
/// <param name="LinkId"></param>  
public void Submit(ulong MsgId, string FeeTerminalId, string\[\] DestTerminalId, string MsgContent, uint SequenceId, string Service\_Id, string FeeType, string FeeCode, string Src\_Id, string WapURL)  
\{  
Submit(MsgId, 1, 0, FeeTerminalId, DestTerminalId, MsgContent, SequenceId, Service\_Id, FeeType, FeeCode, Src\_Id, WapURL);  
\}

/// <summary>  
/// 发送短信  
/// </summary>  
/// <param name="MsgId">信息标识</param>  
/// <param name="RegisteredDelivery">是否要返回状态确认报告</param>  
/// <param name="Fee\_UserType">计费用户类型</param>  
/// <param name="FeeTerminalId">被计费用户的号码</param>  
/// <param name="DestTerminalId">接收短信的MSISDN号码\_多个号码</param>  
/// <param name="MsgContent">短信内容</param>  
/// <param name="SequenceId">序列号</param>  
/// <param name="Service\_Id">业务代码</param>  
/// <param name="FeeType">资费类别</param>  
/// <param name="FeeCode">资费代码(以分为单位)</param>  
/// <param name="Src\_Id">源号码</param>  
/// <param name="LinkID"></param>

public void Submit(ulong MsgId, uint RegisteredDelivery, uint Fee\_UserType, string FeeTerminalId, string\[\] DestTerminalId, string MsgContent, uint SequenceId, string Service\_Id, string FeeType, string FeeCode, string Src\_Id, string WapURL)  
\{  
//这里的字段根据需要设定  
CMPP\_SUBMIT submit = new CMPP\_SUBMIT(SequenceId);  
submit.WapURL = WapURL;  
submit.Msg\_Id = MsgId; // uint \_Msg\_Id; // 8 Unsigned Integer 信息标识。  
submit.Pk\_total = 1; // uint \_Pk\_total; // 1 Unsigned Integer 相同Msg\_Id的信息总条数,从1开始。  
submit.Pk\_number = 1; // uint \_Pk\_number; // 1 Unsigned Integer 相同Msg\_Id的信息序号,从1开始。  
submit.Registered\_Delivery = RegisteredDelivery; // uint \_Registered\_Delivery; // 1 Unsigned Integer 是否要求返回状态确认报告:  
// // 0:不需要;  
// // 1:需要。  
submit.Msg\_level = 1; // uint \_Msg\_level; // 1 Unsigned Integer 信息级别。  
submit.Service\_Id = Service\_Id; // string \_Service\_Id; // 10 Octet String 业务标识,是数字、字母和符号的组合。  
submit.Fee\_UserType = Fee\_UserType; // uint \_Fee\_UserType; // 1 Unsigned Integer 计费用户类型字段:  
// // 0:对目的终端MSISDN计费;  
// // 1:对源终端MSISDN计费;  
// // 2:对SP计费;  
// // 3:表示本字段无效,对谁计费参见Fee\_terminal\_Id字段。  
submit.Fee\_terminal\_Id = ""; // string \_Fee\_terminal\_Id; // 21 Octet String 被计费用户的号码,当Fee\_UserType为3时该值有效,当Fee\_UserType为0、1、2时该值无意义。

submit.TP\_pId = 0; // uint \_TP\_pId; // 1 Unsigned Integer GSM协议类型。详细是解释请参考GSM03.40中的9.2.3.9。  
submit.TP\_udhi = 0; // uint \_TP\_udhi; // 1 Unsigned Integer GSM协议类型。详细是解释请参考GSM03.40中的9.2.3.23,仅使用1位,右对齐。  
submit.Msg\_Fmt = 15; // uint \_Msg\_Fmt; // 1 Unsigned Integer 信息格式:  
// // 0:ASCII串;  
// // 3:短信写卡操作;  
// // 4:二进制信息;  
// // 8:UCS2编码;  
// // 15:含GB汉字......  
submit.Msg\_src = this.\_Source\_Addr; // string \_Msg\_src; // 6 Octet String 信息内容来源(SP\_Id)。  
submit.FeeType = FeeType; // string \_FeeType; // 2 Octet String 资费类别:  
// // 01:对"计费用户号码"免费;  
// // 02:对"计费用户号码"按条计信息费;  
// // 03:对"计费用户号码"按包月收取信息费。  
submit.FeeCode = FeeCode; // string \_FeeCode; // 6 Octet String 资费代码(以分为单位)。

submit.ValId\_Time = "";// Util.Get\_MMDDHHMMSS\_String(DateTime.Now.AddHours(2)) + "032+"; // string \_ValId\_Time; // 17 Octet String 存活有效期,格式遵循SMPP3.3协议。  
submit.At\_Time = "";// Util.Get\_MMDDHHMMSS\_String(DateTime.Now) + "032+"; // string \_At\_Time; // 17 Octet String 定时发送时间,格式遵循SMPP3.3协议。  
//spnum  
submit.Src\_Id = Src\_Id; // string \_Src\_Id; // 21 Octet String 源号码。SP的服务代码或前缀为服务代码的长号码, 网关将该号码完整的填到SMPP协议Submit\_SM消息相应的source\_addr字段,该号码最终在用户手机上显示为短消息的主叫号码。

submit.Dest\_terminal\_Id = DestTerminalId; //new string\[\] \{"1391xxx1138", "1391xxx1137"\}; // string\[\] \_Dest\_terminal\_Id; // 32\*DestUsr\_tl Octet String 接收短信的MSISDN号码。  
submit.DestUsr\_tl = (uint)submit.Dest\_terminal\_Id.Length; // uint \_DestUsr\_tl; // 1 Unsigned Integer 接收信息的用户数量(小于100个用户)。

submit.Msg\_Fmt = 15; // uint \_Msg\_Length; // 1 Unsigned Integer 信息长度(Msg\_Fmt值为0时:<160个字节;其它<=140个字节),取值大于或等于0。  
submit.Msg\_Content = MsgContent; //"大家好!这是一个短信群发测试!"; // string \_Msg\_Content; // Msg\_length Octet String 信息内容。  
submit.Reserve = ""; // string \_LinkID; // 20 Octet String 点播业务使用的LinkID,非点播类业务的MT流程不使用该字段。  
this.WriteToStreamWithLock(submit.ToBytes(), this.\_NetworkStream);  
\}

public void StartRun()  
\{

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

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

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

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

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

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

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

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

\#endregion

\#region private method

/ <summary>  
/ 发送数据通知  
/ </summary>  
/ <param name="data"></param>  
//private void OnCMPPSend(byte\[\] data)  
//\{  
// if (CMPPSendEvent != null)  
// \{  
// CMPPSendEvent(this, new MessageEventArgs(data));  
// \}  
//\}

/ <summary>  
/ 接受数据通知  
/ </summary>  
/ <param name="data"></param>  
//private void OnCMPPReceive(byte\[\] data)  
//\{  
// if (CMPPReceiveEvent != null)  
// \{  
// CMPPReceiveEvent(this, new MessageEventArgs(data));  
// \}  
//\}

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

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

/// <summary>  
/// 写入流  
/// </summary>  
/// <param name="data"></param>  
/// <param name="Stream"></param>  
private void WriteToStreamWithLock(byte\[\] data, NetworkStream Stream)  
\{  
// this.OnCMPPSend(data);  
try  
\{  
lock (\_SyncLockObject)  
\{  
Util.WriteToStream(data, Stream);  
\}  
\}  
catch (Exception ex)  
\{  
IsConnected = false;  
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)  
\{  
IsConnected = false;  
OnError(ex.Message);  
\}  
return null;  
\}

/// <summary>  
///  
/// </summary>  
/// <param name="BreakFlag"></param>  
private 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)  
\{  
IsConnected = false;  
OnError("CMPPClient接收错误："+ex.Message);  
\}  
OnThreadState(ThreadState.Stopped);  
  
\}  
\#endregion

\}  
\}

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

文件 CMPPMessages.cs

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

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

namespace AsiaINFO.SMS.CMPP2  
\{  
//CMPP 消息定义  
public enum CMPP\_Command\_Id : uint  
\{  
CMPP\_CONNECT = 0x00000001 //请求连接  
,  
CMPP\_CONNECT\_RESP = 0x80000001 //请求连接应答  
,  
CMPP\_TERMINATE = 0x00000002 //终止连接  
,  
CMPP\_TERMINATE\_RESP = 0x80000002 //终止连接应答  
,  
CMPP\_SUBMIT = 0x00000004 //提交短信  
,  
CMPP\_SUBMIT\_RESP = 0x80000004 //提交短信应答  
,  
CMPP\_DELIVER = 0x00000005 //短信下发  
,  
CMPP\_DELIVER\_RESP = 0x80000005 //下发短信应答  
,  
CMPP\_QUERY = 0x00000006 //发送短信状态查询  
,  
CMPP\_QUERY\_RESP = 0x80000006 //发送短信状态查询应答  
,  
CMPP\_CANCEL = 0x00000007 //删除短信  
,  
CMPP\_CANCEL\_RESP = 0x80000007 //删除短信应答  
,  
CMPP\_ACTIVE\_TEST = 0x00000008 //激活测试  
,  
CMPP\_ACTIVE\_TEST\_RESP = 0x80000008 //激活测试应答  
,  
CMPP\_FWD = 0x00000009 //消息前转  
,  
CMPP\_FWD\_RESP = 0x80000009 //消息前转应答  
,  
CMPP\_MT\_ROUTE = 0x00000010 //MT路由请求  
,  
CMPP\_MT\_ROUTE\_RESP = 0x80000010 //MT路由请求应答  
,  
CMPP\_MO\_ROUTE = 0x00000011 //MO路由请求  
,  
CMPP\_MO\_ROUTE\_RESP = 0x80000011 //MO路由请求应答  
,  
CMPP\_GET\_MT\_ROUTE = 0x00000012 //获取MT路由请求  
,  
CMPP\_GET\_MT\_ROUTE\_RESP = 0x80000012 //获取MT路由请求应答  
,  
CMPP\_MT\_ROUTE\_UPDATE = 0x00000013 //MT路由更新  
,  
CMPP\_MT\_ROUTE\_UPDATE\_RESP = 0x80000013 //MT路由更新应答  
,  
CMPP\_MO\_ROUTE\_UPDATE = 0x00000014 //MO路由更新  
,  
CMPP\_MO\_ROUTE\_UPDATE\_RESP = 0x80000014 //MO路由更新应答  
,  
CMPP\_PUSH\_MT\_ROUTE\_UPDATE = 0x00000015 //MT路由更新  
,  
CMPP\_PUSH\_MT\_ROUTE\_UPDATE\_RESP = 0x80000015 //MT路由更新应答  
,  
CMPP\_PUSH\_MO\_ROUTE\_UPDATE = 0x00000016 //MO路由更新  
,  
CMPP\_PUSH\_MO\_ROUTE\_UPDATE\_RESP = 0x80000016 //MO路由更新应答  
,  
CMPP\_GET\_MO\_ROUTE = 0x00000017 //获取MO路由请求  
, CMPP\_GET\_MO\_ROUTE\_RESP = 0x80000017 //获取MO路由请求应答  
\}

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

public CMPP\_Command\_Id Command\_Id  
\{  
get  
\{  
return this.\_Command\_Id;  
\}  
\}

public uint Sequence\_Id  
\{  
get  
\{  
return this.\_Sequence\_Id;  
\}  
\}

public uint Total\_Length  
\{  
get  
\{  
return this.\_Total\_Length;  
\}  
\}

private uint \_Total\_Length; // 4 Unsigned Integer 消息总长度(含消息头及消息体)  
private CMPP\_Command\_Id \_Command\_Id; // 4 Unsigned Integer 命令或响应类型  
private uint \_Sequence\_Id; // 4 Unsigned Integer 消息流水号,顺序累加,步长为1,循环使用(一对请求和应答消息的流水号必须相同)

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

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

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

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

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

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

buffer = BitConverter.GetBytes(this.\_Sequence\_Id);  
Array.Reverse(buffer);  
Buffer.BlockCopy(buffer, 0, bytes, 8, 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 CMPP\_CONNECT //: CMPP\_Request  
\{  
public const int BodyLength = 6 + 16 + 1 + 4;

private string \_Source\_Addr; // 6 Octet String 源地址,此处为SP\_Id,即SP的企业代码。  
private string \_Password;  
private byte\[\] \_AuthenticatorSource; // 16 Octet String 用于鉴别源地址。其值通过单向MD5 hash计算得出,表示如下:  
// AuthenticatorSource =  
// MD5(Source\_Addr+9 字节的0 +shared secret+timestamp)  
// Shared secret 由中国移动与源地址实体事先商定,timestamp格式为:MMDDHHMMSS,即月日时分秒,10位。  
private uint \_Version; // 1 Unsigned Integer 双方协商的版本号(高位4bit表示主版本号,低位4bit表示次版本号),对于3.0的版本,高4bit为3,低4位为0  
private uint \_Timestamp; // 4 Unsigned Integer 时间戳的明文,由客户端产生,格式为MMDDHHMMSS,即月日时分秒,10位数字的整型,右对齐 。

private MessageHeader \_Header;

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

public byte\[\] AuthenticatorSource  
\{  
get  
\{  
return this.\_AuthenticatorSource;  
\}  
\}

public CMPP\_CONNECT  
(  
string Source\_Addr  
, string Password  
, DateTime Timestamp  
, uint Version  
, uint Sequence\_Id  
)  
\{  
this.\_Header = new MessageHeader(MessageHeader.Length + BodyLength, CMPP\_Command\_Id.CMPP\_CONNECT, Sequence\_Id);

this.\_Source\_Addr = Source\_Addr;  
this.\_Password = Password;

string s = Util.Get\_MMDDHHMMSS\_String(Timestamp);  
this.\_Timestamp = UInt32.Parse(s);

//byte\[\] buffer = new byte\[6 + 9 + this.\_Password.Length + 10\];  
//Encoding.ASCII.GetBytes(this.\_Source\_Addr).CopyTo(buffer, 0);  
//Encoding.ASCII.GetBytes(this.\_Password).CopyTo(buffer, 6 + 9);  
//Encoding.ASCII.GetBytes(s).CopyTo(buffer, 6 + 9 + this.\_Password.Length);  
//this.\_AuthenticatorSource = new MD5CryptoServiceProvider().ComputeHash(buffer, 0, buffer.Length);

byte\[\] clientid = System.Text.Encoding.ASCII.GetBytes(Source\_Addr);  
byte\[\] password = System.Text.Encoding.ASCII.GetBytes(Password);  
byte\[\] timestamp = System.Text.Encoding.ASCII.GetBytes(s);  
byte\[\] data = new byte\[clientid.Length + 9 + password.Length + timestamp.Length\];  
Array.Copy(clientid, data, clientid.Length);  
Array.Copy(password, 0, data, clientid.Length + 9, password.Length);  
Array.Copy(timestamp, 0, data, clientid.Length + 9 + password.Length, timestamp.Length);  
System.Security.Cryptography.MD5 MD5 = new System.Security.Cryptography.MD5CryptoServiceProvider();  
\_AuthenticatorSource = MD5.ComputeHash(data);

this.\_Version = Version;  
\}

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

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

//Source\_Addr 6  
i += MessageHeader.Length;  
buffer = Encoding.ASCII.GetBytes(this.\_Source\_Addr);  
Buffer.BlockCopy(buffer, 0, bytes, i, buffer.Length);

//AuthenticatorSource 16  
i += 6;  
buffer = this.\_AuthenticatorSource;  
Buffer.BlockCopy(buffer, 0, bytes, i, buffer.Length); //16

//version 1  
i += 16;  
bytes\[i++\] = (byte)this.\_Version; //版本

//Timestamp  
buffer = BitConverter.GetBytes(this.\_Timestamp);  
Array.Reverse(buffer);  
buffer.CopyTo(bytes, i);  
return (bytes);  
\}

public override string ToString()  
\{  
return string.Format("Header=\{0\} AuthenticatorSource=\{1\} Password=\{2\} Source\_Addr=\{3\} Timestamp=\{4\} Version=\{5\}"  
, this.\_Header.ToString()  
, this.\_AuthenticatorSource  
, this.\_Password  
, this.\_Source\_Addr  
, this.\_Timestamp  
, this.\_Version);  
\}  
\}

public class CMPP\_CONNECT\_RESP //: CMPP\_Response  
\{  
private MessageHeader \_Header;  
public const int BodyLength = 4 + 16 + 1;

private uint \_Status; // 4 Unsigned Integer 状态  
// 0:正确  
// 1:消息结构错  
// 2:非法源地址  
// 3:认证错  
// 4:版本太高  
// 5~:其他错误  
private byte\[\] \_AuthenticatorISMG; // 16 Octet String ISMG认证码,用于鉴别ISMG。  
// 其值通过单向MD5 hash计算得出,表示如下:  
// AuthenticatorISMG =MD5(Status+AuthenticatorSource+shared secret),Shared secret 由中国移动与源地址实体事先商定,AuthenticatorSource为源地址实体发送给ISMG的对应消息CMPP\_Connect中的值。  
// 认证出错时,此项为空。  
private uint \_Version; // 1 Unsigned Integer 服务器支持的最高版本号,对于3.0的版本,高4bit为3,低4位为0

public byte\[\] AuthenticatorISMG  
\{  
get  
\{  
return this.\_AuthenticatorISMG;  
\}  
\}

public uint Status  
\{  
get  
\{  
return this.\_Status;  
\}  
\}

public uint Version  
\{  
get  
\{  
return this.\_Version;  
\}  
\}

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

public CMPP\_CONNECT\_RESP(byte\[\] bytes)  
\{  
//header 12  
int i = 0;  
byte\[\] buffer = new byte\[MessageHeader.Length\];  
Buffer.BlockCopy(bytes, 0, buffer, 0, buffer.Length);  
this.\_Header = new MessageHeader(buffer);

//status 4  
i += MessageHeader.Length;  
this.\_Status = bytes\[i\];

//AuthenticatorISMG 16  
i += 1;  
this.\_AuthenticatorISMG = new byte\[16\];  
Buffer.BlockCopy(bytes, MessageHeader.Length + 1, this.\_AuthenticatorISMG, 0, this.\_AuthenticatorISMG.Length);

//version  
i += 16;  
this.\_Version = bytes\[i\];

public override string ToString()  
\{

return string.Format("Header=\{0\} AuthenticatorISMG=\{1\} BodyLength=\{2\} Status=\{3\} Version=\{4\}"  
, this.\_Header.ToString()  
, this.\_AuthenticatorISMG  
, CMPP\_CONNECT\_RESP.BodyLength  
, this.\_Status  
, this.\_Version);

public class CMPP\_SUBMIT //: CMPP\_Request  
\{  
private int \_BodyLength;  
//without \_Dest\_terminal\_Id Msg\_Content  
public const int FixedBodyLength = 8  
\+ 1  
\+ 1  
\+ 1  
\+ 1  
\+ 10  
\+ 1  
\+ 21  
\+ 1  
\+ 1  
\+ 1  
\+ 6  
\+ 2  
\+ 6  
\+ 17  
\+ 17  
\+ 21  
\+ 1  
//+ 21\*DestUsr\_tl  
\+ 1  
//+ Msg\_length  
\+ 8;

private ulong \_Msg\_Id; // 8 Unsigned Integer 信息标识。  
private uint \_Pk\_total; // 1 Unsigned Integer 相同Msg\_Id的信息总条数,从1开始。  
private uint \_Pk\_number; // 1 Unsigned Integer 相同Msg\_Id的信息序号,从1开始。  
private uint \_Registered\_Delivery; // 1 Unsigned Integer 是否要求返回状态确认报告:  
// 0:不需要;  
// 1:需要。  
private uint \_Msg\_level; // 1 Unsigned Integer 信息级别。  
private string \_Service\_Id; // 10 Octet String 业务标识,是数字、字母和符号的组合。  
private uint \_Fee\_UserType; // 1 Unsigned Integer 计费用户类型字段:  
// 0:对目的终端MSISDN计费;  
// 1:对源终端MSISDN计费;  
// 2:对SP计费;  
// 3:表示本字段无效,对谁计费参见Fee\_terminal\_Id字段。  
private string \_Fee\_terminal\_Id; // 21 Octet String 被计费用户的号码,当Fee\_UserType为3时该值有效,当Fee\_UserType为0、1、2时该值无意义。  
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 \_Msg\_Fmt; // 1 Unsigned Integer 信息格式:  
// 0:ASCII串;  
// 3:短信写卡操作;  
// 4:二进制信息;  
// 8:UCS2编码;  
// 15:含GB汉字......  
private string \_Msg\_src; // 6 Octet String 信息内容来源(SP\_Id)。  
private string \_FeeType; // 2 Octet String 资费类别:  
// 01:对"计费用户号码"免费;  
// 02:对"计费用户号码"按条计信息费;  
// 03:对"计费用户号码"按包月收取信息费。  
private string \_FeeCode; // 6 Octet String 资费代码(以分为单位)。  
private string \_ValId\_Time; // 17 Octet String 存活有效期,格式遵循SMPP3.3协议。  
private string \_At\_Time; // 17 Octet String 定时发送时间,格式遵循SMPP3.3协议。  
private string \_Src\_Id; // 21 Octet String 源号码。SP的服务代码或前缀为服务代码的长号码, 网关将该号码完整的填到SMPP协议Submit\_SM消息相应的source\_addr字段,该号码最终在用户手机上显示为短消息的主叫号码。  
private uint \_DestUsr\_tl; // 1 Unsigned Integer 接收信息的用户数量(小于100个用户)。  
private string\[\] \_Dest\_terminal\_Id; // 32\*DestUsr\_tl Octet String 接收短信的MSISDN号码。  
private uint \_Msg\_Length; // 1 Unsigned Integer 信息长度(Msg\_Fmt值为0时:<160个字节;其它<=140个字节),取值大于或等于0。  
private string \_Msg\_Content; // Msg\_length Octet String 信息内容。  
private string \_Reserve; // 8 Octet String 保留

private string \_WapURL = ""; //WAPPUSH  
public string WapURL  
\{  
get \{ return \_WapURL; \}  
set \{ \_WapURL = value; \}  
\}

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

private uint \_Sequence\_Id;

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

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

\_Msg\_Content\_Bytes = WapPush.GetInstance().toBytes(this.\_Msg\_Content, this.\_WapURL);  
this.\_Msg\_Fmt = 0x04;  
this.TP\_pId = 1;  
this.TP\_udhi = 1;  
\}

this.\_Msg\_Length = (uint)\_Msg\_Content\_Bytes.Length;  
this.\_BodyLength = (int)(FixedBodyLength + 21 \* this.\_Dest\_terminal\_Id.Length + this.\_Msg\_Length);  
this.\_Header = new MessageHeader((uint)(MessageHeader.Length + this.\_BodyLength), CMPP\_Command\_Id.CMPP\_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;

//Msg\_Id //8  
buffer = new byte\[8\];  
buffer = BitConverter.GetBytes(this.\_Msg\_Id);  
Array.Reverse(buffer);  
Buffer.BlockCopy(buffer, 0, bytes, i, buffer.Length); //10

//\_Pk\_total  
i += 8;  
bytes\[i++\] = (byte)this.\_Pk\_total;  
bytes\[i++\] = (byte)this.\_Pk\_number;  
bytes\[i++\] = (byte)this.\_Registered\_Delivery;  
bytes\[i++\] = (byte)this.\_Msg\_level;

//Service\_Id  
buffer = Encoding.ASCII.GetBytes(this.\_Service\_Id);  
Buffer.BlockCopy(buffer, 0, bytes, i, buffer.Length); //10

//Fee\_UserType  
i += 10;  
bytes\[i++\] = (byte)this.\_Fee\_UserType;

//Fee\_terminal\_Id  
buffer = Encoding.ASCII.GetBytes(this.\_Fee\_terminal\_Id);  
Buffer.BlockCopy(buffer, 0, bytes, i, buffer.Length); //21

//Fee\_terminal\_type  
i += 21;  
bytes\[i++\] = (byte)this.\_TP\_pId;  
bytes\[i++\] = (byte)this.\_TP\_udhi;  
bytes\[i++\] = (byte)this.\_Msg\_Fmt;

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

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

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

//ValId\_Time  
i += 6;  
buffer = Encoding.ASCII.GetBytes(this.\_ValId\_Time);  
Buffer.BlockCopy(buffer, 0, bytes, i, buffer.Length); //17

//At\_Time  
i += 17;  
buffer = Encoding.ASCII.GetBytes(this.\_At\_Time);  
Buffer.BlockCopy(buffer, 0, bytes, i, buffer.Length); //17

//Src\_Id  
i += 17;  
buffer = Encoding.ASCII.GetBytes(this.\_Src\_Id);  
Buffer.BlockCopy(buffer, 0, bytes, i, buffer.Length); //21

//DestUsr\_tl  
i += 21;  
this.\_DestUsr\_tl = (uint)this.\_Dest\_terminal\_Id.Length;  
bytes\[i++\] = (byte)this.\_DestUsr\_tl;

//Dest\_terminal\_Id  
foreach (string s in this.\_Dest\_terminal\_Id)  
\{  
buffer = Encoding.ASCII.GetBytes(s);  
Buffer.BlockCopy(buffer, 0, bytes, i, buffer.Length);  
i += 21;  
\}

//Msg\_Length  
bytes\[i++\] = (byte)this.\_Msg\_Length;

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

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

public ulong Msg\_Id  
\{  
get  
\{  
return this.\_Msg\_Id;  
\}  
set  
\{  
this.\_Msg\_Id = value;  
\}  
\}

public uint Pk\_total  
\{  
get  
\{  
return this.\_Pk\_total;  
\}  
set  
\{  
this.\_Pk\_total = value;  
\}  
\}

public uint Pk\_number  
\{  
get  
\{  
return this.\_Pk\_number;  
\}  
set  
\{  
this.\_Pk\_number = value;  
\}  
\}

public uint Registered\_Delivery  
\{  
get  
\{  
return this.\_Registered\_Delivery;  
\}  
set  
\{  
this.\_Registered\_Delivery = value;  
\}  
\}

public uint Msg\_level  
\{  
get  
\{  
return this.\_Msg\_level;  
\}  
set  
\{  
this.\_Msg\_level = value;  
\}  
\}

public string Service\_Id  
\{  
get  
\{  
return this.\_Service\_Id;  
\}  
set  
\{  
this.\_Service\_Id = value;  
\}  
\}

public uint Fee\_UserType  
\{  
get  
\{  
return this.\_Fee\_UserType;  
\}  
set  
\{  
this.\_Fee\_UserType = value;  
\}  
\}

public string Fee\_terminal\_Id  
\{  
get  
\{  
return this.\_Fee\_terminal\_Id;  
\}  
set  
\{  
this.\_Fee\_terminal\_Id = value;  
\}  
\}

public uint TP\_pId  
\{  
get  
\{  
return this.\_TP\_pId;  
\}  
set  
\{  
this.\_TP\_pId = value;  
\}  
\}

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

public uint Msg\_Fmt  
\{  
get  
\{  
return this.\_Msg\_Fmt;  
\}  
set  
\{  
this.\_Msg\_Fmt = value;  
if (this.\_Msg\_Content != null)  
\{  
this.SetHeader();  
\}  
\}  
\}

public string Msg\_src  
\{  
get  
\{  
return this.\_Msg\_src;  
\}  
set  
\{  
\_Msg\_src = value;  
\}  
\}

public string FeeType  
\{  
get  
\{  
return this.\_FeeType;  
\}  
set  
\{  
this.\_FeeType = value;  
\}  
\}

public string FeeCode  
\{  
get  
\{  
return this.\_FeeCode;  
\}  
set  
\{  
this.\_FeeCode = value;  
\}  
\}

public string ValId\_Time  
\{  
get  
\{  
return this.\_ValId\_Time;  
\}  
set  
\{  
this.\_ValId\_Time = value;  
\}  
\}

public string At\_Time  
\{  
get  
\{  
return this.\_At\_Time;  
\}  
set  
\{  
this.\_At\_Time = value;  
\}  
\}

public string Src\_Id  
\{  
get  
\{  
return this.\_Src\_Id;  
\}  
set  
\{  
this.\_Src\_Id = value;  
\}  
\}

public uint DestUsr\_tl  
\{  
get  
\{  
return this.\_DestUsr\_tl;  
\}  
set  
\{  
this.\_DestUsr\_tl = value;  
\}  
\}

public string\[\] Dest\_terminal\_Id  
\{  
get  
\{  
return this.\_Dest\_terminal\_Id;  
\}  
set  
\{  
this.\_Dest\_terminal\_Id = value;  
\}  
\}

public uint Msg\_Length  
\{  
get  
\{  
return this.\_Msg\_Length;  
\}  
set  
\{  
this.\_Msg\_Length = value;  
\}  
\}

public string Msg\_Content  
\{  
get  
\{  
return this.\_Msg\_Content;  
\}  
set  
\{  
this.\_Msg\_Content = value;  
this.SetHeader();  
\}  
\}

public string Reserve  
\{  
get  
\{  
return this.\_Reserve;  
\}  
set  
\{  
this.\_Reserve = value;  
\}  
\}  
public override string ToString()  
\{  
return "\[/r/n"  
\+ this.\_Header.ToString() + "/r/n"  
\+ string.Format  
(  
"/tMessageBody:"  
\+ "/r/n/t/tAt\_Time: \{0\}"  
\+ "/r/n/t/tBodyLength: \{1\}"  
\+ "/r/n/t/tDest\_terminal\_Id: \{2\}"  
\+ "/r/n/t/tDestUsr\_tl: \{3\}"  
\+ "/r/n/t/tFee\_terminal\_Id: \{4\}"  
\+ "/r/n/t/tFee\_UserType: \{5\}"  
\+ "/r/n/t/tFeeCode: \{6\}"  
\+ "/r/n/t/tFeeType: \{7\}"  
\+ "/r/n/t/tReserve: \{8\}"  
\+ "/r/n/t/tMsg\_Content: \{9\}"  
\+ "/r/n/t/tMsg\_Fmt: \{10\}"  
\+ "/r/n/t/tMsg\_Id: \{11\}"  
\+ "/r/n/t/tMsg\_Length: \{12\}"  
\+ "/r/n/t/tMsg\_level: \{13\}"  
\+ "/r/n/t/tMsg\_src: \{14\}"  
\+ "/r/n/t/tPk\_number: \{15\}"  
\+ "/r/n/t/tPk\_total: \{16\}"  
\+ "/r/n/t/tRegistered\_Delivery: \{17\}"  
\+ "/r/n/t/tSequence\_Id: \{18\}"  
\+ "/r/n/t/tService\_Id: \{19\}"  
\+ "/r/n/t/tSrc\_Id: \{20\}"  
\+ "/r/n/t/tTP\_pId: \{21\}"  
\+ "/r/n/t/tTP\_udhi: \{22\}"  
\+ "/r/n/t/tValId\_Time: \{23\}"  
, this.\_At\_Time  
, this.\_BodyLength  
, String.Join(",", this.\_Dest\_terminal\_Id)  
, this.\_DestUsr\_tl  
, this.\_Fee\_terminal\_Id  
, this.\_Fee\_UserType  
, this.\_FeeCode  
, this.\_FeeType  
, this.\_Reserve  
, this.\_Msg\_Content  
, this.\_Msg\_Fmt  
, this.\_Msg\_Id  
, this.\_Msg\_Length  
, this.\_Msg\_level  
, this.\_Msg\_src  
, this.\_Pk\_number  
, this.\_Pk\_total  
, this.\_Registered\_Delivery  
, this.\_Sequence\_Id  
, this.\_Service\_Id  
, this.\_Src\_Id  
, this.\_TP\_pId  
, this.\_TP\_udhi  
, this.\_ValId\_Time  
)  
\+ "/r/n\]";  
\}

public class CMPP\_SUBMIT\_RESP //: CMPP\_Response  
\{  
private MessageHeader \_Header;  
// private ulong \_Msg\_Id;  
private string \_Msg\_Id;  
private uint \_Result;

public const int BodyLength = 8 + 1;

public string Msg\_Id  
\{  
get  
\{  
return this.\_Msg\_Id;  
\}  
\}

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

public MessageHeader Header  
\{  
get  
\{

return this.\_Header;  
\}  
\}

public CMPP\_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);

//Msg\_Id  
i += MessageHeader.Length;  
buffer = new byte\[8\];  
Buffer.BlockCopy(bytes, i, buffer, 0, buffer.Length);

this.\_Msg\_Id = System.BitConverter.ToString(buffer);  
//string test = System.BitConverter.ToString(buffer);  
//System.Console.WriteLine("CMPP\_SUBMIT\_RESP Msg\_Id=" + test);

//Array.Reverse(buffer);  
//this.\_Msg\_Id = BitConverter.ToUInt64(buffer, 0);

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

//buffer = new byte\[1\];  
//Buffer.BlockCopy(bytes, i, buffer, 0, buffer.Length);  
//Array.Reverse(buffer);  
//this.\_Result = BitConverter.ToUInt32(buffer, 0);  
\}  
public override string ToString()  
\{  
return "\[/r/n"  
\+ this.\_Header.ToString() + "/r/n"  
\+ string.Format  
(  
"/tMessageBody:"  
\+ "/r/n/t/tMsg\_Id: \{0\}"  
\+ "/r/n/t/tResult: \{1\}"

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

public class CMPP\_DELIVER //: CMPP\_Request  
\{  
public ulong Msg\_Id  
\{  
get  
\{  
return \_Msg\_Id;  
\}  
\}

public string Dest\_Id  
\{  
get  
\{  
return \_Dest\_Id;  
\}  
\}

public string Service\_Id  
\{  
get  
\{  
return \_Service\_Id;  
\}  
\}

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

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

public uint Msg\_Fmt  
\{  
get  
\{  
return \_Msg\_Fmt;  
\}  
\}

public string Src\_terminal\_Id  
\{  
get  
\{  
return \_Src\_terminal\_Id;  
\}  
\}

public uint Registered\_Delivery  
\{  
get  
\{  
return \_Registered\_Delivery;  
\}  
\}

public uint Msg\_Length  
\{  
get  
\{  
return \_Msg\_Length;  
\}  
\}

public string Msg\_Content  
\{  
get  
\{  
return \_Msg\_Content;  
\}  
\}

public string Reserved  
\{  
get  
\{  
return \_Reserved;  
\}  
\}

/// <summary>  
/// 状态报告  
/// </summary>  
public byte\[\] Report  
\{  
get \{ return \_Report; \}

private ulong \_Msg\_Id; // 8 Unsigned Integer 信息标识。  
// 生成算法如下:  
// 采用64位(8字节)的整数:  
// (1)????????? 时间(格式为MMDDHHMMSS,即月日时分秒):bit64~bit39,其中  
// bit64~bit61:月份的二进制表示;  
// bit60~bit56:日的二进制表示;  
// bit55~bit51:小时的二进制表示;  
// bit50~bit45:分的二进制表示;  
// bit44~bit39:秒的二进制表示;  
// (2)????????? 短信网关代码:bit38~bit17,把短信网关的代码转换为整数填写到该字段中;  
// (3)????????? 序列号:bit16~bit1,顺序增加,步长为1,循环使用。  
// 各部分如不能填满,左补零,右对齐。  
private string \_Dest\_Id; // 21 Octet String 目的号码。  
// SP的服务代码,一般4--6位,或者是前缀为服务代码的长号码;该号码是手机用户短消息的被叫号码。  
private string \_Service\_Id; // 10 Octet String 业务标识,是数字、字母和符号的组合。  
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 \_Msg\_Fmt; // 1 Unsigned Integer 信息格式:  
// 0:ASCII串;  
// 3:短信写卡操作;  
// 4:二进制信息;  
// 8:UCS2编码;  
// 15:含GB汉字。  
private string \_Src\_terminal\_Id; // 21 Octet String 源终端MSISDN号码(状态报告时填为CMPP\_SUBMIT消息的目的终端号码)。  
private uint \_Registered\_Delivery; // 1 Unsigned Integer 是否为状态报告:  
// 0:非状态报告;  
// 1:状态报告。  
private uint \_Msg\_Length; // 1 Unsigned Integer 消息长度,取值大于或等于0。  
private string \_Msg\_Content; // Msg\_length Octet String 消息内容。  
private string \_Reserved; // 8 Octet String 保留项。

private byte\[\] \_Report;

private MessageHeader \_Header;

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

public const int FixedBodyLength = 8 // Msg\_Id Unsigned Integer 信息标识。  
// 生成算法如下:  
// 采用64位(8字节)的整数:  
// (1)????????? 时间(格式为MMDDHHMMSS,即月日时分秒):bit64~bit39,其中  
// bit64~bit61:月份的二进制表示;  
// bit60~bit56:日的二进制表示;  
// bit55~bit51:小时的二进制表示;  
// bit50~bit45:分的二进制表示;  
// bit44~bit39:秒的二进制表示;  
// (2)????????? 短信网关代码:bit38~bit17,把短信网关的代码转换为整数填写到该字段中;  
// (3)????????? 序列号:bit16~bit1,顺序增加,步长为1,循环使用。  
// 各部分如不能填满,左补零,右对齐。  
\+ 21 // Dest\_Id Octet String 目的号码。  
// SP的服务代码,一般4--6位,或者是前缀为服务代码的长号码;该号码是手机用户短消息的被叫号码。  
\+ 10 // Service\_Id Octet String 业务标识,是数字、字母和符号的组合。  
\+ 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 // Msg\_Fmt Unsigned Integer 信息格式:  
// 0:ASCII串;  
// 3:短信写卡操作;  
// 4:二进制信息;  
// 8:UCS2编码;  
// 15:含GB汉字。  
\+ 32 // Src\_terminal\_Id Octet String 源终端MSISDN号码(状态报告时填为CMPP\_SUBMIT消息的目的终端号码)。  
\+ 1 // Src\_terminal\_type Unsigned Integer 源终端号码类型,0:真实号码;1:伪码。  
\+ 1 // Registered\_Delivery Unsigned Integer 是否为状态报告:  
// 0:非状态报告;  
// 1:状态报告。  
\+ 1 // Msg\_Length Unsigned Integer 消息长度,取值大于或等于0。  
//Msg\_length // Msg\_Content Octet String 消息内容。  
\+ 20; // LinkID Octet String 点播业务使用的LinkID,非点播类业务的MT流程不使用该字段。  
private int \_BodyLength;

public int BodyLength  
\{  
get  
\{  
return this.\_BodyLength;  
\}  
\}

public CMPP\_DELIVER(byte\[\] bytes)  
\{  
int i = 0;

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

//Msg\_Id 8  
i += MessageHeader.Length;  
buffer = new byte\[8\];  
Buffer.BlockCopy(bytes, i, buffer, 0, buffer.Length);  
Array.Reverse(buffer);  
this.\_Msg\_Id = BitConverter.ToUInt64(buffer, 0);

string s = null;  
//Dest\_Id 21  
i += 8;  
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.\_Dest\_Id = s;

//Service\_Id 10

i += 21;  
buffer = new byte\[10\];  
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.\_Service\_Id = s;

//TP\_pid 1  
i += 10;  
this.\_TP\_pid = (uint)bytes\[i++\];  
this.\_TP\_udhi = (uint)bytes\[i++\];  
this.\_Msg\_Fmt = (uint)bytes\[i++\];

//Src\_terminal\_Id 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.\_Src\_terminal\_Id = s;

//Src\_terminal\_type 1  
i += 21;  
this.\_Registered\_Delivery = (uint)bytes\[i++\];  
this.\_Msg\_Length = (uint)bytes\[i++\];

//Msg\_Content  
buffer = new byte\[this.\_Msg\_Length\];  
Buffer.BlockCopy(bytes, i, buffer, 0, buffer.Length);

if (this.\_Registered\_Delivery == 1)  
\{ ///状态报告 保存至Report  
this.\_Msg\_Content = "";  
this.\_Report = new byte\[\_Msg\_Length\];  
Buffer.BlockCopy(buffer, 0, \_Report, 0, \_Report.Length);  
\}  
else  
\{  
///短信 保存至Msg\_Content  
switch (this.\_Msg\_Fmt)  
\{  
case 8:  
this.\_Msg\_Content = Encoding.BigEndianUnicode.GetString(buffer).Trim();  
break;  
case 15: //gb2312  
this.\_Msg\_Content = Encoding.GetEncoding("gb2312").GetString(buffer).Trim();  
break;  
case 0: //ascii  
case 3: //短信写卡操作  
case 4:  
//二进制信息  
default:  
this.\_Msg\_Content = Encoding.ASCII.GetString(buffer).ToString();  
break;  
\}  
\}

//Reserved 8  
i += (int)this.\_Msg\_Length;  
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.\_Reserved = s;

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

this.\_Msg\_Length = (uint)buf.Length;  
this.\_BodyLength = FixedBodyLength + (int)this.\_Msg\_Length;

byte\[\] bytes = new byte\[MessageHeader.Length + this.\_BodyLength\];

int i = 0;

byte\[\] buffer = null;  
//header 12  
this.\_Header = new MessageHeader((uint)(MessageHeader.Length + this.\_BodyLength), CMPP\_Command\_Id.CMPP\_DELIVER, 0);

//Msg\_Id 8  
i += MessageHeader.Length;  
buffer = new Byte\[8\];  
buffer = BitConverter.GetBytes(this.\_Msg\_Id);  
Array.Reverse(buffer);  
Buffer.BlockCopy(buffer, 0, bytes, i, buffer.Length);

//Dest\_Id 21  
i += 8;  
buffer = new byte\[21\];  
buffer = Encoding.ASCII.GetBytes(this.\_Dest\_Id);  
Buffer.BlockCopy(buffer, 0, bytes, i, buffer.Length);

//Service\_Id 10  
i += 21;  
buffer = new byte\[10\];  
buffer = Encoding.ASCII.GetBytes(this.\_Service\_Id);  
Buffer.BlockCopy(buffer, 0, bytes, i, buffer.Length);

//TP\_pid 1  
i += 10;  
bytes\[i++\] = (byte)this.\_TP\_pid;  
bytes\[i++\] = (byte)this.\_TP\_udhi;  
bytes\[i++\] = (byte)this.\_Msg\_Fmt;

//Src\_terminal\_Id 21  
buffer = new byte\[21\];  
buffer = Encoding.ASCII.GetBytes(this.\_Src\_terminal\_Id);  
Buffer.BlockCopy(buffer, 0, bytes, i, buffer.Length);

//Src\_terminal\_type 1  
i += 21;  
bytes\[i++\] = (byte)this.\_Registered\_Delivery;  
bytes\[i++\] = (byte)this.\_Msg\_Length;

//Msg\_Content  
Buffer.BlockCopy(buf, 0, bytes, i, buf.Length);

//Reserved  
i += (int)this.\_Msg\_Length;

return bytes;  
\}  
public override string ToString()  
\{  
return "\[/r/n"  
\+ this.\_Header.ToString() + "/r/n"  
\+ string.Format  
(  
"/tMessageBody:"  
\+ "/r/n/t/tBodyLength: \{0\}"  
\+ "/r/n/t/tDest\_Id: \{1\}"  
\+ "/r/n/t/tReserved: \{2\}"  
\+ "/r/n/t/tMsg\_Content: \{3\}"  
\+ "/r/n/t/tMsg\_Fmt: \{4\}"  
\+ "/r/n/t/tMsg\_Id: \{5\}"  
\+ "/r/n/t/tMsg\_Length: \{6\}"  
\+ "/r/n/t/tRegistered\_Delivery: \{7\}"  
\+ "/r/n/t/tService\_Id: \{8\}"  
\+ "/r/n/t/tSrc\_terminal\_Id: \{9\}"  
\+ "/r/n/t/tTP\_pid: \{10\}"  
\+ "/r/n/t/tTP\_udhi: \{11\}"  
, this.\_BodyLength  
, this.\_Dest\_Id  
, this.\_Reserved  
, this.\_Msg\_Content  
, this.\_Msg\_Fmt  
, this.\_Msg\_Id  
, this.\_Msg\_Length  
, this.\_Registered\_Delivery  
, this.\_Service\_Id  
, this.\_Src\_terminal\_Id  
, this.\_TP\_pid  
, this.\_TP\_udhi  
)  
\+ "/r/n\]";  
\}  
\}

public class CMPP\_DELIVER\_RESP //: CMPP\_Response  
\{  
private MessageHeader \_Header;  
private ulong \_Msg\_Id;  
private uint \_Result;  
public const int Bodylength = 8 + 1;  
private uint \_Sequence\_Id;  
public CMPP\_DELIVER\_RESP(ulong Msg\_Id, uint Result, uint Sequence\_Id)  
\{  
this.\_Msg\_Id = Msg\_Id;  
this.\_Result = Result;  
this.\_Sequence\_Id = Sequence\_Id;  
\}

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

byte\[\] buffer = new byte\[MessageHeader.Length\];  
//header  
this.\_Header = new MessageHeader(MessageHeader.Length + Bodylength, CMPP\_Command\_Id.CMPP\_DELIVER\_RESP, \_Sequence\_Id);  
buffer = this.\_Header.ToBytes();  
Buffer.BlockCopy(buffer, 0, bytes, 0, buffer.Length);  
i += MessageHeader.Length;

//msg\_id 8  
buffer = BitConverter.GetBytes(this.\_Msg\_Id);  
Array.Reverse(buffer);  
buffer.CopyTo(bytes, i);

//result 1  
i += 8;  
bytes\[i\] = (byte)this.\_Result;  
//buffer = BitConverter.GetBytes(this.\_Result);  
//Array.Reverse(buffer);  
//buffer.CopyTo(bytes, i);  
return bytes;

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

public class CMPP\_Msg\_Content //状态报告  
\{  
public const int BodyLength = 8 + 7 + 10 + 10 + 21 + 4;  
private string \_Msg\_Id; // 8 Unsigned Integer 信息标识。SP提交短信(CMPP\_SUBMIT)操作时,与SP相连的ISMG产生的Msg\_Id。  
private string \_Stat; // 7 Octet String 发送短信的应答结果,含义详见表一。SP根据该字段确定CMPP\_SUBMIT消息的处理状态。  
private string \_Submit\_time; // 10 Octet String YYMMDDHHMM(YY为年的后两位00-99,MM:01-12,DD:01-31,HH:00-23,MM:00-59)。  
private string \_Done\_time; // 10 Octet String YYMMDDHHMM。  
public CMPP\_Msg\_Content(byte\[\] bytes)  
\{  
// if (bytes.Length == BodyLength)  
if (bytes.Length >=60)  
\{  
int i = 0;  
//\_Msg\_Id 8  
byte\[\] buffer = new byte\[8\];  
Buffer.BlockCopy(bytes, i, buffer, 0, buffer.Length);  
this.\_Msg\_Id = System.BitConverter.ToString(buffer);  
//Array.Reverse(buffer);  
// this.\_Msg\_Id = BitConverter.ToUInt32(buffer, 0);

//\_Stat 7  
i += 8;  
buffer = new byte\[7\];  
Buffer.BlockCopy(bytes, i, buffer, 0, buffer.Length);  
this.\_Stat = Encoding.ASCII.GetString(buffer);

//\_Submit\_time 10  
i += 7;  
buffer = new byte\[10\];  
Buffer.BlockCopy(bytes, i, buffer, 0, buffer.Length);  
this.\_Submit\_time = Encoding.ASCII.GetString(buffer);

//\_Done\_time 10  
i += 10;  
buffer = new byte\[10\];  
Buffer.BlockCopy(bytes, i, buffer, 0, buffer.Length);  
this.\_Submit\_time = Encoding.ASCII.GetString(buffer);

//Dest\_terminal\_Id 21  
i += 10;  
buffer = new byte\[bytes.Length-i-4\];  
Buffer.BlockCopy(bytes, i, buffer, 0, buffer.Length);  
//this.\_Dest\_terminal\_Id = Encoding.ASCII.GetString(buffer);

string 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.\_Dest\_terminal\_Id = s;

//i += 10;  
//buffer = new byte\[32\];  
//Buffer.BlockCopy(bytes, i, buffer, 0, buffer.Length);  
//this.\_Dest\_terminal\_Id = Encoding.ASCII.GetString(buffer);

//SMSC\_sequence 4  
// i += 21;  
i += buffer.Length;  
buffer = new byte\[4\];  
Buffer.BlockCopy(bytes, i, buffer, 0, buffer.Length);  
Array.Reverse(buffer);  
this.\_SMSC\_sequence = BitConverter.ToUInt32(buffer, 0);  
\}  
\}

public string Msg\_Id  
\{  
get  
\{  
return this.\_Msg\_Id;  
\}  
\}

public string Stat  
\{  
get  
\{  
return this.\_Stat;  
\}  
\}

public string Submit\_time  
\{  
get  
\{  
return this.\_Submit\_time;  
\}  
\}

public string Done\_time  
\{  
get  
\{  
return this.\_Done\_time;  
\}  
\}

public string Dest\_terminal\_Id  
\{  
get  
\{  
return this.\_Dest\_terminal\_Id;  
\}  
\}

public uint SMSC\_sequence  
\{  
get  
\{  
return this.\_SMSC\_sequence;  
\}  
\}

private string \_Dest\_terminal\_Id; // 32 Octet String 目的终端MSISDN号码(SP发送CMPP\_SUBMIT消息的目标终端)。  
private uint \_SMSC\_sequence; // 4 Unsigned Integer 取自SMSC发送状态报告的消息体中的消息标识。

public override string ToString()  
\{  
return string.Format  
(  
"\[/r/nMessageBody:"  
\+ "/r/n/tBodyLength: \{0\}"  
\+ "/r/n/tDest\_terminal\_Id: \{1\}"  
\+ "/r/n/tDone\_time: \{2\}"  
\+ "/r/n/tMsg\_Id: \{3\}"  
\+ "/r/n/tSMSC\_sequence: \{4\}"  
\+ "/r/n/tStat: \{5\}"  
\+ "/r/n/tSubmit\_time: \{6\}"  
\+ "/r/n\]"  
, CMPP\_Msg\_Content.BodyLength  
, this.\_Dest\_terminal\_Id  
, this.\_Done\_time  
, this.\_Msg\_Id  
, this.\_SMSC\_sequence  
, this.\_Stat  
, this.\_Submit\_time  
);  
\}  
\}

public class CMPP\_QUERY //: CMPP\_Request  
\{  
private MessageHeader \_Header;

private string \_Time; // 8 Octet String 时间YYYYMMDD(精确至日)。  
private uint \_Query\_Type; // 1 Unsigned Integer 查询类别:  
// 0:总数查询;  
// 1:按业务类型查询。  
private string \_Query\_Code; // 10 Octet String 查询码。  
// 当Query\_Type为0时,此项无效;当Query\_Type为1时,此项填写业务类型Service\_Id.。  
private string \_Reserve; // 8 Octet String 保留。

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

public string Time  
\{  
get  
\{  
return this.\_Time;  
\}  
\}

public uint Query\_Type  
\{  
get  
\{  
return this.\_Query\_Type;  
\}  
\}

public string Query\_Code  
\{  
get  
\{  
return this.\_Query\_Code;  
\}  
\}

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

public const int BodyLength = 8 + 1 + 10 + 8;

public CMPP\_QUERY  
(  
DateTime Time  
, uint Query\_Type  
, string Query\_Code  
, string Reserve  
, uint Sequence\_Id  
)  
\{  
this.\_Time = Util.Get\_YYYYMMDD\_String(Time);  
this.\_Query\_Type = Query\_Type;  
this.\_Query\_Code = Query\_Code;  
this.\_Reserve = Reserve;  
this.\_Header = new MessageHeader((uint)(MessageHeader.Length + BodyLength), CMPP\_Command\_Id.CMPP\_QUERY, Sequence\_Id);  
\}

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

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

//Time 8  
i += MessageHeader.Length;  
buffer = new byte\[10\];  
buffer = Encoding.ASCII.GetBytes(this.\_Time);  
buffer.CopyTo(bytes, i);

//Query\_Type 1  
i += 8;  
bytes\[i++\] = (byte)this.\_Query\_Type;

//Query\_Code 10  
buffer = new byte\[10\];  
buffer = Encoding.ASCII.GetBytes(this.\_Query\_Code);  
buffer.CopyTo(bytes, i);

//Reserve 8  
i += 10;  
buffer = new byte\[8\];  
buffer = Encoding.ASCII.GetBytes(this.\_Reserve);  
buffer.CopyTo(bytes, i);

return bytes;  
\}  
public override string ToString()  
\{  
return "\[/r/n"  
\+ this.\_Header.ToString() + "/r/n"  
\+ string.Format  
(  
"/tMessageBody:"  
\+ "/r/n/t/tQuery\_Code: \{0\}"  
\+ "/r/n/t/tQuery\_Type: \{1\}"  
\+ "/r/n/t/tReserve: \{2\}"  
\+ "/r/n/t/tTime: \{3\}"  
\+ "/r/n\]"  
, this.\_Query\_Code  
, this.\_Query\_Type  
, this.\_Reserve  
, this.\_Time  
)  
\+ "/r/n\]";  
\}  
\}

public class CMPP\_QUERY\_RESP  
\{  
public MessageHeader Header  
\{  
get  
\{  
return this.\_Header;  
\}  
\}

public string Time  
\{  
get  
\{  
return this.\_Time;  
\}  
\}

public uint Query\_Type  
\{  
get  
\{  
return this.\_Query\_Type;  
\}  
\}

public string Query\_Code  
\{  
get  
\{  
return this.\_Query\_Code;  
\}  
\}

public uint Mt\_TlMsg  
\{  
get  
\{  
return this.\_MT\_TLMsg;  
\}  
\}

public uint Mt\_Tlusr  
\{  
get  
\{  
return this.\_MT\_Tlusr;  
\}  
\}

public uint Mt\_Scs  
\{  
get  
\{  
return this.\_MT\_Scs;  
\}  
\}

public uint MT\_WT  
\{  
get  
\{  
return this.\_MT\_WT;  
\}  
\}

public uint MT\_FL  
\{  
get  
\{  
return this.\_MT\_FL;  
\}  
\}

public uint MO\_Scs  
\{  
get  
\{  
return this.\_MO\_Scs;  
\}  
\}

public uint MO\_WT  
\{  
get  
\{  
return this.\_MO\_WT;  
\}  
\}

public uint MO\_FL  
\{  
get  
\{  
return this.\_MO\_FL;  
\}  
\}

private MessageHeader \_Header;  
private string \_Time; // 8 Octet String 时间(精确至日)。  
private uint \_Query\_Type; // 1 Unsigned Integer 查询类别:  
// 0:总数查询;  
// 1:按业务类型查询。  
private string \_Query\_Code; // 10 Octet String 查询码。  
private uint \_MT\_TLMsg; // 4 Unsigned Integer 从SP接收信息总数。  
private uint \_MT\_Tlusr; // 4 Unsigned Integer 从SP接收用户总数。  
private uint \_MT\_Scs; // 4 Unsigned Integer 成功转发数量。  
private uint \_MT\_WT; // 4 Unsigned Integer 待转发数量。  
private uint \_MT\_FL; // 4 Unsigned Integer 转发失败数量。  
private uint \_MO\_Scs; // 4 Unsigned Integer 向SP成功送达数量。  
private uint \_MO\_WT; // 4 Unsigned Integer 向SP待送达数量。  
private uint \_MO\_FL; // 4 Unsigned Integer 向SP送达失败数量。

public const int BodyLength = 8 // Octet String 时间(精确至日)。  
\+ 1 // Unsigned Integer 查询类别:  
// 0:总数查询;  
// 1:按业务类型查询。  
\+ 10 // Octet String 查询码。  
\+ 4 // Unsigned Integer 从SP接收信息总数。  
\+ 4 // Unsigned Integer 从SP接收用户总数。  
\+ 4 // Unsigned Integer 成功转发数量。  
\+ 4 // Unsigned Integer 待转发数量。  
\+ 4 // Unsigned Integer 转发失败数量。  
\+ 4 // Unsigned Integer 向SP成功送达数量。  
\+ 4 // Unsigned Integer 向SP待送达数量。  
\+ 4; // Unsigned Integer 向SP送达失败数量。

public CMPP\_QUERY\_RESP(byte\[\] bytes)  
\{  
int i = 0;  
//header 12  
byte\[\] buffer = new byte\[MessageHeader.Length\];  
Buffer.BlockCopy(bytes, 0, buffer, 0, buffer.Length);  
this.\_Header = new MessageHeader(buffer);

//Time 8  
i += MessageHeader.Length;  
buffer = new byte\[8\];  
Buffer.BlockCopy(bytes, i, buffer, 0, buffer.Length);  
this.\_Time = Encoding.ASCII.GetString(buffer);

//Query\_Type 1  
i += 8;  
this.\_Query\_Type = (uint)bytes\[i++\];

//Query\_Code 10  
buffer = new byte\[10\];  
Buffer.BlockCopy(bytes, i, buffer, 0, buffer.Length);  
this.\_Query\_Code = Encoding.ASCII.GetString(buffer);

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

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

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

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

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

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

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

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

public override string ToString()  
\{  
return "\[/r/n"  
\+ this.\_Header.ToString() + "/r/n"  
\+ string.Format  
(  
"/tMessageBody:"  
\+ "/r/n/t/tBodyLength: \{0\}"  
\+ "/r/n/t/tMO\_FL: \{1\}"  
\+ "/r/n/t/tMO\_Scs: \{2\}"  
\+ "/r/n/t/tMO\_WT: \{3\}"  
\+ "/r/n/t/tMT\_FL: \{4\}"  
\+ "/r/n/t/tMT\_Scs: \{5\}"  
\+ "/r/n/t/tMT\_TLMsg: \{6\}"  
\+ "/r/n/t/tMT\_Tlusr: \{7\}"  
\+ "/r/n/t/tMT\_WT: \{8\}"  
\+ "/r/n/t/tQuery\_Code: \{9\}"  
\+ "/r/n/t/tQuery\_Type: \{10\}"  
\+ "/r/n/t/tTime: \{11\}"

, CMPP\_QUERY\_RESP.BodyLength  
, this.\_MO\_FL  
, this.\_MO\_Scs  
, this.\_MO\_WT  
, this.\_MT\_FL  
, this.\_MT\_Scs  
, this.\_MT\_TLMsg  
, this.\_MT\_Tlusr  
, this.\_MT\_WT  
, this.\_Query\_Code  
, this.\_Query\_Type  
, this.\_Time  
)  
\+ "/r/n\]";  
\}  
\}

public class CMPP\_ACTIVE\_TEST  
\{  
private MessageHeader \_Header;

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

public CMPP\_ACTIVE\_TEST(uint Sequence\_Id)  
\{  
this.\_Header = new MessageHeader(MessageHeader.Length, CMPP\_Command\_Id.CMPP\_ACTIVE\_TEST, Sequence\_Id);  
\}

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

public override string ToString()  
\{  
return this.\_Header.ToString();

\}  
\}

public class CMPP\_ACTIVE\_TEST\_RESP  
\{  
private MessageHeader \_Header;  
private uint \_Reserved;

public uint Reserved  
\{  
get  
\{  
return this.\_Reserved;  
\}  
\}

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

public const int Bodylength = 1;

public CMPP\_ACTIVE\_TEST\_RESP(uint Sequence\_Id)  
\{  
this.\_Header = new MessageHeader(MessageHeader.Length + Bodylength, CMPP\_Command\_Id.CMPP\_ACTIVE\_TEST\_RESP, Sequence\_Id);  
// this.\_Header = new MessageHeader((uint)(MessageHeader.Length + BodyLength), CMPP\_Command\_Id.CMPP\_ACTIVE\_TEST\_RESP, Sequence\_Id);  
this.\_Reserved = 0;  
  
\}

public CMPP\_ACTIVE\_TEST\_RESP(byte\[\] bytes)  
\{  
int i = 0;  
//header  
byte\[\] buffer = new byte\[MessageHeader.Length\];  
Buffer.BlockCopy(bytes, i, buffer, 0, buffer.Length);  
this.\_Header = new MessageHeader(buffer);

//Reserved 1  
i += MessageHeader.Length;  
this.\_Reserved = bytes\[i\];  
\}

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

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

return bytes;

\}  
public override string ToString()  
\{  
return this.\_Header.ToString();  
\}

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

文件名MessageEventArgs.cs

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

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

namespace AsiaINFO.SMS.CMPP2  
\{  
  
/// <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);  
\}

\}  
\}

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

文件名StateDictionary.cs

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

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

namespace AsiaINFO.SMS.CMPP2  
\{

/// <summary>  
/// 状态字典  
/// </summary>  
public class StateDictionary  
\{  
  
/// <summary>  
/// 连接状态字典  
/// </summary>  
/// <param name="state"></param>  
/// <returns></returns>  
public static string ConnResDictionary(uint state)  
\{  
string result = "连接结果：";  
switch (state)  
\{  
case 0: result += "成功！"; break;  
case 1: result += "错误！ 原因：消息结构错"; break;  
case 2: result += "错误！ 原因：非法源地址"; break;  
case 3: result += "错误！ 原因：认证错误"; break;  
case 4: result += "错误！ 原因：版本太高"; break;

case 997: result += "错误！ 原因：连接超时"; break;  
case 998: result += "错误！ 原因：远程服务器主动断开"; break;  
case 999: result += "错误！ 原因：未知错误"; break;  
default: result = "错误！ 原因：其他错误" + state.ToString(); break;  
\}  
return result;  
\}

\}  
\}

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

文件名SyncEvents.cs

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

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

namespace AsiaINFO.SMS.CMPP2  
\{  
/// <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.CMPP2  
\{  
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;  
\}  
\}  
\}

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

文件名WapPush.cs

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

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

namespace AsiaINFO.SMS.CMPP2  
\{  
public class WapPush  
\{

private static WapPush push = null;  
public static WapPush GetInstance()  
\{  
if (null == push)  
\{  
push = new WapPush();

\}  
return push;  
\}

//第一部分  
static private readonly byte\[\] WapPushHeader1 = new byte\[\]  
\{  
0x0B, 0x05, 0x04, 0x0B, 0x84, 0x23, 0xF0, 0x00, 0x03, 0x03, 0x01, 0x01  
\};  
//第二部分  
static private readonly byte\[\] WapPushHeader2 = new byte\[\]  
\{  
0x29, 0x06, 0x06, 0x03, 0xAE, 0x81, 0xEA, 0x8D, 0xCA  
\};

//第三部分  
static private readonly byte\[\] WapPushIndicator = new byte\[\]  
\{  
0x02, 0x05, 0x6A, 0x00, 0x45, 0xC6, 0x0C, 0x03  
\};  
//第四部分:URL去掉http://后的UTF8编码  
//第五部分  
static private readonly byte\[\] WapPushDisplayTextHeader = new byte\[\]  
\{  
0x00, 0x01, 0x03,  
\};  
//第六部分:消息文字的UTF8编码  
//第七部分:  
static private readonly byte\[\] EndOfWapPush = new byte\[\]  
\{  
0x00, 0x01, 0x01,  
\};  
public byte\[\] toBytes(string WAP\_Msg, string WAP\_URL)  
\{  
byte\[\] submitData = new byte\[400\];  
int index = 0;  
WapPushHeader1.CopyTo(submitData, index);  
index += WapPushHeader1.Length;

WapPushHeader2.CopyTo(submitData, index);  
index += WapPushHeader2.Length;  
  
WapPushIndicator.CopyTo(submitData, index);  
index += WapPushIndicator.Length;

byte\[\] url = Encoding.UTF8.GetBytes(WAP\_URL);  
url.CopyTo(submitData, index);  
index += url.Length;

WapPushDisplayTextHeader.CopyTo(submitData, index);  
index += WapPushDisplayTextHeader.Length;

byte\[\] msg2 = Encoding.UTF8.GetBytes(WAP\_Msg);  
msg2.CopyTo(submitData, index);  
index += msg2.Length;  
  
EndOfWapPush.CopyTo(submitData, index);  
index += 3;

byte\[\] reVal = new byte\[index\];  
for (int i = 0; i < reVal.Length; i++)  
\{  
reVal = submitData;  
\}

return (reVal);  
\}

\}  
\}

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