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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 模拟服务器 > 查看源码
main.cxx
资源名称：Server_win_src.rar　[点击查看]
上传用户：wzkunzhan
上传日期：2022-04-23
资源大小：2618k
文件大小：64k
源码类别：

模拟服务器

开发平台：

Visual C++

main.cxx：源码内容
  1. /*
  2.  * main.cxx
  3.  *
  4.  * Main source for H323BeaconServer
  5.  *
  6.  *
  7.  * Copyright (c) 1993-2001 Equivalence Pty. Ltd.
  8.  *
  9.  * The contents of this file are subject to the Mozilla Public License
  10.  * Version 1.0 (the "License"); you may not use this file except in
  11.  * compliance with the License. You may obtain a copy of the License at
  12.  * http://www.mozilla.org/MPL/
  13.  *
  14.  * Software distributed under the License is distributed on an "AS IS"
  15.  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
  16.  * the License for the specific language governing rights and limitations
  17.  * under the License.
  18.  *
  19.  * The Original Code is Portable Windows Library.
  20.  *
  21.  * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
  22.  *
  23.  * Portions are Copyright (C) 1993 Free Software Foundation, Inc.
  24.  * All Rights Reserved.
  25.  *
  26.  * Portions are Copyright (C) 2002 ITEC-Ohio.
  27.  * All Rights Reserved.
  28.  *
  29.  */
  31. #include <ptlib.h>
  32. //#include <sys/types.h>
  33. //#include <socket.h>
  34. //#include <string.h>
  35. //#include <arpa/inet.h>
  36. //#include <unistd.h>             
  37. //#include <netinet/in.h>
  38. #include <ptlib/pipechan.h>
  40. #include "version.h"
  41. #include "lpc10codec.h"
  42. #include "speexcodec.h"
  44. #include "mscodecs.h"
  45. #include "opalvxml.h"
  46. #include "main.h"
  47. #include "callermain.h"
  49. PCREATE_PROCESS(H323BeaconServer);
  51. #define new PNEW
  53. #define DEFAULT_MSG_LIMIT 60
  54. #define DEFAULT_TESTS_LOG "tests_log.txt"
  56. #define G7231_BLOCK_SIZE 24
  57. #define G7231_SAMPLES_PER_BLOCK 240
  58. #define G7231_BANDWIDTH 63
  59. #define G7231_SILENCE_FLAG 0x02
  60. #define G7231_SILENCE_LENGTH 0x04
  62. #define CHECK_PCM   1
  63. #define CHECK_G7231 2
  65. #define YES '1'
  66. #define NO '0'
  68. #define MENU_PREFIX "UserMenu-"
  71. //log-server defines
  72. //#define SOCKET_ERROR -1
  73. #define SRVPORT 5050
  74. #define LOG_H323 "sideB.H323"
  76. static PMutex logMutex;
  77. static PTextFile logFile;
  78. static PFilePath logFilename = DEFAULT_TESTS_LOG;
  80. PString G7231Ext = ".g723";
  81. PString WAVExt          = ".wav";
  82. PString PCMExt          = ".sw";
  84. PString receivedDTMFMessage;
  85. PString dtmfTrigger = NO;
  86. PString recordDTMFTrigger = NO;
  87. PString stopRecordDTMFTrigger = NO;
  88. PString startPlayingDTMFTrigger = NO;
  89. int playedFlag = 0; //to make sure that the message has already been played before flushing the queue
  90. PString fn_tmp = "";
  91. PString fnAgain = "";
  92. PString IPAddress ; // stores IP address
  94. PString tmpDir;
  95. unsigned int tmpCallLimit;
  97. BOOL playedOnce = FALSE;
  99. int countwavefiles;
  100. char buffercountwavefiles[100];
  103. PString junkwave = "";
  105. BOOL recordStartedNext = FALSE;
  106. PString fn_original = "";
  108. PFilePath fn;
  109. PFilePath _fn;
  110. PFile *fileclass;
  111. PFile *fileclass_tmp; 
  113. PCM_RecordFile * recordFile;
  115. PCM_RecordFile * recordFilejunkwave;
  117. MyH323Connection  * tmpConn;
  119. //Caller * caller;
  121. static void LogMessage(const PString & str)
  122. {
  123.   PTime now;
  124.   PString msg = now.AsString("hh:mm:ss dd/MM/yyyy") & str;
  125.   logMutex.Wait();
  127.   if (!logFile.IsOpen()) {
  128.     logFile.Open(logFilename, PFile::ReadWrite);
  129.     logFile.SetPosition(0, PFile::End);
  130.   }
  132.   logFile.WriteLine(msg);
  134.   logFile.Close();
  135.   
  136.   logMutex.Signal();
  137. }
  139. static void LogCall(const PFilePath & fn,
  140.                     const PString & from,
  141.                     const PString & user,
  142.                     unsigned len,
  143.                     const PString & codec,
  144.                     const PString & product)
  145. {
  146.   PString addr = from;
  147.   LogMessage(addr & """ + user + """ & PString(PString::Unsigned, len) & codec & """ + product + """ & """ + fn + """);
  148. }
  151. ///////////////////////////////////////////////////////////////
  153. H323BeaconServer::H323BeaconServer()
  154.   : PProcess("H.323 Beacon Project", "H.323 Beacon Server",
  155.              MAJOR_VERSION, MINOR_VERSION, BUILD_TYPE, BUILD_NUMBER)
  156. {
  157. }
  160. H323BeaconServer::~H323BeaconServer()
  161. {
  162. }
  165. void H323BeaconServer::Main()
  166. {
  168.   
  169.   
  170.   cout << "*************************************************************n";
  171.   cout << GetName() << " Version 1.4 built using the librariesn";
  172.   cout << "available at http://www.openh323.orgn"; 
  173.   cout << "(C)Copyright ITEC-Ohio,2004.n";
  174.   cout << "http://www.itecohio.org/beaconn";
  175.   cout << "*************************************************************n";
  176.   cout << "NOTE: For more options, Example usage:" << endl;
  177.   cout << ""C:\Program Files\H.323 Beacon Server\H323BeaconServer -h"" << endl;
  179.   PConfigArgs args(GetArguments());
  181.   args.Parse(
  182.              "D-disable:"
  183.  "a-acceptor:"
  184.  "r-result:"
  185.              "d-directory:"
  186.              "g-gatekeeper:"         "n-no-gatekeeper."
  187.              "-g711-ulaw."           "-no-g711-ulaw."
  188.              "-g711-alaw."           "-no-g711-alaw."
  189.              "-g711message:"         "-no-g711message."
  190.              "-g7231."               "-no-g7231."
  191.              "-g7231message:"        "-no-g7231message."
  192.              "-gsm."                 "-no-gsm."
  193.              "-gsmmessage:"          "-no-gsmmessage."
  194.              "h-help."
  195.              "H-hangup."             "-no-hangup."
  196.              "i-interface:"          "-no-interface."
  197.              "k-kill."               "-no-kill."
  198.              "l-limit:"              "-no-limit."
  199.              "-listenport:"          "-no-listenport."
  200.              "-lpc10message:"        "-no-lpc10message."
  201.              "-speexmessage:"        "-no-speexmessage."
  202.              "m-message:"            "-no-message."
  203.              "-no-recordg7231."
  204. #if PTRACING
  205.              "o-output:"
  206. #endif
  207.              "P-prefer:"
  208.              "-pcm."                 "-no-pcm."
  209.              "-pcmmessage:"          "-no-pcmmessage."
  210.              "-port:"
  211.              "q-quicknet:"           "-no-quicknet:"
  212.              "r-run:"                "-no-run."
  213.      "-recordraw."
  214.              "-require-gatekeeper."  "-no-require-gatekeeper."
  215.              "-save."
  216. #if PMEMORY_CHECK
  217.              "-setallocationbreakpoint:"
  218. #endif
  219. #if PTRACING
  220.              "t-trace."
  221. #endif
  222.      "u-username:"           "-no-username."
  223.           , FALSE);
  225. #if PMEMORY_CHECK
  226.   if (args.HasOption("setallocationbreakpoint"))
  227.     PMemoryHeap::SetAllocationBreakpoint(args.GetOptionString("setallocationbreakpoint").AsInteger());
  228. #endif
  230. //#if PTRACING
  231.   PTrace::Initialise(args.GetOptionCount('t'),
  232.                      args.HasOption('o') ? (const char *)args.GetOptionString('o') : NULL);
  233. //#endif
  235.   if (args.HasOption('h')) {
  236.     cout << "Usage : H323BeaconServer [options]n"
  237.             "Options:n"
  238. "  -a --acceptor IPaddress  : Connect to the Acceptor IP in Initiator moden"  //WM
  239.             "  -r --result option  : 'html' or 'text'n"
  240. "  -md --directory dir  : Put recorded mesages into dirn"  //WM
  241.             "  -l --limit secs     : Limit recorded messages to secs duration (default " << DEFAULT_MSG_LIMIT << ")n"
  242.             "  -m --pcmmessage fn  : Set outgoing message for PCM derived codecs (G.711/GSM) to fnn"
  243.             "  --g7231message fn   : Set outgoing message for G723.1 codec to fnn"
  244.             "  --g711message fn    : Set outgoing message for G711 codec to fnn"
  245.             "  --gsmmessage fn     : Set outgoing message for GSM codec to fnn"
  246.             "  --lpc10message fn   : Set outgoing message for LPC10 codec to fnn"
  247.             "  --speexmessage fn   : Set outgoing message for Speex codec to fnn"
  249.             "  --recordraw         : Record PCM audo in raw files (.sw) instead of .wavn"
  250.             "  -r --run cmd        : Run this command after each recorded messagen"
  251.             "  -k --kill           : Kill recorded files after user commandn"
  252.             "  -H --hangup         : hangup after playing messagen"
  253.             "  -u --username str   : Set the local endpoint name to strn"
  254.             "  -i --interface ip   : Bind to a specific interfacen"
  255.             "  --listenport port   : Listen on a specific portn"
  256.             "  -g --gatekeeper host: Specify gatekeeper host.n"
  257.             "  -n --no-gatekeeper  : Disable gatekeeper discovery.n"
  258.             "  --require-gatekeeper: Exit if gatekeeper discovery fails.n"
  259.             "  -D --disable codec  : Disable the specified codec (may be used multiple times)n"
  260.             "  -P --prefer codec   : Prefer the specified codec (may be used multiple times)n"
  261. #if PTRACING
  262.             "  -t --trace          : Enable trace, use multiple times for more detailn"
  263.             "  -o --output         : File for trace output, default is stderrn"
  264. #endif
  265.             "     --save           : Save arguments in configuration filen"
  266.             "  -h --help           : Display this help messagen";
  267.     return;
  268.   }
  270.   args.Save("save");
  272. #if HAS_IXJ
  273.   if (args.GetCount() > 0) {
  274.     if (args[0] *= "record") 
  275.       RecordFile(args);
  276.     else if (args[0] *= "play") 
  277.       PlayFile(args);
  278.     else
  279.       cerr << "unknown command "" << args[0] << """ << endl;
  280.     return;
  281.   }
  282. #endif
  284.   unsigned callLimit = DEFAULT_MSG_LIMIT;
  285.   if (args.HasOption('l')) {
  286.     callLimit = args.GetOptionString('l').AsInteger();
  287.     if (callLimit > 3600) {
  288.       cout << "warning: maximum call length " << callLimit << " is out of range. Using " << DEFAULT_MSG_LIMIT << " insteadn";
  289.       callLimit = DEFAULT_MSG_LIMIT;
  290.     } else if (callLimit == 0)
  291.       cout << "warning: recorded message call limit disabledn";
  292.   }
  293.   cout << "Maximum duration of audio-recording limited to " << callLimit << " seconds...n";
  295.   PString runCmd;
  296.   if (args.HasOption('r')) {
  297.     runCmd = args.GetOptionString('r');
  298.     cout << "Executing "" << runCmd << "" after each message" << endl;
  299.   }
  301. ///////////////////////////////////////////////////////////////////
  302.   
  303.   PDirectory dir;  //WM
  304.   if (args.HasOption('d')) {
  305.     dir = args.GetOptionString('d');
  306.    }
  308.   PString Carg;
  309.   if (args.HasOption('a')) {
  310. Caller caller;
  311. PString CallerIP;
  312. CallerIP = args.GetOptionString('a');
  313. if (CallerIP==NULL){
  314. cout<<"Error: Acceptor IPaddress Missingn"<<
  315. "Usage:H323BeaconServer -a <AcceptorIPaddress>n";
  316. exit(0);
  317. }
  319. Carg = "-tttttt -o sideA.H323 -m media.wav " + CallerIP;
  320. PTime theTime;
  321. PString date = theTime.GetTimeInSeconds();
  322. //cout <<"Test Start Date:"<<date<<"n";
  323. cout<< "Starting the Server in Test Session Initiator mode with noptions ""<<Carg <<""n";
  324. caller.CallerMain(Carg);
  326. PString option;
  327. PString command;
  328. if (args.HasOption('r')) {
  329. option  = args.GetOptionString('r');
  330. if (option=="text"){
  331. command = "perl GO-text.pl " + CallerIP + " " + date;
  332. }
  333. else {
  334. command = "perl GO-html.pl " + CallerIP + " " + date;
  335. }
  336. }
  337. else {
  338. command ="perl GO-text.pl " + CallerIP + " " + date;
  339. }
  340. //call the E-model 
  341.  
  343. if(system(command)==0){
  345. }
  347. return;
  348.   }
  351. /////////////////////////////////////////////////////////////////////
  355.   int flags = 0;
  357.   if (args.HasOption("no-recordg7231")) {
  358.     cout << "Supressing recording of G723.1 messages" << endl;
  359.     flags |= MyH323EndPoint::NoRecordG7231;
  360.   }
  361.   if (args.HasOption('k')) {
  362.     cout << "Deleting recorded files after processing" << endl;
  363.     if (runCmd.IsEmpty()) 
  364.     flags |= MyH323EndPoint::DeleteAfterRecord;
  365.   }
  367.   if (args.HasOption('H'))
  368.     flags |= MyH323EndPoint::HangupAfterPlay;
  369.   
  370.   cout << "Creating the H.323 endpoint for the test session...n";
  371.   MyH323EndPoint endpoint(callLimit, runCmd, dir, flags);
  373.   PString userName = "H323BeaconServer ver" + GetVersion();
  374.   if (args.HasOption('u'))
  375.     userName = args.GetOptionString('u');
  376.   endpoint.SetLocalUserName(userName);
  378.   cout << "Initializing Codecs.........n";
  379.   if (!endpoint.Initialise(args))
  380.     return;
  382.  
  384.   // start the H.323 listener
  385.   H323ListenerTCP * listener;
  386.   PIPSocket::Address interfaceAddress(INADDR_ANY);
  387.  // WORD listenPort = H323ListenerTCP::DefaultSignalPort;
  388.   WORD listenPort = H323EndPoint::DefaultTcpPort;
  389.   PTRACE(1,"LISTENPORT: " <<listenPort);
  392.   if (args.HasOption("listenport"))
  393.     listenPort = (WORD)args.GetOptionString("listenport").AsInteger();
  395.   if (args.HasOption('i'))
  396.     interfaceAddress = PIPSocket::Address(args.GetOptionString('i'));
  398.   cout << "Creating the H.323 TCP Listener...Listen Port: " << listenPort << endl;
  399.   listener  = new H323ListenerTCP(endpoint, interfaceAddress, listenPort);
  401.   if (!endpoint.StartListener(listener)) {
  402.     cout <<  "Could not open H.323 listener port on "
  403.          << listener->GetListenerPort() << endl;
  404.     delete listener;
  405.     return;
  406.   }
  408.   
  411.   
  412.   cout << "H.323 Beacon Server IP Address: " << getLocalhostIPAddress() << endl;
  413.   cout << "Waiting to accept incoming connections..." << endl;
  414.   for (;;) 
  415.     PThread::Current()->Sleep(5000);
  416. }
  420. ///////////////////////////////////////////////////////////////
  421. //  : H323AudioCapability(12*G7231_BLOCK_SIZE, 4*G7231_BLOCK_SIZE)
  423. G7231_File_Capability::G7231_File_Capability()
  424.   : H323AudioCapability(8, 4)
  425. {
  426. }
  428. BOOL G7231_File_Capability::OnSendingPDU(H245_AudioCapability & cap, unsigned packetSize) const
  429. {
  430.   // set the choice to the correct type
  431.   cap.SetTag(GetSubType());
  433.   // get choice data
  434.   H245_AudioCapability_g7231 & g7231 = cap;
  436.   // max number of audio frames per PDU we want to send
  437.   g7231.m_maxAl_sduAudioFrames = packetSize; 
  439.   // no silence suppression
  440.   g7231.m_silenceSuppression = FALSE;
  442.   return TRUE;
  443. }
  445. BOOL G7231_File_Capability::OnReceivedPDU(const H245_AudioCapability & cap, unsigned & packetSize)
  446. {
  447.   const H245_AudioCapability_g7231 & g7231 = cap;
  448.   packetSize = g7231.m_maxAl_sduAudioFrames;
  449.   return TRUE;
  450. }
  452. PObject * G7231_File_Capability::Clone() const
  453. {
  454.   return new G7231_File_Capability(*this);
  455. }
  457. H323Codec * G7231_File_Capability::CreateCodec(H323Codec::Direction direction) const
  458. {
  459.   return new G7231_File_Codec(direction);
  460. }
  462. ///////////////////////////////////////////////////////////////
  465. ///////////////////////////////////////////////////////////////
  467. G7231_File_Codec::G7231_File_Codec(Direction dir)
  468.   : H323AudioCodec(OPAL_G7231_6k3, dir)
  469. {
  470. }
  473. int G7231_File_Codec::GetFrameLen(int val)
  474. {
  475.   static const int frameLen[] = { 24, 20, 4, 1 };
  476.   return frameLen[val & 3];
  477. }
  479. BOOL G7231_File_Codec::Read(BYTE * buffer, unsigned & length, RTP_DataFrame &)
  480. {
  481.   if (rawDataChannel == NULL)
  482.     return FALSE;
  483.     
  484.   if (!rawDataChannel->Read(buffer, 1)) {
  485.     cerr << "Read failed" << endl;
  486.     return FALSE;
  487.   }
  488.   if (rawDataChannel->GetLastReadCount() == 0) {
  489.     cerr << "Read count is zero" << endl;
  490.     return FALSE;
  491.   }
  493.   int readLen = G7231_File_Codec::GetFrameLen(buffer[0]);
  495.   if (readLen > 0) {
  496.     if (!rawDataChannel->Read(buffer+1, readLen-1)) {
  497.       cerr << "Read failed" << endl;
  498.       return FALSE;
  499.     }
  500.     if (rawDataChannel->GetLastReadCount() == 0) {
  501.       cerr << "Read count is zero" << endl;
  502.       return FALSE;
  503.     }
  504.   }
  506.   length = readLen;
  507.   return TRUE;
  508. }
  510. BOOL G7231_File_Codec::Write(const BYTE * buffer, unsigned length, const RTP_DataFrame & /* rtp */, unsigned & writtenLength)
  511. {
  512.   static const BYTE silence[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  513.                                   0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  514.                                   0, 0, 0, 0};
  515.   // If the length is zero, output silence to the file..
  516.   if (length == 0) {
  517.     PTRACE(1,"G.723.1 zero length frame");
  518.     writtenLength = 0;
  519.     return rawDataChannel->Write(silence, 24);
  520.   }
  522.   int writeLen;
  523.   switch (buffer[0]&3) {
  524.     case 0:
  525.       writeLen = 24;
  526.       break;
  527.     case 1:
  528.       writeLen = 20;
  529.       break;
  530.     case 2:
  531.       // Windows Media Player cannot play 4 byte SID (silence) frames.
  532.       // So write out a 24 byte frame of silence instead.
  533.       PTRACE(1,"Replacing SID with 24 byte frame");
  534.       writtenLength = 4;
  535.       return rawDataChannel->Write(silence, 24);
  536. //    writeLen = 4;
  537. //    break;
  538.     default :
  539.       writeLen = 1;
  540.       break;
  541.   }
  543.   PTRACE(1,"G.723.1 frame length = " <<writeLen);
  545.   writtenLength = writeLen;
  547.   return rawDataChannel->Write(buffer, writeLen);
  548. }
  550. unsigned G7231_File_Codec::GetBandwidth() const      { return G7231_BANDWIDTH; }
  551.       
  552. ///////////////////////////////////////////////////////////////
  560. MyH323EndPoint::MyH323EndPoint(unsigned _callLimit,
  561.                                const PString & _runCmd,
  562.                                const PDirectory & _dir,
  563.                                int   _flags)
  564.   : callLimit(_callLimit), runCmd(_runCmd), dir(_dir), flags(_flags)
  565. {
  566. }
  568. BOOL MyH323EndPoint::OnIncomingCall(H323Connection & _conn,
  569.                                     const H323SignalPDU & setupPDU,
  570.                                     H323SignalPDU &)
  571. {
  572.   MyH323Connection & conn = (MyH323Connection &)_conn;
  574.   // see if incoming call is to a getway address
  575.   PString number;
  576.   if (setupPDU.GetDestinationE164(number)) 
  577.     conn.SetE164Number(number);
  579.   return TRUE;
  580. }
  582. /*
  583. void MyH323EndPoint::OnConnectionEstablished( H323Connection & _conn , const PString & _token  )
  584. {
  586.   MyH323Connection & conn = (MyH323Connection &)_conn;
  587.   RTP_Session * session = conn.GetSession(RTP_Session::DefaultAudioSessionID);
  588.   session->SetReportTimeInterval(1000);
  589. }
  590. */
  592. H323Connection * MyH323EndPoint::CreateConnection(unsigned callReference)
  593. {
  594.   return new MyH323Connection(*this, callReference);
  595. }
  597. BOOL MyH323EndPoint::Initialise(PConfigArgs & args)
  598. {
  599.   // format for record files, raw or wav
  600.   if (args.HasOption("recordraw")) 
  601.     SetRecordWav(FALSE);
  602.   else
  603.     SetRecordWav(TRUE);
  605.   // get G723.1 OGM
  606.   if (args.HasOption("g7231message"))
  607.     g7231Ogm = args.GetOptionString("g7231message");
  608.   else if (args.HasOption('m'))  {
  609.     if (PFile::Exists(args.GetOptionString('m') + "_g7231" + WAVExt)) {
  610.       g7231Ogm = args.GetOptionString('m') + "_g7231" + WAVExt;
  611.     }
  612.     else if (PFile::Exists(args.GetOptionString('m') + PCMExt)) {
  613.       g7231Ogm = args.GetOptionString('m') + G7231Ext;
  614.     }
  615.   }
  617.   if (!g7231Ogm.IsEmpty()) {
  618.     // check if the file exists. (do not check if filename contains %s)
  619.     if ((g7231Ogm.Find("%s") == P_MAX_INDEX) && !PFile::Exists(g7231Ogm)) {
  620.       cout << "warning: cannot open G723.1 OGM file "" << g7231Ogm << """ << endl;
  621.       g7231Ogm = "";
  622.     } 
  623.   }
  625.   /*
  626.   if (g7231Ogm.IsEmpty()) 
  627.     cout << "No G.723.1 outgoing message setn";
  628.   else {
  629.     cout << "Using "" << g7231Ogm << "" as G.723.1 outgoing messagen";
  630.   }
  631.   */
  634.   // Get the OGM message for the 'PCM' codecs
  635.   // Check if the file specified exists. If it does, use it.
  636.   // If it does not exist, try with .wav and .sw extensions.
  637.   if (args.HasOption("pcmmessage")) {
  638.     pcmOgm = args.GetOptionString("pcmmessage");
  639.   }
  640.   else if (args.HasOption('m')) {
  641.   if (g7231Ogm.Find("%s") == P_MAX_INDEX) {
  642.        pcmOgm = args.GetOptionString('m');
  643. } else {
  644.       if (PFile::Exists(args.GetOptionString('m'))) {
  645.         pcmOgm = args.GetOptionString('m');
  646.       }
  647.       else if (PFile::Exists(args.GetOptionString('m') + WAVExt)) {
  648.         pcmOgm = args.GetOptionString('m') + WAVExt;
  649.       }
  650.       else if (PFile::Exists(args.GetOptionString('m') + PCMExt)) {
  651.         pcmOgm = args.GetOptionString('m') + PCMExt;
  652.       }
  653. }
  654.   }
  657.   // By default, use the pcmOgm for all the PCM codecs, but allow the user
  658.   // to override them.
  659.   gsmOgm   = pcmOgm;
  660.   g711Ogm  = pcmOgm;
  661.   lpc10Ogm = pcmOgm;
  662.   speexOgm = pcmOgm;
  665.   // We can set the filename for specific codecs.
  666.   if (args.HasOption("gsmmessage")) 
  667.     gsmOgm = args.GetOptionString("gsmmessage");
  669.   if (args.HasOption("g711message")) 
  670.     g711Ogm = args.GetOptionString("g711message");
  672.   if (args.HasOption("lpc10message")) 
  673.     lpc10Ogm = args.GetOptionString("lpc10message");
  675.   if (args.HasOption("speexmessage")) 
  676.     speexOgm = args.GetOptionString("speexmessage");
  678.   // Check GSM OGM message
  679.   if (!gsmOgm.IsEmpty()) {
  680.     if ((gsmOgm.Find("%s") == P_MAX_INDEX) && !PFile::Exists(gsmOgm)) {
  681.       cout << "warning: cannot open GSM OGM file "" << gsmOgm << """ << endl;
  682.       gsmOgm = "";
  683.     }
  684.   } 
  685.   if (gsmOgm.IsEmpty()) {
  686.     cout << "No outgoing message specified in the arguments...." <<endl;
  687. cout << "Shutting down H.323 Beacon Server!!!!!!!!" <<endl;
  688. cout << "Try, Example usage:" << endl;
  689. cout << ""C:\Program Files\C++ H.323 Beacon Server\H323BeaconServer -m message"" << endl;
  690.   }
  691.     
  692.   else {
  693.     cout << "Using "" << gsmOgm << "" as GSM outgoing messagen";
  694.   }
  696.   // Check G.711 OGM message 
  697.   if (!g711Ogm.IsEmpty()) {
  698.     if ((g711Ogm.Find("%s") == P_MAX_INDEX) && !PFile::Exists(g711Ogm)) {
  699.       cout << "warning: cannot open G711 OGM file "" << g711Ogm << """ << endl;
  700.       g711Ogm = "";
  701.     }
  702.   } 
  703.   /*
  704.   if (g711Ogm.IsEmpty()) 
  705.     cout << "No G711 outgoing message setn";
  706.   else {
  707.     cout << "Using "" << g711Ogm << "" as G.711 outgoing messagen";
  708.   }*/
  710.   // Check LPC10 OGM message 
  711.   if (!lpc10Ogm.IsEmpty()) {
  712.     if ((lpc10Ogm.Find("%s") == P_MAX_INDEX) && !PFile::Exists(lpc10Ogm)) {
  713.       cout << "warning: cannot open LPC10 OGM file "" << lpc10Ogm << """ << endl;
  714.       lpc10Ogm = "";
  715.     }
  716.   } 
  717.   if (lpc10Ogm.IsEmpty()) {
  718. //    cout << "No LPC10 outgoing message setn";
  719.   }
  720.   else {
  721.   //  cout << "Using "" << lpc10Ogm << "" as LPC10 outgoing messagen";
  722.   }
  724.   // Check Speex OGM message 
  725.   if (!speexOgm.IsEmpty()) {
  726.     // check if the file exists. (do not check if filename contains %s)
  727.     if ((speexOgm.Find("%s") == P_MAX_INDEX) && !PFile::Exists(speexOgm)) {
  728.       cout << "warning: cannot open Speex OGM file "" << speexOgm << """ << endl;
  729.       speexOgm = "";
  730.     }
  731.   } 
  732.   if (speexOgm.IsEmpty()) {
  733. //    cout << "No Speex outgoing message setn";
  734.   }
  735.   else {
  736. //    cout << "Using "" << speexOgm << "" as Speex outgoing messagen";
  737.   }
  740.   if (g7231Ogm.IsEmpty() && gsmOgm.IsEmpty() && g711Ogm.IsEmpty()
  741.                          && lpc10Ogm.IsEmpty() 
  742.  && speexOgm.IsEmpty()
  743.  ) {
  744.     cerr << "Must specify at least one outgoing message" << endl;
  745.     return FALSE;
  746.   }
  748.   if (!g7231Ogm.IsEmpty())
  749.     SetCapability(0, 0, new G7231_File_Capability);
  751.   if (!gsmOgm.IsEmpty())
  752.     SetCapability(0, 0, new H323_GSM0610Capability);
  754.   if (!gsmOgm.IsEmpty())
  755.     SetCapability(0, 0, new MicrosoftGSMAudioCapability);
  757.   if (!g711Ogm.IsEmpty())
  758.     SetCapability(0, 0, new H323_G711Capability(H323_G711Capability::muLaw, H323_G711Capability::At64k));
  760.   if (!g711Ogm.IsEmpty())
  761.     SetCapability(0, 0, new H323_G711Capability(H323_G711Capability::ALaw, H323_G711Capability::At64k));
  763.   if (!lpc10Ogm.IsEmpty())
  764.     SetCapability(0, 0, new H323_LPC10Capability(*this));
  766.   if (!speexOgm.IsEmpty())
  767.     SetCapability(0, 0, new SpeexNarrow2AudioCapability());
  768.     SetCapability(0, 0, new SpeexNarrow3AudioCapability());
  769.     SetCapability(0, 0, new SpeexNarrow4AudioCapability());
  770.     SetCapability(0, 0, new SpeexNarrow5AudioCapability());
  771.     SetCapability(0, 0, new SpeexNarrow6AudioCapability());
  773.   capabilities.Remove(args.GetOptionString('D').Lines());
  774.   capabilities.Reorder(args.GetOptionString('P').Lines());
  776.   //cout << "Codecs (in preference order):n" << setprecision(2) << capabilities << endl;
  778.   return TRUE;
  779. }
  781. ///////////////////////////////////////////////////////////////
  783. PCM_RecordFile::PCM_RecordFile(MyH323Connection & _conn, const PFilePath & _fn, unsigned _callLimit)
  784.   : conn(_conn), fn(_fn), callLimit(_callLimit)
  785. {
  786.   //recordStarted = FALSE;
  787.   recordStartedNext = FALSE;
  788.   timeLimitExceeded = FALSE;
  789.   closed        = FALSE;
  790.   dataWritten   = FALSE;
  792.   // If the file name ends in .wav then open the output as a WAV file.
  793.   // Otherwise open it as a raw file.
  794.   if ((_fn.Right(4)).ToLower() == ".wav")
  795.     fileclass = new PWAVFile(_fn, PFile::WriteOnly,
  796.      PFile::ModeDefault,PWAVFile::PCM_WavFile);
  797.   else
  798.     fileclass = new PFile(_fn, PFile::WriteOnly);
  799. }
  801. void PCM_RecordFile::StartRecording()
  802. {
  803.    PWaitAndSignal mutex(pcmrecordMutex);
  804.   
  805.   
  806.   //if (recordStarted) 
  807.     if (recordStartedNext)
  808.     return;
  810.   PTRACE(1, "Starting recording to " << junkwave);
  811.   
  813.   if (playedOnce)
  814.   {
  815.   fn_tmp = junkwave;
  816.   fn = junkwave;
  817.   playedOnce = FALSE;
  818.   }
  819.   else
  820.   {
  821. fn_tmp = fn;
  822.   }
  824.   
  826.   PTime now;
  827.   //recordStarted = TRUE;
  828.   recordStartedNext = TRUE;
  829.   finishTime = now + (callLimit * 1000);
  831. }
  833. BOOL PCM_RecordFile::Close()
  834. {
  835.   PWaitAndSignal mutex(pcmrecordMutex);
  836.   
  837.   closed = TRUE;
  838.   return fileclass->Close();
  839. }
  841. BOOL PCM_RecordFile::Write(const void * buf, PINDEX len)
  842. {
  843.   // Wait for the mutex, and Signal it at the end of this function
  844.   PWaitAndSignal mutex(pcmrecordMutex);
  846.   // If the record file has been closed, or if the time limit has
  847.   // been exceeded, then return immediatly.
  848.   if (closed || timeLimitExceeded)
  849.     return TRUE;
  851.   if (!recordStartedNext) {
  852.     DelayFrame(len);
  853.     return TRUE;
  854.   }
  856.     
  857.   
  858.   //To check for the finish DTMFMessage and not clear the call
  859.   //if time exceeded or if the user stops recording...
  862.   PTime now;
  863.   if ((callLimit != 0) && ((now >= finishTime) || strcmp(stopRecordDTMFTrigger,"1") == 0 )) {
  864.         //PTRACE(1, "Terminating call due to timeout..");
  866. if(now >= finishTime){
  867. cout << "Recording Stopped due to time out%%%%%%%%%" <<endl;
  868. PTRACE(1, "Closing recording due to time out...");
  869. }
  870. else{
  871. cout << "Recording Stopped%%%%%%%%%" <<endl;
  872. PTRACE(1, "Closing recording due to stopRecordDTMFTrigger.."<<stopRecordDTMFTrigger);
  873. }
  875.     timeLimitExceeded = TRUE;
  877. //conn.ClearCall(); //to avoid disconnecting after finishing the recording from Client side..
  878. cout << "Waiting for "Start Playing" message from the H.323 Beacon Client..." <<endl;
  879. PTRACE(1, "Waiting for DTMF 3 Message******************");
  880. while(strcmp(startPlayingDTMFTrigger,"1") != 0 ){
  882. // 
  883. PTRACE(1,"WM_A in while look");
  884. //return FALSE;
  885. return TRUE;
  886. }
  888. PTRACE(1, "Finished waiting for DTMF 3 Message*****************");
  889. //Play the file here..
  890. PTRACE(1, "Playing the recorded file>>>>>>>>>>>>>>>>>>>...."<<fn);
  891. /*
  892. PWAVFile *playSaved;
  893. playSaved = new PWAVFile(fn_tmp, PFile::ReadOnly);
  894. PTRACE(1," fn_tmp = " << fn_tmp);
  895. if (!playSaved->IsOpen()){
  896. PTRACE(1, "Cannot open file "" << playSaved->GetName() << """);
  897. delete playSaved;
  898. } 
  899. else{ 
  900. PTRACE(1, "Playing file "" << playSaved->GetName() << """);
  901. SetReadChannel(playSaved, TRUE);
  902. /* doSilence = FALSE;
  904. if (!doSilence){
  905.  
  906. if (ReadFrame(amount)){
  907. frameBoundary = AdjustFrame(buffer, amount);
  908. totalData += amount;
  909. } 
  910. else{ 
  911. PTRACE(1, "Finished playing the recorded file having " << totalData << " bytes");
  912. PIndirectChannel::Close();
  913. silentCount = 5;   // always do 5 frames of silence after every file
  914.   
  915. // no silence
  916. doSilence = TRUE;
  917. }
  918. }*/
  919. /*
  920. } 
  921. */
  922. PTRACE(1, "Terminating call ########################");
  923. conn.ClearCall(); 
  925.     return TRUE;
  926.   }
  928.   DelayFrame(len);
  930.   dataWritten = TRUE;
  932.   return WriteFrame(buf, len);
  933. }
  935. BOOL PCM_RecordFile::WriteFrame(const void * buf, PINDEX len)
  936. {
  937. /*
  938. if(playedOnce){
  939. return  fileclass_tmp->Write(buf, len);
  940. }
  941. */
  943. PTRACE(1,"In PCM_RecordFile::WriteFrame");
  944. return  fileclass->Write(buf, len); //Place where Write() is actually called..
  946. }
  948. void PCM_RecordFile::DelayFrame(PINDEX len)
  949. {
  950.   delay.Delay(len/16);
  951. }
  953. PCM_RecordFile::~PCM_RecordFile()
  954. {
  955.   PWaitAndSignal mutex(pcmrecordMutex);
  957.   if (!dataWritten) {
  959.   if(playedOnce){
  960. PTRACE(1, "Deleting fn_tmp " << fn << " as no data recorded");
  961. fileclass_tmp->Remove(fn);
  962. delete fileclass_tmp;
  963.   }
  966.     PTRACE(1, "Deleting " << fn << " as no data recorded");
  967.     fileclass->Remove(fn);
  968.   }
  970.   delete fileclass;
  971. }
  973. ///////////////////////////////////////////////////////////////
  974. // Override some of the PCM_RecordFile functions to write
  975. // G723.1 data instead of PCM data.
  977. G7231_RecordFile::G7231_RecordFile(MyH323Connection & _conn, const PFilePath & _fn, unsigned _callLimit)
  978.   : PCM_RecordFile(_conn, _fn, _callLimit)
  979. {
  980.   // If the record file is a .wav file, we need to close the file
  981.   // that PCM_RecordFile will have opened, and reopen it as a G.723.1 Wav file.
  982.   if ((_fn.Right(4)).ToLower() == ".wav") {
  983.     fileclass->Remove(_fn);
  984.     delete fileclass;
  985.     fileclass = new PWAVFile(_fn, PFile::WriteOnly,
  986.      PFile::ModeDefault,PWAVFile::G7231_WavFile);
  987.   }
  988. }
  990. BOOL G7231_RecordFile::WriteFrame(const void * buf, PINDEX /*len*/)
  991. {
  992.   int frameLen = G7231_File_Codec::GetFrameLen(*(BYTE *)buf);
  993. //  cerr << "Writing G7231 " << frameLen << endl;
  994.   return fileclass->Write(buf, frameLen);
  995. }
  997. void G7231_RecordFile::DelayFrame(PINDEX /*len*/)
  998. {
  999.   // Ignore the len parameter as that is the compressed size.
  1000.   // We must delay by the actual sample time.
  1001.   delay.Delay((G7231_SAMPLES_PER_BLOCK*2)/16);
  1002. }
  1004. ///////////////////////////////////////////////////////////////
  1006. static BOOL MatchString(const PString & str1, const PString str2)
  1007. {
  1008.   if (str1.GetLength() != str2.GetLength())
  1009.     return FALSE;
  1011.   PINDEX len = str1.GetLength();
  1013.   PINDEX i;
  1014.   for (i = 0; i < len; i++) 
  1015.     if ((str1[i] != '?') && (str2[i] != '?') && (str1[i] != str2[i]))
  1016.       return FALSE;
  1018.   return TRUE;
  1019. }
  1021. static PINDEX FindMatch(const PStringList & list, const PString & key)
  1022. {
  1023.   PINDEX maxKeyLen = 0;
  1024.   PINDEX i;
  1026.   PINDEX keyLen = key.GetLength();
  1027.   PINDEX listLen = list.GetSize();
  1029.   for (i = 0; i < listLen; i++)
  1030.     maxKeyLen = PMAX(maxKeyLen, list[i].GetLength());
  1032.   if (keyLen == 0 || maxKeyLen == 0)
  1033.     return P_MAX_INDEX;
  1035.   if (keyLen > maxKeyLen)
  1036.     return P_MAX_INDEX;
  1038.   PINDEX len = 1;
  1039.   while (len <= keyLen) {
  1040.     PString subStr = key.Left(len);
  1042.     PINDEX matches = 0;
  1043.     PINDEX lastMatch = P_MAX_INDEX;
  1044.     PINDEX i;
  1046.     // look for a match to the substring
  1047.     for (i = 0; i < list.GetSize(); i++) {
  1048.       if ((list[i].GetLength() >= keyLen) && MatchString(list[i].Left(len), subStr)) {
  1049.         matches++;
  1050.         lastMatch = i;
  1051.       }
  1052.     }
  1054.     // if we got ONE match, we have a winner
  1055.     if (matches == 1)
  1056.       return lastMatch+1;
  1058.     // if we have no matches, then there is no point continuing
  1059.     if (matches == 0)
  1060.       return P_MAX_INDEX;
  1062.     // if we have more than one match, try the next char
  1063.     len++;
  1064.   }
  1066.   // too many matches
  1067.   return 0;
  1068. }
  1071. MyH323Connection::MyH323Connection(MyH323EndPoint & _ep, unsigned callReference)
  1072.   : H323Connection(_ep, callReference), ep(_ep)
  1073. {
  1074.   basename = psprintf("%04i%02i%02i_%02i%02i%02i", callStartTime.GetYear(), callStartTime.GetMonth(),  callStartTime.GetDay(),
  1075.                                                    callStartTime.GetHour(), callStartTime.GetMinute(), callStartTime.GetSecond());
  1076.   recordFile = NULL;
  1077.   ogmChannel = NULL;
  1079.   receiveCodecName = transmitCodecName = "none";
  1080. // SetMaxAudioDelayJitter(150);
  1082.   cout << "Opening Test Session...." << endl;
  1084.   currentMenu = 0;
  1085.   digits = "";
  1087.   PConfig config;
  1088.   PStringList sections = config.GetSections();
  1089.   PINDEX i;
  1090.   for (i = 0; i < sections.GetSize(); i++) {
  1091.     if (sections[i].Find(MENU_PREFIX) == 0) 
  1092.       menuNames.AppendString(sections[i]);
  1093.   }
  1095. }
  1097. MyH323Connection::~MyH323Connection()
  1098. {
  1099.   //cout << "Closing Test Session!!!!!!!" << endl;
  1100.   //cout << "Waiting to accept incoming calls....." << endl;
  1101.   //cout << "H.323 Beacon Server IP Address: " << IPAddress << endl;
  1102.   //PTRACE(1,"Closing connection###########################");
  1105.   PTime now;
  1106.   PTimeInterval interval = now - recordStartTime;
  1107.   PString addr = GetControlChannel().GetRemoteAddress();
  1109.   PString codecStr = receiveCodecName + "/" + transmitCodecName;
  1110.   unsigned duration = (unsigned)((interval.GetMilliSeconds()+999)/1000);
  1112.   LogCall(recordFn, addr, GetRemotePartyName(), duration, codecStr, product);
  1114.   if ((recordFile!= NULL) && (recordFile->WasRecordStarted()) && !ep.GetRunCmd().IsEmpty()) {
  1115.     PString cmdStr = ep.GetRunCmd() &
  1116.                      recordFn &
  1117.                      "'" + addr + "'" &
  1118.                      """ + GetRemotePartyName() + """ &
  1119.                      PString(PString::Unsigned, duration) &
  1120.                      """ + codecStr + """ &
  1121.                      """ + product + """;
  1122.     PTRACE(1, "Executing : " << cmdStr);
  1123.     system((const char *)cmdStr);
  1124.   } else {
  1125.     PTRACE(1, "No action to perform at end of record");
  1126.   }
  1128.   if (ogmChannel != NULL)
  1129.   {
  1130. PTRACE(1, "Deleting OgmChannel ");
  1131.     delete ogmChannel;
  1132.   }
  1134.   if (recordFile != NULL)
  1135.   {
  1136. PTRACE(1, "Deleting recordFile ");
  1137.     delete recordFile;
  1138.   }
  1140.   if (ep.GetDeleteAfterRecord())   {
  1141.    PTRACE(1, "Removing " << recordFn << " as requested by option");
  1142. PString command = "ForceDel.exe ""+recordFn+"" > NUL";
  1143. if(system(command)==0)
  1144. PTRACE(1,"Removal of " << recordFn << " Successful!");
  1145. else
  1146. PTRACE(1,"Removal of " << recordFn << " Failure!");
  1147.   }
  1150.  for(int ii = 0; ii<countwavefiles+2; ii++)
  1151.  {
  1152.   junkwave = psprintf("junkwave%01i",ii);
  1153. junkwave = tmpDir + (junkwave + ".wav");
  1154. if(remove(junkwave) == -1)
  1155. {
  1156. PTRACE(1, "Removing JunkWave Failed**********" << junkwave);
  1157. }
  1158. else
  1159. {
  1160. PTRACE(1, "Removing JunkWave Success!!!!!!!");
  1161. }
  1162.  }
  1164. /* PString message =" This is the Trace Route Message From the Servern";
  1165. if(SendTraceRtToClient(addr,&message)==1){
  1166. cout<<"traceRT sent successfully"<<endl;
  1167. PTRACE(1,"traceRT sent successfullyn");
  1168. }
  1169. else{
  1170. cout<<"traceRT send  unsuccessfull"<<endl;
  1171. PTRACE(1,"traceRT send unsuccessfulln");
  1172. }
  1173. */
  1174. cout << "Closing Test Session!!!!!!!" << endl;
  1175. cout<<"Starting log_server...."<<endl;
  1176. log_server();
  1177. cout <<"Closing log_server...."<<endl;
  1178. cout << "Waiting to accept incoming calls....." << endl;
  1179. cout << "H.323 Beacon Server IP Address: " << IPAddress << endl;
  1180. PTRACE(1,"Closing connection###########################");
  1181. }
  1183. H323Connection::AnswerCallResponse
  1184.      MyH323Connection::OnAnswerCall(const PString & caller,
  1185.                                     const H323SignalPDU & setupPDU,
  1186.                                     H323SignalPDU & /*connectPDU*/)
  1187. {
  1188.   product = "Unknown";
  1190.   const H225_Setup_UUIE & setup = setupPDU.m_h323_uu_pdu.m_h323_message_body;
  1191.   const H225_EndpointType & epInfo = setup.m_sourceInfo;
  1193.   if (epInfo.HasOptionalField(H225_EndpointType::e_vendor)) {
  1194.     const H225_VendorIdentifier & vendorInfo = epInfo.m_vendor;
  1195.     if (vendorInfo.HasOptionalField(H225_VendorIdentifier::e_productId))
  1196.       product = vendorInfo.m_productId.AsString();
  1197.     if (vendorInfo.HasOptionalField(H225_VendorIdentifier::e_versionId))
  1198.       product = product + "/" + vendorInfo.m_versionId.AsString();
  1199.   }
  1200.   
  1201.   cout << "Accepting call from " << caller << " ...n";
  1204.   return AnswerCallNow;
  1205. }
  1207. BOOL MyH323Connection::OpenAudioChannel(BOOL isEncoding, 
  1208.                                         unsigned /* bufferSize */, 
  1209.                                         H323AudioCodec & codec)
  1210. {
  1211. if(playedFlag == 0){ 
  1213.   codec.SetSilenceDetectionMode(H323AudioCodec::NoSilenceDetection);
  1214.   PStringStream codecName;
  1215.   codecName << codec;
  1217.   PString ogm;
  1218.   BOOL isPCM = FALSE;
  1220.   if (codec.IsDescendant(G7231_File_Codec::Class())) {
  1221.     ogm   = ep.GetG7231OGM();
  1222.     isPCM = FALSE;
  1223.   } else if (codec.IsDescendant(H323_GSM0610Codec::Class())) {
  1224.     ogm   = ep.GetGSMOGM();
  1225.     isPCM = TRUE;
  1226.   } else if (codec.IsDescendant(MicrosoftGSMCodec::Class())) {
  1227.     ogm   = ep.GetGSMOGM();
  1228.     isPCM = TRUE;
  1229.   } else if (codec.IsDescendant(H323_muLawCodec::Class())) {
  1230.     ogm   = ep.GetG711OGM();
  1231.     isPCM = TRUE;
  1232.   } else if (codec.IsDescendant(H323_ALawCodec::Class())) {
  1233.     ogm   = ep.GetG711OGM();
  1234.     isPCM = TRUE;
  1235.   } else if (codec.IsDescendant(H323_LPC10Codec::Class())) {
  1236.     ogm   = ep.GetLPC10OGM();
  1237.     isPCM = TRUE;
  1238.   } else if (codec.IsDescendant(SpeexCodec::Class())) {
  1239.     ogm   = ep.GetSPEEXOGM();
  1240.     isPCM = TRUE;
  1241.   } else {
  1242.     cerr << "Unknown codec "" << codecName << endl;
  1243.     return FALSE;
  1244.   }
  1247.   PWaitAndSignal mutex(connMutex);
  1249.   tmpDir = ep.GetDirectory();
  1250.   tmpCallLimit = ep.GetCallLimit();
  1253.   if ((recordFile == NULL) && (isEncoding == FALSE)) {
  1254.     if (isPCM) {
  1255.       if (ep.GetRecordWav() == TRUE)
  1256.       recordFn = ep.GetDirectory() + (basename + ".wav");
  1257.       else
  1258.       recordFn = ep.GetDirectory() + (basename + ".sw");
  1259.       recordFile = new PCM_RecordFile  (*this, recordFn, ep.GetCallLimit());
  1260.     } else {
  1261.       if (ep.GetRecordWav() == TRUE)
  1262.       recordFn = ep.GetDirectory() + (basename + ".wav");
  1263.       else
  1264.       recordFn = ep.GetDirectory() + (basename + ".g723");
  1265.       recordFile = new G7231_RecordFile(*this, recordFn, ep.GetCallLimit());
  1266.     }
  1267.   }
  1269.   if ((ogmChannel == NULL) && (isEncoding == TRUE)) {
  1270.     if (isPCM)
  1271.       ogmChannel = new PCM_OGMChannel(*this);
  1272.     else
  1273.       ogmChannel = new G7231_OGMChannel(*this);
  1274.   }
  1276.   if (isEncoding) {
  1278.     if (ep.GetHangupAfterPlay())
  1279.       ogmChannel->SetPlayOnce();
  1281.     if (ogm.Find("%s"))
  1282.       ogm.Replace("%s", e164Number);
  1284.     transmitCodecName = codecName;
  1285.     if (!StartMenu(0)) {
  1286.       if (!PFile::Exists(ogm))
  1287.         cerr << "error: cannot find OGM "" << ogm << """ << endl;
  1288.       else
  1289.           ogmChannel->QueueFile(ogm); //being called!!
  1290.       if (!ep.GetNoRecordG7231())
  1291.         ogmChannel->SetRecordTrigger();
  1292.     }
  1293.     codec.AttachChannel(ogmChannel, FALSE);
  1294.   } else {
  1295.     receiveCodecName = codecName;
  1296.     codec.AttachChannel(recordFile, FALSE);
  1297.   }
  1299.   return TRUE;
  1300. }
  1301. else 
  1302. return TRUE; 
  1303.   
  1305. }
  1308. BOOL MyH323Connection::OnStartLogicalChannel(H323Channel & channel)
  1309. {
  1310.   if (!H323Connection::OnStartLogicalChannel(channel))
  1311.     return FALSE;
  1313.   cout << "Started logical channel: ";
  1315.   switch (channel.GetDirection()) {
  1316.     case H323Channel::IsTransmitter :
  1317.       cout << "Sending capability information->";
  1318.       break;
  1320.     case H323Channel::IsReceiver :
  1321.       cout << "Receiving capability information-> ";
  1322.       break;
  1324.     default :
  1325.       break;
  1326.   }
  1328.   cout << channel.GetCapability() << endl;
  1330.   return TRUE;
  1331. }
  1333. void MyH323Connection::StartRecording()
  1334. {
  1335.   recordFile->StartRecording();
  1336. }
  1338. void MyH323Connection::OnUserInputString(const PString & value)
  1339. {
  1340.   PINDEX i;
  1341.   for (i = 0; i < value.GetLength(); i++) {
  1342.     OnUserInputChar(value[i]);
  1343.   }
  1344. }
  1346. BOOL MyH323Connection::StartMenu(int menuNumber)
  1347. {
  1348.   digits = "";
  1349.   currentMenu = menuNumber;
  1350.   PString menuName = psprintf("%s%i", MENU_PREFIX, menuNumber);
  1351.   if (menuNames.GetStringsIndex(menuName) == P_MAX_INDEX) 
  1352.     return FALSE;
  1354.   PTRACE(1, "Starting menu " << menuNumber);
  1356.   PConfig menu(menuName);
  1357.   PString startCmd = menu.GetString("start");
  1359.   if (!startCmd.IsEmpty())
  1360.     ProcessMenuCmd(startCmd);
  1362.   return TRUE;
  1363. }
  1365. BOOL MyH323Connection::ProcessMenuCmd(const PString & cmdStr)
  1366. {
  1367.   PTRACE(1, "Processing menu cmd " << cmdStr);
  1368.   PStringArray tokens = cmdStr.Tokenise(" ", FALSE);
  1369.   int len = tokens.GetSize();
  1370.   if (len == 0)
  1371.     return TRUE;
  1373.   PString cmd = tokens[0];
  1375.   if ((len >= 2) && (cmd *= "play")) {
  1376.     ogmChannel->QueueFile(tokens[1]);
  1377.     if (len > 2) {
  1378.       cmd = "menu";
  1379.       tokens[1] = tokens[2];
  1380.     }
  1381.   }
  1383.   if ((len >= 2) && (cmd *= "menu")) {
  1384.     int newMenu = tokens[1].AsInteger();
  1385.     if (newMenu != currentMenu)
  1386.       StartMenu(newMenu);
  1387.   }
  1389.   else if (cmd *= "hangup")
  1390.     ogmChannel->SetHangupTrigger();
  1392.   else if (cmd *= "record")
  1393.     ogmChannel->SetRecordTrigger();
  1395.   return TRUE;
  1396. }
  1398. void MyH323Connection::OnUserInputChar(char ch)
  1399. {
  1400.   if (ch == '#') 
  1401.     digits += '$';
  1402.   else 
  1403.     digits += ch;
  1405.   PTRACE(1, "Processing digit string " << digits);
  1407.     //to change the state of receivedDTMFMessage
  1408.   receivedDTMFMessage = digits;
  1409.   if(strcmp(receivedDTMFMessage,"") != 0)
  1410.   dtmfTrigger = YES;
  1411.   
  1412.   PTRACE(1, "receivedDTMFMessage.........." << receivedDTMFMessage);
  1413.   if(strcmp(receivedDTMFMessage,"1") == 0){
  1414. recordDTMFTrigger = YES;
  1415. cout << "Start recording message received from H.323 Beacon Client..." <<endl;
  1416. PTRACE(1,"recordDTMFTrigger TRUE is----"<<recordDTMFTrigger);
  1417.   }
  1418.   else if (strcmp(receivedDTMFMessage,"2") == 0){
  1419. stopRecordDTMFTrigger = YES;
  1420. cout << "Stop recording message received from H.323 Beacon Client..." <<endl;
  1421. PTRACE(1,"stopRecordDTMFTrigger TRUE is----"<<stopRecordDTMFTrigger);
  1422.   }
  1423.   else if (strcmp(receivedDTMFMessage,"3") == 0){
  1424. startPlayingDTMFTrigger = YES;
  1425. cout << "Start playing message received from H.323 Beacon Client..." <<endl;
  1426. cout << "Playing back the recorded file to the H.323 Beacon Client..." << endl;
  1427. PTRACE(1,"startPlayingDTMFTrigger TRUE is----"<<startPlayingDTMFTrigger);
  1428.   }
  1429.   else if (strcmp(receivedDTMFMessage,"4") == 0){
  1430. cout << "Hang up message received...Hanging up...Please Wait>>>>>>>>"<<endl;
  1431. PTRACE(1,"Hang-up message from client@@@@@@@@@@@@@@@@@@");
  1432.   }
  1433.   else{
  1434. recordDTMFTrigger = NO;
  1435. stopRecordDTMFTrigger = NO;
  1436. startPlayingDTMFTrigger = NO;
  1437. PTRACE(1,"Not a valid DTMF Trigger.....");
  1438.   }
  1440.   if ((strcmp(receivedDTMFMessage,"1") == 0) && (playedFlag > 0)){
  1441. ogmChannel->FlushQueue();
  1442. recordDTMFTrigger = NO; 
  1443. stopRecordDTMFTrigger = NO;
  1444. startPlayingDTMFTrigger = NO;
  1445. playedFlag = 0;
  1447.   }
  1450.   PString menuName = psprintf("%s%i", MENU_PREFIX, currentMenu);
  1451.   if (menuNames.GetStringsIndex(menuName) == P_MAX_INDEX) {
  1452.     PTRACE(1, "Cannot find menu " << menuName);
  1453.     StartMenu(0);
  1454.     return;
  1455.   }
  1457.   PConfig menu(menuName);
  1458.   PStringList keys = menu.GetKeys();
  1459.   PINDEX keyMatch = FindMatch(keys, digits);
  1461.   // if key is still ambiguous, then keep collecting
  1462.   if (keyMatch == 0)
  1463.     return;
  1465.   PString cmd;
  1466.   if (keyMatch != P_MAX_INDEX) {
  1467.     PString key = keys[keyMatch-1];
  1468.     PTRACE(1, "Executing cmd for key " << key);
  1469.     cmd = menu.GetString(key);
  1470.   } else {
  1471.     PTRACE(1, "Cannot match cmd " << digits << " in menu " << menuName);
  1472.     cmd = menu.GetString("error", "menu 0");
  1473.   } 
  1475.   if (!cmd.IsEmpty()) {
  1476.     ProcessMenuCmd(cmd);
  1477.     digits = "";
  1478.   }
  1479.   
  1480. }
  1482. ///////////////////////////////////////////////////////////////
  1484. BOOL CheckWAVFileValid(PWAVFile *chan, int type) {
  1485.   // Check the wave file header
  1486.   if (!chan->IsValid()) {
  1487.     PTRACE(1, chan->GetName() << " wav file header invalid");
  1488.     return FALSE;
  1489.   }
  1491.   // Check the wave file format
  1492.   if ( (type == CHECK_PCM) && (chan->GetFormat() != 0x01) ){
  1493.     PTRACE(1, chan->GetName() << " is not a PCM format wav file");
  1494.     PTRACE(1, "It is format " << chan->GetFormat() );
  1495.     return FALSE;
  1496.   }
  1498.   if ( (type == CHECK_G7231) && 
  1499.        ((chan->GetFormat() != 0x42) && (chan->GetFormat() != 0x111)) ){
  1500.     PTRACE(1, chan->GetName() << " is not a G.723.1 format wav file");
  1501.     PTRACE(1, "It is format " << chan->GetFormat() );
  1502.     return FALSE;
  1503.   }
  1505.   // Check the sample rate for PCM wave files
  1506.   if ( (type == CHECK_PCM) &&
  1507.        ( (chan->GetSampleRate() != 8000)
  1508.        ||(chan->GetChannels() != 1)
  1509.        ||(chan->GetSampleSize() != 16) )
  1510.      ) {
  1511.     PTRACE(1, chan->GetName() << " is not a 16 Bit, Mono, 8000 Hz (8Khz) PCM wav file");
  1512.     PTRACE(1, "It is " << chan->GetSampleSize() << " bits, "
  1513.                        << (chan->GetChannels()==1 ? "mono " : "stereo ")
  1514.                        << chan->GetSampleRate() << " Hz");
  1515.     return FALSE;
  1516.   }
  1518.   return TRUE;
  1519. }
  1521. ///////////////////////////////////////////////////////////////
  1523. PCM_OGMChannel::PCM_OGMChannel(MyH323Connection & _conn)
  1524.   : conn(_conn)
  1525. {
  1526.   silentCount = 20;         // wait 20 frames before playing the OGM
  1527.   recordTrigger = FALSE;
  1528.   hangupTrigger = FALSE;
  1529.   closed        = FALSE;
  1530.   playOnce      = FALSE;
  1532.   frameLen = frameOffs = 0;
  1533. }
  1536. void PCM_OGMChannel::PlayFile(PFile * chan)
  1537. { 
  1538.   PWaitAndSignal mutex(chanMutex);
  1539. //  if (IsOpen())
  1540. //    Close();
  1542.   if (!chan->Open(PFile::ReadOnly)) {
  1543.     PTRACE(1, "Cannot open file "" << chan->GetName() << """);
  1544.     return;
  1545.   }
  1547.   PTRACE(1, "Playing file "" << chan->GetName() << """);
  1548.   totalData = 0;
  1549.   SetReadChannel(chan, TRUE);
  1550. }
  1553. BOOL PCM_OGMChannel::IsWAVFileValid(PWAVFile *chan) {
  1554.   // Check that this is a PCM wave file
  1555.   return CheckWAVFileValid(chan, CHECK_PCM);
  1556. }
  1559. BOOL PCM_OGMChannel::Read(void * buffer, PINDEX amount)
  1560. {
  1561.   PWaitAndSignal mutex(chanMutex);
  1563.   // if the channel is closed, then return error
  1564.   if (closed)
  1565.     return FALSE;
  1567.   // Create the frame buffer using the amount of bytes the codec wants to
  1568.   // read. Different codecs use different read sizes.
  1569.   frameBuffer.SetMinSize(1024);//amount);
  1571.   // assume we are returning silence
  1572.   BOOL doSilence = TRUE;
  1573.   BOOL frameBoundary = FALSE;
  1576.  if (strcmp(startPlayingDTMFTrigger,"1") != 0 && (playedOnce == FALSE)){
  1577.  // if still outputting a frame from last time, then keep doing it
  1578.   if (frameOffs < frameLen) {
  1579.     frameBoundary = AdjustFrame(buffer, amount);
  1580.     doSilence = FALSE;
  1581. } 
  1582.   else {
  1584.     // if we are returning silence frames, then 
  1585.     if (silentCount > 0) 
  1586.       silentCount--;
  1588.     // if a channel is already open, don't do silence
  1589.     else if (GetBaseReadChannel() != NULL)
  1590.       doSilence = FALSE;
  1592.     // If not in silence and no existing channel, open a new file.
  1593.     else {
  1594. if (strcmp(receivedDTMFMessage,"1") == 0){
  1595.       PString * str = playQueue.Dequeue();
  1596.       if (str != NULL) {
  1598.         // check the file extension and open a .wav or a raw (.sw or .g723) file
  1600.         if (((*str).Right(4)).ToLower() == ".wav") {
  1601.           PWAVFile *chan;
  1602.           chan = new PWAVFile(*str, PFile::ReadOnly);
  1603.           if (!chan->IsOpen()) {
  1604.             PTRACE(1, "Cannot open file "" << chan->GetName() << """);
  1605.             delete chan;
  1606.           } else {
  1607.           if (!IsWAVFileValid(chan) ){
  1608.               PTRACE(1, chan->GetName() << " is not a valid wav file");
  1609.               delete chan;
  1610.               cerr << "wave file is invalid" << endl;
  1611.             } else {
  1612.               PTRACE(1, "Playing file "" << chan->GetName() << """);
  1613.               totalData = 0;
  1614.               SetReadChannel(chan, TRUE);
  1615.               doSilence = FALSE;
  1616.             }
  1617.   }
  1619.         } else { // raw file (eg .sw)
  1620.           PFile *chan;
  1621.           chan = new PFile(*str);
  1622.           if (!chan->Open(PFile::ReadOnly)) {
  1623.             PTRACE(1, "Cannot open file "" << chan->GetName() << """);
  1624.             delete chan;
  1625.           } else {
  1626.              cout << "Playing message file-> "" << chan->GetName() << """ <<endl;
  1627. PTRACE(1, "Playing file "" << chan->GetName() << """); //actually playing here!
  1628. fn_original = chan->GetName();
  1629. totalData = 0;
  1630. SetReadChannel(chan, TRUE);
  1631. doSilence = FALSE;
  1632. playedFlag++; 
  1633. }
  1634. } 
  1635.         delete str;
  1636.   }
  1637.       }
  1638.     }
  1640.    /*
  1641. if (strcmp(receivedDTMFMessage,"1") == 0){
  1642. doSilence = FALSE;
  1643. }
  1644. */
  1647.     // if not doing silence, try and read from the file
  1648.     if (!doSilence) {
  1649.   
  1650.          if (ReadFrame(amount)){
  1651. PTRACE(1,"Amount origin file " << amount);
  1652. frameBoundary = AdjustFrame(buffer, amount);
  1653. PTRACE(1,"************** Original Frame Boundary " << frameBoundary);
  1654. totalData += amount;
  1655.   } 
  1656.  else {
  1657.   if (strcmp(receivedDTMFMessage,"1") == 0){ 
  1658. cout << "Finished playing message file........." <<endl;
  1661.         PTRACE(1, "Finished playing " << totalData << " bytes");
  1662.         //closed = TRUE;
  1663.   
  1664.         PIndirectChannel::Close();
  1665.         silentCount = 5;   // always do 5 frames of silence after every file
  1666.   
  1667.         // hangup if required
  1668.         if (hangupTrigger || playOnce) 
  1669.           conn.ClearCall();
  1670.   
  1671.         // trigger record if required
  1672.         else if (recordTrigger) {
  1673.           if ((playQueue.GetSize() == 0) && (GetBaseReadChannel() == NULL))
  1674. cout << "Recording Started%%%%%%%%%" << endl;
  1675. PTRACE(1,"Starting to Record!!!!!!!!!!!!");
  1676.             conn.StartRecording();
  1677. }
  1678.       }
  1679.    
  1680.         // no silence
  1681.         doSilence = TRUE;
  1682.       }
  1683. }
  1684. }
  1685.     }
  1687.     //if (strcmp(startPlayingDTMFTrigger,"1") == 0)
  1688.   else {
  1689. if (strcmp(fn_tmp,"") != 0){
  1690. PWAVFile *playSaved;
  1691. playSaved = new PWAVFile(fn_tmp, PFile::ReadOnly);
  1692. PTRACE(1,"fn_tmp = " << fn_tmp);
  1694. if (!playSaved->IsOpen()){
  1695. PTRACE(1, "Cannot open file "" << playSaved->GetName() << """);
  1696. delete playSaved;
  1697. } 
  1698. else{
  1699. PTRACE(1, "Playing file "" << playSaved->GetName() << """);
  1700. SetReadChannel(playSaved, TRUE);
  1701. doSilence = FALSE;
  1702. }
  1704. if (!doSilence){
  1705. if (ReadFrame(amount)){
  1706. PTRACE(1,"buffer = " << buffer << "   amount = " << amount);
  1707. frameBoundary = AdjustFrame(buffer, amount);
  1708. PTRACE(1, "*******************Recorded File " << frameBoundary);
  1709. totalData += amount;
  1710. } 
  1711. else{
  1712. cout << "Finished playing back...." << endl;
  1713. cout << "Test Session still active......." << endl;
  1714. PTRACE(1, "Finished playing " << totalData << " bytes");
  1716. // junkwave = psprintf("junkwave%01i",countwavefiles);
  1717.   
  1718. //fn = tmpDir + (junkwave + ".wav");
  1719. // junkwave = tmpDir + (junkwave + ".wav");
  1720. //junkwave = fn;
  1721. //_fn = fn;
  1723. // fn = junkwave;
  1724. // _fn = fn;
  1726. // PTRACE(1,"*TEST* fn = " << junkwave);
  1727.  
  1728. // if ((junkwave.Right(4)).ToLower() == ".wav"){
  1729. //PTRACE(1,"Creating the Junk File****************!!!");
  1730. //fileclass_tmp = new PWAVFile(junkwave, PFile::WriteOnly,
  1731. //PFile::ModeDefault,PWAVFile::PCM_WavFile);
  1732. //}
  1733. //else
  1734. // fileclass_tmp = new PFile(junkwave, PFile::WriteOnly);
  1735. //recordFilejunkwave = new PCM_RecordFile (*((MyH323Connection *)tmpConn),junkwave,tmpCallLimit);
  1736. //closed = TRUE;
  1738. // Remove Temporary File
  1739. // if (strcmp(fn_tmp,fn_original) != 0){
  1740. //PTRACE(1,"Removing fn_tmp file " << fn_tmp);
  1741. //PFile::Remove(fn_tmp);
  1742. //if (remove(fn_tmp) == -1)
  1743. /*
  1744. if (PFile::Remove(fn_tmp,TRUE)){
  1745. PTRACE(1,"Removing Complete");
  1746. }
  1747. else{
  1748. PTRACE(1,"Removing NOT Complete");
  1749. }
  1750. */
  1751. // }
  1752.   
  1753. PIndirectChannel::Close();
  1754. silentCount = 5;   // always do 5 frames of silence after every file
  1755.   
  1756. // no silence
  1757. doSilence = TRUE;
  1758. PTRACE(1,"WM_G");
  1760. if ((strcmp(recordDTMFTrigger,"1") == 0) && playedOnce == TRUE){
  1761. PTRACE(1,"Starting to Record  Second Time!!!!!!!!!!!!^^^^^^^");
  1762. if (recordTrigger){
  1763. if ((playQueue.GetSize() == 0) && (GetBaseReadChannel() == NULL)){
  1764. recordStartedNext = FALSE;
  1765. playedOnce = TRUE;
  1767. //fileclass_tmp->StartRecording();
  1768. //conn.StartRecording();
  1769. recordFilejunkwave->StartRecording();
  1771. // PCM_RecordFile::Write(buffer,amount);
  1772. countwavefiles++;
  1774. //recordFile->StartRecording();
  1775. }
  1776. }
  1778. doSilence = TRUE;
  1779. if (doSilence){
  1780. CreateSilenceFrame(amount);
  1781. frameBoundary = AdjustFrame(buffer, amount);
  1782. }
  1783.                     // delay to synchronise to frame boundary
  1784.   if (frameBoundary){
  1785. Synchronise(amount);
  1786. doSilence = TRUE;
  1787. startPlayingDTMFTrigger = NO;
  1788.   }
  1790.   return TRUE;
  1791. }
  1793.   
  1794. //to keep the record, stop, play cycle going without disconnecting..
  1795. dtmfTrigger = NO;
  1796. recordDTMFTrigger = NO;
  1797. stopRecordDTMFTrigger = NO;
  1798. startPlayingDTMFTrigger = NO;
  1799. playedFlag = 0;
  1800. receivedDTMFMessage = "";
  1802. playedOnce = TRUE;
  1804. PTRACE(1, "WAITING for recordDTMFTrigger" << recordDTMFTrigger);
  1806. /*
  1807. if ((strcmp(receivedDTMFMessage,"4") == 0)){
  1808. PTRACE(1,"Clearing Call in Read function.........@@@@@@@@@@@@@@");
  1810. H323Channel *tmpChan = tmpConn->FindChannel(RTP_Session::DefaultAudioSessionID,FALSE);
  1811. dtmfTrigger = NO;
  1812. recordDTMFTrigger = NO;
  1813. stopRecordDTMFTrigger = NO;
  1814. startPlayingDTMFTrigger = NO;
  1815. playedFlag = 0;
  1816. receivedDTMFMessage = "";
  1818. playedOnce = FALSE;
  1820. return FALSE;
  1821. }
  1822. */
  1823. // This code is for Thread NOT Terminating
  1824. for(;;){
  1825. // This code is for Thread NOT Terminating
  1826. doSilence = TRUE;
  1827. if (doSilence) {
  1828. CreateSilenceFrame(amount);
  1829. frameBoundary = AdjustFrame(buffer, amount);
  1830. }
  1832. // delay to synchronise to frame boundary
  1833. if (frameBoundary){
  1834. Synchronise(amount);
  1835. doSilence = TRUE;
  1836. startPlayingDTMFTrigger = NO;
  1837. }
  1839. if ((strcmp(recordDTMFTrigger,"1") == 0) && playedOnce == TRUE){
  1840. PTRACE(1,"Starting to play message for second time@@@@@@@@@@@@@@");
  1841. fn_tmp = fn_original;  // To make play the original message starting from seconnd record seq
  1842. return TRUE;
  1843. }
  1845. if ((strcmp(stopRecordDTMFTrigger,"1") == 0) && playedOnce == TRUE){
  1846. PTRACE(1,"This is Second STOP");
  1847. fn_tmp = "";
  1848. return TRUE;
  1849. }
  1851. if ((strcmp(startPlayingDTMFTrigger,"1") == 0) && playedOnce == TRUE){
  1852. PTRACE(1,"This is Second time Playing");
  1853. junkwave = psprintf("junkwave%01i",countwavefiles);
  1854. //fn = tmpDir + (junkwave + ".wav");
  1855. junkwave = tmpDir + (junkwave + ".wav");
  1856. //junkwave = fn;
  1857. //_fn = fn;
  1859. PTRACE(1,"*TEST* fn = " << junkwave);
  1860.  
  1861. if ((junkwave.Right(4)).ToLower() == ".wav"){
  1862. PTRACE(1,"Creating the Junk File****************!!!");
  1863. fileclass_tmp = new PWAVFile(junkwave, PFile::WriteOnly,
  1864. PFile::ModeDefault,PWAVFile::PCM_WavFile);
  1865. }
  1866. else
  1867. fileclass_tmp = new PFile(junkwave, PFile::WriteOnly);
  1869. fn = junkwave;
  1870. _fn = fn;
  1872. recordFilejunkwave = new PCM_RecordFile (*((MyH323Connection *)tmpConn),junkwave,tmpCallLimit);
  1873. return TRUE;
  1874. }
  1876. if ((strcmp(receivedDTMFMessage,"4") == 0) && playedOnce == TRUE){
  1877. PTRACE(1,"Clearing call in Read function.........@@@@@@@@@@@@@@");
  1878. //H323Channel *tmpChan = tmpConn->FindChannel(RTP_Session::DefaultAudioSessionID,FALSE);
  1880. dtmfTrigger = NO;
  1881. recordDTMFTrigger = NO;
  1882. stopRecordDTMFTrigger = NO;
  1883. startPlayingDTMFTrigger = NO;
  1884. playedFlag = 0;
  1885. receivedDTMFMessage = "";
  1886. playedOnce = FALSE;
  1887. fn = "";
  1888. fn_tmp = "";
  1890. /*
  1891. switch (tmpChan->GetDirection()) {
  1892. case H323Channel::IsTransmitter :
  1893. //cout << "sending ";
  1894. //PTRACE(1,"In Hangup, Channel is Trasnmitting");
  1895. break;
  1897. case H323Channel::IsReceiver :
  1898. //cout << "receiving ";
  1899. //PTRACE(1,"In Hangup, Channel is Receiving");
  1900. break;
  1902. default :
  1903. break;
  1905. }
  1906. */
  1907. /*
  1908. conn.CloseLogicalChannel(RTP_Session::DefaultAudioSessionID,FALSE);
  1910. //H323ChannelNumber num = tmpChan->GetSessionID();
  1911. conn.CloseLogicalChannel(tmpChan->GetSessionID(),FALSE);
  1912. conn.ClearCall();
  1913. PIndirectChannel::Close();
  1914. conn.~MyH323Connection();
  1915. conn.CleanUpOnCallEnd(); 
  1916. closed = TRUE; */
  1918. //delete tmpChan;
  1919. //delete tmpConn;
  1922. return FALSE;
  1923. }
  1924. //return TRUE;
  1925. }
  1926. PTRACE(1, "FINISHED WAITINGGGGGGGGGGGGGGGGGGGGGGGGGGGG recordDTMFTrigger" << recordDTMFTrigger);
  1928. //conn.ClearCall();
  1929. return TRUE;
  1930. }
  1931. }
  1932. }
  1933.   }
  1935.   // start silence frame if required
  1936.   if (doSilence) {
  1937.     CreateSilenceFrame(amount);
  1938.     frameBoundary = AdjustFrame(buffer, amount);
  1939.   }
  1941.   // delay to synchronise to frame boundary
  1942.   if (frameBoundary)
  1943. Synchronise(amount);
  1945. return TRUE;
  1946. }
  1948. BOOL PCM_OGMChannel::Close()
  1949. {
  1950.   PWaitAndSignal mutex(chanMutex);
  1951.   closed = TRUE;
  1952.   PIndirectChannel::Close();
  1953.   return TRUE;
  1954. }
  1956. void PCM_OGMChannel::SetRecordTrigger()
  1957. {
  1958.   PWaitAndSignal mutex(chanMutex);
  1959.   recordTrigger = TRUE;
  1960.   if ((playQueue.GetSize() == 0) && (GetBaseReadChannel() == NULL))
  1961.     conn.StartRecording();
  1962. }
  1964. void PCM_OGMChannel::SetHangupTrigger()
  1965. {
  1966.   PWaitAndSignal mutex(chanMutex);
  1967.   hangupTrigger = TRUE;
  1968.   if (GetBaseReadChannel() == NULL)
  1969.     conn.ClearCall();
  1970. }
  1972. void PCM_OGMChannel::QueueFile(const PString & fn)
  1973. {
  1974.   PWaitAndSignal mutex(chanMutex);
  1975.   PTRACE(1, "Enqueueing file " << fn << " for playing");
  1976.   fnAgain = fn;
  1977.   PTRACE(1, "Value of fnAgain.......######" <<fnAgain);
  1978.   playQueue.Enqueue(new PString(fn));
  1979. }
  1981. void PCM_OGMChannel::FlushQueue()
  1982. {
  1983.   PWaitAndSignal mutex(chanMutex);
  1985.   if (GetBaseReadChannel() != NULL) {
  1986.     PIndirectChannel::Close();
  1987.     if (hangupTrigger) 
  1988.       conn.ClearCall();
  1989.     else if (recordTrigger) 
  1990.       conn.StartRecording();
  1991.   }
  1993.   PString * str;
  1994.   while ((str = playQueue.Dequeue()) != NULL)
  1995.     delete str;
  1996. }
  1998. BOOL PCM_OGMChannel::AdjustFrame(void * buffer, PINDEX amount)
  1999. {
  2000.   if ((frameOffs + amount) > frameLen) {
  2001.     cerr << "Reading past end of frame:offs=" << frameOffs << ",amt=" << amount << ",len=" << frameLen << endl;
  2002.     return TRUE;
  2003.   }
  2004.   //PAssert((frameOffs + amount) <= frameLen, "Reading past end of frame");
  2006.   memcpy(buffer, frameBuffer.GetPointer()+frameOffs, amount);
  2007.   frameOffs += amount;
  2009.   lastReadCount = amount;
  2011.   return frameOffs == frameLen;
  2012. }
  2014. void PCM_OGMChannel::Synchronise(PINDEX amount)
  2015. {
  2016.   ogm_delay.Delay(amount / 16);
  2017. }
  2019. BOOL PCM_OGMChannel::ReadFrame(PINDEX amount)
  2020. {
  2021.   BOOL result;
  2022.   frameOffs = 0;
  2023.   frameLen  = amount;
  2026.   result = PIndirectChannel::Read(frameBuffer.GetPointer(), frameLen); //This is the Read method being actually called..
  2027.   PTRACE(1, "result in ReadFrame is " << result);
  2028.   // if we did not read a full frame of audio, fill the end of the
  2029.   // frame with zeros.
  2030.   PINDEX count = GetLastReadCount();
  2031.   if (count < frameLen)
  2032.   {
  2033.     memset(frameBuffer.GetPointer()+count, 0, frameLen-count);
  2034. PTRACE(1,"memset occured in ReadFrame");
  2035.   }
  2036.   return result;
  2037. }
  2039. void PCM_OGMChannel::CreateSilenceFrame(PINDEX amount)
  2040. {
  2041.   frameOffs = 0;
  2042.   frameLen  = amount;
  2043.   memset(frameBuffer.GetPointer(), 0, frameLen);
  2044. }
  2045.  
  2046. ///////////////////////////////////////////////////////////////
  2048. G7231_OGMChannel::G7231_OGMChannel(MyH323Connection & conn)
  2049.   : PCM_OGMChannel(conn)
  2050. {
  2051. }
  2053. void G7231_OGMChannel::Synchronise(PINDEX /*amount*/)
  2054. {
  2055.   ogm_delay.Delay(30);
  2056. }
  2058. BOOL G7231_OGMChannel::ReadFrame(PINDEX /*amount*/)
  2059. {
  2060.   if (!PIndirectChannel::Read(frameBuffer.GetPointer(), 1))
  2061.     return FALSE;
  2063.   frameOffs = 0;
  2064.   frameLen = G7231_File_Codec::GetFrameLen(frameBuffer[0]);
  2066.   return PIndirectChannel::Read(frameBuffer.GetPointer()+1, frameLen-1);
  2067. }
  2069. void G7231_OGMChannel::CreateSilenceFrame(PINDEX /*amount*/)
  2070. {
  2071.   frameOffs = 0;
  2072.   frameLen  = 4;
  2074.   frameBuffer[0] = 2;
  2075.   memset(frameBuffer.GetPointer()+1, 0, 3);
  2076. }
  2078. BOOL G7231_OGMChannel::IsWAVFileValid(PWAVFile *chan) {
  2079.   // Check that this is a G.723.1 wave file
  2080.   return CheckWAVFileValid(chan, CHECK_G7231);
  2081. }
  2083. ///////////////////////////////////////////////////////////////
  2085. PString H323BeaconServer::getLocalhostIPAddress()
  2086. {
  2087.   PString hostname ; // stores local host name
  2088.     
  2089.   //Get local host IP address
  2090.   hostent FAR *lpHostEnt = gethostbyname ( hostname ) ;
  2092.   if ( lpHostEnt == NULL )
  2093. cout << "IPAddress not available";
  2095.   LPSTR lpAddr = lpHostEnt -> h_addr_list[0] ;
  2097.   if ( lpAddr )
  2098.   { 
  2099. in_addr inAddr ;
  2100. memmove ( &inAddr, lpAddr, 4 ) ;
  2101. IPAddress = inet_ntoa ( inAddr ) ;
  2102. if ( IPAddress.IsEmpty( ) ) 
  2103. cout << "IPAddress not available"; 
  2104.   }
  2105.   return IPAddress;
  2106. }
  2108. /*
  2109. int MyH323Connection::SendTraceRtToClient(PString clientIP, PString *message)
  2110. {
  2112. // WORD nport=5050;
  2113. int rt=0;
  2114. // sock=new PSocket();
  2115. //PChannel chan;
  2116. //PIPXSocket  sock(nport);
  2117. //sock.port(nport);
  2119. char  temp[100];
  2120. char *ip;
  2122. strcpy(temp,clientIP);
  2123. // cout<< "TEMP: "<<temp<<"n";
  2125. ip=strtok(temp,"$");
  2126. ip=strtok(NULL,":");
  2128. char msg[2048]= "";
  2129. PFile fp("ft_result",PFile::ReadOnly,PFile::ModeDefault);
  2130. fp.read(msg,2048);
  2132. SOCKET writeSocket;
  2133.     writeSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
  2136. sockaddr_in service;
  2137.     service.sin_family = AF_INET;
  2138.     service.sin_addr.s_addr = inet_addr(ip);
  2139.     service.sin_port = htons(5051);
  2142. cout <<"Trying to Send the traceRT to client "<< ip<<"n";
  2143. PTRACE(1,"Trying to Send the traceRT to clientn");
  2144. PTRACE(1,ip);
  2146. //char msg[1024] = "MSG FROM SERVER: TRACERT: 1 2 3 4 5 6 7 8 9 10n";
  2148. if (connect (writeSocket, (SOCKADDR*) &service, sizeof(service)) == SOCKET_ERROR) {
  2149. PTRACE(1,"Connection  to client,failed for  traceRT filen");
  2150. }
  2151. else {
  2152. PTRACE(1,"Connection Established to client, sending traceRT filen");
  2153. if(send(writeSocket,msg,sizeof(msg),0)>0) {
  2154. rt=1;
  2155. PTRACE(1,"TRACERT: Successfully writing to client....n");
  2156. }else {
  2157. PTRACE(1,"TRACERT: Send failed....n");
  2158. }
  2159. }
  2163. closesocket (writeSocket);
  2165. return rt;
  2166. }
  2167. */
  2169. int MyH323Connection::log_server(){
  2170.  
  2171. //----------------------
  2172.   // Initialize Winsock
  2173.   WSADATA wsaData;
  2174.   int iResult = WSAStartup(MAKEWORD(2,2), &wsaData);
  2175.   if (iResult != NO_ERROR)
  2176.     printf("Error at WSAStartup()n");
  2178.   //----------------------
  2182. SOCKET ListenSocket;
  2183.     ListenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
  2184.     if (ListenSocket == SOCKET_ERROR) {
  2185.     printf("Error at socket(): %ldn", WSAGetLastError());
  2186.     printf("Error at socket()n");
  2187.     WSACleanup();
  2188.     return 1;
  2189.   }
  2191.   //----------------------
  2193.   //----------------------
  2194.   // The sockaddr_in structure specifies the address family,
  2195.   // IP address, and port for the socket that is being bound.
  2196.   sockaddr_in service;
  2197.   service.sin_family = AF_INET;
  2198.   service.sin_addr.s_addr = inet_addr("0.0.0.0");
  2199.   service.sin_port = htons(SRVPORT);
  2200.   
  2201.   //create a structure for the client address
  2202.   //sockaddr_in clientaddr;
  2203.   //unsigned int clntLen;
  2205.   //Set the socket options to reuse the socket address to avoid bind failures
  2207.   //int opt=1;
  2208.   char optval[5] = "TRUE"; 
  2209.   //unsigned long optval =1;
  2210.   if(setsockopt(ListenSocket, SOL_SOCKET, SO_REUSEADDR, optval, sizeof(optval))==SOCKET_ERROR){
  2211. cout<<"Error setting the reuse address optionn";
  2212.   }
  2213.   
  2214.   if (bind( ListenSocket,
  2215.     (struct sockaddr *) &service,
  2216.     sizeof(service)) != 0) {
  2217.     printf("bind() failed.n");
  2218.     close(ListenSocket);
  2219.     return 1;
  2220.   } 
  2222.  //----------------------
  2223.   // Listen for incoming connection requests
  2224.   // on the created socket
  2225.   if (listen( ListenSocket, 1 ) != 0)
  2226.     printf("Error listening on socket.n");
  2228.   //----------------------
  2229.   // Create a SOCKET for accepting incoming requests.
  2230.   SOCKET AcceptSocket;
  2231.   //int AcceptSocket;
  2232.   printf("Waiting for client to connect...nWill timeout in 15 secsn");
  2233.   //printf("before forn");
  2236. //        int nLen = sizeof(struct sockaddr);
  2237.         char buf[1024];
  2238.         int line = 1;
  2240.         FILE *log;
  2242. //printf("Making socket non-blockingn");
  2243.         //----------------------
  2244.   // Accept the connection.
  2245. //fcntl(ListenSocket, F_SETFL, O_NONBLOCK);
  2246. long par=1;
  2247. if(ioctlsocket (ListenSocket, FIONBIO,(unsigned long *)&par)==SOCKET_ERROR){
  2248. cout<<"Cant set socket to non-blocking moden";
  2249. }
  2251.   //while(1) {
  2252. //printf("before forn");
  2253.         AcceptSocket = INVALID_SOCKET;
  2254.         int i=0;
  2255. //AcceptSocket = accept( ListenSocket, NULL, NULL );
  2256. //printf("before forn");
  2257.         for (i=0;i<15;i++){
  2258. //printf("just inside forn");
  2259. if( AcceptSocket == INVALID_SOCKET ) {
  2260.     if (i==14) {
  2261. printf("Client didnt connect Timed outn");
  2262. shutdown (AcceptSocket,2);
  2263. shutdown (ListenSocket,2);
  2264. close (AcceptSocket);
  2265. close (ListenSocket);
  2266. return 0;
  2267. }
  2268. //printf("Sleeping for a second: %dn",i);
  2269.             Sleep(1000);
  2270. AcceptSocket = accept( ListenSocket, NULL, NULL );
  2271. }
  2272.             else {
  2273. //printf("I am in elsen");
  2274. //AcceptSocket = accept( ListenSocket, (struct sockaddr *) &clientaddr, &clntLen );
  2275.                 //AcceptSocket = accept( ListenSocket, NULL, NULL );
  2276. break;
  2277.             }
  2279.         }
  2280. printf("nClient connected...");
  2282.         if(!(log=fopen(LOG_H323,"r")))
  2283.         {
  2284.                 printf("nFailed on opening LOG_H323");
  2285.         }
  2286.         else
  2287.         {
  2288.                 printf("nSending log file...");
  2289.                 while(1)
  2290.                 {
  2291.                         fgets(buf,line,log);
  2292.                         send( AcceptSocket, buf, strlen(buf), 0 );
  2293.                         line++;
  2294.                         if (feof(log)) break;
  2295.                 }
  2296.                 printf("nThe file log was sent!");
  2298.         fclose(log);
  2299.         }
  2301. shutdown (AcceptSocket,2);
  2302. shutdown (ListenSocket,2);
  2303.         close (AcceptSocket);
  2304. close (ListenSocket);
  2308.   //}
  2310.   WSACleanup();
  2312.   return 1;
  2315. }