开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > 手机短信编程 > 查看源码
smpppacket.cpp
资源名称：smpplib.zip　[点击查看]
上传用户：hkcoast
上传日期：2007-01-12
资源大小：979k
文件大小：10k
源码类别：

手机短信编程

开发平台：

Visual C++

smpppacket.cpp：源码内容
  1. #include "stdafx.h"
  2. #include "smpppacket.h"
  3. #include "smpp.h"
  6. CLinkClose::CLinkClose()
  7. {
  8. setCommandId(SMPP_SPECIAL_LINKCLOSE);
  9. }
  11. CLinkClose::~CLinkClose()
  12. {
  13. }
  15. void CLinkClose::encodeBody(PBYTE &pby, int &nsz)
  16. {
  17. CPacketBase::encodeBody(pby, nsz);
  19. nsz = m_buffer.GetBufferLen();
  20. pby = new byte[nsz];
  22. memcpy(pby, m_buffer.GetBuffer(), nsz);
  23. }
  25. CBindTransmitter::CBindTransmitter()
  26. {
  27. setCommandId(SMPP_BIND_TRANSMITTER);
  28. }
  30. CBindTransmitter::~CBindTransmitter()
  31. {
  32. }
  34. CBindReceiver::CBindReceiver()
  35. {
  36. setCommandId(SMPP_BIND_RECEIVER);
  37. }
  39. CBindReceiver::~CBindReceiver()
  40. {
  41. }
  43. CBindTransceiver::CBindTransceiver()
  44. {
  45. setCommandId(SMPP_BIND_TRANSCEIVER);
  46. }
  48. CBindTransceiver::~CBindTransceiver()
  49. {
  50. }
  52. CQuerySM::CQuerySM()
  53. {
  54. m_message_id = "";
  55. setCommandId(SMPP_QUERY_SM);
  56. }
  58. CQuerySM::~CQuerySM()
  59. {
  60. }
  62. CString CQuerySM::getMessageId()
  63. {
  64. return m_message_id;
  65. }
  67. void CQuerySM::setMessageId(CString msgid)
  68. {
  69. m_message_id = msgid;
  70. }
  72. void CQuerySM::encodeBody(PBYTE &pby, int &nsz)
  73. {
  74. CPacketBase::encodeBody(pby, nsz);
  76. BYTE by;
  78. m_buffer.Write(m_message_id);
  79. m_buffer.WriteNULL();
  81. by = static_cast<byte>(m_source.m_addr_ton);
  82. m_buffer.Write(&by, 1);
  84. by = static_cast<byte>(m_source.m_addr_npi);
  85. m_buffer.Write(&by, 1);
  87. m_buffer.Write(m_source.m_addr);
  88. m_buffer.WriteNULL();
  90. nsz = m_buffer.GetBufferLen();
  91. pby = new byte[nsz];
  93. ASSERT( getCommandLength() == static_cast<uint32>(nsz));
  95. memcpy(pby, m_buffer.GetBuffer(), nsz);
  96. }
  98. bool CQuerySM::loadPacket(PBYTE pby, int nsz)
  99. {
  100. if (!CPacketBase::loadPacket(pby, nsz))
  101. return false;
  103. if (getCommandStatus() != 0)
  104. return false;
  106. int pos = 12;
  108. m_message_id = (LPTSTR) pby+pos;
  109. pos += m_message_id.GetLength() + 1;
  111. m_source.setAddrTon(*(pby+pos));
  112. pos += 1;
  113. m_source.setAddrNpi(*(pby+pos));
  114. pos += 1;
  115. m_source.m_addr = (LPTSTR) pby+pos;
  116. pos += m_source.m_addr.GetLength() + 1;
  118. return true;
  119. }
  121. uint32 CQuerySM::getCommandLength()
  122. {
  123. int len = (CPacketBase::getCommandLength()
  124. + ((!m_message_id.IsEmpty()) ? m_message_id.GetLength() : 0)
  125. + (m_source.getLength()) );
  127. return (len + 1);
  128. }
  130. CUnbind::CUnbind()
  131. {
  132. setCommandId(SMPP_UNBIND);
  133. }
  135. CUnbind::~CUnbind()
  136. {
  137. }
  139. void CUnbind::encodeBody(PBYTE &pby, int &nsz)
  140. {
  141. CPacketBase::encodeBody(pby, nsz);
  143. nsz = m_buffer.GetBufferLen();
  144. pby = new byte[nsz];
  146. memcpy(pby, m_buffer.GetBuffer(), nsz);
  147. }
  149. CSubmitSM::CSubmitSM()
  150. {
  151. setCommandId(SMPP_SUBMIT_SM);
  152. }
  154. CSubmitSM::~CSubmitSM()
  155. {
  156. }
  158. CDeliverSM::CDeliverSM()
  159. {
  160. setCommandId(SMPP_DELIVER_SM);
  161. }
  163. CDeliverSM::~CDeliverSM()
  164. {
  165. }
  167. CDataSM::CDataSM()
  168. {
  169. setCommandId(SMPP_DATA_SM);
  170. }
  172. CDataSM::~CDataSM()
  173. {
  174. }
  176. CDataSMResp::CDataSMResp()
  177. {
  178. setCommandId(SMPP_DATA_SM_RESP);
  179. }
  181. CDataSMResp::CDataSMResp(CDataSM &pak)
  182. {
  183. setCommandId(SMPP_DATA_SM_RESP);
  184. setSequenceNumber(pak.getSequenceNumber());
  185. }
  187. CDataSMResp::~CDataSMResp()
  188. {
  189. }
  191. CBindTransmitterResp::CBindTransmitterResp()
  192. {
  193. setCommandId(SMPP_BIND_TRANSMITTER_RESP);
  194. }
  196. CBindTransmitterResp::CBindTransmitterResp(CBindTransmitter &pak)
  197. {
  198. setCommandId(SMPP_BIND_TRANSMITTER_RESP);
  199. setSequenceNumber(pak.getSequenceNumber());
  200. }
  202. CBindTransmitterResp::~CBindTransmitterResp()
  203. {
  204. }
  206. CBindReceiverResp::CBindReceiverResp()
  207. {
  208. setCommandId(SMPP_BIND_RECEIVER_RESP);
  209. }
  211. CBindReceiverResp::CBindReceiverResp(CBindReceiver &pak)
  212. {
  213. setCommandId(SMPP_BIND_RECEIVER_RESP);
  214. setSequenceNumber(pak.getSequenceNumber());
  215. }
  217. CBindReceiverResp::~CBindReceiverResp()
  218. {
  219. }
  221. CBindTransceiverResp::CBindTransceiverResp()
  222. {
  223. setCommandId(SMPP_BIND_TRANSCEIVER_RESP);
  224. }
  226. CBindTransceiverResp::CBindTransceiverResp(CBindTransceiver &pak)
  227. {
  228. setCommandId(SMPP_BIND_TRANSCEIVER_RESP);
  229. setSequenceNumber(pak.getSequenceNumber());
  230. }
  232. CBindTransceiverResp::~CBindTransceiverResp()
  233. {
  234. }
  236. CQuerySMResp::CQuerySMResp()
  237. {
  238. setCommandId(SMPP_QUERY_SM_RESP);
  239. m_message_id = "";
  240. m_error_code = 0;
  241. m_message_state = 0;
  242. }
  244. CQuerySMResp::CQuerySMResp(CQuerySM &pak)
  245. {
  246. setCommandId(SMPP_QUERY_SM_RESP);
  247. m_message_id = "";
  248. m_error_code = 0;
  249. m_message_state = 0;
  251. setSequenceNumber(pak.getSequenceNumber());
  252. }
  254. CQuerySMResp::~CQuerySMResp()
  255. {
  256. }
  258. CString CQuerySMResp::getMessageId()
  259. {
  260. return m_message_id;
  261. }
  263. void CQuerySMResp::setMessageId(CString msgid)
  264. {
  265. m_message_id = msgid;
  266. }
  268. CSmppDate CQuerySMResp::getFinalDate()
  269. {
  270. return m_final_date;
  271. }
  273. void CQuerySMResp::setFinalDate(CSmppDate &fldate)
  274. {
  275. m_final_date = fldate;
  276. }
  278. uint32 CQuerySMResp::getMessageState()
  279. {
  280. return m_message_state;
  281. }
  283. void CQuerySMResp::setMessageState(uint32 msgst)
  284. {
  285. m_message_state = msgst;
  286. }
  288. uint32 CQuerySMResp::getErrorCode()
  289. {
  290. return m_error_code;
  291. }
  293. void CQuerySMResp::setErrorCode(uint32 errcode)
  294. {
  295. m_error_code = errcode;
  296. }
  298. void CQuerySMResp::encodeBody(PBYTE &pby, int &nsz)
  299. {
  300. CPacketBase::encodeBody(pby, nsz);
  302. BYTE by;
  304. m_buffer.Write(m_message_id);
  305. m_buffer.WriteNULL();
  307. m_buffer.Write(m_final_date.toString());
  308. m_buffer.WriteNULL();
  310. by = static_cast<byte>(m_message_state);
  311. m_buffer.Write(&by, 1);
  313. by = static_cast<byte>(m_error_code);
  314. m_buffer.Write(&by, 1);
  316. nsz = m_buffer.GetBufferLen();
  317. pby = new byte[nsz];
  319. ASSERT( getCommandLength() == static_cast<uint32>(nsz));
  321. memcpy(pby, m_buffer.GetBuffer(), nsz);
  322. }
  324. bool CQuerySMResp::loadPacket(PBYTE pby, int nsz)
  325. {
  326. if (!CPacketBase::loadPacket(pby, nsz))
  327. return false;
  329. if (getCommandStatus() != 0)
  330. return false;
  332. int pos = 12;
  334. m_message_id = (LPTSTR) pby+pos;
  335. pos += m_message_id.GetLength() + 1;
  337. CString finaldt = (LPTSTR) pby+pos;
  338. pos += finaldt.GetLength() + 1;
  340. if (!finaldt.IsEmpty())
  341. m_final_date.setDate(finaldt);
  343. m_message_state = static_cast<uint32>(*(pby+pos));
  344. pos += 1;
  346. m_error_code = static_cast<uint32>(*(pby+pos));
  347. pos += 1;
  349. return true;
  350. }
  352. uint32 CQuerySMResp::getCommandLength()
  353. {
  354. int len = (CPacketBase::getCommandLength()
  355. + ((!m_message_id.IsEmpty()) ? m_message_id.GetLength() : 0)
  356. + (m_final_date.getLength()) );
  358. return (len + 2 + 2);
  359. }
  361. CSubmitSMResp::CSubmitSMResp()
  362. {
  363. setCommandId(SMPP_SUBMIT_SM_RESP);
  364. }
  366. CSubmitSMResp::CSubmitSMResp(CSubmitSM &pak)
  367. {
  368. setCommandId(SMPP_SUBMIT_SM_RESP);
  369. setSequenceNumber(pak.getSequenceNumber());
  370. }
  372. CSubmitSMResp::~CSubmitSMResp()
  373. {
  374. }
  376. CDeliverSMResp::CDeliverSMResp()
  377. {
  378. setCommandId(SMPP_DELIVER_SM_RESP);
  379. }
  381. CDeliverSMResp::CDeliverSMResp(CDeliverSM &pak)
  382. {
  383. setCommandId(SMPP_DELIVER_SM_RESP);
  384. setSequenceNumber(pak.getSequenceNumber());
  385. }
  387. CDeliverSMResp::~CDeliverSMResp()
  388. {
  389. }
  391. CUnbindResp::CUnbindResp()
  392. {
  393. setCommandId(SMPP_UNBIND_RESP);
  394. }
  396. CUnbindResp::CUnbindResp(CUnbind &pak)
  397. {
  398. setCommandId(SMPP_UNBIND_RESP);
  399. setSequenceNumber(pak.getSequenceNumber());
  400. }
  402. CUnbindResp::~CUnbindResp()
  403. {
  404. }
  406. void CUnbindResp::encodeBody(PBYTE &pby, int &nsz)
  407. {
  408. CPacketBase::encodeBody(pby, nsz);
  410. nsz = m_buffer.GetBufferLen();
  411. pby = new byte[nsz];
  413. memcpy(pby, m_buffer.GetBuffer(), nsz);
  414. }
  416. CEnquireLink::CEnquireLink()
  417. {
  418. setCommandId(SMPP_ENQUIRE_LINK);
  419. }
  421. CEnquireLink::~CEnquireLink()
  422. {
  423. }
  425. void CEnquireLink::encodeBody(PBYTE &pby, int &nsz)
  426. {
  427. CPacketBase::encodeBody(pby, nsz);
  429. nsz = m_buffer.GetBufferLen();
  430. pby = new byte[nsz];
  432. memcpy(pby, m_buffer.GetBuffer(), nsz);
  433. }
  435. CEnquireLinkResp::CEnquireLinkResp()
  436. {
  437. setCommandId(SMPP_ENQUIRE_LINK_RESP);
  438. }
  440. CEnquireLinkResp::CEnquireLinkResp(CEnquireLink &pak)
  441. {
  442. setCommandId(SMPP_ENQUIRE_LINK_RESP);
  443. setSequenceNumber(pak.getSequenceNumber());
  444. }
  446. CEnquireLinkResp::~CEnquireLinkResp()
  447. {
  448. }
  450. void CEnquireLinkResp::encodeBody(PBYTE &pby, int &nsz)
  451. {
  452. CPacketBase::encodeBody(pby, nsz);
  454. nsz = m_buffer.GetBufferLen();
  455. pby = new byte[nsz];
  457. memcpy(pby, m_buffer.GetBuffer(), nsz);
  458. }
  460. CGenericNack::CGenericNack()
  461. {
  462. setCommandId(SMPP_GENERIC_NACK);
  463. }
  465. CGenericNack::~CGenericNack()
  466. {
  467. }
  469. void CGenericNack::encodeBody(PBYTE &pby, int &nsz)
  470. {
  471. CPacketBase::encodeBody(pby, nsz);
  473. nsz = m_buffer.GetBufferLen();
  474. pby = new byte[nsz];
  476. memcpy(pby, m_buffer.GetBuffer(), nsz);
  477. }
  480. CAlertNotification::CAlertNotification()
  481. {
  482. setCommandId(SMPP_ALERT_NOTIFICATION);
  483. }
  485. CAlertNotification::~CAlertNotification()
  486. {
  487. }
  489. CSmppAddress CAlertNotification::getSource()
  490. {
  491. return m_source;
  492. }
  494. CSmppAddress CAlertNotification::getEsme()
  495. {
  496. return m_esme;
  497. }
  499. void CAlertNotification::setSource(CSmppAddress &src)
  500. {
  501. m_source = src;
  502. }
  503. void CAlertNotification::setEsme(CSmppAddress &esme)
  504. {
  505. m_esme = esme;
  506. }
  508. void CAlertNotification::encodeBody(PBYTE &pby, int &nsz)
  509. {
  510. CPacketBase::encodeBody(pby, nsz);
  512. BYTE by;
  514. by = static_cast<byte>(m_source.m_addr_ton);
  515. m_buffer.Write(&by, 1);
  517. by = static_cast<byte>(m_source.m_addr_npi);
  518. m_buffer.Write(&by, 1);
  520. m_buffer.Write(m_source.m_addr);
  521. m_buffer.WriteNULL();
  523. by = static_cast<byte>(m_esme.m_addr_ton);
  524. m_buffer.Write(&by, 1);
  526. by = static_cast<byte>(m_esme.m_addr_npi);
  527. m_buffer.Write(&by, 1);
  529. m_buffer.Write(m_esme.m_addr);
  530. m_buffer.WriteNULL();
  532. nsz = m_buffer.GetBufferLen();
  533. pby = new byte[nsz];
  535. ASSERT( getCommandLength() == static_cast<uint32>(nsz));
  537. memcpy(pby, m_buffer.GetBuffer(), nsz);
  538. }
  540. bool CAlertNotification::loadPacket(PBYTE pby, int nsz)
  541. {
  542. if (!CPacketBase::loadPacket(pby, nsz))
  543. return false;
  545. if (getCommandStatus() != 0)
  546. return false;
  548. int pos = 12;
  550. m_source.setAddrTon(*(pby+pos));
  551. pos += 1;
  552. m_source.setAddrNpi(*(pby+pos));
  553. pos += 1;
  554. m_source.m_addr = (LPTSTR) pby+pos;
  555. pos += m_source.m_addr.GetLength() + 1;
  557. m_esme.setAddrTon(*(pby+pos));
  558. pos += 1;
  559. m_esme.setAddrNpi(*(pby+pos));
  560. pos += 1;
  561. m_esme.m_addr = (LPTSTR) pby+pos;
  562. pos += m_esme.m_addr.GetLength() + 1;
  564. return true;
  565. }
  567. uint32 CAlertNotification::getCommandLength()
  568. {
  569. int len = (CPacketBase::getCommandLength()
  570. + (m_source.getLength())
  571. + (m_esme.getLength()) );
  573. return (len + 1);
  574. }