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

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

IP电话/视频会议

开发平台：

WINDOWS

exchange.cpp：源码内容
  1. /*
  2.  * $Revision: 1.19 $
  3.  * $Date: 1999/03/15 22:49:36 $
  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. #if (!defined(WIN32))
  33. #if defined(VXWORKS)
  34. #else
  35. #if (defined(__hpux))
  36. #include <pthread.h>
  37. #else
  38. #include <thread.h>
  39. #endif
  40. #endif
  41. #endif
  43. #include "exchange.h"
  44. #include "call.h"
  45. #include "msg.h"
  46. #include "mq.h"
  48. #include <assert.h>
  50. #if defined(USE_RAS)
  51. extern char *ras_msg_id_str[];
  53. char *ras_msg_id2str[] = 
  54. {
  55.         "INVALID",
  56.         "GRQ",
  57.         "GCF",
  58.         "GRJ",
  59.         "RRQ",
  60.         "RCF",
  61.         "RRJ",
  62.         "URQ",
  63.         "UCF",
  64.         "URJ",
  65.         "ARQ",
  66.         "ACF",
  67.         "ARJ",
  68.         "BRQ",
  69.         "BCF",
  70.         "BRJ",
  71.         "DRQ",
  72.         "DCF",
  73.         "DRJ",
  74.         "LRQ",
  75.         "LCF",
  76.         "LRJ",
  77.         "IRQ",
  78.         "IRR",
  79.         "NSM",
  80.         "XRS"
  81. };
  83. int
  84. find_msg_id(char* msg_str)
  85. {
  87.         for(int i=MSG_INVALID;i<=MSG_XRS;++i)
  88.         {
  89.                 if (!stricmp(msg_str,ras_msg_id2str[i]))
  90.                 {
  91.                         return i;
  92.                 }
  93.         }
  94.         return -1;
  95. }
  99. Exchange::Exchange(H225CSEndpointType& endpoint_type,
  100.         H225CSVendorID& vendor_id, int ras_endpoint,
  101.         ProtReturnCode& result) : 
  102. ConnectionManager(result),
  103. H225RASProtocol(endpoint_type, vendor_id, ras_endpoint, result),
  104. MessageQueue("Exchange",512,0)
  106. #else
  107. Exchange::Exchange(ProtReturnCode &result) : ConnectionManager(result),
  108. MessageQueue("Exchange",512,0)
  109. #endif
  110. {
  111. for (int i = 0; i < NUM_LINES; i++)
  112. {
  113. calls[i] = NULL;
  114. #if defined(USE_RAS)
  115. ras_sess[i].last_seqno = 0; 
  116. ras_sess[i].ARQsent = FALSE;
  117. ras_sess[i].ACFrecd = FALSE;
  118. #endif
  119. }
  120. num_active_calls = 0;
  122. terminal_type = TT_TERMINAL_NO_MC;
  124. // initialize the endpoint_type.
  125. H225CSVendorID vid;
  126. char *desc = "Test audio distribution application";
  128. vid.SetH221NonStd(0xde, 0, 0xad);
  129. vid.SetProductID((unsigned char *)desc, strlen(desc) + 1);
  130. vid.SetVersionID((unsigned char *)desc, strlen(desc) + 1);
  131. endpoint_type.SetVendor(vid);
  132. endpoint_type.SetTerminal(NULL);
  134.     ProtReturnCode ret;
  136. confid_prefix = get_local_ip();
  138. // by default use version 1 procedures.
  139. use_faststart = 0;
  140. use_overlapsend = 0;
  141. use_tunneling = 0;
  142. use_alerting = 0;
  143. use_callproc = 0;
  145. #ifdef USE_RAS
  146. isGKRegistered = FALSE; 
  147. gkdiscovered = FALSE;
  148.     local_ip = get_local_ip(); 
  149. confid_prefix = local_ip;
  151. ((sockaddr_in*)&local_ras)->sin_family = AF_INET;
  152.     ((sockaddr_in*)&local_ras)->sin_port = HTONS(config->localrasport);
  153. #ifdef VXWORKS
  154.     ((sockaddr_in*)&local_ras)->sin_addr.s_addr = htonl(INADDR_ANY);
  155. #else
  156.     ((sockaddr_in*)&local_ras)->sin_addr.s_addr = local_ip;
  157. #endif
  158. ret = SetLocalAddr((sockaddr *) &local_ras);
  159. if (!PROT_IS_SUCCESS(ret)) {
  160. LOG("SetLocalAddr error 0x%xn", ret);
  161. return;
  162. }
  163. // vxworks doesn't like to bind on a named socket, so we bind to 
  164. // INADDR_ANY but we need to communicate the real IP in out RAS messages
  165. #ifdef VXWORKS
  166. ((sockaddr_in*)&local_ras)->sin_addr.s_addr = local_ip;
  167. #endif
  169. ((sockaddr_in*)&local_sig)->sin_family = AF_INET;
  170.     ((sockaddr_in*)&local_sig)->sin_port = HTONS(config->q931port);
  171.     ((sockaddr_in*)&local_sig)->sin_addr.s_addr = local_ip;
  173. SetLastSeqno(1);
  174. #endif
  176. sockaddr_in addr;
  178. addr.sin_family = AF_INET;
  179. addr.sin_port = HTONS(config->q931port);
  180. addr.sin_addr.s_addr = 0;
  182. LOG("Calling ConnectionManager::Listenn");
  183. ret = Listen(ID_H225,(sockaddr*)&addr,LT_MANY);
  184. if (!PROT_IS_SUCCESS(ret))
  185. {
  186. LOG("ConnectionManager::Listen failed, 0x%xn",ret);
  187. return;
  188. }
  189. LOG("Listen succeededn");
  192. }
  194. Exchange::~Exchange()
  195. {
  196. LOG("Exchange::~Exchangen");
  197. }
  199. #ifdef USE_RAS
  200. void
  201. Exchange::DiscoverGK()
  202. {
  203. ProtReturnCode ret = SendGRQ(seqno++,NULL);
  204. if (!PROT_IS_SUCCESS(ret))
  205. {
  206. LOG("H225RASProtocol::SendGRQ failed, 0x%xn",ret);
  207. return;
  208. }
  209. LOG("Discovery request sentn");
  210. }
  212. void
  213. Exchange::RegisterWithGK()
  214. {
  215. struct sockaddr_in gk_address; 
  216. gk_address.sin_family = AF_INET;
  217. gk_address.sin_port =  HTONS(1719);
  218. gk_address.sin_addr.s_addr= inet_addr(config->gkaddrstr);
  220. ChooseGK((sockaddr*) &(gk_address));
  222. ProtReturnCode ret = SendRRQ(seqno++,NULL);
  223. if (!PROT_IS_SUCCESS(ret))
  224. {
  225. LOG("H225RASProtocol::SendRRQ failed, 0x%xn",ret);
  226. return;
  227. }
  228. LOG("Registration request sentn");
  229. }
  231. void
  232. Exchange::UnRegisterWithGK()
  233. {
  234. if(!IsGKRegistered())
  235. return;
  236. ProtReturnCode ret = SendURQ(seqno++,NULL);
  237. if (!PROT_IS_SUCCESS(ret))
  238. {
  239. LOG("H225RASProtocol::SendURQ failed, 0x%xn",ret);
  240. return;
  241. }
  242. LOG("UnRegistration request sentn");
  243. }
  244. #endif
  246. void
  247. Exchange::SendToExchange(int message, unsigned int wparam,
  248. unsigned int lparam)
  249. {
  250. USER_MESSAGE msg;
  252. msg.message = message;
  253. msg.wParam = wparam;
  254. msg.lParam = lparam;
  256. QueueMessage(&msg);
  257. }
  259. int
  260. Exchange::create_call(int outgoing)
  261. {
  262. ProtReturnCode result = 0;
  263. int i;
  265. for(i=0;i<NUM_LINES;++i)
  266. {
  267. if (calls[i] == NULL)
  268. break;
  269. }
  271. if (i == NUM_LINES)
  272. {
  273. assert(num_active_calls == NUM_LINES);
  274. return(-1);
  275. }
  277. char display[20];
  279. sprintf(display, "%s%d", config->h323IDsrc, i);
  281. calls[i] = new H323Call(this,ID_H225 + i, ID_H245 + i,
  282. endpoint_type, terminal_type, display, outgoing, result);
  284. if (!PROT_IS_SUCCESS(result)) 
  285. {
  286. return(result);
  287. }
  289. if (calls[i] == NULL)
  290. {
  291. LOG("Memory allocation for call failedn");
  292. return(-1);
  293. }
  295. #if defined(USE_RAS)
  296. ras_sess[i].ARQsent = ras_sess[i].ACFrecd = FALSE;
  297. if (outgoing)
  298. ras_sess[i].direction = (boolean)DIR_OUTGOING;
  299. else
  300. ras_sess[i].direction = (boolean)DIR_INCOMING;
  301. #endif
  302. calls[i]->SetApplicationPrivate((unsigned long)i);
  303. calls[i]->Start();
  304. ++num_active_calls;
  306. return(i);
  307. }
  309. // Note: connections are closed by the destructor of ConnectionEntity
  310. void
  311. Exchange::destroy_call(int index)
  312. {
  313. assert(calls[index] != NULL);
  315. H245Protocol* h245 = calls[index];
  316. H225CSProtocol* h225 = calls[index];
  318. if (h225)
  319. {
  320. LOG("Closing H.225 connectionn");
  321. CloseConnection(h225);
  322. LOG("Done closing H.225 connectionn");
  323. }
  325. if (h245)
  326. {
  327. LOG("Closing H.245 connectionn");
  328. CloseConnection(h245);
  329. LOG("Done closing H.245 connectionn");
  330. }
  332. calls[index]->Stop();
  334. #ifdef USE_RAS
  335. if (IsGKRegistered() &&
  336. ras_sess[index].ACFrecd )
  337. {
  338. ras_sess[index].last_seqno = seqno++;
  339. SendDRQ(ras_sess[index].last_seqno, NULL, index);
  340.     }
  341. #endif
  343. delete calls[index];
  344. calls[index] = NULL;
  345. --num_active_calls;
  346. }
  348. void
  349. Exchange::ShutDown()
  350. {
  351. StopListening(ID_H225);
  352. SendToExchange(PROT_UI_MSG,UI_CMD_EXIT,0);
  354. while(num_active_calls > 0)
  355. {
  356. #if defined(WIN32)
  357. Sleep(0);
  358. #elif defined(VXWORKS)
  359. taskDelay(1);
  360. #else
  361. #if (defined(__hpux))
  362. pthread_yield();
  363. #else
  364. thr_yield();
  365. #endif
  366. #endif
  367. }
  368. }
  370. void
  371. Exchange::NotifyMessage(USER_MESSAGE& msg)
  372. {
  373. void *data = (void*)msg.lParam;
  375. if (msg.message == PROT_EXCH_MSG)
  376. {
  377. if (msg.wParam == XC_CALL_DROPPED)
  378. {
  379. H323Call *call =(H323Call*)data;
  380. destroy_call((int)call->GetApplicationPrivate());
  381. data = NULL;
  382. }
  384. else if (msg.wParam == CB_NEW_CONNECTION)
  385. {
  386. XchgNewConnection *info = (XchgNewConnection *)data;
  388. if (info->identifier == ID_H225)
  389. {
  390. int index = create_call(0); // incoming call
  391. if (index == -1)
  392. {
  393. RejectConnection(info->conn_ref);
  394. }
  395. else
  396. {
  397. ProtReturnCode ret;
  398. ret = AcceptConnection(info->conn_ref, 
  399. (H225CSProtocol*)calls[index]);
  400. if (!PROT_IS_SUCCESS(ret))
  401. {
  402. LOG("AcceptConnection failed on H.225 portn");
  403. destroy_call(index);
  404. }
  405. }
  406. }
  407. else
  408. {
  409. int index = info->identifier;
  411. assert(index >= ID_H245);
  412. index -= ID_H245;
  414. assert(index < NUM_LINES);
  415. assert(index >= 0);
  417. assert(((H245Protocol*)calls[index])->GetIdentifier()
  418. == info->identifier);
  420. msg.message = PROT_CALL_MSG;
  421. if (calls[index]  == NULL)
  422. {
  423. abort();
  424. }
  425. calls[index]->QueueMessage(&msg);
  427. // We don't have to freeup data.
  428. data = NULL;
  429. }
  430. }
  431. else if (msg.wParam == CB_LISTEN_ERROR)
  432. {
  433. XchgListenError *info = (XchgListenError *)data;
  435. LOG("ERROR: error occurred while accepting on id %dn",
  436. info->identifier);
  437. }
  438. else
  439. {
  440. LOG("ERROR: Unknown PROT_EXCH_MSGn");
  441. }
  442. }
  443. else if (msg.message == PROT_UI_MSG) // this is a command
  444. {
  445. LOG("Message from UIn");
  446. switch(msg.wParam)
  447. {
  448. case UI_CMD_PLACE_CALL: 
  449. {
  450. LOG("UI_CMD_PLACE_CALLn");
  451. int index;
  453. UICmdPlaceCall *info = (UICmdPlaceCall *)data;
  455. // check if any lines are free...
  457. if((index=create_call(1)) == -1) // outgoing call
  458. {
  459. LOG("All lines are busy, try latern");
  460. }
  461. else
  462. {
  464. ProtReturnCode ret;
  466. if (info->dest_addr_length > 0)
  467. {
  468. calls[index]->SetPhoneNumber(info->dest_addr);
  469. }
  471. if (info->transfer_flag == TRUE) // is this a call transfer?
  472. {
  473. calls[index]->SetInvokeID(info->invokeID);
  474. calls[index]->SetTransferFlag(TRUE);
  475. if (info->callID)
  476. calls[index]->SetTransferCallID(info->callID);
  477. calls[index]->SetParentIndex(info->parent_index);
  478. }
  479. #ifdef USE_RAS
  480.     if (IsGKRegistered() != TRUE)
  481.                     {
  482. // Initiate a TCP connection to the remote ends
  483. // Q.931 engine...
  484. ret = Connect((struct sockaddr*)&info->remote_addr, 
  485. (H225CSProtocol*)calls[index]);
  486. if (!PROT_IS_PENDING(ret))
  487. {
  488. // Kinda kludgy... but not too bad..
  489. NotifyConnectionStatus(
  490. (H225CSProtocol*)calls[index],ret);
  491. }
  492. }
  493. else  // we are registered with a gatekeeper; send ARQ
  494. {
  495. SendARQdata *arq_data = new SendARQdata;
  497. // create a src e164 alias in the form YYYXXXX
  498. // where YYY is the prefix and YYYY is the index of the call
  499. // for a gateway app, the app should pass the caller-id
  500. // in the UICmdPlaceCall message
  501. char tmp_phone[256];
  502. sprintf(tmp_phone, "%s%0004d", 
  503. config->e164src, index);
  504. calls[index]->SetSrcPhoneNumber(tmp_phone);
  505. strcpy(arq_data->e164src, tmp_phone);
  506. strcpy(arq_data->e164dst, info->dest_addr);
  508. arq_data->index = index;
  509. LOG("SendARQ for OUTGOING calln");
  510. // info->dest_addr is the outgoing number
  511. ras_sess[index].last_seqno = seqno++;
  512. SendARQ(ras_sess[index].last_seqno,NULL,
  513.                                arq_data );
  514. ras_sess[index].ARQsent = TRUE;
  515. delete arq_data;
  516. }
  518. #else 
  520. ret = Connect((struct sockaddr*)&info->remote_addr, 
  521. (H225CSProtocol*)calls[index]);
  522. if (!PROT_IS_PENDING(ret))
  523. {
  524. // Kinda kludgy... but not too bad..
  525. NotifyConnectionStatus(
  526. (H225CSProtocol*)calls[index],ret);
  527. }
  528. #endif
  529. }
  530. }
  531. break;
  533. case UI_CMD_HANGUP:
  534. {
  535. LOG("UI_CMD_HANGUPn");
  537. UICmdHangup *info = (UICmdHangup *)data;
  539. msg.lParam = 0;
  540. LOG("Hanging up line %dn", info->line_no);
  541. if (calls[info->line_no])
  542. {
  543. calls[info->line_no]->QueueMessage(&msg);
  544. }
  545. }
  546. break;
  548. case UI_CMD_FACILITY:
  549. {
  550. LOG("UI_CMD_FACILITYn");
  552. UICmdFacility *info = (UICmdFacility *)data;
  554. msg.lParam = (unsigned int)info;
  555. LOG("Sending Facility msg on line %dn", info->line_no);
  556. if (calls[info->line_no])
  557. {
  558. calls[info->line_no]->QueueMessage(&msg);
  559. }
  560. // We don't have to freeup data.
  561. data = NULL;
  562. }
  563. break;
  565. case UI_CMD_EXIT:
  566. {
  567. LOG("UI_CMD_EXITn");
  568. msg.lParam = 0;
  569. for (int i = 0; i < NUM_LINES; ++i)
  570. {
  571. if (calls[i] != NULL)
  572. {
  573. calls[i]->QueueMessage(&msg);
  574. }
  575. }
  576. }
  577. break;
  578. case UI_CMD_CTRL: 
  579. {
  580. // Control type command from the user interface.
  581. LOG("UI_CMD_CTRLn");
  583. UICmdCtrl *info = (UICmdCtrl *)data;
  584. for (int i = 0; i < info->num_cmds; i++)
  585. {
  586. switch (info->command[i])
  587. {
  588. case UI_CTRL_CMD_ENABLE_FASTSTART:
  589. use_faststart = 1;
  590. break;
  591. case UI_CTRL_CMD_DISABLE_FASTSTART:
  592. use_faststart = 0;
  593. break;
  594. case UI_CTRL_CMD_ENABLE_TUNNELING:
  595. use_tunneling = 1;
  596. break;
  597. case UI_CTRL_CMD_DISABLE_TUNNELING:
  598. use_tunneling = 0;
  599. break;
  600. case UI_CTRL_CMD_ENABLE_OVERLAP_SEND:
  601. use_overlapsend = 1;
  602. break;
  603. case UI_CTRL_CMD_DISABLE_OVERLAP_SEND:
  604. use_overlapsend = 0;
  605. break;
  606. case UI_CTRL_CMD_ENABLE_ALERTING:
  607. use_alerting = 1;
  608. break;
  609. case UI_CTRL_CMD_DISABLE_ALERTING:
  610. use_alerting = 0;
  611. break;
  612. case UI_CTRL_CMD_ENABLE_CALLPROC:
  613. use_callproc = 1;
  614. break;
  615. case UI_CTRL_CMD_DISABLE_CALLPROC:
  616. use_callproc = 0;
  617. break;
  618. }
  619. }
  620. }
  621. break;
  622. }
  623. }
  624. // code for handling with messages from H323Call 
  625. else if (msg.message == PROT_CALL_MSG)
  626. {
  627. LOG("Message from H323 CALLn");
  628. switch(msg.wParam)
  629. {
  630. #if defined(USE_RAS)
  631. // the following ARQ request message is for an incoming call
  632. case CB_SEND_ARQ:
  633. {
  634. SendARQdata *info = (SendARQdata *)data;
  636. assert(calls[info->index] != NULL);
  638. ras_sess[info->index].last_seqno = seqno++;
  639. SendARQ(ras_sess[info->index].last_seqno, NULL,
  640.                         (SendARQdata*)info );
  641. ras_sess[info->index].ARQsent = TRUE;
  642. }
  643.             break;
  644. #endif
  645. default:
  646. break;
  647. }
  648. }
  650. #if defined(USE_RAS)
  651. else if (msg.message == PROT_RAS_MSG)
  652. {
  653. XchgRASMessage *info = (XchgRASMessage *)data; 
  654. int msg_type = info->ras_message->GetType();
  655. H225RASMessage *ras_message = info->ras_message;
  656. struct sockaddr *origin = info->origin;
  658. LOG("Exchange::NotifyRASMessagen");
  660. LOG("Got message(%d,%s), seqno(%d)n",ras_message->GetType(),
  661.     ((ras_message->GetType() >= MSG_INVALID && 
  662.  ras_message->GetType() <= MSG_XRS) ? 
  663. ras_msg_id2str[ras_message->GetType()] : "UNKNOWN" ),
  664. ras_message->GetSequenceNumber());
  666. int seqno_rcvd = ras_message->GetSequenceNumber();
  668. switch(ras_message->GetType())
  669. {
  670. case MSG_GRQ:
  671. {
  672. struct sockaddr_in host_addr; 
  674. // just snoop and log GRQs received at the multicast address
  675. ((H225RASMsgGCF*)ras_message)->GetRASAddr((sockaddr*)&host_addr);
  676. char *host_addr_str = inet_ntoa(host_addr.sin_addr);
  677. LOG("host %s is looking for a gatekeepern", host_addr_str);
  680. }
  681. break;
  682.             case MSG_GCF:
  683. {
  684. struct sockaddr_in gk_address; 
  686. ((H225RASMsgGCF*)ras_message)->GetRASAddr((sockaddr*)&gk_address);
  687. char *gk_addr_str = inet_ntoa(gk_address.sin_addr);
  688. LOG("%s is offering to become our gatekeepern", gk_addr_str);
  690. // if we have already received a reply from a gatekeeper, ignore this one
  691. // we can selectively filter the replies to find a preferred gatekeeper
  692. if (!gkdiscovered) {
  693. gkdiscovered = TRUE;
  694. strcpy(config->gkaddrstr, gk_addr_str);
  695. RegisterWithGK();
  696. }
  697. }
  698. break;
  699.             case MSG_GRJ:
  700.             case MSG_RRQ:
  701.             break;
  702.             case MSG_RCF:
  703. {
  704. unsigned short *id; 
  706. ((H225RASMsgRCF*)ras_message)->GetEndpointID(id, ep_id_len);
  707. memcpy(&ep_id[0], id, ep_id_len * 2);
  708. LOG("Registration succeeded!n");
  709. SetIsGKRegistered(TRUE);
  711. LOG("Endpoint ID: 0x");
  712. for(int i=0; i<ep_id_len; i++)
  713. LOG("%x", ep_id[i]);
  714. LOG("n");
  716. }
  717. break;
  718.             case MSG_RRJ:
  719. isGKRegistered = FALSE;
  720.             break;
  721.             case MSG_URQ:
  722.             break;
  723.             case MSG_UCF:
  724.    isGKRegistered = FALSE;
  725.             break;
  726.             case MSG_URJ:
  727.             break;
  728.             case MSG_ARQ:
  729.             break;
  730.             case MSG_ACF:
  731. {
  732. ProtReturnCode ret;
  733. struct sockaddr_in addr;
  735. ((H225RASMsgACF*)ras_message)->GetDstCallSigAddr((struct sockaddr*)&addr);
  736. char *rem_addr_str = inet_ntoa(addr.sin_addr);
  737. LOG("gatekeeper offers dest signaling addr <%s>:<%u>n", 
  738. rem_addr_str, ntohs(addr.sin_port));
  741. int index =  -1;
  742. int is_call_valid = 0;
  744. for (int i = 0;i < NUM_LINES; i++)
  745. {
  746. if (seqno_rcvd == ras_sess[i].last_seqno) {
  747. index = i;
  748. if ((void *)calls[index])
  749. {
  750. is_call_valid = 1;
  751. break;
  752. }
  753. }
  754. }
  756. if (is_call_valid) {
  757. ras_sess[index].ACFrecd = TRUE;
  758. if (ras_sess[index].direction == DIR_OUTGOING) {
  759. LOG("valid OUTgoing call  index = %dn",index);
  761. // Initiate a TCP connection to the remote ends
  762. // Q.931 engine...
  764. ret = Connect((struct sockaddr*)&addr,
  765. (H225CSProtocol*)calls[index]);
  766. if (!PROT_IS_PENDING(ret))
  767. {
  768. // Kinda kludgy... but not too bad..
  769. NotifyConnectionStatus(
  770. (H225CSProtocol*)calls[index],ret);
  771. }
  772. }
  773. else if (ras_sess[index].direction == DIR_INCOMING)
  774. {
  775. LOG("valid INcoming call  index = %dn",index);
  776. calls[index]->Q931SendAlerting();
  778. }
  779. else
  780. {
  781. assert(1);
  782. }
  783. }
  784. }
  785. break;
  786.             case MSG_ARJ:
  787.    {
  789. LOG("Received ARJn");
  791. int index =  -1;
  792. int is_call_valid = 0;
  794. for (int i = 0;i < NUM_LINES; i++)
  795. {
  796. if (seqno_rcvd == ras_sess[i].last_seqno) {
  797. index = i;
  798. if ((void *)calls[index])
  799. {
  800. is_call_valid = 1;
  801. break;
  802. }
  803. }
  804. }
  806. if (is_call_valid) {
  807. ras_sess[index].ACFrecd = FALSE;
  809. // this should clean everything
  810. USER_MESSAGE msg;
  811. msg.message = PROT_UI_MSG;
  812. msg.wParam = UI_CMD_HANGUP;
  813. msg.lParam = NULL;
  815. calls[index]->QueueMessage(&msg);
  817. }
  818.    }   
  819. break;
  820. #if 1 // TODO: implement 
  821.             case MSG_BRQ:
  822.             case MSG_BCF:
  823.             case MSG_BRJ:
  824. // DRQ request might come from the GK if the call has to be teared down
  825. // the terminal should tear down the call
  826.             case MSG_DRQ:
  827.             case MSG_DCF:
  828.             case MSG_DRJ:
  829.             case MSG_LRQ:
  830.             case MSG_LCF:
  831.             case MSG_LRJ:
  832.             case MSG_IRQ:
  833.             case MSG_IRR:
  834.             case MSG_NSM:
  835.             case MSG_XRS:
  836. #endif
  837.             break;
  838. default:
  839. break;
  840. }
  842. }
  843. #endif
  844. if (data)
  845. {
  846. delete (CBData*)data;
  847. }
  848. }
  850. void 
  851. Exchange::NotifyListenError(int identifier,
  852. ProtReturnCode status)
  853. {
  854. XchgListenError *msg = new XchgListenError;
  856. msg->identifier = identifier;
  857. msg->status = status;
  859. SendToExchange((unsigned int)PROT_EXCH_MSG,
  860. (unsigned int)CB_LISTEN_ERROR,
  861. (unsigned int)msg);
  863. }
  865. void 
  866. Exchange::NotifyNewConnection(int identifier,
  867. int conn_ref, sockaddr *new_addr)
  868. {
  869. XchgNewConnection *msg = new XchgNewConnection;
  871. msg->identifier = identifier;
  872. msg->conn_ref = conn_ref;
  873. msg->new_addr = *(struct sockaddr_in *)new_addr;
  875. SendToExchange((unsigned int)PROT_EXCH_MSG,
  876. (unsigned int)CB_NEW_CONNECTION,
  877. (unsigned int)msg);
  878. }
  880. void 
  881. Exchange::NotifyConnectionStatus(ConnectionEntity *conn, 
  882. ProtReturnCode connection_status)
  883. {
  884. USER_MESSAGE m;
  886. LOG("NotifyConnectionStatus status = 0x%xn",
  887. connection_status);
  889. int index = conn->GetIdentifier();
  891. if (index < ID_H245)
  892. {
  893. index -= ID_H225;
  894. assert(index >= 0 && index <= NUM_LINES);
  895. }
  896. else
  897. {
  898. index -= ID_H245;
  899. assert(index >= 0 && index <= NUM_LINES);
  900. }
  902. if (calls[index] == NULL)
  903. {
  904. abort();
  905. }
  907. XchgConnectionStatus *msg = new XchgConnectionStatus;
  909. msg->conn = conn;
  910. msg->status = connection_status;
  912. m.message = PROT_CALL_MSG;
  913. m.wParam = CB_CONNECTION_STATUS;
  914. m.lParam = (unsigned int)msg;
  916. calls[index]->QueueMessage(&m);
  917. }
  919. void
  920. Exchange::NotifyConnectionClosed(ConnectionEntity *conn,
  921. ProtReturnCode reason)
  922. {
  923. USER_MESSAGE m;
  924. int index = conn->GetIdentifier();
  926. if (index < ID_H245)
  927. {
  928. index -= ID_H225;
  929. }
  930. else
  931. {
  932. index -= ID_H245;
  933. }
  935. if (calls[index] == NULL)
  936. {
  937. abort();
  938. }
  940. XchgConnectionClosed *msg = new XchgConnectionClosed;
  941. msg->conn = conn;
  942. msg->reason = reason;
  944. m.message = PROT_CALL_MSG;
  945. m.wParam = CB_CONNECTION_CLOSED;
  946. m.lParam = (unsigned int)msg;
  948. calls[index]->QueueMessage(&m);
  949. }
  951. #if defined(__SVR4) && defined(__sun)
  952. extern "C"
  953. {
  954.  int gethostname(char *,int);
  955. };
  956. #endif
  958. unsigned int
  959. Exchange::get_local_ip()
  960. {
  961.     char hostname[256];
  962. unsigned int local_addr;
  964.     gethostname(hostname,sizeof(hostname));
  966. local_addr = inet_addr(hostname);
  968. #if defined(VXWORKS)
  969. // if gethostname() works for your target, you don't need the 
  970. // following line. We use if for our simulator
  971.     sprintf(hostname,"vxworks%d",sysProcNumGet());
  973.     local_addr = hostGetByName(hostname);
  974. LOG("local_addr=0x%xn", local_addr);
  975. return local_addr;
  976. #else
  978.     struct hostent *hent_p;
  979.     hent_p = gethostbyname((const char *)hostname);
  981.     if(hent_p == NULL)
  982.     {
  983. #if defined(WIN32)
  984.      int ret = WSAGetLastError();
  985.         LOG("gethostbyname failed on %s error %dn", hostname,ret);
  986. #else
  987. LOG("gethostbyname failed on %sn", hostname);
  988. #endif
  989.         return 0;
  990. }
  992. int i = 0;
  993. while(hent_p->h_addr_list[i])
  994. {
  995. LOG("Interface %d, ip = 0x%xn",
  996. i,*(unsigned long *)(hent_p->h_addr_list[i]));
  997. ++i;
  998. }
  1000.     return *(unsigned int *)(hent_p->h_addr_list[0]);
  1001. #endif
  1002. }
  1004. #if defined(USE_RAS)
  1006. void 
  1007. Exchange::NotifyRASTimeout(H225RASMessage& ras_message,
  1008. struct sockaddr *destination,
  1009. H225RASTransmitterInfo& info)
  1010. {
  1011. LOG("Exchange::NotifyRASMessagen");
  1013. LOG("message(%d,%s), seqno(%d) timed-outn",ras_message.GetType(),
  1014.     ((ras_message.GetType() >= MSG_INVALID && 
  1015.  ras_message.GetType() <= MSG_XRS) ? 
  1016. ras_msg_id2str[ras_message.GetType()] : "UNKNOWN" ),
  1017. ras_message.GetSequenceNumber());
  1018. }
  1020. void 
  1021. Exchange::NotifyRASMessage(H225RASMessage& ras_message, 
  1022. struct sockaddr *origin, struct sockaddr *destination,
  1023. struct H225RASTransmitterInfo& info)
  1024. {
  1025. XchgRASMessage *msg = new XchgRASMessage;
  1026. int msg_type = ras_message.GetType();
  1027. ProtReturnCode ret = H225RASMessage::Factory(msg->ras_message, msg_type, (H225RASProtocol *)this);
  1028.     if (!PROT_IS_SUCCESS(ret) || !msg->ras_message)
  1029.     {
  1030. LOG("Failed to new ras messagen");
  1031.         return;
  1032. }
  1033. *(msg->ras_message) = ras_message;
  1035. msg->origin = origin;
  1037. SendToExchange((unsigned int)PROT_RAS_MSG,
  1038. (unsigned int)CB_RAS_EVENT,
  1039. (unsigned int)msg);
  1040. }
  1042. sockaddr*
  1043. Exchange::GetLocalRASAddr()
  1044. {
  1045.         return (sockaddr*)&local_ras;
  1046. }
  1048. void 
  1049. Exchange::SetIsGKRegistered(boolean flag)
  1050. {
  1052. isGKRegistered = flag;
  1054. }
  1056. boolean 
  1057. Exchange::IsGKRegistered()
  1058. {
  1059. return isGKRegistered;
  1060. }
  1062. sockaddr*
  1063. Exchange::GetLocalSigAddr()
  1064. {
  1065. return (sockaddr*)&local_sig;
  1066. }
  1068. int
  1069. Exchange::GetLastSeqno()
  1070. {
  1071.    return seqno;
  1072. }
  1074. void Exchange::SetLastSeqno(unsigned int seq_no)
  1075. {
  1076. seqno = seq_no;
  1077. }
  1078. #endif