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

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

IP电话/视频会议

开发平台：

WINDOWS

call.cpp：源码内容
  1. /*
  2.  * $Revision: 1.26 $
  3.  * $Date: 1999/03/17 18:05:31 $
  4.  */
  6. ////////////////////////////////////////////////////////////////
  7. //               Copyright (c) 1996-98 Lucent Technologies    //
  8. //                       All Rights Reserved                  //
  9. //                                                            //
  10. //                       THIS IS UNPUBLISHED                  //
  11. //                       PROPRIETARY SOURCE                   //
  12. //                   CODE OF Lucent Technologies              //
  13. // AND elemedia   //
  14. //                                                            //
  15. ////////////////////////////////////////////////////////////////
  16. //
  17. ////////////////////////////////////////////////////////////////
  18. // Example programs are provided soley to demonstrate one     //
  19. // possible use of the stack libraries and are included for   //
  20. // instructional purposes only.  You are free to use, modify  //
  21. // and/or redistribute any portion of code in the example     //
  22. // programs.  However, such examples are not intended to      //
  23. // represent production quality code.                         //
  24. //                                                            //
  25. // THE COPYRIGHT HOLDERS PROVIDE THESE EXAMPLE PROGRAMS       //
  26. // "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED     //
  27. // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED     //
  28. // WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A            //
  29. // PARTICULAR PURPOSE.                                        //
  30. ////////////////////////////////////////////////////////////////
  32. #include "exchange.h"
  33. #include "call.h"
  34. #include "msg.h"
  35. #include "api/h225ie.h"
  37. #include <assert.h>
  39. #if (defined(WIN32))
  40. #include <winsock.h>
  41. #elif defined(VXWORKS)
  42. #else
  43. // Include the following line in uw2.1.0
  44. #if defined(sun)
  45. extern "C" int gethostname(char *name, int len);
  46. #endif
  47. #if defined(__hpux)
  48. #include <wchar.h>
  49. #else
  50. #include <wctype.h>
  51. #endif
  52. #endif
  54. #if (defined(ENABLE_BENCHMARKS))
  55. #include "perf.h"
  56. #endif
  58. #ifdef USE_RAS
  59. extern int seqno;    
  60. #endif
  62. /*ARGSUSED*/
  63. H323Call::H323Call(Exchange* ex,int h225_id, int h245_id, 
  64. H225CSEndpointType& ep, int tt, char *display, int outgoing_call,
  65. ProtReturnCode& result) :
  66. H225CSProtocol(h225_id,ep,result,display),
  67. H245Protocol(h245_id,tt,result),
  68. MessageQueue(0,0,0)
  69. {
  70. LOG("H323Call::H323Calln");
  72. LOG("terminal_type = %dn",tt);
  74. if (!PROT_IS_SUCCESS(result))
  75. {
  76. LOG("Constructor failed result = 0x%xn", result);
  77. return;
  78. }
  80. cap_done = 0;
  81. olc_done = 0;
  82. msd_done = 0;
  83. audio_session = NULL;
  84. exchange = ex;
  85. endsession_sent = 0;
  86. call_dropped = 0;
  88. faststart_state  = FAST_START_STATE_DISABLED;
  90. do_faststart = ex->use_faststart;
  91. do_tunneling = ex->use_tunneling;
  92. do_overlapsend = ex->use_overlapsend;
  93. do_alerting = ex->use_alerting;
  94. do_proceeding = ex->use_callproc;
  96. remote_name[0] = '';
  97. phone[0] = '';
  98. src_phone[0] = '';
  100. // transfer related
  101. transfer_flag = FALSE;
  102. transfer_invoke_id = -1;
  103. transfer_call_id[0] = '';
  104. transfer_parent_index = -1;
  106. #if !defined(VXWORKS)
  107. char hostname[256];
  108. struct hostent *hent_p;
  110. gethostname(hostname,sizeof(hostname));
  111. hent_p = gethostbyname(hostname);
  113. if(hent_p == NULL)
  114. {
  115. LOG("gethostbyname failed on %s error %dn", hostname,errno);
  116. return;
  117. }
  118. #endif
  120. if (strlen(display))
  121. {
  122. display_str = new char[strlen(display) + 1];
  123. strcpy(display_str, display);
  124. }
  125. else
  126. {
  127. display_str = NULL;
  128. }
  130. #if defined(VXWORKS)
  131. {
  132. char hostname[256];
  133. sprintf(hostname,"vxworks%d",sysProcNumGet());
  134. if_ip_addr = hostGetByName(hostname);
  135. //if_ip_addr = inet_addr("127.0.1.2");
  136. }
  137. #else
  138. int i = 0;
  140. while(hent_p->h_addr_list[i])
  141. {
  142. LOG("Interface %d, ip = 0x%xn",
  143. i,*(unsigned long *)(hent_p->h_addr_list[i]));
  144. ++i;
  145. }
  147. if_ip_addr = *(unsigned long *)(hent_p->h_addr_list[0]);
  148. #endif
  150. is_outgoing_call = outgoing_call;
  152. if (outgoing_call)
  153. {
  154. // Set the conference ID and the Call ID. 
  155. // IP and index just for demonstration purposes.
  157. sprintf(confid, "%00000008x%0004d", 
  158. exchange->confid_prefix, h225_id);
  160. callid.SetCallID((unsigned char *)confid,16);
  161. H225CSProtocol::SetCallID(callid);
  162. H225CSProtocol::SetConfID((unsigned char *)confid,16);
  163. }
  165. #if defined(ENABLE_BENCHMARKS)
  166. get_current_time(st_sec,st_msec);
  167. end_sec = end_msec = 0;
  168. max_stack_size = cur_stack_size = 0;
  169. #endif
  171. audio_session_flag = 0;
  173. memset(&remote_lc0_addr, 0, sizeof(remote_lc0_addr));
  174. memset(&local_lc0_addr, 0, sizeof(local_lc0_addr));
  175. LOG("Defaulting to interface ip address 0x%xn", if_ip_addr);
  176. if (do_faststart)
  177. {
  178. if (CreateRtpSession())
  179. {
  180. result = (unsigned int)-1;
  181. }
  182. }
  183. }
  185. H323Call::~H323Call()
  186. {
  187. LOG("H323Call::~H323Calln");
  189. if (audio_session)
  190. {
  191. delete audio_session;
  192. }
  194. delete display_str;
  195. }
  197. void
  198. H323Call::NotifyMessage(USER_MESSAGE& msg)
  199. {
  200. LOG("H323Call::NotifyMessagen");
  201. ProtReturnCode ret;
  202. void *data = (void*)(msg.lParam);
  204. if (call_dropped)
  205. {
  206. if (data)
  207. {
  208. delete (CBData*)data;
  209. }
  210. return;
  211. }
  213. int myindex = ((H225CSProtocol *)this)->GetIdentifier() - ID_H225;
  214. if (msg.message == PROT_CALL_MSG)
  215. {
  216. switch(msg.wParam)
  217. {
  218. case CB_Q931_EVENT:
  219. {
  220. Q931Evt *info = (Q931Evt *)data;
  221. LOG("CB_Q931_EVENT, event type = %dn", info->event_type);
  223. Q931Message *q931msg = NULL;
  224. int type = 0;
  226. if (info->event_type == Q931EVENT_ERROR)
  227. {
  228. LOG("Got Error from Q931Engine, STATE_NULL,"
  229. " error = 0x%xn",
  230. info->err->GetError());
  232. // Check if the H.245 is listening
  233. if(GetCallDirection() == DIR_INCOMING &&
  234. (!((H245Protocol *)this)->IsConnectionReady()))
  235. {
  236. exchange->StopListening(
  237. ((H245Protocol *)this)->GetIdentifier());
  238. } 
  240. DropQ931(RCR_UNDEFINED);
  241. goto end_call;
  242. }
  244. if (info->event_type == Q931EVENT_MESSAGE)
  245. {
  247. q931msg = info->message;
  249. if (q931msg)
  250. {
  251. q931msg->GetType(type);
  252. LOG("Q931msg = 0x%xn", type);
  253. }
  254. }
  256. if (info->event_type == Q931EVENT_MESSAGE && 
  257. q931msg && type == MESSAGE_Q932_FACILITY)
  258. {
  259. H225CSFacilityUUIE *f = (H225CSFacilityUUIE*)info->ie;
  263. LOG("In call.cpp received FACILITYn");
  264. // Now check for supp services
  266. H4501SuppService *ss;
  267. // ProtReturnCode ret;
  268. int sscount;
  270. ret = f->GetNumH450SupplementaryServices(sscount);
  271. if(!PROT_IS_SUCCESS(ret))
  272. {
  273. LOG("Failed in GetNumH450SupplementaryServices - " 
  274. "getting num supp services ret=%dn", ret);
  275. }
  276. if(sscount != 0)
  277. {
  278. ss = new H4501SuppService[sscount];
  280. ret = f->GetH450SupplementaryServices(ss, sscount);
  281. if(!PROT_IS_SUCCESS(ret))
  282. {
  283. printf("Failed in GetH450SupplementaryServices - " 
  284. "getting supplementary services ret=0x%xn", ret);
  285. //return
  286. } 
  287. else 
  288. {
  289. int isII;
  290. unsigned int ip_addr;
  291. isII = isInitiateInvoke(ss, transfer_invoke_id,
  292. transfer_call_id, ip_addr, phone);
  293. if(isII == 1) {
  294. LOG("Placing a call to transferredTon");
  295. exchange->PlaceTransferedToCall(myindex, ip_addr, 
  296. phone, transfer_invoke_id, transfer_call_id);
  297. } else if(isII == -1) {
  298. break;
  299. }
  300. }
  301. delete [] ss;
  302. }
  303. }
  305. switch(info->new_state)
  306. {
  307. // TODO: FASTSTART FALLBACK incase we recv a facility message
  308. case STATE_NULL:
  309. {
  310. LOG("Got ReleaseComplete,STATE_NULLn");
  311. if (((H245Protocol *)this)->IsConnectionReady())
  312. { 
  313. if ( endsession_sent == 0)
  314. {
  315. LOG("ERROR..Deleting call before "
  316. " end sessionn");
  317. }
  318. }
  319. else
  320. {
  321. // Check if the H.245 is listening
  322. if(GetCallDirection() == DIR_INCOMING &&
  323. (!((H245Protocol *)this)->IsConnectionReady()))
  324. {
  325. exchange->StopListening(
  326. ((H245Protocol *)this)->GetIdentifier());
  327. } 
  328. }
  330. goto end_call;
  331. /*NOTREACHED*/
  332. }
  333. break;
  336. case STATE_CALL_PRESENT:
  337. {
  339. assert(info->event_type == Q931EVENT_MESSAGE);
  340. assert(q931msg != NULL);
  342. if (q931msg && type == MESSAGE_SETUP)
  343. {
  344. LOG("Line <%d> STATE_CALL_PRESENTn", myindex);
  346. LOG("MESSAGE_SETUPn");
  348. H225CSSetupUUIE *s = (H225CSSetupUUIE*)info->ie;
  350. struct sockaddr_in saddr;
  351. int alias_count = 0;
  353. if (s->GetH245Transport((struct sockaddr *)&saddr)
  354. == H225CS_SUCCESS)
  355. {
  356. LOG("H245Transport Address 0x%x, %dn",
  357. saddr.sin_addr.s_addr, 
  358. ntohs(saddr.sin_port));
  359. }
  361. // V2
  362. // Set the call id if the remote end is version 1.
  364. int remote_version = H225_VERSION_INVALID;
  365. s->GetProtocolID(remote_version);
  367. LOG("remote end is a Version %d endpointn", 
  368. remote_version);
  370. #if defined(GK19980320) // this is internal test, do not define it
  371. // Set the Call ID.
  372. char tmp[80];
  373. sprintf(tmp, "%00000008x%00000008d", 
  374.  exchange->confid_prefix, myindex);
  375. callid.SetCallID((unsigned char *)tmp,16);
  376. // Set the callid in the protocol object..
  377. // This dummy callid will be used for all
  378. // q931 messages we send out.
  379. SetCallID(callid);
  381. #else
  382. if (remote_version == H225_VERSION_1)
  383. {
  384. // Set the Call ID.
  385. char tmp[80];
  386. sprintf(tmp, "%00000008x%00000008d", 
  387.  exchange->confid_prefix, myindex);
  388. callid.SetCallID((unsigned char *)tmp,16);
  389. // Set the callid in the protocol object..
  390. // This dummy callid will be used for all
  391. // q931 messages we send out.
  392. SetCallID(callid);
  393. }
  394. else
  395. {
  396. // Get the call id from setup message and 
  397. // fill it in.
  398. if (!PROT_IS_SUCCESS(s->GetCallID(callid)))
  399. {
  400. LOG("Unable to retrieve call id n");
  401. LocalHangup();
  402. goto end_call;
  403. }
  404. }
  405. #endif
  406. // Get and print the Display information element.
  408. Q931IE *ie_display;
  409. if (PROT_IS_SUCCESS(q931msg->GetIE(IE_DISPLAY,
  410.  ie_display)))
  411. {
  412. int len = sizeof(remote_name);
  414. if (PROT_IS_SUCCESS(((Q931DisplayIE *)ie_display)->
  415. GetDisplayString(remote_name, len)))
  416. {
  417. remote_name[len] = 0;
  418. }
  419. }
  421. LOG("Remote Ends DISPLAY is %s.n", remote_name);
  423. // Get and print the Bearer capability element.
  425. Q931IE *ie_bc;
  426. if (PROT_IS_SUCCESS(q931msg->GetIE(IE_BEARER_CAPABILITY, 
  427. ie_bc)))
  428. {
  429. H225CSBearerCapabilityIE *_ie_bc = 
  430. (H225CSBearerCapabilityIE *)ie_bc;
  431. int cap = 0, rate = 0, value = 0;
  433. LOG("Got bearer capsn");
  434. _ie_bc->GetInfoTransferCap(cap);
  435. LOG("tinfo transfer cap = %dn", cap);
  436. _ie_bc->GetInfoTransferRate(rate);
  437. LOG("tinfo transfer rate = %dn", rate);
  438. if (rate == BC_ITR_MULTIRATE)
  439. {
  440. _ie_bc->GetRateMultiplier(value);
  441. LOG("trate multiplier = %dn", value);
  442. }
  443. _ie_bc->GetLayer1Prot(value);
  444. LOG("tlayer 1 protocol = %dn", value);
  445. _ie_bc->GetCodingStd(value);
  446. LOG("tCoding Standard = %dn", value);
  447. }
  448. else
  449. {
  450. LOG("Bearer capability not set !!!n");
  451. }
  453. // Get and print the remote endpoint type
  455. H225CSEndpointType ep;
  456. if (PROT_IS_SUCCESS(s->GetSrcInfo(ep)))
  457. {
  458. if (PROT_IS_SUCCESS(ep.IsGatekeeperSet()))
  459. {
  460. LOG("Remote end is a Gatekeepern");
  461. }
  462. if (PROT_IS_SUCCESS(ep.IsTerminalSet()))
  463. {
  464. LOG("Remote end is a Terminaln");
  465. }
  466. if (PROT_IS_SUCCESS(ep.IsGatewaySet()))
  467. {
  468. LOG("Remote end is a Gatewayn");
  469. }
  470. if (PROT_IS_SUCCESS(ep.IsMCUSet()))
  471. {
  472. LOG("Remote end is an MCUn");
  473. }
  474. }
  476. // get and print the source aliases
  478. if (PROT_IS_SUCCESS(s->GetNumSrcAddrs(alias_count)) &&
  479. alias_count > 0)
  480. {
  481. LOG("Got %d source alias addressesn", alias_count);
  482. int count = alias_count;
  483. H225CSAliasAddress *a = 
  484. new  H225CSAliasAddress[count];
  486. ret = s->GetSrcAddrs(a, count);
  487. assert(count == alias_count);
  489. if (!PROT_IS_SUCCESS(ret))
  490. {
  491. LOG("Unable to extract source address"
  492. " 0x%xn", ret);
  493. }
  494. else
  495. {
  496. unsigned short *id;
  497. unsigned short len;
  498. int j = 0;
  500. while (j < alias_count)
  501. {
  502. ProtReturnCode ret;
  503. if (a[j].GetType() == AAT_H323_ID)
  504. {
  505. if ((ret = a[j].GetH323ID(id, len)) != 
  506. H225CS_SUCCESS)
  507. {
  508. LOG("Unable to extract the H323ID"
  509.  " 0x%xn", ret);
  510. }
  511. else
  512. {
  513. char string[512];
  514. int string_length = 512;
  515. char q = '?';
  516. int ret_length;
  518. #if (defined(WIN32))
  519. if ((ret_length = WideCharToMultiByte(
  520. CP_ACP,
  521. 0,
  522. id,
  523. len,
  524. string,
  525. string_length,
  526. &q,
  527. NULL)) == FALSE)
  528. {
  530. LOG("WideChartoMultiByte"
  531. " conversion failed %dn", 
  532. GetLastError());
  533. }
  534. else
  535. {
  536. string[ret_length] = '';
  538. LOG("source H323ID = %sn",
  539. string);
  540. printf("%sn",string);
  542. strncpy(remote_name, string, 
  543. sizeof(remote_name) -1);
  544. }
  545. #elif defined(VXWORKS)
  546. #else
  547. int i;
  548. for (i = 0; i < len; i++)
  549. {
  550. #if defined(__hpux)
  551. if (iswalnum(id[i]))
  552. #else
  553. if (iswascii(id[i]))
  554. #endif
  555. {
  556. string[i] = (char) id[i];
  557. }
  558. else
  559. {
  560. break;
  561. }
  562. }
  564. string[i] = '';
  565. LOG("source H323ID = %sn", string);
  566. printf("%sn",string);
  568. strncpy(remote_name, string, 
  569. sizeof(remote_name) -1);
  570. #endif
  571. }
  572. }
  573. else if (a[j].GetType() == AAT_E164)
  574. {
  575. char *tmp_phone; 
  576. if ((ret = a[j].GetE164(tmp_phone, len)) != 
  577. H225CS_SUCCESS)
  578. {
  579. LOG("Unable to extract the E164 alias"
  580.  " 0x%xn", ret);
  581. }
  582. else
  583. {
  584. tmp_phone[len] = '';
  585. SetSrcPhoneNumber(tmp_phone);
  586. LOG("src phone = %sn",
  587. src_phone);
  588. }
  589. }
  591. ++j;
  592. }
  593. }
  595. delete [] a;
  596. }
  598. // get and print the destination aliases
  600. if (PROT_IS_SUCCESS(s->GetNumDstAddrs(alias_count)) &&
  601. alias_count > 0)
  602. {
  603. LOG("Got %d dest alias addressesn", alias_count);
  604. int count = alias_count;
  605. H225CSAliasAddress *a = 
  606. new  H225CSAliasAddress[count];
  608. ret = s->GetDstAddrs(a, count);
  609. assert(count == alias_count);
  611. if (!PROT_IS_SUCCESS(ret))
  612. {
  613. LOG("Unable to extract destination address"
  614. " 0x%xn", ret);
  615. }
  616. else
  617. {
  618. unsigned short *id;
  619. unsigned short len;
  620. int j = 0;
  622. while (j < alias_count)
  623. {
  624. ProtReturnCode ret;
  625. if (a[j].GetType() == AAT_H323_ID)
  626. {
  627. if ((ret = a[j].GetH323ID(id, len)) != 
  628. H225CS_SUCCESS)
  629. {
  630. LOG("Unable to extract the destination H323ID"
  631.  " 0x%xn", ret);
  632. }
  633. else
  634. {
  635. char string[512];
  636. int string_length = 512;
  637. char q = '?';
  638. int ret_length;
  640. #if (defined(WIN32))
  641. if ((ret_length = WideCharToMultiByte(
  642. CP_ACP,
  643. 0,
  644. id,
  645. len,
  646. string,
  647. string_length,
  648. &q,
  649. NULL)) == FALSE)
  650. {
  652. LOG("WideChartoMultiByte"
  653. " conversion failed %dn", 
  654. GetLastError());
  655. }
  656. else
  657. {
  658. string[ret_length] = '';
  660. LOG("destination end H323ID = %sn",
  661. string);
  662. printf("%sn",string);
  664. //strncpy(remote_name, string, 
  665. // sizeof(remote_name) -1);
  666. }
  667. #elif defined(VXWORKS)
  668. #else
  669. int i;
  670. for (i = 0; i < len; i++)
  671. {
  672. #if defined(__hpux)
  673. if (iswalnum(id[i]))
  674. #else
  675. if (iswascii(id[i]))
  676. #endif
  677. {
  678. string[i] = (char) id[i];
  679. }
  680. else
  681. {
  682. break;
  683. }
  684. }
  686. string[i] = '';
  687. LOG("destination end H323ID = %sn", string);
  689. //strncpy(remote_name, string, 
  690. // sizeof(remote_name) -1);
  691. #endif
  692. }
  693. }
  694. else if (a[j].GetType() == AAT_E164)
  695. {
  696. char *tmp_phone; 
  697. if ((ret = a[j].GetE164(tmp_phone, len)) != 
  698. H225CS_SUCCESS)
  699. {
  700. LOG("Unable to extract the E164 destination alias"
  701.  " 0x%xn", ret);
  702. }
  703. else
  704. {
  705. tmp_phone[len] = '';
  707. SetPhoneNumber(tmp_phone);
  708. LOG("dest phone = %sn",
  709. phone);
  711. }
  712. }
  714. ++j;
  715. }
  716. }
  718. delete [] a;
  719. }
  721. // Set the conference identifier to be
  722. // the same as the incoming call's cid.
  724. unsigned char *cid_p;
  725. int cid_len;
  726. s->GetConfID(cid_p, cid_len);
  727. SetConfID(cid_p, cid_len);
  729. // check if this a call coming from transferred (B endpoint)
  731. H4501SuppService *ss;
  732. ProtReturnCode ret;
  733. int sscount;
  735. ret = s->GetNumH450SupplementaryServices(sscount);
  736. if(!PROT_IS_SUCCESS(ret))
  737. {
  738. printf("Failed in GetH450SupplementaryServices - " 
  739. "getting supplementary services ret=0x%xn", ret);
  740. }
  741. else if(sscount != 0)
  742. {
  743. ss = new H4501SuppService[sscount];
  745. ret = s->GetH450SupplementaryServices(ss, sscount);
  746. if(!PROT_IS_SUCCESS(ret))
  747. {
  748. printf("Failed in GetH450SupplementaryServices - " 
  749. "getting supplementary services ret=0x%xn", ret);
  750. printf("%s: line %dn",__FILE__,__LINE__);
  751. } 
  752. else 
  753. {
  754. LOG("Got %d Supplementary Servicesn",sscount);
  755. LOG("=============================n");
  756. LOG("Extract Supplementary Services msgn");
  758. extractedSS *extSS = new extractedSS;
  759. extSS->tH4501SuppService(&ss[0]);
  761. if (extSS->ssNumROSs > 0)
  762. {
  763. if (extSS->ssROS[0].type == ROS_INVOKE)
  764. {
  765. if (extSS->ssROS[0].code == CTOT_SETUP) 
  766. {
  768. transfer_invoke_id = extSS->ssROS[0].InvokeId;
  769. strncpy(transfer_call_id, extSS->ssROS[0].Arg.CallID, 5);
  771. SetTransferFlag(TRUE);
  774. }
  775. }
  776. }
  777. delete extSS;
  778. }
  779. delete [] ss;
  780. }
  781. else
  782. {
  783. LOG("There are no Supplementary Services in this SETUPn"); 
  784. }
  786. #if defined(USE_RAS)
  787. if (exchange->IsGKRegistered())
  788. {
  789. SendARQdata *arq_data = new SendARQdata;
  791. if (src_phone[0])
  792. strcpy(arq_data->e164src, src_phone);
  793. else // ARQ needs the srcInfo field anyway, so fill it up 
  794. strcpy(arq_data->e164src, "999999");
  795. strcpy(arq_data->e164dst, phone);
  796. arq_data->index = GetApplicationPrivate();
  797. // ask the RAS protocol handler to send ARQ for this call
  798. exchange->SendToExchange(PROT_CALL_MSG, CB_SEND_ARQ,
  799. (unsigned long)arq_data);
  800. } 
  801. // not registered, sent ALERTING
  802. else if (do_alerting && (Q931SendAlerting() < 0))
  803. goto end_call;
  804. else 
  805. {
  806. if (Q931SendConnect() < 0)
  807. goto end_call;
  808. else
  809. printf("Connected to %sn", remote_name);
  810. }
  811. #else // defined(USE_RAS)
  812. if (do_overlapsend)
  813. {
  814. // We have to send back a setupack.
  815. if (Q931SendSetupAck() < 0)
  816. goto end_call;
  817. }
  818. else
  819. {
  820. if (do_alerting)
  821. {
  822. if (Q931SendAlerting() < 0)
  823. goto end_call;
  824. }
  825. else 
  826. {
  827. if (Q931SendConnect() < 0)
  828. goto end_call;
  829. else
  830. printf("Connected to %sn", remote_name);
  831. }
  832. }
  833. #endif //defined(USE_RAS)
  835. }
  837. }
  838. break;
  841. case STATE_INCOMING_CALL_PROCEEDING:
  842. {
  843. LOG("Line <%d> STATE_INCOMING_CALL_PROCEEDINGn", myindex);
  844. }
  845. break;
  846. case STATE_OUTGOING_CALL_PROCEEDING:
  847. {
  848. LOG("Line <%d> STATE_OUTGOING_CALL_PROCEEDINGn", myindex);
  849. }
  850. break;
  851. case STATE_CALL_RECEIVED:
  852. {
  853. #if 1
  854. LOG("Line <%d> STATE_CALL_RECEIVEDn", myindex);
  855. if (Q931SendConnect() < 0)
  856. goto end_call;
  857. else
  858. printf("Connected to %sn", remote_name);
  859. #endif
  860. }
  861. break;
  862. case STATE_CALL_INITIATED:
  863. {
  864. LOG("Line <%d> STATE_CALL_INITIATEDn", myindex);
  865. }
  866. break;
  868.  case STATE_OVERLAP_SENDING:
  869. {
  870. LOG("Line <%d> STATE_OVERLAP_SENDINGn", myindex);
  872. if (Q931SendInformation("12345#") < 0)
  873. goto end_call;
  874. }
  875. break;
  876.  case STATE_OVERLAP_RECEIVING:
  877. {
  878. LOG("Line <%d> STATE_OVERLAP_RECEIVINGn", myindex);
  879. if (q931msg && type == MESSAGE_INFORMATION)
  880. {
  881. LOG("Got Information messagen");
  883. // Fetch the keypad facility ie.
  884. LOG("Fetching keytpad facility ien");
  885. Q931IE *ie_keypad_fac;
  886. if (PROT_IS_SUCCESS(q931msg->GetIE(
  887. IE_KEYPAD_FACILITY,ie_keypad_fac)))
  888. {
  889. Q931KeypadFacilityIE *ie_kp = 
  890. (Q931KeypadFacilityIE*)ie_keypad_fac;
  891. char info[256];
  892. int length = sizeof(info) - 1;
  894. if (PROT_IS_SUCCESS(ie_kp->GetKeypadInfo(
  895. info,length)))
  896. {
  897. info[length] = 0;
  898. LOG("Keypad fac[%s]n",info);
  899. }
  901. }
  902. else
  903. {
  904. LOG("keytpad facility ie fetch failedn");
  905. }
  906. Q931IE *ie_snd_comp;
  907. if (PROT_IS_SUCCESS(q931msg->GetIE(
  908. IE_SENDING_COMPLETE,ie_snd_comp)))
  909. {
  910. printf("Got sending_complete...!n");
  912. if (Q931SendConnect() < 0)
  913. goto end_call;
  914. }
  915. }
  916. }
  917. break;
  918. case STATE_CALL_DELIVERED:
  919. {
  920. LOG("Line <%d> STATE_CALL_DELIVEREDn", myindex);
  921. }
  922. break;
  924. case STATE_CALL_ACTIVE:
  925. {
  926. LOG("Line <%d> STATE_CALL_ACTIVEn", myindex);
  927. // Q.931 negotiations succeeded.
  929. // Q.931 Call is active, but faststart is still
  930. // pending.. disable it, something went wrong..
  931. if (do_faststart && 
  932. faststart_state == FAST_START_STATE_PENDING)
  933. {
  934. faststart_state = FAST_START_STATE_DISABLED;
  935. }
  937. if (GetCallDirection() == DIR_OUTGOING &&
  938. info->new_state != info->old_state)
  939. {
  940. assert (type == MESSAGE_CONNECT);
  941. assert(q931msg != NULL);
  943. // Connect message from the remote end...
  944. // Get the H245 address and open a logical channel.
  946. H225CSConnectUUIE *c = 
  947. (H225CSConnectUUIE*)info->ie;
  948. assert(c != NULL);
  950. struct sockaddr_in saddr;
  952. if (c->GetH245Transport(
  953. (struct sockaddr *)&saddr) == H225CS_SUCCESS)
  954. {
  955. LOG("H245Transport Address 0x%x, %dn",
  956. saddr.sin_addr.s_addr, 
  957. ntohs(saddr.sin_port));
  959. remote_lc0_addr = saddr;
  961. // Connect only if no faststart or faststart
  962. // failed.
  963. if (!do_faststart ||
  964. (do_faststart && faststart_state == 
  965. FAST_START_STATE_DISABLED))
  966. {
  967. ret = exchange->Connect(
  968. (sockaddr *)&remote_lc0_addr, 
  969. (H245Protocol *)this);
  970. if (!PROT_IS_PENDING(ret))
  971. {
  972. exchange->NotifyConnectionStatus(
  973. (H245Protocol*)this,ret);
  974. }
  975. }
  976. }
  978. // Get the Display Information element..
  980. Q931IE *ie_display;
  982. if (PROT_IS_SUCCESS(q931msg->GetIE(IE_DISPLAY, 
  983. ie_display)))
  984. {
  985. int len = sizeof(remote_name);
  987. if (PROT_IS_SUCCESS(ie_display->
  988. GetContent(remote_name, len)))
  989. {
  990. remote_name[len] = 0;
  991. }
  992. }
  994. LOG("Remote Ends DISPLAY is %s.n", remote_name);
  995. printf("Connected to %sn",remote_name);
  997. // now check if this is a call that was transferred successfully
  999. if (transfer_flag)
  1000. {
  1001. H4501SuppService *ss;
  1002. ProtReturnCode ret;
  1003. int sscount;
  1005. ret = c->GetNumH450SupplementaryServices(sscount);
  1006. if(!PROT_IS_SUCCESS(ret))
  1007. {
  1008. LOG("Failed in GetNumH450SupplementaryServices - "
  1009. "getting num supp services ret=%dn", ret);
  1010. break;
  1011. }
  1012. if(sscount != 0)
  1013. {
  1014. ss = new H4501SuppService[sscount];
  1016. ret = c->GetH450SupplementaryServices(ss, sscount);
  1017. if(!PROT_IS_SUCCESS(ret))
  1018. {
  1019. printf("Failed in GetH450SupplementaryServices - "
  1020. "getting supplementary services ret=0x%xn", ret);
  1021. //return
  1022. } 
  1023. else 
  1024. {
  1025. LOG("Got %d Supplementary Servicesn",sscount);
  1026. LOG("=============================n");
  1027. LOG("Extract Supplementary Services msgn");
  1028. extractedSS *extSS = new extractedSS;
  1029. extSS->tH4501SuppService(&ss[0]);
  1031. if (extSS->ssNumROSs > 0)
  1032. {
  1033. if (extSS->ssROS[0].type == ROS_RETURN_RESULT)
  1034. {
  1035. if (extSS->ssROS[0].code == CTOT_SETUP) 
  1036. {
  1038. // transfer_invoke_id = extSS->ssROS[0].InvokeId;
  1039. // strncpy(transfer_call_id, extSS->ssROS[0].Arg.CallID, 5);
  1041. // LOG("Dropping the transferring calln");
  1042. exchange->DropTranferringCall(transfer_parent_index);
  1044. }
  1045. }
  1046. }
  1047. delete extSS;
  1048. }
  1049. delete [] ss;
  1050. }
  1051. else
  1052. {
  1053. LOG("There are no Supplementary Services in this SETUPn"); 
  1054. }
  1055. }
  1056. }
  1057. }
  1058. break;
  1059. }
  1060. }
  1061. break;
  1063. case CB_CONNECTION_CLOSED:
  1064. {
  1065. LOG("CB_CONNECTION_CLOSEDn");
  1066. XchgConnectionClosed *info = (XchgConnectionClosed *)data;
  1068. if (info->conn->GetIdentifier() == 
  1069. ((H225CSProtocol *)this)->GetIdentifier())
  1070. {
  1071. // check for the h.245 connection closure here...
  1072. if (((H245Protocol *)this)->IsConnectionReady())
  1073. {
  1074. if (endsession_sent != 0)
  1075. {
  1076. H245SigCommand *cmd ; 
  1077. H245SigCommand::Factory(cmd, CMDT_END_SESSION);
  1078. ((H245SigEndSessionCommand *)cmd)->SetType(ESTY_DISCONNECT);
  1080. SendCommand(*cmd);
  1082. delete cmd;
  1084. endsession_sent = 1;
  1085. }
  1086. }
  1087. else
  1088. {
  1089. // Check if the H.245 is listening
  1090. if(GetCallDirection() == DIR_INCOMING &&
  1091. (!((H245Protocol *)this)->IsConnectionReady()))
  1092. {
  1093. exchange->StopListening(
  1094. ((H245Protocol *)this)->GetIdentifier());
  1095. } 
  1096. }
  1098. LOG("H.225 Connection closedn");
  1099. goto end_call;
  1100. }
  1101. else
  1102. {
  1103. assert(info->conn->GetIdentifier() == 
  1104. ((H245Protocol *)this)->GetIdentifier());
  1106. LOG("H.245 Connection closedn");
  1107. }
  1108. }
  1109. break;
  1111. // Exchange indicates the state of the H.245 logical channel 0
  1112. // tcp connection.
  1114. case CB_CONNECTION_STATUS:
  1115. {
  1116. LOG("CB_CONNECTION_STATUSn");
  1117. XchgConnectionStatus *info = (XchgConnectionStatus *)data;
  1119. if (info->conn->GetIdentifier() ==  // is this a H.225 connection?
  1120. ((H225CSProtocol *)this)->GetIdentifier())
  1121. {
  1122. // either something went wrong with the connection
  1123. if (PROT_IS_ERROR(info->status))
  1124. {
  1125. LOG("H225 Connect Failedn");
  1126. goto end_call;
  1127. }
  1128. else // or the nonblocking connection succeeded.
  1129. {
  1130. LOG("H225 Connect Succeededn");
  1132. // Create the bearer capability information element..
  1134. Q931Message q931msg(MESSAGE_SETUP);
  1135. H225CSBearerCapabilityIE bc;
  1137. bc.SetInfoTransferCap(BC_ITC_SPEECH);
  1138. bc.SetInfoTransferRate(BC_ITR_PACKET);
  1139. bc.SetLayer1Prot(BC_L1P_ULAW);
  1140. bc.SetCodingStd(BC_CS_ISO);
  1142. q931msg.SetIE(bc);
  1144. H225CSSetupUUIE setup_uuie(*(H225CSProtocol *)this);
  1146. // Plug in the destination Address in the setup uuie.
  1148. // If the phone number field is set.. then set
  1149. // the destinationAddress.
  1150. if (phone[0] != '')
  1151. {
  1152. Q931CalledPartyNumberIE cpn;
  1154. cpn.SetNumberParams(NUMBERTYPE_UNKNOWN, 
  1155. NUMBERINGPLAN_ISDN);
  1156. cpn.SetDigits((char *)phone, strlen(phone));
  1157. q931msg.SetIE(cpn);
  1159. H225CSAliasAddress e164;
  1162. LOG("Phone number set in Setup message(%s)n",
  1163. phone);
  1165. e164.SetE164(phone,(unsigned short)strlen(phone));
  1166. setup_uuie.AddDstAddr(e164);
  1167. }
  1169. if (config->e164src[0] != '')
  1170. {
  1171. Q931CallingPartyNumberIE cpn;
  1173. // here we generate the originator phone number
  1174. // in real life you should get that from the callerID (e.g. PSTN)
  1175. // and pass it here
  1176. char tmp_phone[256];
  1177. sprintf(tmp_phone, "%s%0004d", config->e164src,
  1178. GetApplicationPrivate());
  1179. SetSrcPhoneNumber(tmp_phone);
  1181. cpn.SetNumberParams(NUMBERTYPE_UNKNOWN, 
  1182. NUMBERINGPLAN_ISDN);
  1183. cpn.SetDigits((char *)src_phone, strlen(src_phone));
  1184. q931msg.SetIE(cpn);
  1186. H225CSAliasAddress e164;
  1188.   LOG("Originator Phone number set in Setup message(%s)n",
  1189. src_phone);
  1191. e164.SetE164(src_phone,(unsigned short)strlen(src_phone));
  1192. setup_uuie.AddSrcAddr(e164);
  1193. }
  1195. struct sockaddr_in dst_ip_addr;
  1196. struct sockaddr_in src_ip_addr;
  1198. // Warning! Unixware libnsl is buggy, the following call
  1199. // can block indefinitely.
  1200. ((H225CSProtocol *)this)->GetConnectionAddrs(
  1201. (struct sockaddr*)&src_ip_addr,
  1202. (struct sockaddr*)&dst_ip_addr);
  1203. char *src_addr_str = inet_ntoa(src_ip_addr.sin_addr);
  1204. LOG("source IP set in Setup mesg <%s>:<%u>n", 
  1205. src_addr_str, ntohs(src_ip_addr.sin_port));
  1206. char *rem_addr_str = inet_ntoa(dst_ip_addr.sin_addr);
  1207. LOG("dest IP set in Setup msg <%s>:<%u>n", 
  1208. rem_addr_str, ntohs(dst_ip_addr.sin_port));
  1209. // d.sin_family = AF_INET;
  1210. // d.sin_port = htons(1720);
  1211. #if (!defined(BUGGY_NSL)) // returns 0 in remote address...
  1212. setup_uuie.SetDstCallSig((sockaddr*)&dst_ip_addr);
  1213. #endif
  1214. setup_uuie.SetSrcCallSig((sockaddr*)&src_ip_addr);
  1217. if (transfer_flag)
  1218. {
  1219. // Set the H4501 Supplimentary Services in setup_uuie
  1220. H4501SuppService *pss;
  1222. pss = ctSetupInvoke(transfer_invoke_id, &transfer_call_id[0]);
  1223. //pss = ctSetupInvoke(transfer_invoke_id, &transfer_call_id[0]);
  1225. ret = setup_uuie.AddH450SupplementaryService(*pss);
  1226. if (!PROT_IS_SUCCESS(ret))
  1227. {
  1228. LOG("Failed to set setup request ");
  1229. LOG("AddH450SupplementaryService, error = 0x%xn", ret);
  1230. }
  1231. delete pss;
  1233. }
  1235. // Check if we are to attempt fast start. If so,
  1236. // then create the list of OLCs and send it in 
  1237. // the setup message.
  1238. if (do_faststart)
  1239. {
  1240. if (InitFastStartProposal(&setup_uuie) == 0)
  1241. {
  1242. faststart_state = FAST_START_STATE_PENDING;
  1243. }
  1244. }
  1246. // Send the setup request..
  1248. ret = InvokeCCPrim(CCP_SETUP_REQUEST, &q931msg, 
  1249. setup_uuie);
  1251. if (!PROT_IS_SUCCESS(ret))
  1252. {
  1253. LOG("Failed to send setup messagen");
  1254. goto end_call;
  1255. }
  1256. }
  1257. }
  1258. else  // it is not a H.225 TCP connection. It must be H.245 TCP connection
  1259. {
  1260. assert(info->conn->GetIdentifier() == 
  1261. ((H245Protocol *)this)->GetIdentifier());
  1263. // either something went wrong with the previous
  1264. // outgoing H.245 LC0 connection
  1266. if (PROT_IS_ERROR(info->status))
  1267. {
  1268. LOG("H245 Connect Failedn");
  1270. if (((H225CSProtocol *)this)->IsConnectionReady())
  1271. {
  1272. DropQ931(RCR_UNDEFINED);
  1273. goto end_call;
  1274. }
  1275. }
  1276. else // or the connection succeeded.
  1277. {
  1278. LOG("H245 Connect succeeded (LC0 Connected)n");
  1279. // TODO: FASTSTART FALLBACK....
  1281. // pick interface ip address.
  1283. sockaddr_in local_addr;
  1284. #if (!defined(BUGGY_NSL)) // unixware nsl is buggy, alas! no multihomed hosts...
  1285. if (PROT_IS_SUCCESS(
  1286. ((H245Protocol *)this)->GetConnectionAddrs
  1287. ((sockaddr*)&local_addr,NULL)))
  1288. {
  1289. if_ip_addr = local_addr.sin_addr.s_addr;
  1290. LOG("Using i/f 0x%x for this calln", if_ip_addr);
  1291. }
  1292. #endif
  1294. // Initiate capability exchange proceedures.
  1296. H245SigH225Cap mc;
  1297. H245SigCapTable ct;
  1298. H245SigCapDescs cd;
  1300. InitCapTable(ct);
  1301. InitCapDescs(cd);
  1302. InitMuxCap(mc);
  1304. ret =  SendTermCaps(&mc, &ct, &cd);
  1306. if (!PROT_IS_SUCCESS(ret))
  1307. {
  1308. LOG("SendTermCaps failed..n");
  1309. LocalHangup();
  1310. goto end_call;
  1311. }
  1312. }
  1313. }
  1314. }
  1315. break;
  1317. case CB_NEW_CONNECTION:
  1318. {
  1319. LOG("LC0_CONNECTEDn");
  1321. XchgNewConnection *info = (XchgNewConnection *)data;
  1323. // We will get only H.245 new connections here...
  1325. remote_lc0_addr = info->new_addr;
  1327. // First accept the connection from the remote end.
  1328. ret = exchange->AcceptConnection(
  1329. info->conn_ref,(H245Protocol *)this);
  1330. if (!PROT_IS_SUCCESS(ret))
  1331. {
  1332. LOG("H245 accept connection failed..n");
  1333. LocalHangup();
  1334. goto end_call;
  1335. }
  1336. // Initiate capability exchange proceedures.
  1338. H245SigH225Cap mc;
  1339. H245SigCapTable ct;
  1340. H245SigCapDescs cd;
  1342. InitCapTable(ct);
  1343. InitCapDescs(cd);
  1344. InitMuxCap(mc);
  1346. ret =  SendTermCaps(&mc, &ct, &cd);
  1347. if (!PROT_IS_SUCCESS(ret))
  1348. {
  1349. LOG("SendTermCaps failed.. after H245Accept connn");
  1350. LocalHangup();
  1351. goto end_call;
  1352. }
  1353. }
  1354. break;
  1356. case CB_REMOTE_TERM_CAPS:
  1357. {
  1358. LOG("CB_REMOTE_TERM_CAPSn");
  1360. // Just acknowledge the remote terminals capabilities.
  1361. // TODO: parse them and see if they are acceptable.
  1363. RemoteTermCaps *info = (RemoteTermCaps *)data;
  1365. PrintCaps(*info->cap_table);
  1367. ret = AckTermCaps();
  1369. if (!PROT_IS_SUCCESS(ret))
  1370. {
  1371. LOG("Failed to ack remote caps, error = 0x%xn",
  1372. ret);
  1373. LocalHangup();
  1374. goto end_call;
  1375. }
  1377. // both ends have exchanged caps successfully.
  1379. if (++cap_done == 2)
  1380. {
  1381. ret = DetermineMS();
  1383. if (!PROT_IS_SUCCESS(ret))
  1384. {
  1385. LOG("Failed to ack remote caps,"
  1386. " error = 0x%xn", ret);
  1387. LocalHangup();
  1388. goto end_call;
  1389. }
  1390. }
  1391. }
  1392. break;
  1394. case CB_TERM_CAPS_ACK:
  1395. {
  1396. LOG("CB_TERM_CAPS_ACKn");
  1398. // Remote end has accepted our terminal capabilities.
  1399. // both ends have exchanged caps successfully.
  1401. if (++cap_done == 2)
  1402. {
  1403. ret = DetermineMS();
  1405. if (!PROT_IS_SUCCESS(ret) && !PROT_IS_PENDING(ret))
  1406. {
  1407. LOG("Failure in DetermineMS,"
  1408. " error = 0x%xn", ret);
  1409. LocalHangup();
  1410. goto end_call;
  1411. }
  1412. }
  1413. }
  1414. break;
  1416. case CB_TERM_CAPS_REJECT:
  1417. {
  1418. LOG("CB_TERM_CAPS_REJECTn");
  1419. TermCapsReject *info = (TermCapsReject *)data;
  1421. LOG("Remote end rejected our terminal capabilities"
  1422. " cause = %d, direction = %dn", info->cause, info->direction);
  1423. LocalHangup();
  1424. goto end_call;
  1425. }
  1426. /*NOTREACHED*/
  1427. break;
  1429. case CB_OUT_LC_ERROR:
  1430. {
  1431. LOG("CB_OUT_LC_ERRORn");
  1432. }
  1433. break;
  1435. case CB_MSD_ERROR:
  1436. {
  1437. LOG("CB_MSD_ERRORn");
  1438. MSDError *info = (MSDError *)data;
  1440. LOG("Master slave determination failed," 
  1441. "error = 0x%lxn", info->error);
  1442. LocalHangup();
  1443. goto end_call;
  1444. }
  1445. /*NOTREACHED*/
  1446. break;
  1448. case CB_MSD_CONFIRM:
  1449. {
  1450. LOG("CB_MSD_CONFIRMn");
  1452. MSDConfirm *info = (MSDConfirm *)data;
  1454. if(msd_done)
  1455. {
  1456. break;
  1457. }
  1458. msd_done++;
  1460. LOG("Master slave determine succeeded,"
  1461. "decision = %sn",
  1462. (info->decision == MSDRES_MASTER) ?
  1463. "MASTER" : "SLAVE");
  1465. // Open a logical channel with the remote end 
  1466. // do to G.723 audio.
  1468. // First get the capability table entry corresponding
  1469. // to G723.1 from the capability table.
  1471. H245SigCapTable *ct= new H245SigCapTable;
  1473. ret = GetCapTable(*ct);
  1474. if (!PROT_IS_SUCCESS(ret))
  1475. {
  1476. LOG("Could not retrieve the cap table"
  1477. ", error = 0x%lxn", ret);
  1478. LocalHangup();
  1479. goto end_call;
  1480. }
  1482. H245SigCap *c = NULL;
  1483. H245SigCap::Factory(c,CAP_AUDIO,AUD_G7231);
  1485. assert(c != NULL);
  1486. ret = ct->GetCap(*c, G7231_INDEX);
  1488. if (!PROT_IS_SUCCESS(ret))
  1489. {
  1490. LOG("Could not get G.723 audio capability"
  1491. "from cap table, error = 0x%lxn", ret);
  1492. delete c;
  1493. LocalHangup();
  1494. goto end_call;
  1495. }
  1497. // Prepare the Data type to use with the out_lc_num
  1499. H245SigAudDataType *d = new H245SigAudDataType;
  1501. ret = d->Set(*(H245SigAudCap *)c);
  1502. if (!PROT_IS_SUCCESS(ret))
  1503. {
  1504. LOG("Could not set G.723 audio capability"
  1505. "in audio data type, error = 0x%lxn", ret);
  1506. delete c;
  1507. LocalHangup();
  1508. goto end_call;
  1509. }
  1511. delete c;
  1512. delete ct;
  1514. // Prepare the mux params to use with the out_lc_num.
  1516. H245SigH225Params m;
  1518. // Create an audio session if not already created
  1519. // and generate the local ends RTP/RTCP addresses.
  1521. if (!audio_session)
  1522. {
  1523. int status;
  1525. audio_session = new H245RTPSession("RTP:ELEMEDIA", 
  1526. G7231_RTP_PAYLOAD_TYPE,G7231_AUDIO_SAMPLING_RATE,status);
  1527. if (status)
  1528. {
  1529. LOG("new H245RTPSession failedd. status = 0x%xn",
  1530. status);
  1531. delete d;
  1532. LocalHangup();
  1533. goto end_call;
  1534. }
  1536. unsigned short rtp_port = 0, rtcp_port = 0;
  1538. audio_session->SetLocalPorts(if_ip_addr, 
  1539. rtp_port, rtcp_port);
  1541. rtcp_addr.sin_family = AF_INET;
  1542. rtcp_addr.sin_addr.s_addr = if_ip_addr;
  1543. rtcp_addr.sin_port = rtcp_port;
  1545. rtp_addr.sin_family = AF_INET;
  1546. rtp_addr.sin_addr.s_addr = if_ip_addr;
  1547. rtp_addr.sin_port = rtp_port;
  1549. audio_session->SetLocalPayloadType(
  1550. G7231_RTP_PAYLOAD_TYPE);
  1551. }
  1553. m.SetSessionID(PRI_SSID_AUDIO);
  1554. m.SetDynamicRTPPayloadType(G7231_RTP_PAYLOAD_TYPE);
  1555. m.SetSilenceSupp(FALSE);
  1556. m.SetMediaCtrlChan((struct sockaddr *)&rtcp_addr);
  1558. out_lc_num = 1;
  1560. ret = OpenLC(out_lc_num, 0, *d, m);
  1562. if (!PROT_IS_PENDING(ret) && PROT_IS_ERROR(ret))
  1563. {
  1564. LOG("Open LC failed, lcnum = %d"
  1565. " error = 0x%lxn", out_lc_num,ret);
  1566. }
  1568. delete d;
  1569. }
  1570. break;
  1572. case CB_IN_LC_ERROR:
  1573. {
  1574. LOG("CB_IN_LC_ERRORn");
  1576. LCError *info = (LCError *)data;
  1577. LOG("Error in ILCSE signalling entity,"
  1578. " lc = %d, error = %dn", info->lc_num, info->error);
  1580. LocalHangup();
  1581. goto end_call;
  1582. }
  1583. /*NOTREACHED*/
  1584. break;
  1586. case CB_OLC_REQUEST:
  1587. {
  1588. OLCReq *info = (OLCReq *)data;
  1589. int dtype;
  1590. int cap_type;
  1591. int cap_sub_type;
  1592. H245SigH225Params *mux;
  1593. int dynamic_rtp_pt = 0;
  1594. sockaddr_in remote_rtcp_addr;
  1595. H245SigG7231Cap *g7231;
  1596. H245SigCap *gen_cap;
  1598. LOG("CB_OLC_REQUESTn");
  1599. in_lc_num = info->lc_num;
  1601. assert(info->mux_params);
  1602. assert(info->data_type);
  1604. info->data_type->GetType(dtype,cap_type,cap_sub_type);
  1605. if ((dtype != DT_AUDIO) || (cap_type != CAP_AUDIO) ||
  1606.  cap_sub_type != AUD_G7231)
  1607. {
  1608. LOG("Remote end request data type that we don't supportn");
  1609. // Send OLC reject here...
  1610. RejectOpenLCReq(info->lc_num,
  1611. OLCRR_DATATYPE_NOT_SUPPORTED);
  1612. LocalHangup();
  1613. goto end_call;
  1615. }
  1617. H245SigCap::Factory(gen_cap,cap_type, cap_sub_type);
  1618. g7231 = (H245SigG7231Cap*)gen_cap;
  1619. assert(g7231 != NULL);
  1621. ((H245SigAudDataType *)info->data_type)->Get(*g7231);
  1623. mux = (H245SigH225Params*)info->mux_params;
  1624. ret = mux->GetDynamicRTPPayloadType(dynamic_rtp_pt);
  1625. if (mux->GetMediaCtrlChan((sockaddr*)&remote_rtcp_addr) !=
  1626. H245SIG_SUCCESS)
  1627. {
  1628. LOG("Remote has not supplied RTCP address");
  1629. RejectOpenLCReq(info->lc_num,OLCRR_UNSPECIFIED);
  1630. delete g7231;
  1632. LocalHangup();
  1633. goto end_call;
  1634. }
  1636. // Create an audio session if not already created
  1637. // and generate the local ends RTP/RTCP addresses.
  1638. if (!audio_session)
  1639. {
  1640. unsigned short rtp_port = 0, rtcp_port = 0;
  1641. int status;
  1643. audio_session = new H245RTPSession("RTP:ELEMEDIA", 
  1644. G7231_RTP_PAYLOAD_TYPE,G7231_AUDIO_SAMPLING_RATE,status);
  1645. if (status)
  1646. {
  1647. LOG("new H245RTPSession failedd. status = 0x%xn",
  1648. status);
  1649. delete g7231;
  1650. LocalHangup();
  1651. goto end_call;
  1652. }
  1654. audio_session->SetLocalPorts(if_ip_addr, 
  1655. rtp_port, rtcp_port);
  1657. rtcp_addr.sin_family = AF_INET;
  1658. rtcp_addr.sin_addr.s_addr = if_ip_addr;
  1659. rtcp_addr.sin_port = rtcp_port;
  1661. rtp_addr.sin_family = AF_INET;
  1662. rtp_addr.sin_addr.s_addr = if_ip_addr;
  1663. rtp_addr.sin_port = rtp_port;
  1665. }
  1667. audio_session->SetRemotePayloadType(dynamic_rtp_pt);
  1668. audio_session->SetRemotePorts(
  1669. remote_rtcp_addr.sin_addr.s_addr,
  1670. 0,remote_rtcp_addr.sin_port);
  1672. H245SigH225AckParams ack;
  1674. ack.SetSessionID(PRI_SSID_AUDIO);
  1675. ack.SetMediaChan((sockaddr*)&rtp_addr);
  1676. ack.SetMediaCtrlChan((sockaddr*)&rtcp_addr);
  1678. LOG("calling AckOpenLCReqn");
  1679. AckOpenLCReq(in_lc_num, &ack);
  1681. if (++olc_done == 2)
  1682. {
  1683. audio_session_flag = 1;
  1684. #if defined (ENABLE_BENCHMARKS)
  1685. get_current_time(end_sec,end_msec);
  1686. #endif
  1687. StartAudio();
  1688. }
  1690. delete g7231;
  1691. }
  1692. break;
  1694. case CB_OLC_REJECT:
  1695. {
  1696. LOG("CB_OLC_REJECTn");
  1697. OLCReject *info = (OLCReject *)data;
  1699. LOG("Remote end rejected our open channel request"
  1700. " lc = %d, reason = %dn", info->lc_num, info->reason);
  1702. LocalHangup();
  1703. goto end_call;
  1704. }
  1705. /*NOTREACHED*/
  1706. break;
  1708. case CB_OLC_ACK:
  1709. {
  1710. LOG("CB_OLC_ACKn");
  1711. OLCAck *info = (OLCAck *)data;
  1713. LOG("Open logical channel ack, lc = %dn", 
  1714. info->lc_num);
  1716. H245SigH225AckParams *ap = info->ack_params;
  1718. struct sockaddr_in rrtp_addr;
  1719. struct sockaddr_in rrtcp_addr;
  1721. ret = ap->GetMediaChan((sockaddr*)&rrtp_addr);
  1722. ret = ap->GetMediaCtrlChan((sockaddr*)&rrtcp_addr);
  1724. assert(audio_session != NULL);
  1726. audio_session->SetRemotePorts(rrtp_addr.sin_addr.s_addr,
  1727. rrtp_addr.sin_port,rrtcp_addr.sin_port);
  1729. if (++olc_done == 2)
  1730. {
  1731. audio_session_flag = 1;
  1732. #if defined (ENABLE_BENCHMARKS)
  1733. get_current_time(end_sec,end_msec);
  1734. #endif
  1735. StartAudio();
  1736. }
  1737. }
  1738. break;
  1740. case CB_CLOSE_OUT_LC_REQUEST:
  1741. {
  1742. LOG("CB_CLOSE_OUT_LC_REQUESTn");
  1743. }
  1744. break;
  1746. case CB_CLOSE_OUT_LC_ACK:
  1747. {
  1748. LOG("CB_CLOSE_OUT_LC_ACKn");
  1749. CloseXXX *info = (CloseXXX *)data;
  1750. LOG("Remote end acked close lc, lc = %dn",
  1751. info->lc_num);
  1752. }
  1753. break;
  1755. case CB_CLOSE_IN_LC:
  1756. {
  1757. LOG("CB_CLOSE_IN_LCn");
  1759. // remote end decided to close its lc, 
  1760. // we will close ours too...
  1762. CloseOutLC(out_lc_num);
  1763. }
  1764. break;
  1766. case CB_CLOSE_IN_LC_ACK:
  1767. {
  1768. LOG("CB_CLOSE_IN_LC_ACKn");
  1769. }
  1770. break;
  1772. case CB_CLOSE_IN_LC_REJECT:
  1773. {
  1774. LOG("CB_CLOSE_IN_LC_REJECTn");
  1775. }
  1776. break;
  1778. case CB_NOTIFY_CMD:
  1779. {
  1780. LOG("CB_NOTIFY_CMDn");
  1782. // check if an end session was generated from the remote end.
  1784. H245CMD *info = (H245CMD *)data;
  1785. int type = 0;
  1786. info->cmd->GetCommandType(type);
  1788. LOG("command type = %dn", type);
  1790. if (type == CMDT_END_SESSION) 
  1791. {
  1792. LOG("CMDT_END_SESSIONn");
  1793. // send an end session.
  1795. H245SigCommand *cmd ; 
  1796. H245SigCommand::Factory(cmd, CMDT_END_SESSION);
  1797. ((H245SigEndSessionCommand *)cmd)->SetType(
  1798. ESTY_DISCONNECT);
  1800. SendCommand(*cmd);
  1802. delete cmd;
  1804. endsession_sent = 1;
  1805. }
  1806. }
  1807. break;
  1809. case CB_NOTIFY_IND:
  1810. {
  1811. LOG("CB_NOTIFY_INDn");
  1812. }
  1813. break;
  1814. }
  1815. }
  1816. else if (msg.message == PROT_UI_MSG)
  1817. {
  1818. if ((msg.wParam == UI_CMD_EXIT) || 
  1819. (msg.wParam == UI_CMD_HANGUP))
  1820. {
  1821. if (msg.wParam == UI_CMD_HANGUP)
  1822. {
  1823. LocalHangup();
  1824. }
  1826. goto end_call;
  1827. } else if (msg.wParam == UI_CMD_FACILITY) {
  1828. UICmdFacility *info = (UICmdFacility *)data;
  1829. SendFacility(info->suppsvcs);
  1830. }
  1831. else if (msg.wParam == UI_CMD_CTRL)
  1832. {
  1833. }
  1834. }
  1836. if (data)
  1837. {
  1838. delete (CBData*)data;
  1839. }
  1840. return;
  1842. end_call:
  1843. call_dropped = 1;
  1844. exchange->SendToExchange(PROT_EXCH_MSG, XC_CALL_DROPPED,
  1845. (unsigned long)this);
  1846. if (data)
  1847. {
  1848. delete (CBData*)data;
  1849. }
  1851. return;
  1852. }
  1854. int
  1855. H323Call::LocalHangup()
  1856. {
  1857. // Request from the user to drop the call. 
  1859. if (((H245Protocol *)this)->IsConnectionReady())
  1860. {
  1861. H245SigCommand *cmd ; 
  1862. H245SigCommand::Factory(cmd, CMDT_END_SESSION);
  1863. ((H245SigEndSessionCommand *)cmd)->SetType(ESTY_DISCONNECT);
  1865. LOG("Sending END_SESSIONn");
  1866. SendCommand(*cmd);
  1868. delete cmd;
  1870. endsession_sent = 1;
  1871. }
  1872. else
  1873. {
  1874. if(GetCallDirection() == DIR_INCOMING)
  1875. {
  1876. exchange->StopListening(
  1877. ((H245Protocol *)this)->GetIdentifier());
  1878. } 
  1879. }
  1881. if(((H225CSProtocol *)this)->IsConnectionReady()) 
  1882. {
  1883. LOG("Sending Release completen");
  1884. DropQ931(RCR_UNDEFINED);
  1885. return(-1);
  1886. }
  1888. return -1;
  1889. }
  1891. void
  1892. H323Call::DropQ931(int rc_reason)
  1893. {
  1894. LOG("H323Call::DropQ931n");
  1896. LOG("rc_reason = %dn", rc_reason);
  1898. ProtReturnCode ret;
  1900. H225CSReleaseCompleteUUIE ie(*this);
  1902. ret = ie.SetReason(rc_reason);
  1904. if (!PROT_IS_SUCCESS(ret))
  1905. {
  1906. LOG("Failed to set release complete reason, error = 0x%xn", 
  1907. ret);
  1908. }
  1910. if (transfer_flag)
  1911. {
  1912. // Set the H4501 Supplimentary Services in setup_uuie
  1913. H4501SuppService *pss;
  1915. // invokeID is 0 for now until OSS fixes the bug
  1916. pss = ctInitiateReturnResult(transfer_invoke_id);
  1918. ret = ie.AddH450SupplementaryService(*pss);
  1919. if (!PROT_IS_SUCCESS(ret))
  1920. {
  1921. LOG("Failed to set setup request ");
  1922. LOG("AddH450SupplementaryService, error = 0x%xn", ret);
  1923. }
  1924. delete pss;
  1926. }
  1928. ret = InvokeCCPrim(CCP_RELEASE_REQUEST, NULL, ie);
  1930. if (!PROT_IS_SUCCESS(ret))
  1931. {
  1932. LOG("Failed to send release complete, error = 0x%xn", ret);
  1933. }
  1934. }
  1936. int
  1937. H323Call::Q931SendAlerting()
  1938. {
  1939. ProtReturnCode ret;
  1940. // send connect
  1941. assert(GetCallDirection() == DIR_INCOMING);
  1943. LOG("DIR_INCOMING, sending alertingn");
  1944. // Send the alerting message.
  1946. H225CSAlertingUUIE ie(*this);
  1948. if (do_faststart && faststart_state == FAST_START_STATE_PENDING)
  1949. {
  1950. if ((ie.AddOLC(fs_channels[FS_CHANNEL_OUTGOING]) != H245SIG_SUCCESS) ||
  1951. (ie.AddOLC(fs_channels[FS_CHANNEL_INCOMING]) != H245SIG_SUCCESS))
  1952. {
  1953. LOG("ERROR: Failed to add the fast start OLCs.n"); 
  1954. faststart_state = FAST_START_STATE_DISABLED;
  1955. return LocalHangup();
  1956. }
  1957. faststart_state = FAST_START_STATE_ENABLED;
  1958. }
  1960. ret = InvokeCCPrim(CCP_ALERTING_REQUEST, NULL, ie);
  1961. if (!PROT_IS_SUCCESS(ret))
  1962. {
  1963. LOG("Failed to send alerting, error = 0x%xn", ret);
  1964. return LocalHangup();
  1965. }
  1966. else
  1967. {
  1968. if (do_faststart && audio_session_flag == 0 && 
  1969. faststart_state == FAST_START_STATE_ENABLED)
  1970. {
  1971. audio_session_flag = 1;
  1972. #if defined (ENABLE_BENCHMARKS)
  1973. get_current_time(end_sec,end_msec);
  1974. #endif
  1975. StartAudio();
  1976. }
  1977. }
  1978. return 1;
  1979. }
  1981. int
  1982. H323Call::Q931SendSetupAck()
  1983. {
  1984. ProtReturnCode ret;
  1985. assert(GetCallDirection() == DIR_INCOMING);
  1988. LOG("DIR_INCOMING, sending setup_ackn");
  1990. ret = InvokeCCPrim(CCP_MORE_INFO_REQUEST, NULL);
  1991. if (!PROT_IS_SUCCESS(ret))
  1992. {
  1993. LOG("Failed to send setup_ack, error = 0x%xn", ret);
  1994. return LocalHangup();
  1995. }
  1996. return 1;
  1997. }
  1999. int
  2000. H323Call::Q931SendInformation(char *info)
  2001. {
  2002. ProtReturnCode ret;
  2003. Q931Message q931msg(MESSAGE_INFORMATION);
  2004. Q931KeypadFacilityIE ie_kp;
  2005. Q931IE snd_comp;
  2006. H225CSInformationUUIE info_uuie(*(H225CSProtocol *)this);
  2008. ie_kp.SetKeypadInfo(info,strlen(info));
  2010. // Sending Complete is a fixed length ie.
  2011. snd_comp.SetContent(IE_SENDING_COMPLETE,NULL,0);
  2013. if (!PROT_IS_SUCCESS(q931msg.SetIE(ie_kp)))
  2014. {
  2015. LOG("Error inserting keypad facility ie!n");
  2016. }
  2018. if (!PROT_IS_SUCCESS(q931msg.SetIE(snd_comp)))
  2019. {
  2020. LOG("Error inserting sending complete ie!n");
  2021. }
  2023. ret = InvokeCCPrim(CCP_INFO_REQUEST, &q931msg,info_uuie);
  2024. if (!PROT_IS_SUCCESS(ret))
  2025. {
  2026. LOG("Failed to send information, error = 0x%xn", ret);
  2027. return LocalHangup();
  2028. }
  2029. return 1;
  2030. }
  2032. int
  2033. H323Call::Q931SendProceeding()
  2034. {
  2035. ProtReturnCode ret;
  2037. // send proceeding
  2038. assert(GetCallDirection() == DIR_INCOMING);
  2040. LOG("DIR_INCOMING, sending proceedingn");
  2041. // Send the proceeding message.
  2043. H225CSCallProceedingUUIE ie(*this);
  2045. if (do_faststart && faststart_state == FAST_START_STATE_PENDING)
  2046. {
  2047. if ((ie.AddOLC(fs_channels[FS_CHANNEL_OUTGOING]) != H245SIG_SUCCESS) ||
  2048. (ie.AddOLC(fs_channels[FS_CHANNEL_INCOMING]) != H245SIG_SUCCESS))
  2049. {
  2050. LOG("ERROR: Failed to add the fast start OLCs.n"); 
  2051. faststart_state = FAST_START_STATE_DISABLED;
  2052. return LocalHangup();
  2053. }
  2054. faststart_state = FAST_START_STATE_ENABLED;
  2055. }
  2057. ret = InvokeCCPrim(CCP_PROCEEDING_REQUEST, NULL, ie);
  2058. if (!PROT_IS_SUCCESS(ret))
  2059. {
  2060. LOG("Failed to send proceeding,"
  2061. " error = 0x%xn", ret);
  2062. return LocalHangup();
  2063. }
  2064. else
  2065. {
  2066. if (do_faststart && audio_session_flag == 0 && 
  2067. faststart_state == FAST_START_STATE_ENABLED)
  2068. {
  2069. audio_session_flag = 1;
  2070. #if defined (ENABLE_BENCHMARKS)
  2071. get_current_time(end_sec,end_msec);
  2072. #endif
  2073. StartAudio();
  2074. }
  2075. }
  2076. return 1;
  2077. }
  2079. int 
  2080. H323Call::Q931SendConnect()
  2081. {
  2082. ProtReturnCode ret;
  2084. assert(GetCallDirection() == DIR_INCOMING);
  2086. LOG("DIR_INCOMING, sending connectn");
  2087. // Send the connect message.
  2089. H225CSConnectUUIE ie(*this);
  2091. if (do_faststart && faststart_state == FAST_START_STATE_PENDING)
  2092. {
  2093. if ((ie.AddOLC(fs_channels[FS_CHANNEL_OUTGOING]) != H245SIG_SUCCESS) ||
  2094. (ie.AddOLC(fs_channels[FS_CHANNEL_INCOMING]) != H245SIG_SUCCESS))
  2095. {
  2096. LOG("ERROR: Failed to add the fast start OLCs.n"); 
  2097. faststart_state = FAST_START_STATE_DISABLED;
  2098. return LocalHangup();
  2099. }
  2100. faststart_state = FAST_START_STATE_ENABLED;
  2101. }
  2103. //send the H.245 address if either, faststart is disabled, or
  2104. //if we refused the faststart the remote side sent us.
  2105. if (!do_faststart ||
  2106. do_faststart && faststart_state == FAST_START_STATE_DISABLED)
  2107. {
  2108. // First insert the H245address into the connect
  2109. // user to user information element.
  2111. memset(&local_lc0_addr, 0, sizeof(local_lc0_addr));
  2112. local_lc0_addr.sin_family = AF_INET;
  2114. // 07/01/97 Added support for multi-homed hosts..
  2116. #if (defined(BUGGY_NSL)) // Needed for unixware, alas! no multihomed hosts...
  2117. local_lc0_addr.sin_addr.s_addr = if_ip_addr;
  2118. #else
  2119. if (!PROT_IS_SUCCESS(
  2120. ((H225CSProtocol *)this)->GetConnectionAddrs(
  2121. (struct sockaddr*)&local_lc0_addr,
  2122. NULL)))
  2123. {
  2124. LOG("Can't get i/f ip addressn");
  2125. local_lc0_addr.sin_addr.s_addr = if_ip_addr;
  2126. }
  2127. else
  2128. {
  2129. LOG("Got i/f ip address, 0x%xn",
  2130. local_lc0_addr.sin_addr.s_addr);
  2131. if_ip_addr = local_lc0_addr.sin_addr.s_addr;
  2132. }
  2133. #endif
  2135. // Make the connection manager pick a port for
  2136. // us.
  2138. local_lc0_addr.sin_port = 0;
  2140. ret = exchange->Listen(
  2141. ((H245Protocol *)this)->GetIdentifier(),
  2142. (struct sockaddr *)&local_lc0_addr, 
  2143. LT_ONCE);
  2146. if (!PROT_IS_SUCCESS(ret))
  2147. {
  2148. LOG("Failed to create H.245 address error = 0x%xn",ret);
  2150. return LocalHangup();
  2152. }
  2154. ret = ie.SetH245Transport(
  2155. (struct sockaddr *)&local_lc0_addr);
  2157. if (!PROT_IS_SUCCESS(ret))
  2158. {
  2159. LOG("Failed to set H.245 address"
  2160. " in connectUUIE error = 0x%xn",ret);
  2161. return LocalHangup();
  2163. }
  2165. }
  2167. if (transfer_flag)
  2168. {
  2169. // Set the H4501 Supplimentary Services in setup_uuie
  2170. H4501SuppService *pss;
  2172. // invokeID is 0 for now until OSS fixes the bug
  2173. pss = ctSetupReturnResult(transfer_invoke_id);
  2174. ret = ie.AddH450SupplementaryService(*pss);
  2175. if (!PROT_IS_SUCCESS(ret))
  2176. {
  2177. LOG("Failed to set setup response ");
  2178. LOG("AddH450SupplementaryService, error = 0x%xn", ret);
  2179. }
  2180. delete pss;
  2182. }
  2183. ret = InvokeCCPrim(CCP_SETUP_RESPONSE, NULL, ie);
  2184. if (!PROT_IS_SUCCESS(ret))
  2185. {
  2186. LOG("Failed to send connect, error = 0x%xn", ret);
  2187. return LocalHangup();
  2189. }
  2190. else
  2191. {
  2192. if (do_faststart && audio_session_flag == 0 && 
  2193. faststart_state == FAST_START_STATE_ENABLED)
  2194. {
  2195. audio_session_flag = 1;
  2196. #if defined (ENABLE_BENCHMARKS)
  2197. get_current_time(end_sec,end_msec);
  2198. #endif
  2199. StartAudio();
  2200. }
  2201. }
  2203. return 1;
  2204. }
  2206. int
  2207. H323Call::SendFacility(H450SSseq *ssSeq)
  2208. {
  2209. // Request from the user to send Facility message. 
  2211. if(((H225CSProtocol *)this)->IsConnectionReady()) 
  2212. {
  2213. LOG("H323Call::SendFacility() sending (ssSeq=0x%x)t",ssSeq);
  2214. SendQ932Facility(FYR_UNDEFINED, ssSeq);
  2215. return(-1);
  2216. }
  2218. return -1;
  2219. }
  2221. void
  2222. H323Call::SendQ932Facility(int reason, H450SSseq *ssSeq)
  2223. {
  2224. LOG("H323Call::SendQ932Facilityn");
  2226. LOG("Facility reason = %dn", reason);
  2228. ProtReturnCode ret;
  2230. H225CSFacilityUUIE ie(*this);
  2231. Q931Message fmsg(MESSAGE_Q932_FACILITY);
  2233. // Set Reason in H225CSFacilityUUIE
  2234. ret = ie.SetReason(reason);
  2235. if (!PROT_IS_SUCCESS(ret))
  2236. {
  2237. LOG("Failed to set facility reason, error = 0x%xn", ret);
  2238. }
  2240. #ifdef NOTNEEDED
  2241. // {
  2242. // Set AlternativeAliasAddress in H225CSFacilityUUIE
  2243. H225CSAliasAddress e164;
  2244. char dummy[15];
  2245. strcpy(dummy,"12345678901");
  2246. e164.SetE164(dummy,(unsigned short)strlen(dummy));
  2247. ret = ie.AddAlternativeAliasAddr(e164);
  2248. if (!PROT_IS_SUCCESS(ret))
  2249. {
  2250. LOG("Failed to set facility AddAlternativeAliasAddr, error = 0x%xn", ret);
  2251. }
  2253. // Set AlternativeAddress in H225CSFacilityUUIE
  2254. struct sockaddr_in addr;
  2255. addr.sin_family = AF_INET;
  2256. addr.sin_addr.s_addr = inet_addr("123.45.67.89");
  2257. addr.sin_port = htons(1122);
  2258. ret = ie.SetAlternativeAddr((sockaddr *)&addr);
  2259. if (!PROT_IS_SUCCESS(ret))
  2260. {
  2261. LOG("Failed to set facility SetAlternativeAddr, error = 0x%xn", ret);
  2262. }
  2263. // }
  2264. #endif
  2266. // Set the H4501 Supplimentary Services
  2267. H4501SuppService *pss;
  2268. H450SSseq *p;
  2269. int i = 0;
  2270. p = ssSeq;
  2271. while(p != NULL)
  2272. {
  2273. pss = p->value;
  2274. if(pss != NULL) {
  2275. ret = ie.AddH450SupplementaryService(*pss);
  2276. if (!PROT_IS_SUCCESS(ret))
  2277. {
  2278. LOG("Failed to set facility AddH450SupplementaryService, error = 0x%xn", ret);
  2279. }
  2280. }
  2281. p = p->next;
  2282. i++;
  2283. }
  2284. LOG("Added %d SuppServices to FACILITY_REQUESTn",i);
  2286. ret = InvokeCCPrim(CCP_FACILITY_REQUEST, &fmsg, ie);
  2287. if (!PROT_IS_SUCCESS(ret))
  2288. {
  2289. LOG("Failed to send facility, error = 0x%xn", ret);
  2290. }
  2291. // deleteSSlist(ssSeq);
  2292. }
  2294. // return 0 on success
  2295. int
  2296. H323Call::CreateRtpSession()
  2297. {
  2298. unsigned short rtp_port = 0, rtcp_port = 0;
  2299. int status;
  2301. audio_session = 
  2302. new H245RTPSession("RTP:ELEMEDIA", 
  2303. G7231_RTP_PAYLOAD_TYPE,
  2304. G7231_AUDIO_SAMPLING_RATE,status);
  2305. if (status)
  2306. {
  2307. LOG("new H245RTPSession failed. "
  2308. "status = 0x%xn", status);
  2309. return status;
  2310. }
  2312. audio_session->SetLocalPorts(if_ip_addr, 
  2313. rtp_port, rtcp_port);
  2315. rtcp_addr.sin_family = AF_INET;
  2316. rtcp_addr.sin_addr.s_addr = if_ip_addr;
  2317. rtcp_addr.sin_port = rtcp_port;
  2319. rtp_addr.sin_family = AF_INET;
  2320. rtp_addr.sin_addr.s_addr = if_ip_addr;
  2321. rtp_addr.sin_port = rtp_port;
  2323. return 0;
  2324. }
  2326. // return 0 on success
  2327. int
  2328. H323Call::SwitchToRegularH245()
  2329. {
  2330. // Switch to Regular H.245 proceedures.
  2331. ProtReturnCode ret;
  2333. assert(do_faststart == 1);
  2335. // Check if we already have the remote endpoints H.245 address.
  2336. // If not obtain it by sending out a facility message.
  2338. if (remote_lc0_addr.sin_addr.s_addr != 0)
  2339. {
  2340. // we already have the remote ends H.245 address. Just connect to it.
  2341. ret = exchange->Connect( (sockaddr *)&remote_lc0_addr, 
  2342. (H245Protocol *)this);
  2343. faststart_state = H245_FAST_START_STATE_SWITCH_OUT_BEGIN; 
  2344. if (!PROT_IS_PENDING(ret))
  2345. {
  2346. exchange->NotifyConnectionStatus(
  2347. (H245Protocol*)this,ret);
  2348. faststart_state = H245_FAST_START_STATE_SWITCHED_OUT; 
  2349. }
  2350. }
  2351. else
  2352. {
  2353. // Try to get the remote end to switch to regular H.245 
  2354. // procedure by providing our lc0 address.
  2355. H225CSFacilityUUIE ie(*this);
  2357. // Insert our H245address 
  2359. local_lc0_addr.sin_family = AF_INET;
  2361. #if (defined(BUGGY_NSL)) // Needed for unixware, alas! no multihomed hosts...
  2362. local_lc0_addr.sin_addr.s_addr = if_ip_addr;
  2363. #else
  2364. if (!PROT_IS_SUCCESS(
  2365. ((H225CSProtocol *)this)->GetConnectionAddrs(
  2366. (struct sockaddr*)&local_lc0_addr,
  2367. NULL)))
  2368. {
  2369. LOG("Can't get i/f ip addressn");
  2370. local_lc0_addr.sin_addr.s_addr = if_ip_addr;
  2371. }
  2372. else
  2373. {
  2374. LOG("Got i/f ip address, 0x%xn",
  2375. local_lc0_addr.sin_addr.s_addr);
  2376. if_ip_addr = local_lc0_addr.sin_addr.s_addr;
  2377. }
  2378. #endif
  2380. // Make the connection manager pick the port.
  2381. local_lc0_addr.sin_port = 0;
  2382. ret = exchange->Listen(
  2383. ((H245Protocol *)this)->GetIdentifier(),
  2384. (struct sockaddr *)&local_lc0_addr, 
  2385. LT_ONCE);
  2386. if (!PROT_IS_SUCCESS(ret))
  2387. {
  2388. LOG("Failed to create H.245 address" " error = 0x%xn",ret);
  2389. return -1;
  2390. }
  2392. ret = ie.SetH245Transport((struct sockaddr *)&local_lc0_addr);
  2393. if (!PROT_IS_SUCCESS(ret))
  2394. {
  2395. LOG("Failed to set H.245 address in facilityUUIE error = 0x%xn",
  2396. ret);
  2397. return -1;
  2399. }
  2401. ret = InvokeCCPrim(CCP_FACILITY_REQUEST, NULL, ie);
  2402. if (!PROT_IS_SUCCESS(ret))
  2403. {
  2404. LOG("Failed to send facility, error = 0x%xn", ret);
  2405. return -1;
  2406. }
  2408. faststart_state = H245_FAST_START_STATE_SWITCH_OUT_BEGIN; 
  2409. }
  2411. return 0;
  2412. }