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

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

IP电话/视频会议

开发平台：

WINDOWS

callTransfer.cpp：源码内容
  1. /*
  2.  * $Revision: 1.2 $
  3.  * $Date: 1998/11/03 18:32:02 $
  4.  */
  5. #include <stdio.h>
  6. #include <stdlib.h>
  7. #include <string.h>
  9. #include "exchange.h"
  10. #include "h450msgs.h"
  12. /////////////////////////////////////////////////////////////
  13. //
  14. // ctInitiateInvoke()
  15. //
  16. // Inputs:
  17. // invokeID - must be zero until OSS updated
  18. //   to fix bug.
  19. // callid - string upto 4 chars + NULL
  20. // ip - string with transfer-to ip address
  21. // e164 (opt) - will add if not NULL
  22. //
  23. // Output:
  24. // A pointer to a single H4501SuppService
  25. // object for which memory is allocated.
  26. //
  27. // CALLING FUNCTION MUST DELETE RETURD OBJECT.
  28. //
  29. /////////////////////////////////////////////////////////////
  32. H4501SuppService *
  33. ctInitiateInvoke(int invokeID, char *callid, unsigned int ip, char *e164)
  34. {
  35. ProtReturnCode ret;
  36. int len;
  37. int local;
  39. H4501SuppService *ss;
  41. H450AliasAddress *firstAA;
  42. H450AliasAddress *secondAA;
  43. H4501EndpointAddr *ep;
  44. H4502CTInitiateArg *initarg;
  45. H4501Invoke *inv;
  46. H4501Code *code;
  48. ss = new H4501SuppService;
  50. firstAA = new H450AliasAddress;
  51. secondAA = new H450AliasAddress;
  52. ep = new H4501EndpointAddr;
  53. initarg = new H4502CTInitiateArg;
  54. inv = new H4501Invoke;
  55. code = new H4501Code;
  57. LOG("nctInitiateInvoke()n");
  59. if(ip != 0) {
  60. sockaddr_in addr;
  61. addr.sin_family = AF_INET;
  62. addr.sin_port = htons(1720);
  63. addr.sin_addr.s_addr = ip;
  65. LOG("  firstAA->SetTransportID() to set address to: ip=0x%xn", ip);
  66. ret = firstAA->SetTransportID((sockaddr *)&addr);
  67. if (!PROT_IS_SUCCESS(ret))  {
  68. doError(ret,EXIT_ON_ERROR);
  69. }
  71. LOG("  ep->AddDestAddr(*firstAA) to add first AliasAddress to EndpointAddressn");
  72. ret = ep->AddDestAddr(*firstAA);
  73. if (!PROT_IS_SUCCESS(ret))  {
  74. doError(ret,EXIT_ON_ERROR);
  75. }
  76. }
  78. if(e164 != NULL) {
  79. len = strlen(e164);
  80. LOG("  secondAA->SetE164() to set address to: %s len=%dn", e164,len);
  81. ret = secondAA->SetE164(e164, len);
  82. if (!PROT_IS_SUCCESS(ret))  {
  83. doError(ret,EXIT_ON_ERROR);
  84. }
  86. LOG("  ep->AddDestAddr(*secondAA) to add second AliasAddressn");
  87. ret = ep->AddDestAddr(*secondAA);
  88. if (!PROT_IS_SUCCESS(ret))  {
  89. doError(ret,EXIT_ON_ERROR);
  90. }
  91. }
  93. // callIdentity is mandatory
  94. len = strlen(callid);
  95. LOG("  initarg->SetCallID() to set callIdentity of InitiateArg, callid = %s len=%dn", callid, len);
  96. ret = initarg->SetCallID(callid,len);
  97. if (!PROT_IS_SUCCESS(ret))  {
  98. doError(ret,EXIT_ON_ERROR);
  99. }
  101. LOG("  initarg->SetNumber(*ep) to set reroutingNumber of InitiateArg  n");
  102. ret = initarg->SetNumber(*ep);
  103. if (!PROT_IS_SUCCESS(ret))  {
  104. doError(ret,EXIT_ON_ERROR);
  105. }
  107. local = CTOT_INITIATE;
  108. LOG("  code->SetLocalCode() to set code to local:%d n",local);
  109. ret = code->SetLocalCode(local);
  110. if (!PROT_IS_SUCCESS(ret))  {
  111. doError(ret,EXIT_ON_ERROR);
  112. }
  114. invokeID = 0;
  115. LOG("  inv->SetInvokeId(%d) to set InvokeId of Invoke n",invokeID);
  116. ret = inv->SetInvokeId(invokeID);
  117. if (!PROT_IS_SUCCESS(ret))  {
  118. doError(ret,EXIT_ON_ERROR);
  119. }
  121. LOG("  inv->SetCode(*code) to set opcode of Invoke n");
  122. ret = inv->SetCode(*code);
  123. if (!PROT_IS_SUCCESS(ret))  {
  124. doError(ret,EXIT_ON_ERROR);
  125. }
  127. LOG("  inv->SetArgument(*initarg) to set argument of Invoke n");
  128. ret = inv->SetArgument(*initarg);
  129. if (!PROT_IS_SUCCESS(ret))  {
  130. doError(ret,EXIT_ON_ERROR);
  131. }
  133. LOG("  SuppService->AddROS(*inv) to add the Invoken");
  134. ret = ss->AddROS(*inv);
  135. if (!PROT_IS_SUCCESS(ret))  {
  136. doError(ret,EXIT_ON_ERROR);
  137. }
  139. delete firstAA;
  140. delete secondAA;
  141. delete ep;
  142. delete initarg;
  143. delete inv;
  144. delete code;
  146. return (ss);
  147. }
  150. /////////////////////////////////////////////////////////////
  151. //
  152. // ctSetupInvoke()
  153. //
  154. // Inputs:
  155. // invokeID - must be zero until OSS updated
  156. //   to fix bug.
  157. // callid - string upto 4 chars + NULL
  158. //
  159. // Output:
  160. // A pointer to a single H4501SuppService
  161. // object for which memory is allocated.
  162. //
  163. // CALLING FUNCTION MUST DELETE RETURD OBJECT.
  164. //
  165. /////////////////////////////////////////////////////////////
  166. H4501SuppService *
  167. ctSetupInvoke(int invokeID, char *callid)
  168. {
  169. ProtReturnCode ret;
  170. int len;
  171. int local;
  173. H4501SuppService *ss;
  175. H4502CTSetupArg *setuparg;
  176. H4501Invoke *inv;
  177. H4501Code *code;
  179. LOG("nctSetupInvoke(): enteredn");
  181. ss = new H4501SuppService;
  182. inv = new H4501Invoke;
  183. code = new H4501Code;
  184. setuparg = new H4502CTSetupArg;
  186. LOG("inv->SetInvokeId(%d)n",invokeID); // ???? ONLY ACCEPTS 0 FOR NOW
  187. ret = inv->SetInvokeId(invokeID);
  188. if (!PROT_IS_SUCCESS(ret))  {
  189. doError(ret,EXIT_ON_ERROR);
  190. }
  192. local = CTOT_SETUP;
  193. LOG("code->SetLocalCode(%d)  n",local);
  194. ret = code->SetLocalCode(local);
  195. if (!PROT_IS_SUCCESS(ret))  {
  196. doError(ret,EXIT_ON_ERROR);
  197. }
  199. LOG("inv->SetCode(*code) n");
  200. ret = inv->SetCode(*code);
  201. if (!PROT_IS_SUCCESS(ret))  {
  202. doError(ret,EXIT_ON_ERROR);
  203. }
  205. len = strlen(callid);
  206. LOG("setuparg->SetCallID("%s",%d)n",callid,len);
  207. ret = setuparg->SetCallID(callid,len);
  208. if (!PROT_IS_SUCCESS(ret))  {
  209. doError(ret,EXIT_ON_ERROR);
  210. }
  212. LOG("inv->SetArgument(*setuparg) n");
  213. ret = inv->SetArgument(*setuparg);
  214. if (!PROT_IS_SUCCESS(ret))  {
  215. doError(ret,EXIT_ON_ERROR);
  216. }
  218. LOG("ss->AddROS(*inv)n");
  219. ret = ss->AddROS(*inv);
  220. if (!PROT_IS_SUCCESS(ret))  {
  221. doError(ret,EXIT_ON_ERROR);
  222. }
  224. delete inv;
  225. delete code;
  226. delete setuparg;
  228. return(ss);
  229. }
  231. /////////////////////////////////////////////////////////////
  232. //
  233. // ctSetupReturnResult()
  234. //
  235. // Inputs:
  236. // invokeID - invokeID from received message
  237. //
  238. // Output:
  239. // A pointer to a single H4501SuppService
  240. // object for which memory is allocated.
  241. //
  242. // CALLING FUNCTION MUST DELETE RETURD OBJECT.
  243. //
  244. /////////////////////////////////////////////////////////////
  245. H4501SuppService *
  246. ctSetupReturnResult(int invokeID)
  247. {
  248. ProtReturnCode ret;
  249. int len;
  250. int local;
  252. H4501SuppService *ss;
  254. H4501ReturnResult *res;
  255. H450NonStdParam *param;
  256. H4502DummyRes *dum;
  257. H4501Code *code;
  259. ss = new H4501SuppService;
  261. res = new H4501ReturnResult;
  262. param = new H450NonStdParam;
  263. dum = new H4502DummyRes;
  264. code = new H4501Code;
  266. LOG("ctSetupReturnResult: enteredn");
  268. LOG("  res->SetInvokeId(%d) on ReturnResult n",invokeID);
  269. ret = res->SetInvokeId(invokeID);
  270. if (!PROT_IS_SUCCESS(ret))  {
  271. doError(ret,EXIT_ON_ERROR);
  272. }
  274. local = CTOT_SETUP;
  275. LOG("  code->SetLocalCode() to set to local:%d n",local);
  276. ret = code->SetLocalCode(local);
  277. if (!PROT_IS_SUCCESS(ret))  {
  278. doError(ret,EXIT_ON_ERROR);
  279. }
  281. // This seems weird but in order to set the code in the result we
  282. // need to have either and Extension or NonStdData in DummyRes
  283. // so let's put NonStdData since it is easier to use for some junk
  284. unsigned short cc = 12;
  285. unsigned short ext = 34;
  286. unsigned short mc = 56;
  287. LOG("  param->SetH221NonStd(%d,%d,%d) to set NonStandardIdentifier n",cc,ext,mc);
  288. ret = param->SetH221NonStd(cc,ext,mc);
  289. if (!PROT_IS_SUCCESS(ret))  {
  290. doError(ret,EXIT_ON_ERROR);
  291. }
  293. unsigned char data[7] = {0x61,0x62,0x63,0x64,0x65,0x66,0x67};
  294. len = 7;
  295. LOG("  param->SetNonStdData() to set Data field of NonStandardParameter data=%s len=%dn",(char *)data,len);
  296. ret = param->SetNonStdData(data,len);
  297. if (!PROT_IS_SUCCESS(ret))  {
  298. doError(ret,EXIT_ON_ERROR);
  299. }
  301. LOG("  dum->SetNonStdData(*param) to load DummyRes with NonStandardDatan");
  302. ret = dum->SetNonStdData(*param);
  303. if (!PROT_IS_SUCCESS(ret))  {
  304. doError(ret,EXIT_ON_ERROR);
  305. }
  307. LOG("  res->SetResult(*code, *dum) to set Emresult field  n");
  308. ret = res->SetResult(*code, *dum);
  309. if (!PROT_IS_SUCCESS(ret))  {
  310. doError(ret,EXIT_ON_ERROR);
  311. }
  313. LOG("  ss->AddROS(*res) to add the ReturnResultn");
  314. ret = ss->AddROS(*res);
  315. if (!PROT_IS_SUCCESS(ret))  {
  316. doError(ret,EXIT_ON_ERROR);
  317. }
  320. delete res;
  321. delete param;
  322. delete dum;
  323. delete code;
  325. return(ss);
  326. }
  328. /////////////////////////////////////////////////////////////
  329. //
  330. // ctInitiateReturnResult()
  331. //
  332. // Inputs:
  333. // invokeID - invokeID from received message
  334. //
  335. // Output:
  336. // A pointer to a single H4501SuppService
  337. // object for which memory is allocated.
  338. //
  339. // CALLING FUNCTION MUST DELETE RETURD OBJECT.
  340. //
  341. /////////////////////////////////////////////////////////////
  342. H4501SuppService *
  343. ctInitiateReturnResult(int invokeID)
  344. {
  345. ProtReturnCode ret;
  346. int len;
  347. int local;
  349. H4501SuppService *ss;
  351. H4501ReturnResult *res;
  352. H450NonStdParam *param;
  353. H4502DummyRes *dum;
  354. H4501Code *code;
  356. ss = new H4501SuppService;
  358. res = new H4501ReturnResult;
  359. param = new H450NonStdParam;
  360. dum = new H4502DummyRes;
  361. code = new H4501Code;
  363. LOG("ctInitiateReturnResult: enteredn");
  365. LOG("  res->SetInvokeId(%d) on ReturnResult n",invokeID);
  366. ret = res->SetInvokeId(invokeID);
  367. if (!PROT_IS_SUCCESS(ret))  {
  368. doError(ret,EXIT_ON_ERROR);
  369. }
  371. local = CTOT_INITIATE;
  372. LOG("  code->SetLocalCode() to set to local:%d n",local);
  373. ret = code->SetLocalCode(local);
  374. if (!PROT_IS_SUCCESS(ret))  {
  375. doError(ret,EXIT_ON_ERROR);
  376. }
  378. // This seems weird but in order to set the code in the result we
  379. // need to have either and Extension or NonStdData in DummyRes
  380. // so let's put NonStdData since it is easier to use for some junk
  381. unsigned short cc = 88;
  382. unsigned short ext = 77;
  383. unsigned short mc = 66;
  384. LOG("  param->SetH221NonStd(%d,%d,%d) to set NonStandardIdentifier n",cc,ext,mc);
  385. ret = param->SetH221NonStd(cc,ext,mc);
  386. if (!PROT_IS_SUCCESS(ret))  {
  387. doError(ret,EXIT_ON_ERROR);
  388. }
  390. unsigned char data[7] = {0x31,0x32,0x33,0x34,0x35,0x36,0x37};
  391. len = 7;
  392. LOG("  param->SetNonStdData() to set Data field of NonStandardParameter data=%s len=%dn",(char *)data,len);
  393. ret = param->SetNonStdData(data,len);
  394. if (!PROT_IS_SUCCESS(ret))  {
  395. doError(ret,EXIT_ON_ERROR);
  396. }
  398. LOG("  dum->SetNonStdData(*param) to load DummyRes with NonStandardDatan");
  399. ret = dum->SetNonStdData(*param);
  400. if (!PROT_IS_SUCCESS(ret))  {
  401. doError(ret,EXIT_ON_ERROR);
  402. }
  404. LOG("  res->SetResult(*code, *dum) to set Emresult field  n");
  405. ret = res->SetResult(*code, *dum);
  406. if (!PROT_IS_SUCCESS(ret))  {
  407. doError(ret,EXIT_ON_ERROR);
  408. }
  410. LOG("  ss->AddROS(*res) to add the ReturnResultn");
  411. ret = ss->AddROS(*res);
  412. if (!PROT_IS_SUCCESS(ret))  {
  413. doError(ret,EXIT_ON_ERROR);
  414. }
  417. delete res;
  418. delete param;
  419. delete dum;
  420. delete code;
  422. return(ss);
  423. }
  426. int
  427. isInitiateInvoke(H4501SuppService *ss, int &invokeID, char *call_id,
  428. unsigned int &ip_addr, char *phone)
  429. {
  431. ProtReturnCode ret;
  432. extractedSS extSS;
  434. extSS.tH4501SuppService(ss);
  436. if (extSS.ssNumROSs > 0)
  437. {
  438. LOG("ssNumROSs=%d type=%d code=%dn",extSS.ssNumROSs,extSS.ssROS[0].type,extSS.ssROS[0].code);
  439. if (extSS.ssROS[0].type == ROS_INVOKE)
  440. {
  441. if (extSS.ssROS[0].code == CTOT_INITIATE) 
  442. {
  443. LOG("initiate.invoke receivedn");
  445. invokeID = extSS.ssROS[0].InvokeId;
  446. strncpy(call_id, extSS.ssROS[0].Arg.CallID, 5);
  447. H4501EndpointAddr *ep = extSS.ssROS[0].Arg.EndpointAddr;
  448. H450AliasAddress *pAA;
  449. int count;
  450. int len;
  451. int type;
  453. ret = ep->GetNumDestAddrs(count);
  454. if (!PROT_IS_SUCCESS(ret))  {
  455. doError(ret,EXIT_ON_ERROR);
  456. }
  457. if(count == 0) {
  458. LOG("ERROR: No Dst addrs in initiate.invn");
  459. return(-1);
  460. }
  461. pAA = new H450AliasAddress[count];
  462. ret = ep->GetDestAddrs(pAA, count);
  463. if (!PROT_IS_SUCCESS(ret))  {
  464. doError(ret,EXIT_ON_ERROR);
  465. }
  467. for(int ia = 0; ia < count; ia++) {
  468. type = pAA[ia].GetType();
  469. switch(type) {
  470. case AAT_INVALID:
  471. LOG("test_extractedSS: AliasAddress type is AAT_INVALIDn");
  472. break;
  473. case AAT_E164:
  474. {
  475. char *e164;
  476. ret = pAA[ia].GetE164(e164, len);
  477. if (!PROT_IS_SUCCESS(ret)) {
  478. doError(ret,EXIT_ON_ERROR);
  479. } else {
  480. char retstr[MAXOUTSTR];
  481. LOG(" GetE164() e164 = %sn",
  482. sprint_string((unsigned char *)e164,
  483. MAXSTRLEN(len), retstr));
  484. LOG(" len = %dn",len);
  485. strncpy (phone, e164, len);
  486. phone[len] = '';
  487. }
  488. break;
  489. }
  491. case AAT_TRANSPORT_ID:
  492. {
  493.  struct sockaddr_in addr;
  494. ret = pAA[ia].GetTransportID((sockaddr *)&addr);
  495. if (!PROT_IS_SUCCESS(ret)) {
  496. doError(ret,EXIT_ON_ERROR);
  497. } else {
  498. char sockstr[25];
  499. LOG("%sGetTransportID() transportID = %sn",
  500. sprint_sockaddr((sockaddr *)&addr,sockstr));
  501. ip_addr = addr.sin_addr.s_addr;
  503. }
  504. break;
  506. }
  508. default:
  509. LOG("AliasAddr type being ignored %dn",type);
  510. break;
  511. }
  512. }
  513. delete [] pAA;
  514. // LOG("Placing a call to transferredTon");
  515. // exchange->PlaceTransferedToCall(myindex, ip_addr, 
  516. // phone, transfer_invoke_id, transfer_call_id);
  518. }
  519. else
  520. {
  521. return(0);
  522. }
  523. }
  524. else
  525. {
  526. return(0);
  527. }
  528. }
  529. else
  530. {
  531. return(0);
  532. }
  533. return(1);
  534. }