//附CMPPClient.cs:
/*
作者：TNT 时间：2003年12月
文件说明：本文件实现SP端的协议开发。
*/
using System;
using System.Security.Cryptography;
using System.Net.Sockets;
using System.Net;
using System.Text;
using System.Threading;
using System.Collections;
namespace CMPP.YOURCOMPANY
{
public delegate void ReportEventHandler(object sender, ReportEventArgs e); //声明一个事件的指代（指针）
public delegate void SMSEventHandler(object sender, SMSEventArgs e); //声明一个事件的指代（指针）
public delegate void TerminateEventHandler(object sender, TerminateEventArgs e); //声明收到终止信号
public delegate void TerminateRespEventHandler(object sender, TerminateRespEventArgs e); //回应事件发生
public delegate void TestEventHandler(object sender, TestEventArgs e);
public delegate void TestRespEventHandler(object sender, TestRespEventArgs e);
public delegate void ConnectRespEventHandler(object sender, ConnectRespEventArgs e);
public delegate void CancelRespEventHandler(object sender, CancelRespEventArgs e);
public delegate void SubmitRespEventHandler(object sender, SubmitRespEventArgs e);
public delegate void QueryRespEventHandler(object sender, QueryRespEventArgs e);
public delegate void LogonSuccEventHandler(object sender, EventArgs e); //当成功登录系统
public delegate void SocketClosedEventHandler(object sender, EventArgs e); //当套接字被检测到关闭
public delegate void FailedItemDeletedEventHandler(object sender, WaitingQueueItemEventArgs e); //当一条等待队列的消息超过60秒没有回应
public delegate void CMPPClientSvcStopEventHandler(object sender, ClientQueueStateArgs e); //当CMPP服务停止时候触发事件
/// <summary>
/// 作为CMPP协议的客户端，具有的登陆、发送、接受功能
/// 会开3 个线程处理: 1、处理需要发送 MO(下行)的消息
/// 2、处理从移动服务器发送过来CMPP的消息
/// 3、处理连接断等信息，检查需要重发的消息，检查收到的报告、短信，并调用 OnReport 事件 OnSMS事件
/// </summary>
public class CMPPClient
{
public static long CMPP_ACTIVE_TEST_C_TICKs = 30; // *3 ; //长连接的active_test测试时间
public static long CMPP_ACTIVE_TEST_T_TICKs = 60; // 消息失败时间 60秒
public static int CMPP_ACTIVE_TEST_N_COUNT = 3; //3次
//public static int CMPP_MSG_MAX=100; //一次取得的最大消息数量
public static int CMPP_Port = 7890;
public event ReportEventHandler onReportHandler; //指向事件处理代码的指针
public event SMSEventHandler onSMSHandler; //短信到来处理
public event TestEventHandler onTestHandler;
public event TestRespEventHandler onTestRespHandler;
public event ConnectRespEventHandler onConnectRespHandler;
public event CancelRespEventHandler onCancelRespHandler;
public event TerminateEventHandler onTerminateHandler;
public event TerminateRespEventHandler onTerminateRespHandler;
public event SubmitRespEventHandler onSubmitRespHandler;
public event QueryRespEventHandler onQueryRespHandler;
public event LogonSuccEventHandler onLogonSuccEventHandler;
public event SocketClosedEventHandler onSocketClosedHandler;
public event FailedItemDeletedEventHandler onWaitingItemDeltedHandler; //当等待队列消息超时
public event CMPPClientSvcStopEventHandler onClientSvcStopedHandler; //当服务停止时候的事件
//private 函数区域//
private Socket tcp = null;
private IPHostEntry ip = null;
private IPEndPoint cmpp_ep = null;
private int RecvTimeOut = 1000; //2000ms的接受超时
private int SendTimeout = 2000; //2000ms的发送超时
private string CMPP_Server = ""; //移动的服务器IP或者DNS名
private string systemID = ""; //企业编号
private string userName = ""; //sp的号码 /企业编号
private string PassWord = ""; //口令
private bool isStop = false; //本服务是否终止运行
private bool isLogin = false; //是否已经登录
private Thread Send_Thread; //发送线程,专门处理对移动的数据包
private Thread Recv_Thread; //专门处理接收包
private Thread Deamo_Thread; //监控线程
private string ErrorInfo = ""; //存放最后一次发生的错误信息 或者参考信息
private DateTime _current_time = DateTime.Now; //上一次 ping的时间
private uint lastSequence; //流水号，每一次重新启动都需要重新设定 lastSequence
private SortedList _outSeqQueue = new SortedList(); //消息队列存储 QueueItem,存储发送队列中的状态
private SortedList _waitingSeqQueue = new SortedList(); //消息队列存储 QueueItem
private int sub_resp = 0; //最后返回的包 Sequence
private DateTime _lastOkTime; //最后正确发送消息时间
private bool _bNre = false; //空引用错误，套接字错误
//private ManualResetEvent _connectionDone=new ManualResetEvent(false); //是否连接到套接字服务器,也就是CMPP服务器
//private ManualResetEvent _lastsendDone=new ManualResetEvent(false); //上一次发送是否完毕
//private ManualResetEvent _lastrecvDone=new ManualResetEvent(false); //上一次接收是否完毕
private void ping() //发送一次ping包 ，不经过_outSeqQueue 直接存储在 out queue中
{
uint seq = this.getNextSequence();
MSG.CMPP_MSG_TEST test = new MSG.CMPP_MSG_TEST(seq);
QueueItem q = new QueueItem(seq, (uint) MSG.CMPP_COMMAND_ID.CMPP_ACTIVE_TEST, 0, 0);
q.setmsgObj(test);
this.addToOutQueue(q);
}
private string getValIdTime(DateTime d) //返回短信存活时间
{
DateTime n = d.AddHours(2); //2小时
return (n.Year.ToString().Substring(2) + n.Month.ToString().PadLeft(2, '0') + n.Day.ToString().PadLeft(2, '0') + n.Hour.ToString().PadLeft(2, '0') + n.Minute.ToString().PadLeft(2, '0') + n.Second.ToString().PadLeft(2, '0') + "032+");
}
private bool isPingTime() //是否到了ping一次的时间
{
System.TimeSpan l = (DateTime.Now - this._current_time);
if (l.TotalSeconds >= (CMPPClient.CMPP_ACTIVE_TEST_C_TICKs))
{
lock (this)
{
this._current_time = DateTime.Now;
return (true);
}
}
else
{
return (false);
}
}
private void checkReSend() //是否需要再一次ping //查询 _waitingSeqQueue 是否存在 上一次 没有相应的消息
{ //调查waiting queue 中的所有消息，如果入列时间超过60
for (int i = 0; i < this._waitingSeqQueue.Count; i++)
{
Thread.Sleep(20);
QueueItem q = (QueueItem) this._waitingSeqQueue.GetByIndex(i);
if (q != null)
{
DateTime this_time = DateTime.Now; //去当前时间
TimeSpan t = this_time - q.inQueueTime;
if (t.TotalSeconds > CMPPClient.CMPP_ACTIVE_TEST_T_TICKs) //达到超时时间
{//需要重新发送消息
if (q.FailedCount >= CMPPClient.CMPP_ACTIVE_TEST_N_COUNT)
{
//报告消息发送失败
if (this.onWaitingItemDeltedHandler != null)
{
WaitingQueueItemEventArgs e = new WaitingQueueItemEventArgs(q);
this.onWaitingItemDeltedHandler(this, e);
}
this.delFromWaitingQueue(q); //从等待队列中删除
//q.MsgState =(int)MSG_STATE.SENDED_WAITTING;
}
else
{//可以尝试继续发送
q.inQueueTime = this_time;
q.FailedCount++;
q.MsgState = (int) MSG_STATE.SENDED_WAITTING;
this.sendQueueItem(q);
}
}
}
}
}
private void startThreads()
{
Deamo_Thread = new Thread(new ThreadStart(this.DeamonThread));
Deamo_Thread.Start();
}
private QueueItem newQueueItem(int msgtype, int msgstate, object msg) //生成一个消息队列成员对象实例
{
uint seq = this.getNextSequence(); //
QueueItem q = new QueueItem(seq, (uint) msgtype, 0, msgstate);
q.setmsgObj(msg); //设定消息为 object
return (q);
}
private QueueItem getOutQueueItem(uint seq) //获取MT 队列中的消息项目
{
lock (this)
{
return ((QueueItem) this._outSeqQueue[seq]);
}
}
private QueueItem getWaitingQueueItem(uint seq) //获取等待队列中的消息
{
return ((QueueItem) this._waitingSeqQueue[seq]);
}
private void addToOutQueue(QueueItem q)
{
lock (this)
{
this._outSeqQueue.Add(q.Sequence, q);
}
}
private void addToWaitingQueue(QueueItem q)
{
lock (this)
{
if (!this._waitingSeqQueue.ContainsKey(q.Sequence))
{
this._waitingSeqQueue.Add(q.Sequence, q);
}
}
}
private QueueItem getTopOutQueue() //需要在取之前进行判断
{
for (int i = 0; i < this._outSeqQueue.Count; i++)
{
QueueItem q = (QueueItem) this._outSeqQueue.GetByIndex(i);
if (q != null)
{
if (q.MsgState == (int) MSG_STATE.NEW) //新消息，立即返回
{
lock (this)
{
q.MsgState = (int) MSG_STATE.SENDING; //发送状态
}
return (q);
}
else
{
q = null;
}
}
}
return (null);
}
private ArrayList getTop16Queue() //返回16条最顶的消息
{
int arrlength = 0;
ArrayList reArr = new ArrayList();
QueueItem q = getTopOutQueue();
while (q != null || arrlength <= 16)
{
if (q != null)
{
reArr.Add(q);
arrlength++;
}
else
{
break;
}
q = getTopOutQueue();
}
if (arrlength > 0)
{
return (reArr);
}
else
{
return (null);
}
}
private void delFromOutQueue(QueueItem q)
{
lock (this)
{
this._outSeqQueue.Remove(q.Sequence);
}
}
private void delFromOutQueue(uint seq)
{
lock (this)
{
this._outSeqQueue.Remove(seq);
}
}
private void delFromWaitingQueue(QueueItem q)
{
lock (this)
{
this._waitingSeqQueue.Remove(q.Sequence);
}
}
private void delFromWaitingQueue(uint seq)
{
this._waitingSeqQueue.Remove(seq);
}
private void SendLogin(string SystemID, string spNum, string Password)
{//发送登录验证包
systemID = SystemID;
userName = spNum;
PassWord = Password;
uint seq = this.getNextSequence(); //取得一个流水号
MSG.CMPP_MSG_CONNECT cn = new MSG.CMPP_MSG_CONNECT(seq);
cn.Password = Password.Trim();
cn.SourceAdd = SystemID.Trim();
tcp.Send(cn.ToBytes());
}
private byte[] prepairPKs(QueueItem outitem)//将QueueItem发送出去
{
uint seq = outitem.Sequence;
uint msgtype = outitem.MsgType;
switch (msgtype)
{
case (uint) MSG.CMPP_COMMAND_ID.CMPP_ACTIVE_TEST:
MSG.CMPP_MSG_TEST test = (MSG.CMPP_MSG_TEST) outitem.getMsgObj(); //发送队列中取出
lock (this)
{
outitem.MsgState = (int) MSG_STATE.SENDING;
this.delFromOutQueue(seq);
this.addToWaitingQueue(outitem); //等待服务器的active_TEST_resp
}
outitem.MsgState = (int) MSG_STATE.SENDED_WAITTING;
return (test.toBytes());
case (uint) MSG.CMPP_COMMAND_ID.CMPP_ACTIVE_TEST_RESP:
MSG.CMPP_MSG_TEST_RESP test_reply = (MSG.CMPP_MSG_TEST_RESP) outitem.getMsgObj(); //发送队列中取出//取出需要发送的具体消息
lock (this)
{
outitem.MsgState = (int) MSG_STATE.SENDING;
this.delFromOutQueue(seq);
}
outitem.MsgState = (int) MSG_STATE.SENDING_FINISHED; //完成
return (test_reply.toBytes());
case (uint) MSG.CMPP_COMMAND_ID.CMPP_CANCEL:
MSG.CMPP_MSG_CANCEL cancel = (MSG.CMPP_MSG_CANCEL) outitem.getMsgObj(); //还原成消息类
lock (this)
{
outitem.MsgState = (int) MSG_STATE.SENDING;
this.delFromOutQueue(seq);
this.addToWaitingQueue(outitem); //等待回应
}
outitem.MsgState = (int) MSG_STATE.SENDED_WAITTING;
return (cancel.toBytes());
case (uint) MSG.CMPP_COMMAND_ID.CMPP_DELIVER_RESP:
MSG.CMPP_MSG_DELIVER_RESP deliver_resp = (MSG.CMPP_MSG_DELIVER_RESP) outitem.getMsgObj(); //发送队列中取出;
lock (this)
{
outitem.MsgState = (int) MSG_STATE.SENDING;
this.delFromOutQueue(seq);
}
outitem.MsgState = (int) MSG_STATE.SENDING_FINISHED; //完成
return (deliver_resp.toBytes());
case (uint) MSG.CMPP_COMMAND_ID.CMPP_QUERY:
MSG.CMPP_MSG_QUERY query = (MSG.CMPP_MSG_QUERY) outitem.getMsgObj(); //发送队列中取出;
lock (this)
{
outitem.MsgState = (int) MSG_STATE.SENDING;
this.delFromOutQueue(seq);
this.addToWaitingQueue(outitem);
}
outitem.MsgState = (int) MSG_STATE.SENDED_WAITTING; //等待回应
return (query.toBytes());
case (uint) MSG.CMPP_COMMAND_ID.CMPP_SUBMIT:
MSG.CMPP_MSG_SUBMIT submit = (MSG.CMPP_MSG_SUBMIT) outitem.getMsgObj(); //发送队列中取出;
lock (this)
{
outitem.MsgState = (int) MSG_STATE.SENDING;
this.delFromOutQueue(seq);
this.addToWaitingQueue(outitem);
}
outitem.MsgState = (int) MSG_STATE.SENDING_FINISHED;
return (submit.toBytes());
case (uint) MSG.CMPP_COMMAND_ID.CMPP_TERMINATE:
MSG.CMPP_MSG_TERMINATE terminate = (MSG.CMPP_MSG_TERMINATE) outitem.getMsgObj(); //发送队列中取出;
lock (this)
{
outitem.MsgState = (int) MSG_STATE.SENDING;
this.delFromOutQueue(seq);
this.addToWaitingQueue(outitem);
}
outitem.MsgState = (int) MSG_STATE.SENDED_WAITTING;
return (terminate.toBytes());
case (uint) MSG.CMPP_COMMAND_ID.CMPP_TERMINATE_RESP:
MSG.CMPP_MSG_TERMINATE_RESP terminate_resp = (MSG.CMPP_MSG_TERMINATE_RESP) outitem.getMsgObj(); //发送队列中取出;
lock (this)
{
outitem.MsgState = (int) MSG_STATE.SENDING;
this.delFromOutQueue(seq);
}
outitem.MsgState = (int) MSG_STATE.SENDING_FINISHED;
return (terminate_resp.toBytes());
default:
test = (MSG.CMPP_MSG_TEST) outitem.getMsgObj(); //发送队列中取出
lock (this)
{
outitem.MsgState = (int) MSG_STATE.SENDING;
this.delFromOutQueue(seq);
this.addToWaitingQueue(outitem); //等待服务器的active_TEST_resp
}
outitem.MsgState = (int) MSG_STATE.SENDED_WAITTING;
return (test.toBytes());
}
}
private void sendQueueItem(QueueItem outitem)//将QueueItem发送出去
{
uint seq = outitem.Sequence;
uint msgtype = outitem.MsgType;
try
{
switch (msgtype)
{
case (uint) MSG.CMPP_COMMAND_ID.CMPP_ACTIVE_TEST:
MSG.CMPP_MSG_TEST test = (MSG.CMPP_MSG_TEST) outitem.getMsgObj(); //发送队列中取出
lock (this)
{
outitem.MsgState = (int) MSG_STATE.SENDING;
this.delFromOutQueue(seq);
this.addToWaitingQueue(outitem); //等待服务器的active_TEST_resp
}
tcp.Send(test.toBytes());
outitem.MsgState = (int) MSG_STATE.SENDED_WAITTING;
break;
case (uint) MSG.CMPP_COMMAND_ID.CMPP_ACTIVE_TEST_RESP:
MSG.CMPP_MSG_TEST_RESP test_reply = (MSG.CMPP_MSG_TEST_RESP) outitem.getMsgObj(); //发送队列中取出//取出需要发送的具体消息
lock (this)
{
outitem.MsgState = (int) MSG_STATE.SENDING;
this.delFromOutQueue(seq);
}
tcp.Send(test_reply.toBytes());
outitem.MsgState = (int) MSG_STATE.SENDING_FINISHED; //完成
break;
case (uint) MSG.CMPP_COMMAND_ID.CMPP_CANCEL:
MSG.CMPP_MSG_CANCEL cancel = (MSG.CMPP_MSG_CANCEL) outitem.getMsgObj(); //还原成消息类
lock (this)
{
outitem.MsgState = (int) MSG_STATE.SENDING;
this.delFromOutQueue(seq);
this.addToWaitingQueue(outitem); //等待回应
}
tcp.Send(cancel.toBytes());
outitem.MsgState = (int) MSG_STATE.SENDED_WAITTING;
break;
case (uint) MSG.CMPP_COMMAND_ID.CMPP_DELIVER_RESP:
MSG.CMPP_MSG_DELIVER_RESP deliver_resp = (MSG.CMPP_MSG_DELIVER_RESP) outitem.getMsgObj(); //发送队列中取出;
lock (this)
{
outitem.MsgState = (int) MSG_STATE.SENDING;
this.delFromOutQueue(seq);
}
tcp.Send(deliver_resp.toBytes());
outitem.MsgState = (int) MSG_STATE.SENDING_FINISHED; //完成
break;
case (uint) MSG.CMPP_COMMAND_ID.CMPP_QUERY:
MSG.CMPP_MSG_QUERY query = (MSG.CMPP_MSG_QUERY) outitem.getMsgObj(); //发送队列中取出;
lock (this)
{
outitem.MsgState = (int) MSG_STATE.SENDING;
this.delFromOutQueue(seq);
this.addToWaitingQueue(outitem);
}
tcp.Send(query.toBytes());
outitem.MsgState = (int) MSG_STATE.SENDED_WAITTING; //等待回应
break;
case (uint) MSG.CMPP_COMMAND_ID.CMPP_SUBMIT:
MSG.CMPP_MSG_SUBMIT submit = (MSG.CMPP_MSG_SUBMIT) outitem.getMsgObj(); //发送队列中取出;
lock (this)
{
outitem.MsgState = (int) MSG_STATE.SENDING;
this.delFromOutQueue(seq);
this.addToWaitingQueue(outitem);
}
tcp.Send(submit.toBytes());
outitem.MsgState = (int) MSG_STATE.SENDING_FINISHED;
break;
case (uint) MSG.CMPP_COMMAND_ID.CMPP_TERMINATE:
MSG.CMPP_MSG_TERMINATE terminate = (MSG.CMPP_MSG_TERMINATE) outitem.getMsgObj(); //发送队列中取出;
lock (this)
{
outitem.MsgState = (int) MSG_STATE.SENDING;
this.delFromOutQueue(seq);
this.addToWaitingQueue(outitem);
}
if (this.tcpIsCanUse())
{
tcp.Send(terminate.toBytes());
outitem.MsgState = (int) MSG_STATE.SENDED_WAITTING;
}
this.isStop = true; //通知其他线程可以退出了
break;
case (uint) MSG.CMPP_COMMAND_ID.CMPP_TERMINATE_RESP:
MSG.CMPP_MSG_TERMINATE_RESP terminate_resp = (MSG.CMPP_MSG_TERMINATE_RESP) outitem.getMsgObj(); //发送队列中取出;
lock (this)
{
outitem.MsgState = (int) MSG_STATE.SENDING;
this.delFromOutQueue(seq);
}
tcp.Send(terminate_resp.toBytes());
outitem.MsgState = (int) MSG_STATE.SENDING_FINISHED;
break;
}
LogLastOkTime(DateTime.Now); //记录当前最后一次消息soket正确时间
}
catch (SocketException se)
{
//发生套接字错误
this.ErrorInfo = this.ErrorInfo + "/r/n" + se.ToString();
}
catch (NullReferenceException nre)
{
this._bNre = true; //出现空引用错误
this.ErrorInfo = this.ErrorInfo + "/r/n" + nre.ToString();
}
}
private bool tcpIsCanUse() //测试当前tcp是否可用
{
bool reval = true;
DateTime t = DateTime.Now;
TimeSpan ts = t - this._lastOkTime;
if (ts.TotalSeconds > CMPPClient.CMPP_ACTIVE_TEST_T_TICKs) //60秒
{
reval = false; //不可用
}
if (this._bNre)
{
reval = false;
}
return (reval);
}
private void _reStartRecvNSend()
{
Send_Thread = new Thread(new ThreadStart(this.SendSPMsgThread));
Send_Thread.Start();
Recv_Thread = new Thread(new ThreadStart(this.RecvISMGMsgThread));
Recv_Thread.Start();
}
private void LogLastOkTime(DateTime lastoktime)
{
lock (this)
{
this._lastOkTime = lastoktime; //设定最后成功消息交互时间
}
}
private void defaultReportHandler() //却省的报告事件处理函数
{
}
private void defaultSMSHandler()
{
}
private void defaultTeminateHandler()
{
}
private void defaultTestEventHandler()
{
}
private void defaultTestRespEventHandler()
{
}
private void defaultTerminateEventHandler()
{
}
private void defaultTerminateRespEventHandler()
{
}
private void defaultCancelRespEventHandler()
{
}
private void defaultQueryRespEventHandler()
{
}
private void defaultConnectRespEventHandler()
{
QueueItem q = new QueueItem(this.getNextSequence(), (uint) MSG.CMPP_COMMAND_ID.CMPP_ACTIVE_TEST, 0, (int) MSG_STATE.NEW);
MSG.CMPP_MSG_TEST test = new MSG.CMPP_MSG_TEST(q.Sequence); //立即发送包过去
q.setmsgObj(test);
this.addToOutQueue(q);
}
private void defaultSubmitRespEventHandler()
{
}
private void defaultClientStopEventHandler()
{ }
private void rePortError(string info)
{
}
private bool _init(string CMPPServer, int CMPPPort)
{
bool reVal = false;
CMPP_Server = CMPPServer;
CMPP_Port = CMPPPort;
try
{
tcp = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
ip = Dns.GetHostByName(CMPP_Server);
cmpp_ep = new IPEndPoint(ip.AddressList[0], CMPP_Port);
tcp.Connect(cmpp_ep); //连接
reVal = true;
}
catch (SocketException se)
{
ErrorInfo = "Socker Error:" + se.ToString();
}
return (reVal);
}
private uint getNextSequence()
{
lock (typeof(CMPPClient))
{
try
{
lastSequence++;
}
catch (OverflowException ofe)
{
this.ErrorInfo = this.ErrorInfo + "/r/n" + ofe.ToString();
lastSequence = uint.MinValue;
}
return (lastSequence);
}
}
private void RecvISMGMsgThread() //处理ISMG消息的线程
{
while (!this.isStop)
{
try
{
byte[] rbuf = new byte[10240]; //结果缓冲区
byte[] recv_temp = new Byte[1024]; //recv临时缓冲区
int index = 0;
int msglength = tcp.Receive(rbuf); //阻塞接收//分析收到的数据
MSG.CMPP_MSG_Header header; //=new MSG.CMPP_MSG_Header(rbuf,index); //取得一个消息
while (index < msglength) //逐个消息分析
{
header = new MSG.CMPP_MSG_Header(rbuf, index); //取得一个消息
byte[] the_pk = new byte[header.MSGLength]; //生成此消息的大小
for (int i = 0; i < header.MSGLength; i++)
{
the_pk[i] = rbuf[index++];
}
uint seq; //取得回复消息的下一个流水序列号
switch (header.Command_ID)
{
case (uint) MSG.CMPP_COMMAND_ID.CMPP_ACTIVE_TEST: //服务器给客户的测试信号
this.ErrorInfo = this.ErrorInfo + "/r/n" + "收到：CMPP_ACTIVE_TEST";
MSG.CMPP_MSG_TEST test = new MSG.CMPP_MSG_TEST(the_pk);
seq = test.Sequence; //取得发送过来的流水号
MSG.CMPP_MSG_TEST_RESP test_reply = new MSG.CMPP_MSG_TEST_RESP(seq);
tcp.Send(test_reply.toBytes()); //马上送出回应包,不需要进入队列
if (this.onTestHandler != null)
{
TestEventArgs e = new TestEventArgs(test);
onTestHandler(this, e);
}
else
{
defaultTestEventHandler();
}
this.ErrorInfo = this.ErrorInfo + "/r/n" + "发送：CMPP_ACTIVE_TEST_RESP ";
break;
case (uint) MSG.CMPP_COMMAND_ID.CMPP_ACTIVE_TEST_RESP: //服务器的回应消息,应当丢弃不管
this.ErrorInfo = this.ErrorInfo + "/r/n" + ("收到：CMPP_ACTIVE_TEST_RESP ");
MSG.CMPP_MSG_TEST_RESP test_reply2 = new MSG.CMPP_MSG_TEST_RESP(the_pk); //构造消息
seq = test_reply2.Sequence; //寻找 曾经发送过去的消息
this.delFromWaitingQueue(seq); //删除等待队列中的消息 //清空等待回应队列
if (this.onTestRespHandler != null)
{
TestRespEventArgs e = new TestRespEventArgs(test_reply2);
onTestRespHandler(this, e);
}
else
{
defaultTestRespEventHandler();
}
break;
case (uint) MSG.CMPP_COMMAND_ID.CMPP_CANCEL_RESP:
this.ErrorInfo = this.ErrorInfo + "/r/n" + ("收到：CMPP_CANCEL_RESP ");
MSG.CMPP_MSG_CANCEL_RESP cancel_reply = new MSG.CMPP_MSG_CANCEL_RESP(the_pk);//构造消息
seq = cancel_reply.Sequence;
this.delFromWaitingQueue(seq);
if (this.onCancelRespHandler != null)
{
CancelRespEventArgs e = new CancelRespEventArgs(cancel_reply);
onCancelRespHandler(this, e);
}
else
{
defaultCancelRespEventHandler();
}
break;
case (uint) MSG.CMPP_COMMAND_ID.CMPP_CONNECT_RESP: //检查下消息的正确性，清除等待队列 设定连接成功标志
this.ErrorInfo = this.ErrorInfo + "/r/n" + ("收到：CMPP_CONNECT_RESP ");
MSG.CMPP_MSG_CONNECT_RESP cn_reply = new MSG.CMPP_MSG_CONNECT_RESP(the_pk);
seq = cn_reply.Sequence; //取得消息的seq
if (this.onConnectRespHandler != null)
{
ConnectRespEventArgs e = new ConnectRespEventArgs(cn_reply);
onConnectRespHandler(this, e);
}
else
{
defaultConnectRespEventHandler();
}
if (cn_reply.isOk)
{
this.isLogin = true;
}
else
{
this.isLogin = false;
}
this.delFromWaitingQueue(seq); //删除队列中的等待连接信息包
break;
case (uint) MSG.CMPP_COMMAND_ID.CMPP_DELIVER: //检查消息正确定，立即返回 正确 或者 失败,正确则处理是否状态包，不是状态包则存到MO缓存，表示收到信息,时状态包则判断缓存消息进行消息送达处理
this.ErrorInfo = this.ErrorInfo + "/r/n" + ("收到：CMPP_DELIVER ");
BIConvert.DumpBytes(the_pk, "c://CMPP_DELIVER.txt");//保留映像
MSG.CMPP_MSG_DELIVER deliver = new MSG.CMPP_MSG_DELIVER(the_pk);
seq = (uint) deliver.ISMGSequence; //发过来的流水号,需要立即发送一个deliver_resp //一条 ISMG--〉SP 的消息
MSG.CMPP_MSG_DELIVER_RESP deliver_resp = new MSG.CMPP_MSG_DELIVER_RESP(seq);
deliver_resp.MsgID = deliver.MsgID;
deliver_resp.Result = 0;
byte[] t = deliver_resp.toBytes();
tcp.Send(t);
this.ErrorInfo = this.ErrorInfo + "/r/n" + ("发送：CMPP__DELIVER_RESP ");
if (deliver.isReport)
{ //删除等待队列的消息//报告消息已经正确发送到
//UInt64 ReportMsgID=deliver.ReportMsgID ; //取得消息ID ,更新 MsgID
string StateReport = deliver.StateReport; //取得关于此消息的状态
//_debugBs(the_pk);
ReportEventArgs arg = new ReportEventArgs(the_pk, MSG.CMPP_MSG_Header.HeaderLength + 8 + 21 + 10 + 1 + 1 + 1 + 21 + 1 + 1); //构造报告事件参数
//ReportEventArgs arg=new ReportEventArgs(ReportMsgID.ToString(),
if (this.onReportHandler != null) //ReportEventArgs传递的字节数组是 报告信息包的数据,在此不考虑多个报告的情况
{
onReportHandler(this, arg);
}
else
{
this.defaultReportHandler();
}
}
else
{//SMSEventArgs 传递的整个deliver包
SMSEventArgs smsarg = new SMSEventArgs(the_pk, MSG.CMPP_MSG_Header.HeaderLength);
if (this.onSMSHandler != null)
{
onSMSHandler(this, smsarg); //触发事件,应当很快结束处理，不要靠考虑存储之类的耗费资源事宜
}
else
{
defaultSMSHandler();
}
}
break;
case (uint) MSG.CMPP_COMMAND_ID.CMPP_QUERY_RESP:
this.ErrorInfo = this.ErrorInfo + "/r/n" + ("收到：CMPP_QUERY_RESP ");
//收到消息，处理后存入数据库
MSG.CMPP_MSG_QUERY_RESP query_resp = new MSG.CMPP_MSG_QUERY_RESP(the_pk);
this.delFromWaitingQueue(query_resp.Sequence); //将等待的队列中的元素删除
if (this.onQueryRespHandler != null)
{
QueryRespEventArgs e = new QueryRespEventArgs(query_resp);
}
else
{
defaultQueryRespEventHandler();
}
break;
case (uint) MSG.CMPP_COMMAND_ID.CMPP_SUBMIT_RESP: //收到服务器送达的慧英消息
this.ErrorInfo = this.ErrorInfo + "/r/n" + ("收到：CMPP_SUBMIT_RESP ");
MSG.CMPP_MSG_SUBMIT_RESP submit_resp = new MSG.CMPP_MSG_SUBMIT_RESP(the_pk);
BIConvert.DumpBytes(the_pk, "c://CMPP_SUBMIT_RESP.txt");//保留映像
//BIConvert.DumpBytes(initValue,"c://CMPP_SUBMIT_RESP.txt");//保留映像
sub_resp++; //该变量仅供测试使用
delFromWaitingQueue(submit_resp.Sequence); //删除需要等待的消息
if (this.onSubmitRespHandler != null)
{
SubmitRespEventArgs e = new SubmitRespEventArgs(submit_resp);
//submit_resp.
onSubmitRespHandler(this, e);
}
else
{
defaultSubmitRespEventHandler();
}
break;
case (uint) MSG.CMPP_COMMAND_ID.CMPP_TERMINATE:
this.ErrorInfo = this.ErrorInfo + "/r/n" + "收到：CMPP_TERMINATE";
MSG.CMPP_MSG_TERMINATE terminate = new MSG.CMPP_MSG_TERMINATE(the_pk);
seq = terminate.Sequence;
MSG.CMPP_MSG_TERMINATE_RESP terminate_resp = new MSG.CMPP_MSG_TERMINATE_RESP(seq);
this.ErrorInfo = this.ErrorInfo + "/r/n" + "收到：CMPP_TERMINATE_RESP";
tcp.Send(terminate_resp.toBytes());
if (this.onTerminateHandler != null)
{
TerminateEventArgs e = new TerminateEventArgs(terminate);
onTerminateHandler(this, e);
this.StopMe(); //准备自我停止?
}
else
{
defaultTerminateEventHandler();
}
this._StopMe(); //发出终止设定
return; //退出线程
case (uint) MSG.CMPP_COMMAND_ID.CMPP_TERMINATE_RESP:
this.ErrorInfo = this.ErrorInfo + "/r/n" + "收到：CMPP_TERMINATE_RESP";
MSG.CMPP_MSG_TERMINATE_RESP ter_resp = new MSG.CMPP_MSG_TERMINATE_RESP(the_pk);
seq = ter_resp.Sequence; //取得流水信号
this.delFromOutQueue(seq); //删除输出表重点项目
if (this.onTerminateRespHandler != null)
{
TerminateRespEventArgs e = new TerminateRespEventArgs(ter_resp);
onTerminateRespHandler(this, e);
}
else
{
defaultTerminateRespEventHandler();
}
this._StopMe();
break;
}
}
LogLastOkTime(DateTime.Now); //记录当前最后一次消息soket正确时间
}
catch (SocketException se)
{
//超时
}
Thread.Sleep(50);
}
}
//debug
// private void _debugBs(byte[] the_pk) //存储byte字节
// {
//
// }
//debug
private void DeamonThread() //监视本系统连接是否正常
{//此线程是监视线程
int t_count = 0; //循环时间计数
_reStartRecvNSend(); //启动接收和发送
while (!this.isStop)
{
t_count++; //0.1秒
if (tcpIsCanUse())
{
if (this.isPingTime())
{
this.ping(); //发送一个ping包
}
if (t_count > 50) // 500*100=50000=50秒
{
t_count = 0;
checkReSend(); //检查需要重新发送的消息
//触发一个事件，让系统自动检查消息队列，存储消息队列中的消息状态
}
}
else
{
EventArgs e = new EventArgs();
if (this.onSocketClosedHandler != null)
{
onSocketClosedHandler(this, e);
}
else
{
}
this.isStop = true; //通知其他线程退出
}
Thread.Sleep(1000);
}
}
private void SendSPMsgThread()
{
while (!this.isStop)
{
Thread.Sleep(10);
if (this.isLogin)
{
ArrayList lists = this.getTop16Queue(); //取出16条最顶的消息
if (lists != null && lists.Count > 0)
{
int count = lists.Count;
ArrayList pks = new ArrayList(count); //定义容量
for (int i = 0; i < lists.Count; i++)
{
QueueItem outitem = (QueueItem) lists[i]; //取出每一个消息对象
if (outitem != null)
{
try
{
sendQueueItem(outitem); //发送每一个消息
}
catch (SocketException se)
{
//发送失败
outitem.FailedCount++;
}
}
}
}
}
Thread.Sleep(100);
}
}
private void _StopMe()
{
lock (this)
{
this.isStop = true;
}
}
private void _forcedSubThread(Thread t) //强制停止线程
{
try
{
t.Abort();
t.Join();
}
catch (Exception)
{ }
}
//private 函数区域//
//公用函数 属性区域
public bool Init(string CMPPServer, int CMPPPort)
{
return (this._init(CMPPServer, CMPPPort));
}
public bool Init(string CMPPServer, int CMPPPort, int recvtimeout, int sendtimeout)
{
this.RecvTimeOut = recvtimeout;
this.SendTimeout = sendtimeout;
return (this._init(CMPPServer, CMPPPort));
}
public bool Init(string CMPPServer, int CMPPPort, int recvtimeout)
{
this.RecvTimeOut = recvtimeout;
this.SendTimeout = recvtimeout;
return (this._init(CMPPServer, CMPPPort));
}
public bool Login(string SystemID, string UserName, string Password)
{
try
{
SendLogin(SystemID, UserName, Password);
this.LogLastOkTime(DateTime.Now); //最后一次正确的发送
}
catch (SocketException se)
{
//发送出错
this.ErrorInfo = this.ErrorInfo + "/r/n" + se.ToString();
return (false);
}
DateTime t1 = DateTime.Now;
while (!this.isLogin)
{
byte[] rbuf = new Byte[400];
int l;
try
{
l = tcp.Receive(rbuf);
if (l > 16)
{
if (BIConvert.Bytes2UInt(rbuf, 4) == (uint) MSG.CMPP_COMMAND_ID.CMPP_CONNECT_RESP)
{
MSG.CMPP_MSG_CONNECT_RESP resp = new MSG.CMPP_MSG_CONNECT_RESP(rbuf);
if (resp.isOk)
{
EventArgs e = new EventArgs();
if (onLogonSuccEventHandler != null)
{
onLogonSuccEventHandler(this, e);
}
else
{
this.defaultConnectRespEventHandler();
}
this.isLogin = true;
}
else
{
}
break;
}
}
this._lastOkTime = DateTime.Now; //更新当前最后成功收发套接字的时间
}
catch (SocketException)
{
}
System.TimeSpan t = DateTime.Now - t1;
if (t.TotalSeconds > 10)
{
break;
}
}
if (this.isLogin)
{ //登录ok,就立即发送active_test包
this.ErrorInfo = this.ErrorInfo + "/r/n" + " Logon succ! ";
startThreads(); // 启动 主监视程序de线程
return (true);
}
else
{
return (false);
}
}
public uint SubmitSMS(string to_user, string fee_code, string svc_code, string fee_user, string spnum, string content, int fee_usertype)
{
MSG.CMPP_MSG_SUBMIT sndmsg;
uint seq = this.getNextSequence(); //取得下一个sequence
sndmsg = new MSG.CMPP_MSG_SUBMIT(seq);
sndmsg.FeeCode = fee_code;
sndmsg.FeeTerminalId = to_user;
sndmsg.FeeType = MSG.FeeType.FEE_TERMINAL_PERITEM; //按条收取
sndmsg.FeeUserType = fee_usertype;
sndmsg.Msg_Level = 0;
sndmsg.MSGFormat = (uint) MSG.Msg_Format.UCS2;
sndmsg.SMS_Content = content;
sndmsg.SrcID = spnum; //长号码
sndmsg.SPID = this.systemID;
sndmsg.Svc_Code = svc_code;
sndmsg.UDHI = 0;
sndmsg.ValIdTime = getValIdTime(DateTime.Now); //存活时间
sndmsg.addTerminalID(to_user);
QueueItem q = new QueueItem(seq, (uint) MSG.CMPP_COMMAND_ID.CMPP_SUBMIT, 0, 0);
q.setmsgObj(sndmsg);
this.addToOutQueue(q);
return (seq);
}
public uint SendMsg(string to_user, string fee_user, string fee, string svccode, string content, string spnum)
{
uint seq = this.getNextSequence();
MSG.CMPP_MSG_SUBMIT sndmsg = new MSG.CMPP_MSG_SUBMIT(seq);
sndmsg.FeeCode = fee;
sndmsg.FeeType = MSG.FeeType.FEE_TERMINAL_PERITEM;
sndmsg.FeeTerminalId = fee_user;
sndmsg.FeeUserType = (int) MSG.FeeUserType.FEE_NULL; //计费 按照计费号码计费
sndmsg.SPID = this.systemID; //企业代码
sndmsg.UDHI = 0; //
sndmsg.MSGFormat = (uint) MSG.Msg_Format.GB2312;
sndmsg.SMS_Content = content;
sndmsg.SrcID = spnum;
sndmsg.Svc_Code = svccode;
sndmsg.addTerminalID(to_user);
QueueItem q = new QueueItem(seq, (uint) MSG.CMPP_COMMAND_ID.CMPP_SUBMIT, 0, 0);
q.setmsgObj(sndmsg);
this.addToOutQueue(q);
return (seq);
}
public uint SendSMC(string fee_user, string feecode, string svccode) //向计费用户发送一条包月计费信息
{
uint seq = this.getNextSequence();
MSG.CMPP_MSG_SUBMIT sndmsg = new MSG.CMPP_MSG_SUBMIT(seq);
sndmsg.SMS_Delivery_Type = 2; //产生包月SMC
sndmsg.FeeCode = feecode;
sndmsg.FeeType = MSG.FeeType.FEE_TERMINAL_MONTH; //包月计费
sndmsg.FeeTerminalId = fee_user;
sndmsg.FeeUserType = (int) MSG.FeeUserType.FEE_TERMINAL_ID; //计费 按照计费号码计费
sndmsg.SPID = this.systemID; //企业代码
sndmsg.UDHI = 0; //
sndmsg.MSGFormat = (uint) MSG.Msg_Format.UCS2;
sndmsg.SMS_Content = "SMC";
sndmsg.SrcID = this.userName; //sp的特符号码
sndmsg.Svc_Code = svccode;
sndmsg.addTerminalID(fee_user);
QueueItem q = new QueueItem(seq, (uint) MSG.CMPP_COMMAND_ID.CMPP_SUBMIT, 0, 0);
q.setmsgObj(sndmsg);
this.addToOutQueue(q);
return (seq);
}
public uint SendSMT(string to_user, string feecode, string svccode, string spnum, string content)
{
uint seq = this.getNextSequence();
MSG.CMPP_MSG_SUBMIT sndmsg = new MSG.CMPP_MSG_SUBMIT(seq);
sndmsg.SMS_Delivery_Type = 1; //产生包月SMC
sndmsg.FeeCode = feecode; //包月计费代码
sndmsg.FeeType = MSG.FeeType.FEE_TERMINAL_MONTH; //包月计费
sndmsg.FeeTerminalId = to_user;
sndmsg.FeeUserType = (int) MSG.FeeUserType.FEE_TERMINAL_ID; //计费 按照计费号码计费
sndmsg.SPID = this.systemID; //企业代码
sndmsg.UDHI = 0; //
sndmsg.MSGFormat = (uint) MSG.Msg_Format.UCS2;
sndmsg.SMS_Content = content;
sndmsg.SrcID = spnum; //sp的特符号码
sndmsg.Svc_Code = svccode;
sndmsg.addTerminalID(to_user);
QueueItem q = new QueueItem(seq, (uint) MSG.CMPP_COMMAND_ID.CMPP_SUBMIT, 0, 0);
q.setmsgObj(sndmsg);
this.addToOutQueue(q);
return (seq);
}
public uint SendQuery(string svccode, string whichday) //查询某个业务的总计数
{
string wd = whichday.Trim();
int query_type = 0;
if (svccode == null || svccode.CompareTo("") == 0)
{//查询全部页数量
}
else
{//查询某项业务
query_type = 1;
}
if (wd == null || wd.CompareTo("") == 0)
{
DateTime d = DateTime.Now;
wd = d.Year.ToString() + d.Month.ToString().PadLeft(2, '0') + d.Day.ToString().PadLeft(2, '0');
}
uint seq = this.getNextSequence();
MSG.CMPP_MSG_QUERY query = new MSG.CMPP_MSG_QUERY(seq);
query.Query_Type = query_type;
query.Query_Code = svccode;
query.Time = wd; //设定那一天
QueueItem q = new QueueItem(seq, (uint) MSG.CMPP_COMMAND_ID.CMPP_QUERY, 0, 0);
q.setmsgObj(query);
this.addToOutQueue(q);
return (seq); //返回消息的内部编号
}
public uint StopCMPPConnection() //停止CMPP协议的socket连接
{
uint seq = this.getNextSequence();
MSG.CMPP_MSG_TERMINATE t = new MSG.CMPP_MSG_TERMINATE(seq);
QueueItem q = new QueueItem(seq, (uint) MSG.CMPP_COMMAND_ID.CMPP_TERMINATE, 0, 0);
q.setmsgObj(t);
this.addToOutQueue(q);
return (seq); //返回终止消息，便于等待
}
public uint CancelMsg(string msgid)
{
uint seq = this.getNextSequence();
MSG.CMPP_MSG_CANCEL cancel = new MSG.CMPP_MSG_CANCEL(seq);
cancel.MsgID = msgid;
QueueItem q = new QueueItem(seq, (uint) MSG.CMPP_COMMAND_ID.CMPP_CANCEL, 0, 0);
q.setmsgObj(cancel);
this.addToOutQueue(q);
return (seq); //返回消息的内部编号
}
public void StopMe()
{
if (!this.isStop)
{
if (this.tcpIsCanUse())//发送一条对服务器的通告
{
uint seq = this.getNextSequence();
MSG.CMPP_MSG_TERMINATE t = new MSG.CMPP_MSG_TERMINATE(seq);
QueueItem q = new QueueItem(seq, (uint) MSG.CMPP_COMMAND_ID.CMPP_TERMINATE, 0, 0);
q.setmsgObj(t);
this.addToOutQueue(q);
}
Thread.Sleep(500); //等待1000ms,告知服务器
this._StopMe();
tcp.Close();
if (this.onClientSvcStopedHandler != null)
{
ClientQueueStateArgs arg = new ClientQueueStateArgs(this._outSeqQueue, this._waitingSeqQueue);
onClientSvcStopedHandler(this, arg);
}
else
{
this.defaultClientStopEventHandler();
}
Thread.Sleep(500); //再次主动等待线程结束
//此处报告 2个队列中的信息
}
//准备强行结束
_forcedSubThread(this.Send_Thread);
Thread.Sleep(500); //等待1000ms,告知服务器
_forcedSubThread(this.Recv_Thread);
Thread.Sleep(500); //等待1000ms,告知服务器
_forcedSubThread(this.Deamo_Thread);
Thread.Sleep(500); //等待1000ms,告知服务器
}
public string getLogInfo()
{
string t = this.ErrorInfo;
this.ErrorInfo = "";
return (t);
}
public int getQueueItemState(uint seq) //根据seq寻找发送内部队列的消息对象的状态
{
int status = 0; //状态未知
if (this._outSeqQueue.ContainsKey(seq)) //存在于outSeqQueue中
{
if (this._waitingSeqQueue.Contains(seq))
{
//正在发送等待返回，状态未定
}
else
{
//还没有发送
}
}
else
{
if (this._waitingSeqQueue.ContainsKey(seq))
{
//正等待回应
}
else
{
//已经发送结束了
}
}
return (status);
}
public void TestSubmit(string[] nums, int topI, int topJ) //发送测试包
{
int count = 0;
int total = 0;
ArrayList pks = new ArrayList();
//准备100个包
for (int i = 0; i < 10; i++)
{
for (int j = 0; j < 10; j++)
{
uint seq = this.getNextSequence(); //准备流水号
MSG.CMPP_MSG_SUBMIT sndmsg = new MSG.CMPP_MSG_SUBMIT(seq);
sndmsg.FeeCode = "000001";
sndmsg.FeeTerminalId = nums[i];
sndmsg.FeeType = MSG.FeeType.FEE_TERMINAL_PERITEM; //按条收取
sndmsg.FeeUserType = 0; //终端用户计费
sndmsg.Msg_Level = 0;
sndmsg.MSGFormat = (uint) MSG.Msg_Format.UCS2;
sndmsg.SMS_Content = "test";
sndmsg.SrcID = "09880"; //长号码
sndmsg.SPID = this.systemID;
sndmsg.Svc_Code = "cmcctest";
sndmsg.UDHI = 0;
sndmsg.ValIdTime = getValIdTime(DateTime.Now); //存活时间
sndmsg.addTerminalID(nums[i]);
pks.Add(sndmsg.toBytes()); //存入数组
}
}
DateTime t1 = DateTime.Now;
for (int i = 0; i < topI; i++)
{
for (int j = 0; j < topJ; j++)
{
try
{
tcp.Send((byte[]) pks[i * 10 + j]);
count++;
total++;
}
catch (SocketException se)
{
this.ErrorInfo = this.ErrorInfo + "/r/n" + "发送错误： " + se.ToString();
}
if (count >= 16)
{
count = 0; //复位
Thread.Sleep(50); //暂停20ms
}
}
}
DateTime t2 = DateTime.Now;
TimeSpan t = t2 - t1;
this.ErrorInfo = this.ErrorInfo + "/r/n" + "发送: " + total + " 条消息, 总计花费时间:" + t.TotalMilliseconds + "毫秒";
} //测试函数供测试移动网络测试
//测试翰数区域///
//公用函数 属性区域
}
//*************工具类结束***********************************
enum MSG_STATE //CMPP消息在队列中的状态枚举值
{
NEW = 0, //加入到队列等待发送出去
SENDING = 1, //正被某个线程锁定
SENDED_WAITTING = 2, //发送出去，现在等待resp消息返回
SENDING_FINISHED = 3 //得到回应，一般等待被清理出队列
}
public class QueueItem //代表一个存储在缓存队列中的消息，序列号由CMPPClient产生
{
uint _sequence; //消息索引 就是流水号
uint _msgType; //消息的类别就是COMMAND_ID,根据此值决定 Object _msgObj的原类型
int _failedCount = 0; //失败计数，如果失败次数超过3此需要进行清理
int _msgState; //当前消息状态,具体为 MSG_STATE的枚举类型
object _msgObj; //存放消息对象,具体类型参考 _msgType
DateTime _inQueueTime; //消息进入队列的时间,上次消息的发送时间
public int FailedCount
{
set
{
this._failedCount = value;
}
get
{
return (this._failedCount);
}
}
public object getMsgObj()
{
return (this._msgObj);
}
public void setmsgObj(object inmsg)
{
this._msgObj = inmsg;
}
public DateTime inQueueTime
{
set
{
this._inQueueTime = value;
}
get
{
return (this._inQueueTime);
}
}
public uint MsgType
{
get
{
return (this._msgType);
}
}
public int MsgState
{
get
{
return (this._msgState);
}
set
{
this._msgState = value;
}
}
public uint Sequence
{
get
{
return (this._sequence);
}
set
{
this._sequence = value;
}
}
public QueueItem(uint sequence, uint msgtype, int faildedcount, int msgstate)
{
this._failedCount = faildedcount;
this._msgState = msgstate;
this._msgType = msgtype;
this._sequence = sequence;
}
public QueueItem(uint sequence, uint msgtype, int faildedcount, int msgstate, object msgobj)
{
this._failedCount = faildedcount;
this._msgState = msgstate;
this._msgType = msgtype;
this._sequence = sequence;
this.setmsgObj(msgobj);
}
}
public class BIConvert //字节 整形 转换类 网络格式转换为内存格式
{
public static byte[] Int2Bytes(uint i) //转换整形数据网络次序的字节数组
{
byte[] t = BitConverter.GetBytes(i);
byte b = t[0];
t[0] = t[3];
t[3] = b;
b = t[1];
t[1] = t[2];
t[2] = b;
return (t);
}
public static uint Bytes2UInt(byte[] bs, int startIndex) //返回字节数组代表的整数数字，4个数组
{
byte[] t = new byte[4];
for (int i = 0; i < 4 && i < bs.Length - startIndex; i++)
{
t[i] = bs[startIndex + i];
}
byte b = t[0];
t[0] = t[3];
t[3] = b;
b = t[1];
t[1] = t[2];
t[2] = b;
return (BitConverter.ToUInt32(t, 0));
}
public static uint Bytes2UInt(byte[] bs) //没有指定起始索引
{
return (Bytes2UInt(bs, 0));
}
public static void DumpBytes(byte[] bs, string txt)
{
System.IO.StreamWriter sw = new System.IO.StreamWriter(txt);
for (int i = 0; i < bs.Length; i++)
{
byte b = bs[i];
sw.WriteLine(b.ToString("X") + " ");
}
sw.WriteLine("-----" + DateTime.Now.ToLocalTime());
sw.Close();
}
public static void DebugString(string bs, string txt)
{
System.IO.StreamWriter sw = new System.IO.StreamWriter(txt);
sw.WriteLine(bs);
sw.WriteLine("-----" + DateTime.Now.ToLocalTime());
sw.Close();
}
}
public class ReportEventArgs : EventArgs //报告事件携带的数据
{
string _smsState; //发送短信的应答结果，含义与SMPP协议要求中stat字段定义相同 。SP根据该字段确定CMPP_SUBMIT消息的处理状态。
string _submitTime; //提交短信的时间，也可根据此时间决定是否重发
string _doneTime; //送达目的地的时间
string _destNum; //送达的号码
string _msgID; //关于那一条消息的报告
uint _sequence; //CMPP网关产生的流水号
UInt64 _msg_id; //被报告的提交短信的msgID,ISMG在submit_resp返回给SP的
public string State
{
get
{
return (this._smsState);
}
set
{
this._smsState = value;
}
}
public uint Sequence
{
get
{
return (this._sequence);
}
set
{
this._sequence = value;
}
}
public string toUserNum
{
get
{
return (this._destNum);
}
set
{
this._destNum = value;
}
}
public string MsgID
{
get
{
return (this._msgID);
}
set
{
this._msgID = value;
}
}
public string SubmitTime
{
get
{
return (this._submitTime);
}
set
{
this._submitTime = value;
}
}
public string DoneTime
{
get
{
return (this._doneTime);
}
set
{
this._doneTime = value;
}
}
public ReportEventArgs(byte[] bs) //从一个字节数组中获得报告
{
byte[] temp = new byte[8 + 7 + 10 + 10 + 21 + 4];
for (int i = 0; i < temp.Length; i++)
{
temp[i] = bs[i];
}
init(temp);
}
public ReportEventArgs(byte[] bs, int startIndex) //起始
{
byte[] temp = new byte[8 + 7 + 10 + 10 + 21 + 4];//定义长度
for (int i = 0; i < temp.Length; i++)
{
temp[i] = bs[startIndex + i];
}
init(temp);
}
public ReportEventArgs(string msgid, string destnum, string smsstate, string submittime, string donetime, uint seq)
{
this._msgID = msgid;
this._destNum = destnum;
this._smsState = smsstate;
this._submitTime = submittime;
this._doneTime = donetime;
this._sequence = seq;
}
public DateTime getSubmitTime()
{
return (getTime(this._submitTime));
}
public DateTime getDoneTime()
{
return (getTime(this._doneTime));
}
private DateTime getTime(string time_string)
{
int index = 0;
int yy = Convert.ToInt32("20" + time_string.Substring(index, 2));
index += 2;
int mm = Convert.ToInt32(time_string.Substring(index, 2));
index += 2;
int dd = Convert.ToInt32(time_string.Substring(index, 2));
index += 2;
int hh = Convert.ToInt32(time_string.Substring(index, 2));
index += 2;
int mms = Convert.ToInt32(time_string.Substring(index, 2));
DateTime t = new DateTime(yy, mm, dd, hh, mms, 0);
return (t);
}
private void init(byte[] bs)
{
BIConvert.DumpBytes(bs, "c://ReportEventArgs.txt");//保留映像
int index = 0;
this._msg_id = BitConverter.ToUInt64(bs, index); //BitConverter.ToUInt64(bs,index);
this._msgID = (this._msg_id.ToString());
// BIConvert.DebugString(this._msgID ,"c://MSGID.txt");
index += 8;
this._smsState = Encoding.ASCII.GetString(bs, index, 7);
index += 7;
this._submitTime = Encoding.ASCII.GetString(bs, index, 10);
index += 10;
this._doneTime = Encoding.ASCII.GetString(bs, index, 10);
index += 10;
this._destNum = Encoding.ASCII.GetString(bs, index, 21);
index += 21;
this._sequence = BIConvert.Bytes2UInt(bs, index);
}
}
public class SMSEventArgs : EventArgs
{
UInt64 _msgid; //8字节的消息标示
string _destID; //接受信息的目标ID
string _svcCode; //业务代码
int _tpPID; //参考GSM协议
int _tpUDHI; //
int _msgFrm; //消息的编码格式
string _srcTerminateID; //源终端ID,如果使报告
int _msgLength; //消息的字节数，并非实际字符串长度
string _Content; //消息正文内容
public SMSEventArgs(byte[] bs)
{
int msglen = BitConverter.ToInt32(bs, 8 + 21 + 10 + 1 + 1 + 1 + 21 + 1); //取得消息长度字节长度
int tempLen = msglen + 8 + 21 + 10 + 1 + 1 + 1 + 21 + 1 + 1 + msglen + 8;
byte[] temp = new byte[tempLen];
for (int i = 0; i < temp.Length; i++)
{
temp[i] = bs[i];
}
init(temp);
}
public SMSEventArgs(byte[] bs, int baseIndex)
{
int msglen = (int) bs[MSG.CMPP_MSG_Header.HeaderLength + 8 + 21 + 10 + 1 + 1 + 1 + 21 + 1]; //取得消息长度字节长度
int tempLen = 8 + 21 + 10 + 1 + 1 + 1 + 21 + 1 + 1 + msglen + 8;
byte[] temp = new byte[tempLen];
for (int i = 0; i < temp.Length; i++)
{
temp[i] = bs[i + baseIndex];
}
init(temp);
}
private void init(byte[] bs)
{
BIConvert.DumpBytes(bs, "c://SMSEventArgs.txt");//保留映像
int index = 0;
this._msgid = BitConverter.ToUInt64(bs, 0);
index += 8;
this._destID = Encoding.ASCII.GetString(bs, index, _getRealBytesLength(bs, index));
index += 21;
this._svcCode = Encoding.ASCII.GetString(bs, index, _getRealBytesLength(bs, index));
index += 10;
this._tpPID = (int) bs[index++];
this._tpUDHI = (int) bs[index++];
this._msgFrm = (int) bs[index++];
this._srcTerminateID = Encoding.ASCII.GetString(bs, index, _getRealBytesLength(bs, index));
index += 21;
index++; //是否是状态报告字节
this._msgLength = (int) bs[index++]; //取得字节长度
switch (this._msgFrm)
{
case (int) MSG.Msg_Format.ASCII:
this._Content = Encoding.ASCII.GetString(bs, index, this._msgLength);
break;
case (int) MSG.Msg_Format.GB2312:
this._Content = Encoding.Default.GetString(bs, index, this._msgLength);
break;
case (int) MSG.Msg_Format.UCS2:
this._Content = Encoding.BigEndianUnicode.GetString(bs, index, this._msgLength);
break;
case (int) MSG.Msg_Format.BINARY:
break;
case (int) MSG.Msg_Format.WRITECARD:
break;
default:
break;
}
}
public string toSPNum
{
get
{
return (this._destID);
}
}
public string SrcNum
{
get
{
return (this._srcTerminateID);
}
}
public string Content
{
get
{
return (this._Content);
}
}
public string SvcCode
{
get
{
return (this._svcCode);
}
}
public UInt64 MsgID
{
get
{
return (this._msgid);
}
//set
//{
// this._msgid =value;
//}
}
public string MsgIDString
{
get
{
return (this._msgid).ToString();
}
}
private int _getRealBytesLength(byte[] bts, int index)
{
int i = index;
for (; i < bts.Length; i++)
{
if (bts[i] == 0)
{
break;
}
}
return i - index;
}
}
public class TerminateEventArgs : EventArgs
{
private uint _seq;
private MSG.CMPP_MSG_TERMINATE _msg;
public TerminateEventArgs(uint seq)
{
this._seq = seq;
}
public TerminateEventArgs(object msg)
{
this._msg = (MSG.CMPP_MSG_TERMINATE) msg;
this._seq = this._msg.Sequence;
}
public object getMSG()
{
return (this._msg);
}
}
public class TerminateRespEventArgs : EventArgs
{
private uint _seq;
private MSG.CMPP_MSG_TERMINATE_RESP _msg;
public TerminateRespEventArgs(uint seq)
{
this._seq = seq;
}
public TerminateRespEventArgs(object msg)
{
this._msg = (MSG.CMPP_MSG_TERMINATE_RESP) msg;
this._seq = this._msg.Sequence;
}
public object getMSG()
{
return (this._msg);
}
public uint Sequence
{
set
{
this._seq = value;
}
get
{
return (this._seq);
}
}
}
public class TestEventArgs : EventArgs
{
private uint _seq;
private MSG.CMPP_MSG_TEST _msg;
public TestEventArgs(uint seq)
{
this._seq = seq;
}
public TestEventArgs(object msg)
{
this._msg = (MSG.CMPP_MSG_TEST) msg;
this._seq = this._msg.Sequence;
}
public object getMSG()
{
return (this._msg);
}
public uint Sequence
{
set
{
this._seq = value;
}
get
{
return (this._seq);
}
}
}
public class TestRespEventArgs : EventArgs
{
private uint _seq;
private MSG.CMPP_MSG_TEST_RESP _msg;
public TestRespEventArgs(uint seq)
{
this._seq = seq;
}
public TestRespEventArgs(object msg)
{
this._msg = (MSG.CMPP_MSG_TEST_RESP) msg;
this._seq = this._msg.Sequence;
}
public object getMSG()
{
return (this._msg);
}
public uint Sequence
{
set
{
this._seq = value;
}
get
{
return (this._seq);
}
}
}
public class CancelRespEventArgs : EventArgs
{
private uint _seq;
private MSG.CMPP_MSG_CANCEL_RESP _msg;
public CancelRespEventArgs(uint seq)
{
this._seq = seq;
}
public CancelRespEventArgs(object msg)
{
this._msg = (MSG.CMPP_MSG_CANCEL_RESP) msg;
this._seq = this._msg.Sequence;
}
public object getMSG()
{
return (this._msg);
}
public uint Sequence
{
set
{
this._seq = value;
}
get
{
return (this._seq);
}
}
}
public class QueryRespEventArgs : EventArgs
{
private uint _seq;
private MSG.CMPP_MSG_QUERY_RESP _msg;
public QueryRespEventArgs(uint seq)
{
this._seq = seq;
}
public QueryRespEventArgs(object msg)
{
this._msg = (MSG.CMPP_MSG_QUERY_RESP) msg;
this._seq = this._msg.Sequence;
}
public object getMSG()
{
return (this._msg);
}
public uint Sequence
{
set
{
this._seq = value;
}
get
{
return (this._seq);
}
}
}
public class ConnectRespEventArgs : EventArgs
{
private uint _seq;
private MSG.CMPP_MSG_CONNECT_RESP _msg;
public ConnectRespEventArgs(uint seq)
{
this._seq = seq;
}
public ConnectRespEventArgs(object msg)
{
this._msg = (MSG.CMPP_MSG_CONNECT_RESP) msg;
this._seq = this._msg.Sequence;
}
public object getMSG()
{
return (this._msg);
}
public uint Sequence
{
set
{
this._seq = value;
}
get
{
return (this._seq);
}
}
}
public class SubmitRespEventArgs : EventArgs
{
private uint _seq;
private MSG.CMPP_MSG_SUBMIT_RESP _msg;
public SubmitRespEventArgs(uint seq)
{
this._seq = seq;
}
public SubmitRespEventArgs(object msg)
{
this._msg = (MSG.CMPP_MSG_SUBMIT_RESP) msg;
this._seq = this._msg.Sequence;
}
public object getMSG()
{
return (this._msg);
}
public uint Sequence
{
set
{
this._seq = value;
}
get
{
return (this._seq);
}
}
}
public class WaitingQueueItemEventArgs : EventArgs
{
private uint _seq;
private object _q;
public WaitingQueueItemEventArgs(uint seq)
{
this._seq = seq;
}
public WaitingQueueItemEventArgs(object q)
{
this._q = q;
}
public uint Sequence
{
set
{
this._seq = value;
}
get
{
return (this._seq);
}
}
public object getQueueItem()
{
return (this._q);
}
}
public class ClientQueueStateArgs //当CMPP client的服务停止时候，队列的状态参数
{
private SortedList _waiting;
private SortedList _out;
public ClientQueueStateArgs(SortedList outQueue, SortedList inQueue)
{
this._waiting = inQueue;
this._out = outQueue;
}
public SortedList WaitingQueue
{
get
{
return (this._waiting);
}
set
{
this._waiting = value;
}
}
public SortedList OutQueue
{
get
{
return (this._out);
}
set
{
this._out = value;
}
}
}
public class StateObject
{
public Socket workSocket = null; // Client socket.
public const int BufferSize = 1024; // Size of receive buffer.
public byte[] buffer = new byte[BufferSize]; // Receive buffer.
public byte[] result_buf = null; //接收最终的结果缓冲区
public int _msglength = 0; //接收到多少个字节数据
}
public enum SMSDBQueue_Status : int
{
NEW = 0, //新消息，等待发送
SENDED = 1, //正在发送，等待回应
RESP = 2, //送达SMSC，得到msgid
DELIVRD = 3, //得到报告，状态ok
EXPIRED = 4, //过期
DELETED = 5, //已经删除此消息 UNDELIV
ACCEPTD = 6, // ACCEPTD 状态 未送达 ACCEPTED为中间状态，网关若从短信中心收到后应丢弃，不做任何操作
UNDELIV = 7, //未送达
UNKNOWN = 8, //未知
REJECTD = 9 //被弹回
}
public class SMSDBQueue
{
private uint _sequence = 0; //对应的cmppclient的序列号
private int _smsdbID = 0; //对应的数据库的发送自动增长ID
private int _cmpp_msgType; //cmpp协议的定义的消息类型
private object _cmpp_msg_object; //cmpp消息对象,备检索
private int _currentStatus; //当前消息体状态
private DateTime _inQueueTime = DateTime.Now; //消息产生设定值
private UInt64 _msgid; //消息返回的SMSC给出的id遍号
public uint Sequence
{
get
{
return (this._sequence);
}
set
{
this._sequence = value;
}
}
public int SMSDBID
{
get
{
return (this._smsdbID);
}
set
{
this._smsdbID = value;
}
}
public int CurrentStatus
{
get
{
return (this._currentStatus);
}
set
{
this._currentStatus = value;
}
}
public int CMPPMsgType
{
get
{
return (this._cmpp_msgType);
}
set
{
this._cmpp_msgType = value;
}
}
public DateTime InQueueTime
{
get
{
return (this._inQueueTime);
}
set
{
this._inQueueTime = value;
}
}
public object MsgObject
{
get
{
return (this._cmpp_msg_object);
}
set
{
this._cmpp_msg_object = value;
}
}
public UInt64 UIMsgID
{
get
{
return (this._msgid);
}
set
{
this._msgid = value;
}
}
public string MsgID
{
get
{
return (this._msgid.ToString());
}
set
{
this._msgid = Convert.ToUInt64(value);
}
}
}
//*************工具类结束***********************************
//********************接口类，用于连接对外的短信存储系统**********************
public interface ISMSStore //定义一个存储接口
{
SMSRec[] getSMSsFromStore(); //从外部存储中获取消息
void updateStoreObjec(int storeObjectID, string state); //更新id代表的对象状态,用于监测状态报告
void updateSMSCMsgID(int storeObjectID, UInt64 msgid);
bool addSMS2Store(SMSRec sms); //向store中存储短消息
string getFeeCode(string svccode); //根据svccode返回消息的收费,根据移动参数进行设定
}
public class SMSRec //SMS载数据库中的表达
{
private int _RecID;
private string _feeUser; //计费用户
private int _smsType = 0; //短信类型 0 普通文字短信 1 闪烁短信 2 查询命令短信 3 包月短信
private string _svccode; //服务代码
private string _msg; //消息
private string _state; //消息状态
private string _feecode;
private string _spnum;
private string _toUser;
public SMSRec(int recid, string feeuser, string feecode, string svccode, string msg, string spnum)
{
this._RecID = recid;
this._feeUser = feeuser;
this._toUser = feeuser;
this._svccode = svccode;
this._msg = msg;
this._spnum = spnum;
}
public SMSRec(int recid, string feeuser, string touser, string feecode, string svccode, string msg, string spnum)
{
this._RecID = recid;
this._feeUser = feeuser;
this._toUser = touser;
this._svccode = svccode;
this._msg = msg;
this._spnum = spnum;
}
public string SvcCode
{
get
{
return (this._svccode);
}
set
{
this._svccode = value;
}
}
public string FeeCode
{
get
{
return (this._feecode);
}
set
{
this._feecode = value;
}
}
public string FeeUser
{
get
{
return (this._feeUser);
}
set
{
this._feeUser = value;
}
}
private string ToUser
{
get
{
return (this._toUser);
}
set
{
this._toUser = value;
}
}
public string SPNum
{
get
{
return (this._spnum);
}
set
{
this._spnum = value;
}
}
public string Message
{
get
{
return (this._msg);
}
set
{
this._msg = value;
}
}
}
//****************************** 接口类结束 *********************************
//*************************定义 处理数据库接口的SMS系统类，该类对外提供CMPP处理功能***********
//**功能，实现队列监测，处理失败消息、成功消息，处理定时存储更新等抽象功能的组织，将CMPPClient包装提供
public class SMSSystem
{
private ISMSStore dbcls = null;
private CMPPClient client = null;
private string pwd;
private string systemid;
private string spnum;
public void setISMSStoreInterface(ISMSStore ismsstore)
{
dbcls = ismsstore;
}
public SMSSystem(string systemid, string spnum, string password, string cmppserverip, int cmppport)
{
client = new CMPPClient();
client.Init(cmppserverip, cmppport);
this.spnum = spnum;
this.systemid = systemid;
this.pwd = password;
}
}
//********************************处理SMS系统类结束
namespace MSG //消息类定义
{
//*************枚举类型开始***********************************
public enum CMPP_COMMAND_ID : uint
{
CMPP_CONNECT = 1,
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 // 激活测试应答
}
public enum FeeUserType
{
FEE_TERMINAL_ID = 0, //
FEE_SOURCE_ID = 1,
FEE_SP = 2,
FEE_NULL = 3
}
public enum Msg_Format
{
ASCII = 0,
WRITECARD = 1,
BINARY = 2,
UCS2 = 8,
GB2312 = 15
}
public enum SUBMIT_RESULT
{
SUCC = 0,
MSG_STRUCTURE_ERR = 1,
COMMANID_ERR = 2,
MSG_SEQUENCE_ERR = 3,
MSG_LENGTH_ERR = 4,
FEE_CODE_ERR = 5,
OUT_OF_MSG_LEN_ERR = 6,
SVC_CODE_ERR = 7,
FLUX_ERR = 8,
OTHER_ERR = 9
}
//*************枚举类型结束***********************************
//*************结构定义开始***********************************
public struct FeeType
{
public static readonly string FEE_TERMINAL_FREE = "01";
public static readonly string FEE_TERMINAL_PERITEM = "02";
public static readonly string FEE_TERMINAL_MONTH = "03";
public static readonly string FEE_TERMINAL_TOP = "04";
public static readonly string FEE_TERMINAL_SP = "05";
}
public struct DELIVER_STATE
{
public static readonly string DELIVERED = "DELIVRD";
public static readonly string EXPIRED = "EXPIRED";
public static readonly string DELETED = "DELETED";
public static readonly string UNDELIVERABLE = "UNDELIV";
public static readonly string ACCEPTED = "ACCEPTD";
public static readonly string UNKNOWN = "UNKNOWN";
public static readonly string REJECTED = "REJECTD";
}
//*************结构类型结束***********************************
//****************消息类**************************************
public class CMPP_MSG_Header //消息头
{
private byte[] initValue = new byte[MSG.CMPP_MSG_Header.HeaderLength];
public CMPP_MSG_Header(CMPP_COMMAND_ID Command_ID) //发送前
{
BIConvert.Int2Bytes((uint) Command_ID).CopyTo(initValue, 4);
}
public CMPP_MSG_Header(byte[] bs) //根据受到的字节进行构造 字节序列
{
int l = MSG.CMPP_MSG_Header.HeaderLength;
for (int i = 0; i < l; i++)
{
initValue[i] = bs[i];
}
}
public CMPP_MSG_Header(byte[] bs, int baseIndex) //根据受到的字节进行构造 字节序列
{
int l = MSG.CMPP_MSG_Header.HeaderLength;
for (int i = 0; i < l; i++)
{
initValue[i] = bs[baseIndex + i];
}
}
public uint MSGLength //获取此消息头代表的消息的整个长度
{
get
{
return (BIConvert.Bytes2UInt(initValue, 0));
}
set
{
byte[] t = BIConvert.Int2Bytes(value);
for (int i = 0; i < 4; i++)
{
initValue[i] = t[i];
}
}
}
public uint Command_ID
{
get
{
return (BIConvert.Bytes2UInt(initValue, 4));
}
set
{
byte[] t = BIConvert.Int2Bytes(value);
for (int i = 0; i < 4; i++)
{
initValue[i + 4] = t[i];
}
}
}
public uint SequenceId
{
get
{
return (BIConvert.Bytes2UInt(initValue, 8));
}
set
{
byte[] t = BIConvert.Int2Bytes(value);
for (int i = 0; i < 4; i++)
{
initValue[i + 4 + 4] = t[i];
}
}
}
public byte[] toBytes()
{
return (initValue); //将字段转化为字节
}
public void fromBytes(byte[] bs)
{
for (int i = 0; i < MSG.CMPP_MSG_Header.HeaderLength; i++)
{
initValue[i] = bs[i];
}
}
public static int HeaderLength
{
get
{
return (4 + 4 + 4);
}
}
}
public class CMPP_MSG_CONNECT
{
CMPP_MSG_Header header;
byte[] initValue;
byte[] body;
int baseIndex = MSG.CMPP_MSG_Header.HeaderLength; //消息的起始
byte ver = 0x20;
byte[] AuthenticatorSource = new Byte[16]; //发送的验证信息
string _SystemID = "000000";
string _Password = "00000000";
string _timestamp = "0000000000";
public CMPP_MSG_CONNECT(uint sequence)
{
header = new MSG.CMPP_MSG_Header(MSG.CMPP_COMMAND_ID.CMPP_CONNECT);
header.SequenceId = sequence;
header.MSGLength = (uint) (this.BodyLength + MSG.CMPP_MSG_Header.HeaderLength);
body = new byte[this.BodyLength];
}
public CMPP_MSG_CONNECT(byte[] bs)
{
initValue = new byte[bs.Length];
bs.CopyTo(initValue, 0); //进行初始化行为
byte[] temp = new byte[MSG.CMPP_MSG_Header.HeaderLength];
for (int i = 0; i < temp.Length; i++)
{
temp[i] = bs[i];
}
byte[] body = new Byte[bs.Length - MSG.CMPP_MSG_Header.HeaderLength];
for (int i = 0; i < body.Length; i++)
{
body[i] = bs[MSG.CMPP_MSG_Header.HeaderLength + i]; //将消息的字节存储
}
header = new MSG.CMPP_MSG_Header(temp); //构造 消息头
header.MSGLength = (uint) (this.BodyLength + MSG.CMPP_MSG_Header.HeaderLength);
header.Command_ID = (uint) MSG.CMPP_COMMAND_ID.CMPP_CONNECT;
}
public int BodyLength
{
get
{
return (6 + 16 + 4 + 1);
}
}
public string SourceAdd
{
set
{
_SystemID = value;
byte[] t = Encoding.ASCII.GetBytes(_SystemID); //转换为字节数组
t.CopyTo(body, 0);
}
}
public string Password
{
set
{
_Password = value;
}
}
public string Version
{
set
{
ver = Convert.ToByte("0x" + value, 16);
}
}
private static string getTimestamp() //返回一个时间戳 4 字节
{
DateTime msgtime = DateTime.Now;
string u = msgtime.Month.ToString().PadLeft(2, '0');
u = u + msgtime.Day.ToString().PadLeft(2, '0');
u = u + msgtime.Hour.ToString().PadLeft(2, '0');
u = u + msgtime.Minute.ToString().PadLeft(2, '0');
u = u + msgtime.Second.ToString().PadLeft(2, '0');
return (u);
}
private byte[] getMd5Code()
{
MD5 md5 = new MD5CryptoServiceProvider(); //创建MD5类别
byte[] buf = new byte[6 + 9 + _Password.Length + 10];
byte[] s_a = Encoding.ASCII.GetBytes(_SystemID); //Source_ADD 就是企业代码
byte[] s_0 ={ 0, 0, 0, 0, 0, 0, 0, 0, 0 }; //9字节的0,此处当作右补0
byte[] s_p = Encoding.ASCII.GetBytes(_Password); //密码
this._timestamp = getTimestamp(); //取得认证码时赋值字符串
byte[] s_t = Encoding.ASCII.GetBytes(_timestamp); //10位的字符串字节数组
s_a.CopyTo(buf, 0); //base 0
s_0.CopyTo(buf, 6); //base 6
s_p.CopyTo(buf, 6 + 9); //base 6+9
s_t.CopyTo(buf, 6 + 9 + _Password.Length); //base 6+9+password.length
return (md5.ComputeHash(buf, 0, buf.Length));
}
private byte[] getSourceAdd()
{
return (Encoding.ASCII.GetBytes(this._SystemID));
}
public byte[] ToBytes() //返回当前对象的字节数组印象
{
byte[] reVal = new Byte[MSG.CMPP_MSG_Header.HeaderLength + this.BodyLength];
header.toBytes().CopyTo(reVal, 0); //消息头
getSourceAdd().CopyTo(reVal, MSG.CMPP_MSG_Header.HeaderLength); //源地址 企业代码
getMd5Code().CopyTo(reVal, MSG.CMPP_MSG_Header.HeaderLength + 6); //认证md5
reVal[MSG.CMPP_MSG_Header.HeaderLength + 6 + 16] = this.ver; //版本字节
BIConvert.Int2Bytes(Convert.ToUInt32(this._timestamp)).CopyTo(reVal, MSG.CMPP_MSG_Header.HeaderLength + 6 + 16 + 1);
return (reVal);
}
}
public class CMPP_MSG_CONNECT_RESP
{
CMPP_MSG_Header header;
byte Status;
byte[] AuthenticatorISMG;
byte _Version;
public CMPP_MSG_CONNECT_RESP(byte[] bs)
{
byte[] temp_head = new Byte[MSG.CMPP_MSG_Header.HeaderLength];
int index = 0;
for (int i = 0; i < MSG.CMPP_MSG_Header.HeaderLength; i++)
{
temp_head[i] = bs[index++];
}
header = new MSG.CMPP_MSG_Header(temp_head);
Status = bs[index++]; //状态字节
AuthenticatorISMG = new byte[16]; //回应摘要
for (int i = 0; i < AuthenticatorISMG.Length; i++)
{
AuthenticatorISMG[i] = bs[index++];
}
_Version = bs[index++];
}
public bool isOk
{
get
{
return (true);
}
}
public string Ver
{
get
{
return (Convert.ToString(this._Version, 16));
}
}
public string ISMGREturnAuthCode
{
get
{
return (Encoding.ASCII.GetString(AuthenticatorISMG));
}
}
public uint Command_ID
{
get
{
return (header.Command_ID);
}
set
{
header.Command_ID = value;
}
}
public uint Sequence
{
get
{
return (header.SequenceId);
}
}
}
public class CMPP_MSG_TERMINATE
{
CMPP_MSG_Header header;
public CMPP_MSG_TERMINATE(uint sequence)
{
header = new MSG.CMPP_MSG_Header(CMPP.YOURCOMPANY.MSG.CMPP_COMMAND_ID.CMPP_TERMINATE);
header.MSGLength = (uint) MSG.CMPP_MSG_Header.HeaderLength;
header.SequenceId = sequence;
}
public CMPP_MSG_TERMINATE(byte[] bs)
{
header = new MSG.CMPP_MSG_Header(bs);
}
public byte[] toBytes()
{
return (header.toBytes());
}
public uint Sequence
{
get
{
return (header.SequenceId);
}
}
}
public class CMPP_MSG_TERMINATE_RESP
{
CMPP_MSG_Header header;
public CMPP_MSG_TERMINATE_RESP(byte[] bs)
{
header = new CMPP_MSG_Header(bs);
}
public CMPP_MSG_TERMINATE_RESP(uint sequence)
{
header = new MSG.CMPP_MSG_Header(MSG.CMPP_COMMAND_ID.CMPP_TERMINATE_RESP);
header.MSGLength = (uint) MSG.CMPP_MSG_Header.HeaderLength;
header.SequenceId = sequence;
}
public byte[] toBytes()
{
return (header.toBytes());
}
public uint Command_ID
{
get
{
return (header.Command_ID);
}
set
{
header.Command_ID = value;
}
}
public uint Sequence
{
get
{
return (header.SequenceId);
}
}
}
public class CMPP_MSG_SUBMIT
{
CMPP_MSG_Header header;
int _isReportOrSMC = 1; //是否需要状态报告
int _msgTotal = 1; //相同消息的条数
int _msgNumber = 1; //
int _msgLevel = 0; //消息级别,却胜0
string _svcCode = ""; //业务类型
int _feeUserType = 0; //计费用户类型字段0：对目的终端MSISDN计费；1：对源终端MSISDN计费；2：对SP计费;3：表示本字段无效，对谁计费参见Fee_terminal_Id字段
string _feeTerminalId = ""; //被计费终端
int _tpPid = 0;
int _tpUDHI = 0;
uint _msgFmt = 0; //消息格式
string _msgsrc = ""; //消息来源 即spid
string _feeType = MSG.FeeType.FEE_TERMINAL_PERITEM; //
string _feeCode = ""; //资费
string _valIdTime = ""; //存活期
string _atTime = ""; //调度时间
string _srcId = ""; //源号码，就是在手机上显示的号码
int _destUsrNum = 0; //接受消息的手机数
string[] _destTerminalIds = new string[100]; //至多100个号码
int _msgLengt = (int) MSG.Msg_Format.GB2312;
string _MsgContent = "";
UInt64 _MsgID; //返回的消息ID
public CMPP_MSG_SUBMIT(uint sequence)
{
header = new MSG.CMPP_MSG_Header(CMPP.YOURCOMPANY.MSG.CMPP_COMMAND_ID.CMPP_SUBMIT);
header.SequenceId = sequence;
}
//属性
public string SMS_Content
{
set
{
this._MsgContent = value;
byte[] t = Encoding.ASCII.GetBytes(value);
this._msgLengt = t.Length;
}
}
public int SMS_Delivery_Type //是否要求返回状态确认报告：0：不需要1：需要2：产生SMC话单 （该类型短信仅供网关计费使用，不发送给目的终端)
{
set
{
_isReportOrSMC = value;
}
}
public int Msg_Level
{
set
{
this._msgLevel = value;
}
}
public string Svc_Code
{
set
{
this._svcCode = value;
}
}
public int FeeUserType
{
set
{
this._feeUserType = value;
}
}
public string FeeTerminalId
{
set
{
this._feeTerminalId = value;
}
}
public int UDHI
{
set
{
this._tpUDHI = value;
}
}
public uint MSGFormat
{
set
{
this._msgFmt = value;
}
}
public string SPID
{
set
{
this._msgsrc = value;
}
}
public string SrcID //可以此处确定长号码
{
set
{
this._srcId = value;
}
}
public string FeeType
{
set
{
this._feeType = value.PadLeft(2, '0');
}
}
public string FeeCode
{
set
{
this._feeCode = value;
}
}
public string ValIdTime
{
set
{
this._valIdTime = value;
}
}
public string AtTime
{
set
{
this._atTime = value;
}
}
public UInt64 MsgID
{
set
{
this._MsgID = value;
}
get
{
return (this._MsgID);
}
}
//属性结束//
public void addTerminalID(string id)
{
if (this._destUsrNum < 100)
{
this._destTerminalIds[this._destUsrNum++] = id;
}
}
public byte[] toBytes() //返回字节数印象
{
byte[] submitData = new byte[400];
int index = MSG.CMPP_MSG_Header.HeaderLength; //当前包的填充指针
{//进入填充包的过程
index = index + 8; //msgid跳过
submitData[index++] = (byte) this._msgTotal;
submitData[index++] = (byte) this._msgNumber;
submitData[index++] = (byte) this._isReportOrSMC;
submitData[index++] = (byte) this._msgLevel;
byte[] svccode = Encoding.ASCII.GetBytes(this._svcCode);
svccode.CopyTo(submitData, index); //拷贝到目标
index = index + 10; //index增加
submitData[index++] = (byte) this._feeUserType;
byte[] feetid = Encoding.ASCII.GetBytes(this._feeTerminalId);
feetid.CopyTo(submitData, index);
index = index + 21;
submitData[index++] = (byte) this._tpPid;
submitData[index++] = (byte) this._tpUDHI;
submitData[index++] = (byte) this._msgFmt;
byte[] spid = Encoding.ASCII.GetBytes(this._msgsrc);
spid.CopyTo(submitData, index);
index = index + 6;
byte[] feetype = Encoding.ASCII.GetBytes(this._feeType);
feetype.CopyTo(submitData, index);
index = index + 2;
byte[] feecode = Encoding.ASCII.GetBytes(this._feeCode);
feecode.CopyTo(submitData, index);
index = index + 6;
//byte[] validtime=Encoding.ASCII.GetBytes(this._valIdTime);
//validtime.CopyTo (submitData,index);
index = index + 17;
//byte[] attime=Encoding.ASCII.GetBytes(this._valIdTime);
//attime.CopyTo (submitData,index);
index = index + 17;
byte[] srcid = Encoding.ASCII.GetBytes(this._srcId);
srcid.CopyTo(submitData, index);
index = index + 21;
submitData[index++] = (byte) this._destUsrNum;
for (int i = 0; i < this._destUsrNum; i++)
{
byte[] temp = Encoding.ASCII.GetBytes(this._destTerminalIds[i]);
temp.CopyTo(submitData, index);
index = index + 21;
}
submitData[index++] = (byte) this._msgLengt;
byte[] msg = null;
switch (this._msgFmt)
{//根据编码类型确定转换字节
case (uint) MSG.Msg_Format.ASCII:
msg = Encoding.ASCII.GetBytes(this._MsgContent);
msg.CopyTo(submitData, index);
submitData[index - 1] = (byte) msg.Length; //重新设定长度
index = index + msg.Length;
break;
case (uint) MSG.Msg_Format.BINARY:
msg = Encoding.ASCII.GetBytes(this._MsgContent);
msg.CopyTo(submitData, index);
submitData[index - 1] = (byte) msg.Length; //重新设定长度
index = index + msg.Length;
break;
case (uint) MSG.Msg_Format.GB2312:
msg = Encoding.Default.GetBytes(this._MsgContent);
msg.CopyTo(submitData, index);
submitData[index - 1] = (byte) msg.Length; //重新设定长度
index = index + msg.Length;
break;
case (uint) MSG.Msg_Format.UCS2:
msg = Encoding.BigEndianUnicode.GetBytes(this._MsgContent);
msg.CopyTo(submitData, index);
submitData[index - 1] = (byte) msg.Length; //重新设定长度
index = index + msg.Length;
break;
case (uint) MSG.Msg_Format.WRITECARD: //写卡操作
msg = Encoding.ASCII.GetBytes(this._MsgContent);
msg.CopyTo(submitData, index);
submitData[index - 1] = (byte) msg.Length; //重新设定长度
index = index + msg.Length;
break;
default:
msg = Encoding.ASCII.GetBytes(this._MsgContent);
msg.CopyTo(submitData, index);
submitData[index - 1] = (byte) msg.Length; //重新设定长度
index = index + msg.Length;
break;
}
index = index + 8; //8个保留字节
}
header.MSGLength = (uint) index;//根据index的长度决定传输数据字节长度
byte[] reVal = new byte[index];
header.toBytes().CopyTo(reVal, 0);
for (int i = MSG.CMPP_MSG_Header.HeaderLength; i < reVal.Length; i++)
{
reVal[i] = submitData[i];
}
return (reVal);
}
}
public class CMPP_MSG_SUBMIT_RESP
{
CMPP_MSG_Header header;
byte[] Msg_Id = new byte[8];
byte[] initValue;
public CMPP_MSG_SUBMIT_RESP(byte[] bs)
{
initValue = new byte[bs.Length];
for (int i = 0; i < bs.Length; i++)
{
initValue[i] = bs[i];
}
init();
}
private void init()
{
int index = 0;
byte[] temp = new byte[MSG.CMPP_MSG_Header.HeaderLength];
for (int i = 0; i < MSG.CMPP_MSG_Header.HeaderLength; i++)
{
temp[i] = initValue[i];
index = i;
}
index += 1;//指到正确位置
header = new MSG.CMPP_MSG_Header(temp);
for (int i = 0; i < 8; i++)
{
Msg_Id[i] = initValue[index + i];
}
BIConvert.DumpBytes(Msg_Id, "C://Submit_resp_MsgID.txt");
}
public UInt64 Msg_ID
{
get
{
UInt64 t = BitConverter.ToUInt64(this.Msg_Id, 0);
return (t);
}
}
public string MsgID
{
get
{
return BitConverter.ToUInt64(this.Msg_Id, 0).ToString();
}
}
public uint Command_ID
{
get
{
return (header.Command_ID);
}
set
{
header.Command_ID = value;
}
}
public uint Sequence
{
get
{
return (header.SequenceId);
}
}
public bool isOK
{
get
{
byte b = initValue[MSG.CMPP_MSG_Header.HeaderLength + 8];
if ((int) b == 0)
{
return (true);
}
else
{
return (false);
}
}
}
}
public class CMPP_MSG_QUERY
{
CMPP_MSG_Header header;
string _time;
int _queryType = 0;
string _queryCode;
public string Time
{
set
{
_time = value;
}
}
public int Query_Type
{
set
{
_queryType = value;
}
}
public string Query_Code
{
set
{
_queryCode = value;
}
}
public CMPP_MSG_QUERY(uint sequence)
{
header = new MSG.CMPP_MSG_Header(MSG.CMPP_COMMAND_ID.CMPP_QUERY);
header.SequenceId = sequence;
}
public byte[] toBytes()
{
byte[] reVal = new byte[MSG.CMPP_MSG_Header.HeaderLength + 8 + 1 + 10 + 8];
int index = 0;
header.toBytes().CopyTo(reVal, index);
index = index + MSG.CMPP_MSG_Header.HeaderLength;
Encoding.ASCII.GetBytes(this._time).CopyTo(reVal, index);//8 Octet String 时间YYYYMMDD(精确至日)
index = index + 8;
reVal[index++] = Convert.ToByte(this._queryType);
Encoding.ASCII.GetBytes(this._queryCode).CopyTo(reVal, index);
return (reVal);
}
}
public class CMPP_MSG_QUERY_RESP
{
CMPP_MSG_Header header;
string _time;
byte _queryType;
string _queryCode;
System.UInt32 _MT_TLMsg;
System.UInt32 _MT_Tlusr;
System.UInt32 _MT_Scs;
System.UInt32 _MT_WT;
System.UInt32 _MT_FL;
System.UInt32 _MO_Scs;
System.UInt32 _MO_WT;
System.UInt32 _MO_FL;
public CMPP_MSG_QUERY_RESP(byte[] bs)
{
header = new MSG.CMPP_MSG_Header(bs);
int index = MSG.CMPP_MSG_Header.HeaderLength;
_time = BitConverter.ToString(bs, index, 8);
index = index + 8;
this._queryType = bs[index++];
this._queryCode = BitConverter.ToString(bs, index, 10);
index = index + 10;
this._MT_TLMsg = BIConvert.Bytes2UInt(bs, index);
index = index + 4;
this._MT_Tlusr = BIConvert.Bytes2UInt(bs, index);
index = index + 4;
this._MT_Scs = BIConvert.Bytes2UInt(bs, index);
index = index + 4;
this._MT_WT = BIConvert.Bytes2UInt(bs, index);
index = index + 4;
this._MT_FL = BIConvert.Bytes2UInt(bs, index);
index = index + 4;
this._MO_Scs = BIConvert.Bytes2UInt(bs, index);
index = index + 4;
this._MO_WT = BIConvert.Bytes2UInt(bs, index);
index = index + 4;
this._MO_FL = BIConvert.Bytes2UInt(bs, index);
}
public string Time
{
get
{
return (this._time);
}
}
public int Qery_Type
{
get
{
return (this._queryType);
}
}
public string QueryCode
{
get
{
return (this._queryCode);
}
}
public uint Sequence
{
get
{
return (header.SequenceId);
}
}
public uint MT_TLMsg
{
get
{
return (this._MT_TLMsg);
}
}
public uint MT_TLUsr
{
get
{
return (this._MT_Tlusr);
}
}
public uint MT_Src
{
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_Src
{
get
{
return (this._MO_Scs);
}
}
public uint MO_WT
{
get
{
return (this._MO_WT);
}
}
public uint MO_FL
{
get
{
return (this._MO_FL);
}
}
}
public class CMPP_MSG_DELIVER
{
CMPP_MSG_Header header;
System.UInt64 _msgid;
string _destid;
string _svccode;
int _tpid;
int _udhi;
int _msgfmt;
string _srctid;
bool _isReport;
int _msglength;
string _msg;
System.UInt64 _reportForMsgid;
string _reportState;
string _submitTime;
string _doneTime;
string _reportDesttid;
int _smscSequence;
public CMPP_MSG_DELIVER(byte[] bs)
{
header = new MSG.CMPP_MSG_Header(bs);
int index = MSG.CMPP_MSG_Header.HeaderLength;
this._msgid = BitConverter.ToUInt64(bs, index);
index += 8;
this._destid = Encoding.ASCII.GetString(bs, index, 21);
index = index + 21;
this._svccode = Encoding.ASCII.GetString(bs, index, 10);
index = index + 10;
this._tpid = (int) bs[index++];
this._udhi = (int) bs[index++];
this._msgfmt = (int) bs[index++];
this._srctid = Encoding.ASCII.GetString(bs, index, 21);
index += 21;
if (bs[index++] == 1)
{
this._isReport = true;
}
else
{
this._isReport = false;
}
this._msglength = (int) bs[index++];
if (!this._isReport)
{
switch (this._msgfmt)
{
case (int) MSG.Msg_Format.ASCII:
this._msg = Encoding.ASCII.GetString(bs, index, this._msglength);
index += this._msglength;
break;
case (int) MSG.Msg_Format.BINARY:
this._msg = Encoding.Default.GetString(bs, index, this._msglength);
index += this._msglength;
break;
case (int) MSG.Msg_Format.GB2312:
this._msg = Encoding.Default.GetString(bs, index, this._msglength);
index += this._msglength;
break;
case (int) MSG.Msg_Format.UCS2:
this._msg = Encoding.BigEndianUnicode.GetString(bs, index, this._msglength);
index += this._msglength;
break;
default:
break;
}
}
else
{//状态报告
this._reportForMsgid = BitConverter.ToUInt64(bs, index);
index += 8;
this._reportState = BitConverter.ToString(bs, index, 7);
index += 7;
this._submitTime = BitConverter.ToString(bs, index, 10);
index += 10;
this._doneTime = BitConverter.ToString(bs, index, 10);
index += 10;
this._reportDesttid = BitConverter.ToString(bs, index, 21);
index += 21;
this._smscSequence = (int) BIConvert.Bytes2UInt(bs, index);
}
}
public bool isReport
{
get
{
return (_isReport);
}
}
public string Msg
{
get
{
return (this._msg);
}
}
public string SrcID
{
get
{
return (this._srctid);
}
}
public string SvcCode
{
get
{
return (this._svccode);
}
}
public string DestID
{
get
{
return (this._destid);
}
}
public UInt64 MsgID //给应用程序提供序号
{
get
{
return (this._msgid);
}
}
public string StateReport
{
get
{
{
return (this._reportState);
}
}
}
public UInt64 ReportMsgID
{
get
{
{
return (this._reportForMsgid);
}
}
}
public string SubmitTime
{
get
{
{
return (this._submitTime);
}
}
}
public string DoneTime
{
get
{
{
return (this._doneTime);
}
}
}
public string ReportbyDestID
{
get
{
{
return (this._reportDesttid);
}
}
}
public int SMSCSequence
{
get
{
return (this._smscSequence);
}
}
public int ISMGSequence
{
get
{
return ((int) this.header.SequenceId);
}
}
public int MsgBytelen
{
get
{
return (this._msglength); //返回deliver包的报告正文长度
}
}
}
public class CMPP_MSG_DELIVER_RESP
{
CMPP_MSG_Header header;
int _result;
//byte[] _msgidbytes=new byte[8];
System.UInt64 _msgid;
public CMPP_MSG_DELIVER_RESP(uint sequence)
{
header = new MSG.CMPP_MSG_Header(MSG.CMPP_COMMAND_ID.CMPP_DELIVER_RESP);
header.SequenceId = sequence;
header.MSGLength = (uint) MSG.CMPP_MSG_Header.HeaderLength + 8 + 1;
}
public int Result
{
set
{
this._result = value;
}
}
public UInt64 MsgID
{
set
{
this._msgid = value;
}
}
public byte[] toBytes()
{
byte[] reVal = new byte[MSG.CMPP_MSG_Header.HeaderLength + 9];
int index = 0;
header.toBytes().CopyTo(reVal, index);
index = index + MSG.CMPP_MSG_Header.HeaderLength;
BitConverter.GetBytes(this._msgid).CopyTo(reVal, index);
index = index + 8;
reVal[index++] = Convert.ToByte(this._result);
return (reVal);
}
}
public class CMPP_MSG_CANCEL
{
CMPP_MSG_Header header;
byte[] Msg_Id = new byte[8];
string _msgid;
public CMPP_MSG_CANCEL(uint sequence)
{
header = new MSG.CMPP_MSG_Header(MSG.CMPP_COMMAND_ID.CMPP_CANCEL);
header.SequenceId = sequence;
header.MSGLength = (uint) (MSG.CMPP_MSG_Header.HeaderLength + 8);
}
public string MsgID
{
set
{
this._msgid = value;
}
}
public byte[] toBytes()
{
byte[] reVal = new byte[MSG.CMPP_MSG_Header.HeaderLength + 8];
int index = 0;
header.toBytes().CopyTo(reVal, index);
index = index + MSG.CMPP_MSG_Header.HeaderLength;
Encoding.ASCII.GetBytes(this._msgid).CopyTo(reVal, index);
return (reVal);
}
}
public class CMPP_MSG_CANCEL_RESP
{
CMPP_MSG_Header header;
bool _Suceeid;
public CMPP_MSG_CANCEL_RESP(byte[] bs)
{
header = new MSG.CMPP_MSG_Header(bs);
if (bs[MSG.CMPP_MSG_Header.HeaderLength] == 0)
{
this._Suceeid = false;
}
else
{
this._Suceeid = true;
}
}
public bool isSucc
{
get
{
return (this._Suceeid);
}
}
public uint Sequence
{
get
{
return (this.header.SequenceId);
}
set
{
header.SequenceId = value;
}
}
}
public class CMPP_MSG_TEST
{
CMPP_MSG_Header header;
public CMPP_MSG_TEST(uint sequence)
{
header = new MSG.CMPP_MSG_Header(MSG.CMPP_COMMAND_ID.CMPP_ACTIVE_TEST);
header.MSGLength = (uint) MSG.CMPP_MSG_Header.HeaderLength;
header.SequenceId = sequence;
}
public CMPP_MSG_TEST(byte[] bs)
{
header = new MSG.CMPP_MSG_Header(bs);
}
public byte[] toBytes()
{
return (header.toBytes());
}
public uint Sequence
{
get
{
return (header.SequenceId);
}
}
}
public class CMPP_MSG_TEST_RESP
{
CMPP_MSG_Header header;
public CMPP_MSG_TEST_RESP(uint sequence)
{
header = new MSG.CMPP_MSG_Header(MSG.CMPP_COMMAND_ID.CMPP_ACTIVE_TEST_RESP);
header.MSGLength = (uint) (MSG.CMPP_MSG_Header.HeaderLength + 1);
header.SequenceId = sequence;
}
public CMPP_MSG_TEST_RESP(byte[] bs)
{
header = new MSG.CMPP_MSG_Header(bs);
}
public uint Sequence
{
get
{
return (header.SequenceId);
}
}
public byte[] toBytes()
{
byte[] reVal = new byte[MSG.CMPP_MSG_Header.HeaderLength + 1];
header.toBytes().CopyTo(reVal, 0);
return (reVal);
}
}
}
}
657
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
