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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > IP电话/视频会议 > 查看源码
rasstuff.cpp
资源名称：h323.zip　[点击查看]
上传用户：hnnddl
上传日期：2007-01-06
资源大小：3580k
文件大小：22k
源码类别：

IP电话/视频会议

开发平台：

WINDOWS

rasstuff.cpp：源码内容
  1. /*
  2.  * $Revision: 1.2 $
  3.  * $Date: 1998/10/14 22:48:28 $
  4.  */
  5. ////////////////////////////////////////////////////////////////
  6. //               Copyright (c) 1996-98 Lucent Technologies    //
  7. //                       All Rights Reserved                  //
  8. //                                                            //
  9. //                       THIS IS UNPUBLISHED                  //
  10. //                       PROPRIETARY SOURCE                   //
  11. //                   CODE OF Lucent Technologies              //
  12. // AND elemedia   //
  13. //                                                            //
  14. ////////////////////////////////////////////////////////////////
  15. //
  16. ////////////////////////////////////////////////////////////////
  17. // Example programs are provided soley to demonstrate one     //
  18. // possible use of the stack libraries and are included for   //
  19. // instructional purposes only.  You are free to use, modify  //
  20. // and/or redistribute any portion of code in the example     //
  21. // programs.  However, such examples are not intended to      //
  22. // represent production quality code.                         //
  23. //                                                            //
  24. // THE COPYRIGHT HOLDERS PROVIDE THESE EXAMPLE PROGRAMS       //
  25. // "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED     //
  26. // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED     //
  27. // WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A            //
  28. // PARTICULAR PURPOSE.                                        //
  29. ////////////////////////////////////////////////////////////////
  31. #if defined(USE_RAS)
  33. #include "exchange.h"
  34. #include "call.h"
  35. #include "msg.h"
  36. #include <api/h225rastypes.h>
  37. #include <api/h225raserr.h>
  38. //#include "config.h"
  40. ProtReturnCode
  41. Exchange::SendGRQ(int seq_num, struct sockaddr *dst_addr)
  42. {
  43.     LOG("SendGRQn");
  45.     H225RASMsgGRQ *msg;
  46.     H225RASMessage *m;
  47.     ProtReturnCode ret = H225RASMessage::Factory(m, MSG_GRQ, (H225RASProtocol *)this);
  48.     if (!PROT_IS_SUCCESS(ret) || !m)
  49.     {
  50.             LOG_ERROR("Failed to new GRQ messagen");
  51.             return(ret);
  52.     }
  53.     msg = (H225RASMsgGRQ *)m;
  55.     msg->SetSequenceNumber(seq_num);
  56.     msg->SetRASAddr(GetLocalRASAddr());
  58. // get the endpointType info from Exchange
  59. H225CSEndpointType et;
  61. ((H225RASProtocol *)this)->GetEndpointType(et);
  63. // now set the appropriate mandatory endpointType field of the message
  65. ret = ((ItemEndpointType *)msg)->SetEndpointType(et);
  66. if(!PROT_IS_SUCCESS(ret)) {
  67.             LOG_ERROR("msg->SetEndpointType() failure, ret = %xn", ret);
  68.     }
  70. ret = SendRASMessage(dst_addr, *msg);
  71.     if (!PROT_IS_SUCCESS(ret))
  72.     {
  73.             LOG_ERROR("Failed to send GRQ message 0x%xn", ret);
  74.     }
  76.     delete m;
  77.     return ret;
  78. }
  81. ProtReturnCode
  82. Exchange::SendRRQ(int seq_num, struct sockaddr *dst_addr)
  83. {
  84.     LOG("SendRRQn");
  86.     H225RASMsgRRQ *msg;
  87.     H225RASMessage *m;
  88. H225CSAliasAddress aa;
  89.     ProtReturnCode ret;
  91. ret = H225RASMessage::Factory(m, MSG_RRQ, (H225RASProtocol *)this);
  92.     if (!PROT_IS_SUCCESS(ret) || !m)
  93.     {
  94.             LOG_ERROR("Failed to new RRQ messagen");
  95.             return(ret);
  96.     } 
  98. msg = (H225RASMsgRRQ *)m;
  100.     msg->SetSequenceNumber(seq_num);
  102. msg->SetDiscoveryComplete(FALSE) ;
  103.     if(!PROT_IS_SUCCESS(ret)) {
  104.             LOG_ERROR("msg->SetDiscoveryComplete() failure, ret = %xn", ret);
  105.     }
  107. // call signalling address is mandatory
  108. ret = msg->AddCallSigAddr(GetLocalSigAddr()) ; 
  109.     if(!PROT_IS_SUCCESS(ret)) {
  110.             LOG("msg->AddCallSigAddr() failure, ret = %xn", ret);
  111.     }
  112.      
  113. // ras address is mandatory
  114. ret = msg->AddRASAddr(GetLocalRASAddr()); 
  115.     if(!PROT_IS_SUCCESS(ret)) {
  116.             LOG_ERROR("msg->AddRASAddr() failure, ret = %xn", ret);
  117.     }
  119. // get the endpointType and vendorID info from Exchange
  120. H225CSEndpointType et;
  121.     H225CSVendorID vendor_id;
  123. ((H225RASProtocol *)this)->GetVendorID(vendor_id);
  124. ((H225RASProtocol *)this)->GetEndpointType(et);
  126. // now set the appropriate mandatory vendorID and endpointType fields of the message
  127. ret = ((ItemVendorID *)msg)->SetVendorID(vendor_id);
  128. if(!PROT_IS_SUCCESS(ret)) {
  129.             LOG_ERROR("msg->SetVendorID() failure, ret = %xn", ret);
  130.     }
  131. ret = ((ItemEndpointType *)msg)->SetEndpointType(et);
  132. if(!PROT_IS_SUCCESS(ret)) {
  133.             LOG_ERROR("msg->SetEndpointType() failure, ret = %xn", ret);
  134.     }
  136. char display_str[256];
  138. sprintf(display_str, "%s", config->h323IDsrc);
  139. if  (display_str != NULL)
  140. {
  141. #if 0
  142. H225CSAliasAddress alias;
  143. WCHAR h323_id[128];
  144. int h323_id_len;
  146. h323_id_len =  MultiByteToWideChar(
  147. CP_ACP,
  148. MB_ERR_INVALID_CHARS,
  149. display_str,
  150. strlen(display_str),
  151. h323_id,
  152. 128);
  154. alias.SetH323ID(h323_id,h323_id_len);
  156. ret = msg->AddEndpointAlias(alias);
  157. if(!PROT_IS_SUCCESS(ret)) {
  158. LOG_ERROR("msg->AddEndpointAlias() failure, ret = %xn", ret);
  159. }
  160. #endif
  161. }
  163. // set the phone numbers we want to register as aliases
  164. for (int i=0; i< NUM_LINES; i++) {
  165. char e164[128];
  167. sprintf(e164, "%s%0004d", 
  168. config->e164src, i);
  169. ret = aa.SetE164(e164,(unsigned short)strlen(e164));
  170. if(!PROT_IS_SUCCESS(ret)) {
  171.             LOG_ERROR("aa.SetE164() failure, ret = %xn", ret);
  172. }
  173. ret = msg->AddEndpointAlias(aa);
  174. if(!PROT_IS_SUCCESS(ret)) {
  175.             LOG_ERROR("msg->AddEndpointAlias() failure, ret = %xn", ret);
  176. }
  177. }
  178. int count;
  179. ret = msg->GetNumEndpointAliases(count);
  180. if(!PROT_IS_SUCCESS(ret)) {
  181. LOG_ERROR("msg->GetNumEndpointAliases() failure, ret = %xn", ret);
  182. }
  184. #if 0
  185.     // the gatekeeperIdentifier is optional 
  186. unsigned short ep_id[128];
  187.     int len;
  189.     char *mystring = "elemediaGK";
  190.     for(len = 0; len < 128; len++) {                        
  191.             if(mystring[len] != '') {                     
  192.                     ep_id[len] = (short)mystring[len];      
  193.             } else {                                        
  194.                     ep_id[len] = 0;                         
  195.                     break;                                  
  196.             }                                               
  197.     }
  199.     ret = msg->SetGKID(ep_id,len);
  200.     if(!PROT_IS_SUCCESS(ret)) {
  201.         LOG_ERROR("msg->SetGKID() failure, ret = %xn", ret);
  202.     }
  204.     unsigned short id[128];
  205.     unsigned short *ptr = id;
  206.     char rcvstring[128];
  207.     int len2 = 0;
  209.     ret = msg->GetGKID(ptr,len2);
  210.     if(!PROT_IS_SUCCESS(ret)) {
  211. LOG_ERROR("msg->SetGKID() failure, ret = %xn", ret);
  212.     }
  213.     LOG("Gatekeeper ID len = %dn", len2);
  214.     rcvstring[0] = 'X';
  215.     for(len = 0; len < len2; len++) {              
  216.             rcvstring[len] = (char)*ptr++;         
  217.     }                                              
  218.     rcvstring[len2] = '';
  219.     if (len2 < 100)  {
  220. LOG_ERROR("Gatekeeper ID = %sn",rcvstring);
  221.     }
  222. #endif
  224.     ret = SendRASMessage(dst_addr, *m);
  225.     if (!PROT_IS_SUCCESS(ret))
  226.     {
  227.             LOG_ERROR("Failed to send RRQ message, 0x%x n", ret);
  228.     }
  230.     delete m;
  231.     return ret;
  232. }
  235. ProtReturnCode
  236. Exchange::SendURQ(int seq_num, struct sockaddr *dst_addr)
  237. {
  238.     LOG("SendURQn");
  240.     H225RASMsgURQ *msg;
  241.     H225RASMessage *m;
  242. H225CSAliasAddress aa;
  244.     ProtReturnCode ret = H225RASMessage::Factory(m, MSG_URQ, (H225RASProtocol *)this);
  245.     if (!PROT_IS_SUCCESS(ret) || !m)
  246.     {
  247.             LOG_ERROR("Failed to new URQ messagen");
  248.             return(ret);
  249.     }
  250.     msg = (H225RASMsgURQ *)m;
  252.     msg->SetSequenceNumber(seq_num);
  254. ret = msg->AddCallSigAddr(GetLocalSigAddr()) ; 
  255. if(!PROT_IS_SUCCESS(ret)) {
  256.             LOG("msg->AddCallSigAddr() failure, ret = %xn", ret);
  257.     }
  259. // set the phone numbers we want to unregister 
  260. for (int i=0; i< 10; i++) {
  261. char e164[128];
  263. sprintf(e164, "%s%d", 
  264. config->e164src, i);
  265. ret = aa.SetE164(e164,(unsigned short)strlen(e164));
  266. if(!PROT_IS_SUCCESS(ret)) {
  267.             LOG_ERROR("aa.SetE164() failure, ret = %xn", ret);
  268. }
  269. ret = msg->AddEndpointAlias(aa);
  270. if(!PROT_IS_SUCCESS(ret)) {
  271.             LOG_ERROR("msg->AddEndpointAlias() failure, ret = %xn", ret);
  272. }
  273. }
  274. int count;
  275. ret = msg->GetNumEndpointAliases(count);
  276. if(!PROT_IS_SUCCESS(ret)) {
  277. LOG_ERROR("msg->GetNumEndpointAliases() failure, ret = %xn", ret);
  278. }
  280. // set the endpoint ID that was assigned by the gatekeeper in RRQ
  281. ret = msg->SetEndpointID(ep_id, ep_id_len);
  282. if(!PROT_IS_SUCCESS(ret)) {
  283.             LOG("msg->SetEndpointID() failure, ret = %xn", ret);
  284.     } 
  286.     ret = SendRASMessage(dst_addr, *msg);
  287.     if (!PROT_IS_SUCCESS(ret))
  288.     {
  289.             LOG_ERROR("Failed to send URQ  message, ret = %xn", ret);
  290.     }
  292.     delete m;
  293.     return ret;
  294. }
  296. ProtReturnCode
  297. Exchange::SendUCF(int seq_num, struct sockaddr *dst_addr)
  298. {
  299.         LOG("SendUCFn");
  301.         H225RASMsgUCF *msg;
  302.         H225RASMessage *m;
  303.         ProtReturnCode ret = H225RASMessage::Factory(m, MSG_UCF, (H225RASProtocol *)this);
  304.         if (!PROT_IS_SUCCESS(ret) || !m)
  305.         {
  306.                 LOG_ERROR("Failed to new UCF messagen");
  307.                 return(ret);
  308.         }
  309.         msg = (H225RASMsgUCF *)m;
  311.         msg->SetSequenceNumber(seq_num);
  313.         ret = SendRASMessage(dst_addr, *msg);
  314.         if (!PROT_IS_SUCCESS(ret))
  315.         {
  316.                 LOG_ERROR("Failed to send UCF messagen");
  317.         }
  319.         delete m;
  320.         return ret;
  321. }
  323. ProtReturnCode
  324. Exchange::SendURJ(int seq_num, struct sockaddr *dst_addr)
  325. {
  326.         LOG("SendURJn");
  328.         H225RASMsgURJ *msg;
  329.         H225RASMessage *m;
  330.         ProtReturnCode ret = H225RASMessage::Factory(m, MSG_URJ, (H225RASProtocol *)this);
  331.         if (!PROT_IS_SUCCESS(ret) || !m)
  332.         {
  333.                 LOG_ERROR("Failed to new URJ messagen");
  334.                 return(ret);
  335.         }
  336.         msg = (H225RASMsgURJ *)m;
  338.         msg->SetSequenceNumber(seq_num);
  340.         ret = SendRASMessage(dst_addr, *msg);
  341.         if (!PROT_IS_SUCCESS(ret))
  342.         {
  343.                 LOG_ERROR("Failed to send URJ messagen");
  344.         }
  346.         delete m;
  347.         return ret;
  348. }
  350. ProtReturnCode
  351. Exchange::SendARQ(int seq_num, struct sockaddr *dst_addr, class SendARQdata *arq_data) 
  352. {
  353. LOG("SendARQn");
  354. int index = arq_data->index;
  355.     H225RASMsgARQ *msg;
  356.     H225RASMessage *m;
  357.     ProtReturnCode ret = H225RASMessage::Factory(m, MSG_ARQ, (H225RASProtocol *)this);
  358.     if (!PROT_IS_SUCCESS(ret) || !m)
  359.     {
  360.             LOG_ERROR("Failed to new ARQ message, ret = 0x%xn", ret);
  361.             return(ret);
  362.     }
  363.     msg = (H225RASMsgARQ *)m;
  365.     msg->SetSequenceNumber(seq_num);
  367. ret = msg->SetCallType(CT_POINT_TO_POINT); 
  368. if(!PROT_IS_SUCCESS(ret)) {
  369. LOG_ERROR("msg->SetCallType() failure, ret = %xn", ret);
  370. }
  371. ret = msg->SetCallModel(CM_GATEKEEPER_ROUTED); 
  372. if(!PROT_IS_SUCCESS(ret)) {
  373. LOG_ERROR("msg->SetCallModel() failure, ret = %xn", ret);
  374. }
  375. ret = msg->SetEndpointID(ep_id, ep_id_len);
  376. if(!PROT_IS_SUCCESS(ret)) {
  377. LOG_ERROR("msg->SetEndpointID() failure, ret = %xn", ret);
  378. }
  380. // how much bandwidth do we need for this call? - mandatory 
  381. ret = msg->SetBandwidth(200); // 20kbits
  382. if(!PROT_IS_SUCCESS(ret)) {
  383. LOG_ERROR("msg->SetBandwidth() failure, ret = %xn", ret);
  384. }
  386. // is this endpoint gonna be the active MC? - mandatory
  387. ret = msg->SetActiveMC(FALSE);
  388. if(!PROT_IS_SUCCESS(ret)) {
  389. LOG_ERROR("msg->SetActiveMC() failure, ret = %xn", ret);
  390. }
  392. // are we placing or receiving a call? - mandatory
  393. //  DIR_INCOMING = 1
  394. //  DIR_OUTGOING = 0;
  395. ret = msg->SetAnswerCall(ras_sess[index].direction);
  396. if(!PROT_IS_SUCCESS(ret)) {
  397. LOG_ERROR("msg->SetAnswerCall() failure, ret = %xn", ret);
  398. }
  400. // set the conference ID - mandatory
  401. unsigned char *confID;
  402. int len;
  404. (H225CSProtocol*)calls[index]->GetConfID(confID, len);
  405. ret = msg->SetConfID((char *)confID, len);
  406. if(!PROT_IS_SUCCESS(ret)) {
  407. LOG_ERROR("msg->SetConfID() failure, ret = %xn", ret);
  408. }
  410. // set the call reference value - mandatory
  411. ret = msg->SetCRV(index);
  412. if(!PROT_IS_SUCCESS(ret)) {
  413. LOG_ERROR("msg->SetCRV() failure, ret = %xn", ret);
  414. }
  416. // The application who calls SendARQ must consider:
  417. // if the call is outgoing, the e164dst should be filled with the remote e164 alias
  418. // and the e164src with the local e164 alias
  419. // if the call is incoming, the e164dst should be filled with the local e164 alias
  420. // and the e164src with the remote e164 alias
  421. // Additionally, we only need to address the destination either with an alias 
  422. // like e164 or h323ID or its Q.931 call signalling IP address 
  424. if (arq_data->e164dst[0] != '')
  425. {
  426. H225CSAliasAddress aa;
  427. char e164[128];
  429. sprintf(e164, "%s",arq_data->e164dst);
  430. ret = aa.SetE164(e164,(unsigned short)strlen(e164));
  431. if(!PROT_IS_SUCCESS(ret)) {
  432. LOG_ERROR("aa.SetE164() failure, ret = %xn", ret);
  433. }
  434. ret = msg->AddDstInfo(aa);
  436. if(!PROT_IS_SUCCESS(ret)) {
  437. LOG_ERROR("msg->AddDstInfo() failure, ret = %xn", ret);
  438. }
  439. }
  441. if (arq_data->e164src[0] != '')
  442. {
  443. H225CSAliasAddress aa;
  444. char e164[128];
  446. sprintf(e164, "%s",arq_data->e164src);
  447. ret = aa.SetE164(e164,(unsigned short)strlen(e164));
  448. if(!PROT_IS_SUCCESS(ret)) {
  449. LOG_ERROR("aa.SetE164() failure, ret = %xn", ret);
  450. }
  451. ret = msg->AddSrcInfo(aa);
  452. if(!PROT_IS_SUCCESS(ret)) {
  453. LOG_ERROR("msg->AddSrcInfo() failure, ret = %xn", ret);
  454. }
  455. }
  457. // fill up the srcInfo with h323 alias
  458. #if 0 
  459. if  (arq_data->h323IDsrc[0] != '')
  460. {
  461. H225CSAliasAddress aa;
  462. WCHAR h323_id[128];
  463. int h323_id_len;
  465. h323_id_len =  MultiByteToWideChar(
  466. CP_ACP,
  467. MB_ERR_INVALID_CHARS,
  468. arq_data->h323IDsrc,
  469. strlen(arq_data->h323IDsrc),
  470. h323_id,
  471. 128);
  473. aa.SetH323ID(h323_id,h323_id_len);
  475. ret = msg->AddSrcInfo(aa);
  477. if(!PROT_IS_SUCCESS(ret)) {
  478. LOG_ERROR("msg->AddSrcInfo() failure, ret = %xn", ret);
  479. }
  481. }
  483. // fill up the destinationInfo with h323 alias
  484. if  (arq_data->h323IDdst[0] != '')
  485. {
  486. H225CSAliasAddress aa;
  487. WCHAR h323_id[128];
  488. int h323_id_len;
  490. h323_id_len =  MultiByteToWideChar(
  491. CP_ACP,
  492. MB_ERR_INVALID_CHARS,
  493. arq_data->h323IDsrc,
  494. strlen(arq_data->h323IDdst),
  495. h323_id,
  496. 128);
  498. aa.SetH323ID(h323_id,h323_id_len);
  500. ret = msg->AddDstInfo(aa);
  502. if(!PROT_IS_SUCCESS(ret)) {
  503. LOG_ERROR("msg->AddDstInfo() failure, ret = %xn", ret);
  504. }
  505. }
  506. #endif
  508. // as we send earlier we can send ARQ with destination either H.323 or E.164 alias so the 
  509. // gatekeeper can resolve the destination IP address or we might know 
  510. // the destination IP and we only need authorization for this call from the GK
  511. // 
  512. if (arq_data->callsigdst)
  513. {
  514. msg->SetDstCallSigAddr((sockaddr *)arq_data->callsigdst);
  515. }
  517. // set the call ID - mandatory
  518. H225CSCallID callID;
  520. (H225CSProtocol*)calls[index]->GetCallID(callID);
  521. unsigned char *tmp; char tmp1[256]; 
  522. callID.GetCallID(tmp, len);
  523. strncpy(tmp1, (char*)tmp, len);
  524. LOG("in SendARQ, callid=%sn", tmp1);
  525. ret = msg->SetCallID(callID);
  526. if(!PROT_IS_SUCCESS(ret)) {
  527. LOG_ERROR("msg->SetCallID() failure, ret = %xn", ret);
  528. }
  530. // the message should be fine, send it
  531.     ret = SendRASMessage(dst_addr, *msg);
  532.     if (!PROT_IS_SUCCESS(ret))
  533.     {
  534.             LOG_ERROR("Failed to send ARQ message, ret = 0x%xn", ret);
  535.     }
  537.     delete m;
  538.     return ret;
  539. }
  542. ProtReturnCode
  543. Exchange::SendBRQ(int seq_num, struct sockaddr *dst_addr)
  544. {
  545.         LOG("SendBRQn");
  547.         H225RASMsgBRQ *msg;
  548.         H225RASMessage *m;
  549.         ProtReturnCode ret = H225RASMessage::Factory(m, MSG_BRQ, (H225RASProtocol *)this);
  550.         if (!PROT_IS_SUCCESS(ret) || !m)
  551.         {
  552.                 LOG_ERROR("Failed to new BRQ messagen");
  553.                 return(ret);
  554.         }
  555.         msg = (H225RASMsgBRQ *)m;
  557.         msg->SetSequenceNumber(seq_num);
  559.         ret = SendRASMessage(dst_addr, *msg);
  560.         if (!PROT_IS_SUCCESS(ret))
  561.         {
  562.                 LOG_ERROR("Failed to send BRQ  messagen");
  563.         }
  565.         delete m;
  566.         return ret;
  567. }
  570. ProtReturnCode
  571. Exchange::SendDRQ(int seq_num, struct sockaddr *dst_addr, int index)
  572. {
  573.     LOG("SendDRQn");
  575.     H225RASMsgDRQ *msg;
  576.     H225RASMessage *m;
  577.     ProtReturnCode ret = H225RASMessage::Factory(m, MSG_DRQ, (H225RASProtocol *)this);
  578.     if (!PROT_IS_SUCCESS(ret) || !m)
  579.     {
  580.             LOG_ERROR("Failed to new DRQ messagen");
  581.             return(ret);
  582.     }
  583.     msg = (H225RASMsgDRQ *)m;
  585.     msg->SetSequenceNumber(seq_num);
  586. msg->SetReason(DRQ_NORMAL_DROP);
  588. // mandatory
  589. unsigned char *confID;
  590. int len;
  591. (H225CSProtocol*)calls[index]->GetConfID(confID, len);
  592. ret = msg->SetConfID((char *)confID, len);
  593. if(!PROT_IS_SUCCESS(ret)) {
  594. LOG_ERROR("msg->SetConfID() failure, ret = %xn", ret);
  595. }
  597. // mandatory
  598. ret = msg->SetCRV(index);
  599. if(!PROT_IS_SUCCESS(ret)) {
  600. LOG_ERROR("msg->SetCRV() failure, ret = %xn", ret);
  601. }
  603. // mandatory
  604. ret = msg->SetEndpointID(ep_id, ep_id_len);
  605. if(!PROT_IS_SUCCESS(ret)) {
  606. LOG_ERROR("msg->SetEndpointID() failure, ret = %xn", ret);
  607. }
  609. // set the call ID - mandatory
  610. H225CSCallID callID;
  612. (H225CSProtocol*)calls[index]->GetCallID(callID);
  613. unsigned char *tmp; char tmp1[256]; 
  614. callID.GetCallID(tmp, len);
  615. strncpy(tmp1, (char*)tmp, len);
  616. LOG("in SendDRQ, callid=%sn", tmp1);
  617. ret = msg->SetCallID(callID);
  618. if(!PROT_IS_SUCCESS(ret)) {
  619. LOG_ERROR("msg->SetCallID() failure, ret = %xn", ret);
  620. }
  621.     ret = SendRASMessage(dst_addr, *msg);
  622.     if (!PROT_IS_SUCCESS(ret))
  623.     {
  624. LOG_ERROR("Failed to send DRQ message, ret = 0x%xn", ret);
  625.     }
  627.     delete m;
  628.     return ret;
  629. }
  631. ProtReturnCode
  632. Exchange::SendDCF(int seq_num, struct sockaddr *dst_addr)
  633. {
  634.         LOG("SendDCFn");
  636.         H225RASMsgDCF *msg;
  637.         H225RASMessage *m;
  638.         ProtReturnCode ret = H225RASMessage::Factory(m, MSG_DCF, (H225RASProtocol *)this);
  639.         if (!PROT_IS_SUCCESS(ret) || !m)
  640.         {
  641.                 LOG_ERROR("Failed to new DCF messagen");
  642.                 return(ret);
  643.         }
  644.         msg = (H225RASMsgDCF *)m;
  646.         msg->SetSequenceNumber(seq_num);
  648.         ret = SendRASMessage(dst_addr, *msg);
  649.         if (!PROT_IS_SUCCESS(ret))
  650.         {
  651.                 LOG_ERROR("Failed to send DCF messagen");
  652.         }
  654.         delete m;
  655.         return ret;
  656. }
  658. ProtReturnCode
  659. Exchange::SendDRJ(int seq_num, struct sockaddr *dst_addr)
  660. {
  661.         LOG("SendDRJn");
  663.         H225RASMsgDRJ *msg;
  664.         H225RASMessage *m;
  665.         ProtReturnCode ret = H225RASMessage::Factory(m, MSG_DRJ, (H225RASProtocol *)this);
  666.         if (!PROT_IS_SUCCESS(ret) || !m)
  667.         {
  668.                 LOG_ERROR("Failed to new DRJ messagen");
  669.                 return(ret);
  670.         }
  671.         msg = (H225RASMsgDRJ *)m;
  673.         msg->SetSequenceNumber(seq_num);
  675.         ret = SendRASMessage(dst_addr, *msg);
  676.         if (!PROT_IS_SUCCESS(ret))
  677.         {
  678.                 LOG_ERROR("Failed to send DRJ messagen");
  679.         }
  681.         delete m;
  682.         return ret;
  683. }
  685. ProtReturnCode
  686. Exchange::SendLRQ(int seq_num, struct sockaddr *dst_addr)
  687. {
  688.         LOG("SendLRQn");
  690.         H225RASMsgLRQ *msg;
  691.         H225RASMessage *m;
  692.         ProtReturnCode ret = H225RASMessage::Factory(m, MSG_LRQ, (H225RASProtocol *)this);
  693.         if (!PROT_IS_SUCCESS(ret) || !m)
  694.         {
  695.                 LOG_ERROR("Failed to new LRQ messagen");
  696.                 return(ret);
  697.         }
  698.         msg = (H225RASMsgLRQ *)m;
  700.         msg->SetSequenceNumber(seq_num);
  702.         ret = SendRASMessage(dst_addr, *msg);
  703.         if (!PROT_IS_SUCCESS(ret))
  704.         {
  705.                 LOG_ERROR("Failed to send LRQ messagen");
  706.         }
  708.         delete m;
  709.         return ret;
  710. }
  712. ProtReturnCode
  713. Exchange::SendLCF(int seq_num, struct sockaddr *dst_addr)
  714. {
  715.         LOG("SendLCFn");
  717.         H225RASMsgLCF *msg;
  718.         H225RASMessage *m;
  719.         ProtReturnCode ret = H225RASMessage::Factory(m, MSG_LCF, (H225RASProtocol *)this);
  720.         if (!PROT_IS_SUCCESS(ret) || !m)
  721.         {
  722.                 LOG_ERROR("Failed to new LCF messagen");
  723.                 return(ret);
  724.         }
  725.         msg = (H225RASMsgLCF *)m;
  727.         msg->SetSequenceNumber(seq_num);
  729.         ret = SendRASMessage(dst_addr, *msg);
  730.         if (!PROT_IS_SUCCESS(ret))
  731.         {
  732.                 LOG_ERROR("Failed to send LCF messagen");
  733.         }
  735.         delete m;
  736.         return ret;
  737. }
  739. ProtReturnCode
  740. Exchange::SendLRJ(int seq_num, struct sockaddr *dst_addr)
  741. {
  742.         LOG("SendLRJn");
  744.         H225RASMsgLRJ *msg;
  745.         H225RASMessage *m;
  746.         ProtReturnCode ret = H225RASMessage::Factory(m, MSG_LRJ, (H225RASProtocol *)this);
  747.         if (!PROT_IS_SUCCESS(ret) || !m)
  748.         {
  749.                 LOG_ERROR("Failed to new LRJ messagen");
  750.                 return(ret);
  751.         }
  752.         msg = (H225RASMsgLRJ *)m;
  754.         msg->SetSequenceNumber(seq_num);
  756.         ret = SendRASMessage(dst_addr, *msg);
  757.         if (!PROT_IS_SUCCESS(ret))
  758.         {
  759.                 LOG_ERROR("Failed to send LRJ messagen");
  760.         }
  762.         delete m;
  763.         return ret;
  764. }
  766. ProtReturnCode
  767. Exchange::SendIRQ(int seq_num, struct sockaddr *dst_addr)
  768. {
  769.         LOG("SendIRQn");
  771.         H225RASMsgIRQ *msg;
  772.         H225RASMessage *m;
  773.         ProtReturnCode ret = H225RASMessage::Factory(m, MSG_IRQ, (H225RASProtocol *)this);
  774.         if (!PROT_IS_SUCCESS(ret) || !m)
  775.         {
  776.                 LOG_ERROR("Failed to new IRQ messagen");
  777.                 return(ret);
  778.         }
  779.         msg = (H225RASMsgIRQ *)m;
  781.         msg->SetSequenceNumber(seq_num);
  783.         ret = SendRASMessage(dst_addr, *msg);
  784.         if (!PROT_IS_SUCCESS(ret))
  785.         {
  786.                 LOG_ERROR("Failed to send IRQ messagen");
  787.         }
  789.         delete m;
  790.         return ret;
  791. }
  793. ProtReturnCode
  794. Exchange::SendIRR(int seq_num, struct sockaddr *dst_addr)
  795. {
  796.         LOG("SendIRRn");
  798.         H225RASMsgIRR *msg;
  799.         H225RASMessage *m;
  800.         ProtReturnCode ret = H225RASMessage::Factory(m, MSG_IRR, (H225RASProtocol *)this);
  801.         if (!PROT_IS_SUCCESS(ret) || !m)
  802.         {
  803.                 LOG_ERROR("Failed to new IRR messagen");
  804.                 return(ret);
  805.         }
  806.         msg = (H225RASMsgIRR *)m;
  808.         msg->SetSequenceNumber(seq_num);
  810.         ret = SendRASMessage(dst_addr, *msg);
  811.         if (!PROT_IS_SUCCESS(ret))
  812.         {
  813.                 LOG_ERROR("Failed to send IRR messagen");
  814.         }
  816.         delete m;
  817.         return ret;
  818. }
  820. #endif // USE_RAS