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

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

IP电话/视频会议

开发平台：

Visual C++

main.cxx：源码内容
  1. /*
  2.  * main.cxx
  3.  *
  4.  * PWLib application source file for Voxilla
  5.  *
  6.  * A H.323 "net telephone" application.
  7.  *
  8.  * Copyright (c) 1993-1998 Equivalence Pty. Ltd.
  9.  *
  10.  * The contents of this file are subject to the Mozilla Public License
  11.  * Version 1.0 (the "License"); you may not use this file except in
  12.  * compliance with the License. You may obtain a copy of the License at
  13.  * http://www.mozilla.org/MPL/
  14.  *
  15.  * Software distributed under the License is distributed on an "AS IS"
  16.  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
  17.  * the License for the specific language governing rights and limitations
  18.  * under the License.
  19.  *
  20.  * The Original Code is Portable Windows Library.
  21.  *
  22.  * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
  23.  *
  24.  * Portions of this code were written with the assisance of funding from
  25.  * Vovida Networks, Inc. http://www.vovida.com.
  26.  *
  27.  * Portions are Copyright (C) 1993 Free Software Foundation, Inc.
  28.  * All Rights Reserved.
  29.  *
  30.  * Contributor(s): ______________________________________.
  31.  *
  32.  * $Log: main.cxx,v $
  33.  * Revision 1.24  2000/06/20 02:38:27  robertj
  34.  * Changed H323TransportAddress to default to IP.
  35.  *
  36.  * Revision 1.23  2000/06/17 09:14:52  robertj
  37.  * Added setting of closed flag when closing OGM.
  38.  *
  39.  * Revision 1.22  2000/05/25 13:25:47  robertj
  40.  * Fixed incorrect "save" parameter specification.
  41.  *
  42.  * Revision 1.21  2000/05/25 12:06:17  robertj
  43.  * Added PConfigArgs class so can save program arguments to config files.
  44.  *
  45.  * Revision 1.20  2000/05/11 11:47:11  robertj
  46.  * Fixed alpha linux GNU compiler problems.
  47.  *
  48.  * Revision 1.19  2000/05/10 05:14:25  robertj
  49.  * Changed capabilities so has a function to get name of codec, instead of relying on PrintOn.
  50.  *
  51.  * Revision 1.18  2000/05/09 11:22:15  craigs
  52.  * Fixed problems caused by new jitter buffer code
  53.  * and fixed OGM problems
  54.  *
  55.  * Revision 1.17  2000/05/09 02:41:32  craigs
  56.  * Added extra debugging, and fixed problems with OGM in non-IVR mode
  57.  *
  58.  * Revision 1.16  2000/04/26 03:18:38  craigs
  59.  * Fixed problem when GSM specified as preferred codec
  60.  *
  61.  * Revision 1.15  2000/04/25 23:34:22  craigs
  62.  * Added lots of new code, including outgoing and incoming
  63.  * multiplexors, and the start of an IVR system
  64.  *
  65.  * Revision 1.14  2000/01/13 04:03:45  robertj
  66.  * Added video transmission
  67.  *
  68.  * Revision 1.13  2000/01/07 08:28:09  robertj
  69.  * Additions and changes to line interface device base class.
  70.  *
  71.  * Revision 1.12  1999/12/10 01:44:46  craigs
  72.  * Added ability to set interface
  73.  *
  74.  * Revision 1.11  1999/12/01 04:38:25  robertj
  75.  * Added gatekeeper support to OpenAM
  76.  *
  77.  * Revision 1.10  1999/11/11 00:27:49  robertj
  78.  * Changed OnAnswerCall() call back function  to allow for asyncronous response.
  79.  *
  80.  * Revision 1.9  1999/11/06 13:27:48  craigs
  81.  * Added extra output and changed for new library changes
  82.  *
  83.  * Revision 1.8  1999/10/29 10:57:04  robertj
  84.  * Added answering machine project.
  85.  *
  86.  * Revision 1.7  1999/10/24 12:50:37  craigs
  87.  * Fixed G723.1 capability, and added ability for discrete OGMs
  88.  *
  89.  * Revision 1.6  1999/10/24 08:24:56  craigs
  90.  * Added GSM capability back in
  91.  *
  92.  * Revision 1.5  1999/10/24 08:19:58  craigs
  93.  * Fixed problem that caused crash when unknown codecs used
  94.  *
  95.  * Revision 1.4  1999/10/24 03:29:07  craigs
  96.  * Fixed problem with -h parsing
  97.  *
  98.  * Revision 1.3  1999/10/24 03:08:49  craigs
  99.  * Fixed problem with recording zero length messages, and added autodelete of files
  100.  *
  101.  * Revision 1.2  1999/10/22 09:56:24  craigs
  102.  * Fixed various compile warnings
  103.  *
  104.  * Revision 1.1  1999/10/11 00:15:18  craigs
  105.  * Initial version
  106.  *
  107.  */
  109. #include <ptlib.h>
  110. #include <ptlib/pipechan.h>
  112. #include "main.h"
  113. #include "version.h"
  115. PCREATE_PROCESS(OpenAm);
  117. #define new PNEW
  119. #define DEFAULT_MSG_LIMIT 30
  120. #define DEFAULT_CALL_LOG "call_log.txt"
  122. #define G7231_BLOCK_SIZE 24
  123. #define G7231_SAMPLES_PER_BLOCK 240
  124. #define G7231_BANDWIDTH 63
  126. #define MENU_PREFIX "UserMenu-"
  128. static PMutex logMutex;
  129. static PTextFile logFile;
  130. static PFilePath logFilename = DEFAULT_CALL_LOG;
  132. static PString G7231Ext = ".g723";
  133. static PString PCMExt   = ".sw";
  135. static void LogMessage(const PString & str)
  136. {
  137.   PTime now;
  138.   PString msg = now.AsString("hh:mm:ss dd/MM/yyyy") & str;
  139.   logMutex.Wait();
  141.   if (!logFile.IsOpen()) {
  142.     logFile.Open(logFilename, PFile::ReadWrite);
  143.     logFile.SetPosition(0, PFile::End);
  144.   }
  146.   logFile.WriteLine(msg);
  148.   logFile.Close();
  149.   
  150.   logMutex.Signal();
  151. }
  153. static void LogCall(const PFilePath & fn,
  154.                     const PString & from,
  155.                     const PString & user,
  156.                     unsigned len,
  157.                     const PString & codec,
  158.                     const PString & product)
  159. {
  160.   PString addr = from;
  161.   LogMessage(addr & """ + user + """ & PString(PString::Unsigned, len) & codec & """ + product + """ & """ + fn + """);
  162. }
  165. ///////////////////////////////////////////////////////////////
  167. OpenAm::OpenAm()
  168.   : PProcess("OpenH323 Project", "OpenAm",
  169.              MAJOR_VERSION, MINOR_VERSION, BUILD_TYPE, BUILD_NUMBER)
  170. {
  171. }
  174. OpenAm::~OpenAm()
  175. {
  176. }
  179. void OpenAm::Main()
  180. {
  181.   cout << GetName()
  182.        << " Version " << GetVersion(TRUE)
  183.        << " by " << GetManufacturer()
  184.        << " on " << GetOSClass() << ' ' << GetOSName()
  185.        << " (" << GetOSVersion() << '-' << GetOSHardware() << ")nn";
  187.   //PArgList & args = GetArguments();
  188.   PConfigArgs args(GetArguments());
  190.   args.Parse(
  191.              "d-directory:"
  192.              "g-gatekeeper:"         "n-no-gatekeeper."
  193.              "-require-gatekeeper."  "-no-require-gatekeeper."
  194.              "-g7231message:"        "-no-g7231message."
  195.              "-g711message:"         "-no-g711message."
  196.              "-gsmmessage:"          "-no-gsmmessage."
  197.              "-no-recordg7231."
  198.              "-gsm."                 "-no-gsm."
  199.              "-g711-ulaw."           "-no-g711-ulaw."
  200.              "-g711-alaw."           "-no-g711-alaw."
  201.              "-g7231."               "-no-g7231."
  202.              "h-help."
  203.              "i-interface:"          "-no-interface."
  204.              "k-kill."               "-no-kill."
  205.              "l-limit:"              "-no-limit."
  206.              "m-pcmmessage:"         "-no-message."
  207. #if PTRACING
  208.              "o-output:"
  209. #endif
  210.              "r-run:"                "-no-run."
  211.              "-save."
  212. #if PTRACING
  213.              "t-trace."
  214. #endif
  215.      "u-username:"           "-no-username."
  216.           , FALSE);
  218. #if PTRACING
  219.   PTrace::SetOptions(PTrace::Timestamp | PTrace::Thread);
  220.   PTrace::SetLevel(args.GetOptionCount('t'));
  221.   if (args.HasOption('o')) {
  222.     /* This is a bit tricky. We allocate the file for tracing on the heap, and
  223.        we never actually deallocate it. So it come up as a leak on exit if
  224.        memory checking is on. We cannot deallocate it as during termination
  225.        some PTRACE's may get executed and attempt to trace to a closed (and
  226.        deleted!) file object which crashes. Not good.
  227.      */
  228.     PTextFile * output = new PTextFile;
  229.     if (output->Open(args.GetOptionString('o'), PFile::WriteOnly))
  230.       PTrace::SetStream(output);
  231.     else {
  232.       cout << "Warning: could not open trace output file ""
  233.            << args.GetOptionString('o') << '"' << endl;
  234.       delete output;
  235.     }
  236.   }
  237.   PTRACE(1, GetName()
  238.          << " Version " << GetVersion(TRUE)
  239.          << " by " << GetManufacturer()
  240.          << " on " << GetOSClass() << ' ' << GetOSName()
  241.          << " (" << GetOSVersion() << '-' << GetOSHardware() << ')');
  242. #endif
  244.   if (args.HasOption('h')) {
  245.     cout << "Usage : " << GetName() << " [options]n"
  246.             "Options:n"
  247.             "  -d --directory dir  : Put recorded mesages into dirn"
  248.             "  -l --limit secs     : Limit recorded messages to secs duration (default " << DEFAULT_MSG_LIMIT << ")n"
  249.             "  -m --pcmmessage fn  : Set outgoing message for PCM derived codecs (G.711/GSM) to fnn"
  250.             "  --g7231message fn   : Set outgoing message for G723.1 codec to fnn"
  251.             "  --g711message fn    : Set outgoing message for G711 codec to fnn"
  252.             "  --gsmmessage fn     : Set outgoing message for GSM codec to fnn"
  253.             "  -r --run cmd        : Run this command after each recorded messagen"
  254.             "  -k --kill           : Kill recorded files after user commandn"
  255.             "  -u --username str   : Set the local endpoint name to strn"
  256.             "  -i --interface ip   : Bind to a specific interfacen"
  257.             "  -g --gatekeeper host: Specify gatekeeper host.n"
  258.             "  -n --no-gatekeeper  : Disable gatekeeper discovery.n"
  259.             "  --require-gatekeeper: Exit if gatekeeper discovery fails.n"
  260. #if PTRACING
  261.             "  -t --trace          : Enable trace, use multiple times for more detailn"
  262.             "  -o --output         : File for trace output, default is stderrn"
  263. #endif
  264.             "     --save           : Save arguments in configuration filen"
  265.             "  -h --help           : Display this help messagen";
  266.     return;
  267.   }
  269.   args.Save("save");
  271. #ifdef HAS_CMDS
  272.   if (args.GetCount() > 0) {
  273.     if (args[0] *= "record") 
  274.       RecordFile(args);
  275.     else if (args[0] *= "play") 
  276.       PlayFile(args);
  277.     else
  278.       cerr << "unknown command "" << args[0] << """ << endl;
  279.     return;
  280.   }
  281. #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 << "Recorded messages limited to " << callLimit << " secondsn";
  295.   PString runCmd;
  296.   if (args.HasOption('r')) {
  297.     runCmd = args.GetOptionString('r');
  298.     cout << "Executing "" << runCmd << "" after each message" << endl;
  299.   }
  301.   PDirectory dir;
  302.   if (args.HasOption('d'))
  303.     dir = args.GetOptionString('d');
  305.   int flags = 0;
  307.   if (args.HasOption("no-recordg7231")) {
  308.     cout << "Supressing recording of G723.1 messages" << endl;
  309.     flags |= MyH323EndPoint::NoRecordG7231;
  310.   }
  311.   if (args.HasOption('k')) {
  312.     cout << "Deleting recorded files after processing" << endl;
  313.     if (runCmd.IsEmpty()) 
  314.       cout << "WARNING: recorded files will be deleted even though no run command is present" << endl;
  315.     flags |= MyH323EndPoint::DeleteAfterRecord;
  316.   }
  317.   
  318.   MyH323EndPoint endpoint(callLimit, runCmd, dir, flags);
  320.   PString userName = "OpenH323 Answering Machine v" + GetVersion();
  321.   if (args.HasOption('u'))
  322.     userName = args.GetOptionString('u');
  323.   endpoint.SetLocalUserName(userName);
  325.   BOOL g7231Disable  = args.HasOption("no-g7231");
  326.   BOOL gsmDisable    = args.HasOption("no-gsm");
  327.   BOOL ulaw64Disable = args.HasOption("no-g711-ulaw");
  329.   if (g7231Disable && gsmDisable && ulaw64Disable) {
  330.     cerr << "Cannot disable all codecs - please enable one of GSM, G723.1 or G.711 uLaw64" << endl;
  331.     return;
  332.   }
  334.   H323Capability * g7231  = NULL;
  335.   H323Capability * gsm    = NULL;
  336.   H323Capability * ulaw64 = NULL;
  338.   // get G723.1 OGM
  339.   PString g7231Ogm;
  340.   if (!g7231Disable) {
  341.     if (args.HasOption("g7231message")) {
  342.       PFilePath fn = g7231Ogm = args.GetOptionString("g7231message");
  343.       if (!PFile::Exists(fn + G7231Ext)) {
  344.         cout << "warning: cannot open G723.1 OGM file "" << (fn + G7231Ext) << """ << endl;
  345.         g7231Ogm = "";
  346.       } 
  347.     }
  348.     if (g7231Ogm.IsEmpty()) 
  349.       cout << "No G.723.1 outgoing message setn";
  350.     else {
  351.       cout << "Using "" << (g7231Ogm + G7231Ext) << "" as G.723.1 outgoing messagen";
  352.       endpoint.SetG7231OGM(g7231Ogm);
  353.     }
  354.     g7231  = new G7231_File_Capability;
  355.     if (args.HasOption("g7231"))
  356.       endpoint.AddCapability(g7231);
  357.   }
  359.   // get PCM OGM message which will do for GSM and G711
  360.   PString pcmOgm;
  361.   if (args.HasOption('m')) 
  362.     pcmOgm = args.GetOptionString('m');
  364.   // get GSM OGM message 
  365.   PString gsmOgm = pcmOgm;
  366.   if (!gsmDisable) {
  367.     if (args.HasOption("gsmmessage")) 
  368.       gsmOgm = args.GetOptionString("gsmmessage");
  370.     PFilePath fn = gsmOgm;
  371.     if (!PFile::Exists(fn + PCMExt)) {
  372.       cout << "warning: cannot open GSM OGM file "" << (fn + PCMExt) << """ << endl;
  373.       gsmOgm = "";
  374.     } 
  375.     if (gsmOgm.IsEmpty()) 
  376.       cout << "No GSM outgoing message setn";
  377.     else {
  378.       cout << "Using "" << gsmOgm << "" as GSM outgoing messagen";
  379.       endpoint.SetGSMOGM(gsmOgm);
  380.     }
  381.     gsm    = new H323_GSM0610Capability;
  382.     if (args.HasOption("gsm"))
  383.       endpoint.AddCapability(gsm);
  384.   }
  386.   // get G.711 OGM message 
  387.   PString g711Ogm = pcmOgm;
  388.   if (!ulaw64Disable) {
  389.     if (args.HasOption("g711message")) 
  390.       g711Ogm = args.GetOptionString("g711message");
  392.     PFilePath fn = g711Ogm;
  393.     if (!PFile::Exists(fn + PCMExt)) {
  394.       cout << "warning: cannot open G711 OGM file "" << (fn + PCMExt) << """ << endl;
  395.       g711Ogm = "";
  396.     } 
  397.     if (g711Ogm.IsEmpty()) 
  398.       cout << "No G711 outgoing message setn";
  399.     else {
  400.       cout << "Using "" << g711Ogm << "" as G.711 outgoing messagen";
  401.       endpoint.SetG711OGM(g711Ogm);
  402.     }
  403.     ulaw64 = new H323_G711Capability(H323_G711Capability::muLaw, H323_G711Capability::At64k);
  404.     if (args.HasOption("g711-ulaw"))
  405.       endpoint.AddCapability(ulaw64);
  406.   }
  408.   if ((g7231 == NULL) && (gsm == NULL) && (ulaw64 == NULL)) {
  409.     cerr << "Cannot disable all capabilites - please enable one of GSM, G723.1 or G.711 uLaw64" << endl;
  410.     return;
  411.   }
  413.   if (g7231 != NULL)
  414.     endpoint.SetCapability(0, 0, g7231);
  416.   if (gsm != NULL)
  417.     endpoint.SetCapability(0, 0, gsm);
  419.   if (ulaw64 != NULL)
  420.     endpoint.SetCapability(0, 0, ulaw64);
  422.   // start the H.323 listener
  423.   H323ListenerTCP * listener;
  424.   if (args.GetOptionString('i').IsEmpty())
  425.     listener  = new H323ListenerTCP(endpoint);
  426.   else {
  427.     PIPSocket::Address interfaceAddress(args.GetOptionString('i'));
  428.     listener  = new H323ListenerTCP(endpoint, interfaceAddress);
  429.   }
  430.   if (!endpoint.StartListener(listener)) {
  431.     cout <<  "Could not open H.323 listener port on "
  432.          << listener->GetListenerPort() << endl;
  433.     return;
  434.   }
  436.   if (args.HasOption('g')) {
  437.     PString gkName = args.GetOptionString('g');
  438.     if (endpoint.SetGatekeeper(gkName, new H323TransportUDP(endpoint)))
  439.       cout << "Gatekeeper set: " << *endpoint.GetGatekeeper() << endl;
  440.     else {
  441.       cout << "Error registering with gatekeeper at "" << gkName << '"' << endl;
  442.       return;
  443.     }
  444.   }
  445.   else if (!args.HasOption('n')) {
  446.     cout << "Searching for gatekeeper..." << flush;
  447.     if (endpoint.DiscoverGatekeeper(new H323TransportUDP(endpoint)))
  448.       cout << "nGatekeeper found: " << *endpoint.GetGatekeeper() << endl;
  449.     else {
  450.       cout << "nNo gatekeeper found." << endl;
  451.       if (args.HasOption("require-gatekeeper"))
  452.         return;
  453.     }
  454.   }
  456.   endpoint.ListenForIncomingCalls();
  457.   endpoint.AwaitTermination();
  458. }
  461. ///////////////////////////////////////////////////////////////
  463. G7231_File_Capability::G7231_File_Capability()
  464.  : H323AudioCapability(12*G7231_BLOCK_SIZE, 4*G7231_BLOCK_SIZE)
  465. {
  466. }
  468. PString G7231_File_Capability::GetFormatName() const
  469. {
  470.   return "G723.1";
  471. }
  473. BOOL G7231_File_Capability::OnSendingPDU(H245_AudioCapability & cap, unsigned packetSize) const
  474. {
  475.   // set the choice to the correct type
  476.   cap.SetTag(GetSubType());
  478.   // get choice data
  479.   H245_AudioCapability_g7231 & g7231 = cap;
  481.   // max number of audio frames per PDU we want to send
  482.   g7231.m_maxAl_sduAudioFrames = packetSize; //G7231_BLOCK_SIZE;
  484.   // no silence suppression
  485.   g7231.m_silenceSuppression = FALSE;
  487.   return TRUE;
  488. }
  490. BOOL G7231_File_Capability::OnReceivedPDU(const H245_AudioCapability & cap, unsigned & packetSize)
  491. {
  492.   const H245_AudioCapability_g7231 & g7231 = cap;
  493.   packetSize = g7231.m_maxAl_sduAudioFrames*G7231_BLOCK_SIZE;
  494.   return TRUE;
  495. }
  497. PObject * G7231_File_Capability::Clone() const
  498. {
  499.   return new G7231_File_Capability();
  500. }
  502. H323Codec * G7231_File_Capability::CreateCodec(H323Codec::Direction direction) const
  503. {
  504.   return new G7231_File_Codec(direction);
  505. }
  507. ///////////////////////////////////////////////////////////////
  509. G7231_File_Codec::G7231_File_Codec(Direction dir)
  510. : H323AudioCodec(dir, G7231_SAMPLES_PER_BLOCK)
  511. {
  512.   rtpPayloadType = RTP_DataFrame::G7231;
  513. }
  515. BOOL G7231_File_Codec::Read(BYTE * buffer, unsigned & length, RTP_DataFrame &)
  516. {
  517.   if (rawDataChannel == NULL)
  518.     return FALSE;
  519.     
  520.   BOOL stat = rawDataChannel->Read(buffer, G7231_BLOCK_SIZE);
  521.   if (!stat)
  522.     return FALSE;
  524.   if (rawDataChannel->GetLastReadCount() == 0)
  525.     length = 0;
  526.   else
  527.     length = G7231_BLOCK_SIZE;
  529.   return TRUE;
  530. }
  532. BOOL G7231_File_Codec::Write(const BYTE * buffer, unsigned length, const RTP_DataFrame & /* rtp */, unsigned & writtenLength)
  533. {
  534.   writtenLength = G7231_BLOCK_SIZE;
  536.   if (length == 0)
  537.     return TRUE;
  539.   return rawDataChannel->Write(buffer, writtenLength);
  540. }
  542. unsigned G7231_File_Codec::GetBandwidth() const      { return G7231_BANDWIDTH; }
  543.       
  544. ///////////////////////////////////////////////////////////////
  547. MyH323EndPoint::MyH323EndPoint(unsigned _callLimit,
  548.                                const PString & _runCmd,
  549.                                const PDirectory & _dir,
  550.                                int   _flags)
  551.   : callLimit(_callLimit), runCmd(_runCmd), dir(_dir), flags(_flags)
  552. {
  553. }
  555. H323Connection * MyH323EndPoint::CreateConnection(unsigned callReference)
  556. {
  557.   return new MyH323Connection(*this, callReference);
  558. }
  560. void MyH323EndPoint::ListenForIncomingCalls()
  561. {
  562.   cout << "Waiting for incoming calls for "" << GetLocalUserName() << '"' << endl;
  563. }
  566. void MyH323EndPoint::AwaitTermination()
  567. {
  568.   for (;;) {
  569.     PThread::Current()->Sleep(5000);
  570.   }
  571. }
  573. ///////////////////////////////////////////////////////////////
  575. RecordFile::RecordFile(MyH323Connection & _conn, const PFilePath & _fn, unsigned _callLimit)
  576.   : PFile(_fn, PFile::WriteOnly), conn(_conn), fn(_fn), callLimit(_callLimit)
  577. {
  578.   recordStarted = FALSE;
  579.   closed        = FALSE;
  580. }
  582. void RecordFile::StartRecording()
  583. {
  584.   if (recordStarted)
  585.     return;
  587.   PTRACE(1, "Starting recording to " << fn);
  589.   PTime now;
  590.   recordStarted = TRUE;
  591.   finishTime = now + (callLimit * 1000);
  592. }
  594. BOOL RecordFile::Close()
  595. {
  596.   closed = TRUE;
  597.   return PFile::Close();
  598. }
  600. BOOL RecordFile::Write(const void * buf, PINDEX len)
  601. {
  602.   if (closed)
  603.     return FALSE;
  605.   if (!recordStarted) 
  606.     return TRUE;
  608.   BOOL stat =  PFile::Write(buf, len);
  610.   PTime now;
  611.   if ((callLimit == 0) || (now <= finishTime)) 
  612.     PThread::Current()->Sleep(((int)len / 2) / 8);
  613.   else {
  614.     PTRACE(1, "Terminating call due to timeout");
  615.     conn.ClearCall();
  616.   }
  618.   return stat;
  619. }
  621. RecordFile::~RecordFile()
  622. {
  623.   if (!recordStarted) {
  624.     PTRACE(1, "Deleting " << fn << " as no data recorded");
  625.     PFile::Remove(fn);
  626.   }
  627. }
  629. ///////////////////////////////////////////////////////////////
  631. static BOOL MatchString(const PString & str1, const PString str2)
  632. {
  633.   if (str1.GetLength() != str2.GetLength())
  634.     return FALSE;
  636.   PINDEX len = str1.GetLength();
  638.   PINDEX i;
  639.   for (i = 0; i < len; i++) 
  640.     if ((str1[i] != '?') && (str2[i] != '?') && (str1[i] != str2[i]))
  641.       return FALSE;
  643.   return TRUE;
  644. }
  646. static PINDEX FindMatch(const PStringList & list, const PString & key)
  647. {
  648.   PINDEX maxKeyLen = 0;
  649.   PINDEX i;
  651.   PINDEX keyLen = key.GetLength();
  652.   PINDEX listLen = list.GetSize();
  654.   for (i = 0; i < listLen; i++)
  655.     maxKeyLen = PMAX(maxKeyLen, list[i].GetLength());
  657.   if (keyLen == 0 || maxKeyLen == 0)
  658.     return P_MAX_INDEX;
  660.   if (keyLen > maxKeyLen)
  661.     return P_MAX_INDEX;
  663.   PINDEX len = 1;
  664.   while (len <= keyLen) {
  665.     PString subStr = key.Left(len);
  667.     PINDEX matches = 0;
  668.     PINDEX lastMatch = P_MAX_INDEX;
  669.     PINDEX i;
  671.     // look for a match to the substring
  672.     for (i = 0; i < list.GetSize(); i++) {
  673.       if ((list[i].GetLength() >= keyLen) && MatchString(list[i].Left(len), subStr)) {
  674.         matches++;
  675.         lastMatch = i;
  676.       }
  677.     }
  679.     // if we got ONE match, we have a winner
  680.     if (matches == 1)
  681.       return lastMatch+1;
  683.     // if we have no matches, then there is no point continuing
  684.     if (matches == 0)
  685.       return P_MAX_INDEX;
  687.     // if we have more than one match, try the next char
  688.     len++;
  689.   }
  691.   // too many matches
  692.   return 0;
  693. }
  696. MyH323Connection::MyH323Connection(MyH323EndPoint & _ep, unsigned callReference)
  697.   : H323Connection(_ep, callReference), ep(_ep)
  698. {
  699.   basename = psprintf("%04i%02i%02i_%02i%02i%02i", callStartTime.GetYear(), callStartTime.GetMonth(),  callStartTime.GetDay(),
  700.                                                    callStartTime.GetHour(), callStartTime.GetMinute(), callStartTime.GetSecond());
  701.   recordFile = NULL;
  702.   ogmChannel = NULL;
  704.   receiveCodecName = transmitCodecName = "none";
  706.   cout << "Opening connection" << endl;
  708.   currentMenu = 0;
  709.   digits = "";
  711.   PConfig config;
  712.   PStringList sections = config.GetSections();
  713.   PINDEX i;
  714.   for (i = 0; i < sections.GetSize(); i++) {
  715.     if (sections[i].Find(MENU_PREFIX) == 0) 
  716.       menuNames.AppendString(sections[i]);
  717.   }
  719. }
  721. MyH323Connection::~MyH323Connection()
  722. {
  723.   cout << "Closing connection" << endl;
  725.   PTime now;
  726.   PTimeInterval interval = now - recordStartTime;
  727.   PString addr = GetControlChannel().GetRemoteAddress();
  729.   PString codecStr = receiveCodecName + "/" + transmitCodecName;
  730.   unsigned duration = (unsigned)((interval.GetMilliSeconds()+999)/1000);
  732.   LogCall(recordFn, addr, GetRemotePartyName(), duration, codecStr, product);
  734.   if ((recordFile!= NULL) && (recordFile->WasRecordStarted()) && !ep.GetRunCmd().IsEmpty()) {
  735.     PString cmdStr = ep.GetRunCmd() &
  736.                      recordFn &
  737.                      "'" + addr + "'" &
  738.                      """ + GetRemotePartyName() + """ &
  739.                      PString(PString::Unsigned, duration) &
  740.                      """ + codecStr + """ &
  741.                      """ + product + """;
  742.     PTRACE(1, "Executing : " << cmdStr);
  743.     system((const char *)cmdStr);
  744.   } else {
  745.     PTRACE(1, "No action to perform at end of record");
  746.   }
  749.   if (recordFile != NULL)
  750.     delete recordFile;
  752.   if (ep.GetDeleteAfterRecord()) {
  753.     PTRACE(1, "Removing " << recordFn << " as requested by option");
  754.     PFile::Remove(recordFn);
  755.   }
  756. }
  758. H323Connection::AnswerCallResponse
  759.      MyH323Connection::OnAnswerCall(const PString & caller,
  760.                                     const H323SignalPDU & setupPDU,
  761.                                     H323SignalPDU & /*connectPDU*/)
  762. {
  763.   product = "Unknown";
  765.   const H225_Setup_UUIE & setup = setupPDU.m_h323_uu_pdu.m_h323_message_body;
  766.   const H225_EndpointType & epInfo = setup.m_sourceInfo;
  768.   if (epInfo.HasOptionalField(H225_EndpointType::e_vendor)) {
  769.     const H225_VendorIdentifier & vendorInfo = epInfo.m_vendor;
  770.     if (vendorInfo.HasOptionalField(H225_VendorIdentifier::e_productId))
  771.       product = vendorInfo.m_productId.AsString();
  772.     if (vendorInfo.HasOptionalField(H225_VendorIdentifier::e_versionId))
  773.       product = product + "/" + vendorInfo.m_versionId.AsString();
  774.   }
  775.   
  776.   cout << "Accepting call from " << caller << " using " << product << endl;
  778.   return AnswerCallNow;
  779. }
  781. BOOL MyH323Connection::OpenAudioChannel(BOOL isEncoding, unsigned /* bufferSize */, H323AudioCodec & codec)
  782. {
  783.   codec.SetSilenceDetectionMode(H323AudioCodec::NoSilenceDetection);
  784.   PStringStream codecName;
  785.   codecName << codec;
  787.   PString ext;
  788.   PString ogm;
  789.   BOOL isPCM = FALSE;
  791.   if (codec.IsDescendant(G7231_File_Codec::Class())) {
  792.     ext   = ".g723";
  793.     ogm   = ep.GetG7231OGM();
  794.     isPCM = FALSE;
  795.   } else if (codec.IsDescendant(H323_GSM0610Codec::Class())) {
  796.     ogm   = ep.GetGSMOGM();
  797.     ext   = PCMExt;
  798.     isPCM = TRUE;
  799.   } else if (codec.IsDescendant(H323_muLawCodec::Class())) {
  800.     ogm   = ep.GetG711OGM();
  801.     ext   = PCMExt;
  802.     isPCM = TRUE;
  803.   } else {
  804.     cerr << "Unknown codec "" << codecName << endl;
  805.     return FALSE;
  806.   }
  808.   PWaitAndSignal mutex(connMutex);
  809.   if (recordFile == NULL) {
  810.     recordFn   = ep.GetDirectory() + (basename + ext);
  811.     recordFile = new RecordFile(*this, recordFn, ep.GetCallLimit());
  812.   }
  813.   if (ogmChannel == NULL) {
  814.     ogmChannel = new OGMChannel(*this);;
  815.   }
  817.   if (isEncoding) {
  818.     transmitCodecName = codecName;
  819.     ogmChannel->SetIsPCM(isPCM);
  820.     ogmChannel->SetExtension(ext);
  821.     if (!StartMenu(0)) {
  822.       if (!PFile::Exists(ogm + ext))
  823.         cerr << "error: cannot find OGM "" << (ogm + ext) << """ << endl;
  824.       else
  825.         ogmChannel->QueueFile(ogm);
  826.       if (!ep.GetNoRecordG7231())
  827.         ogmChannel->SetRecordTrigger();
  828.     }
  829.     codec.AttachChannel(ogmChannel, FALSE);
  830.   } else {
  831.     receiveCodecName = codecName;
  832.     codec.AttachChannel(recordFile, FALSE);
  833.   }
  835.   return TRUE;
  836. }
  838. BOOL MyH323Connection::OnStartLogicalChannel(H323Channel & channel)
  839. {
  840.   if (!H323Connection::OnStartLogicalChannel(channel))
  841.     return FALSE;
  843.   cout << "Started logical channel: ";
  845.   switch (channel.GetDirection()) {
  846.     case H323Channel::IsTransmitter :
  847.       cout << "sending ";
  848.       break;
  850.     case H323Channel::IsReceiver :
  851.       cout << "receiving ";
  852.       break;
  854.     default :
  855.       break;
  856.   }
  858.   cout << channel.GetCapability() << endl;
  860.   return TRUE;
  861. }
  863. void MyH323Connection::StartRecording()
  864. {
  865.   recordFile->StartRecording();
  866. }
  868. void MyH323Connection::OnUserInputString(const PString & value)
  869. {
  870.   PINDEX i;
  871.   for (i = 0; i < value.GetLength(); i++) {
  872.     OnUserInputChar(value[i]);
  873.   }
  874. }
  876. BOOL MyH323Connection::StartMenu(int menuNumber)
  877. {
  878.   digits = "";
  879.   currentMenu = menuNumber;
  880.   PString menuName = psprintf("%s%i", MENU_PREFIX, menuNumber);
  881.   if (menuNames.GetStringsIndex(menuName) == P_MAX_INDEX) 
  882.     return FALSE;
  884.   PTRACE(1, "Starting menu " << menuNumber);
  886.   PConfig menu(menuName);
  887.   PString startCmd = menu.GetString("start");
  889.   if (!startCmd.IsEmpty())
  890.     ProcessMenuCmd(startCmd);
  892.   return TRUE;
  893. }
  895. BOOL MyH323Connection::ProcessMenuCmd(const PString & cmdStr)
  896. {
  897.   PTRACE(1, "Processing menu cmd " << cmdStr);
  898.   PStringArray tokens = cmdStr.Tokenise(" ", FALSE);
  899.   int len = tokens.GetSize();
  900.   if (len == 0)
  901.     return TRUE;
  903.   PString cmd = tokens[0];
  905.   if ((len >= 2) && (cmd *= "play")) {
  906.     ogmChannel->QueueFile(tokens[1]);
  907.     if (len > 2) {
  908.       cmd = "menu";
  909.       tokens[1] = tokens[2];
  910.     }
  911.   }
  913.   if ((len >= 2) && (cmd *= "menu")) {
  914.     int newMenu = tokens[1].AsInteger();
  915.     if (newMenu != currentMenu)
  916.       StartMenu(newMenu);
  917.   }
  919.   else if (cmd *= "hangup")
  920.     ogmChannel->SetHangupTrigger();
  922.   else if (cmd *= "record")
  923.     ogmChannel->SetRecordTrigger();
  925.   return TRUE;
  926. }
  928. void MyH323Connection::OnUserInputChar(char ch)
  929. {
  930.   if (ch == '#') 
  931.     digits += '$';
  932.   else 
  933.     digits += ch;
  935.   PTRACE(1, "Processing digit string " << digits);
  937.   ogmChannel->FlushQueue();
  939.   PString menuName = psprintf("%s%i", MENU_PREFIX, currentMenu);
  940.   if (menuNames.GetStringsIndex(menuName) == P_MAX_INDEX) {
  941.     PTRACE(1, "Cannot find menu " << menuName);
  942.     StartMenu(0);
  943.     return;
  944.   }
  946.   PConfig menu(menuName);
  947.   PStringList keys = menu.GetKeys();
  948.   PINDEX keyMatch = FindMatch(keys, digits);
  950.   // if key is still ambiguous, then keep collecting
  951.   if (keyMatch == 0)
  952.     return;
  954.   PString cmd;
  955.   if (keyMatch != P_MAX_INDEX) {
  956.     PString key = keys[keyMatch-1];
  957.     PTRACE(1, "Executing cmd for key " << key);
  958.     cmd = menu.GetString(key);
  959.   } else {
  960.     PTRACE(1, "Cannot match cmd " << digits << " in menu " << menuName);
  961.     cmd = menu.GetString("error", "menu 0");
  962.   } 
  964.   if (!cmd.IsEmpty()) {
  965.     ProcessMenuCmd(cmd);
  966.     digits = "";
  967.   }
  968. }
  970. ///////////////////////////////////////////////////////////////
  972. OGMChannel::OGMChannel(MyH323Connection & _conn)
  973.   : conn(_conn)
  974. {
  975.   lastTime    = PTime();
  976.   silentCount = 20;
  977.   recordTrigger = FALSE;
  978.   hangupTrigger = FALSE;
  979.   closed        = FALSE;
  980. }
  982. void OGMChannel::PlayFile(PFile * chan)
  983. { 
  984.   PWaitAndSignal mutex(chanMutex);
  985. //  if (IsOpen())
  986. //    Close();
  988.   if (!chan->Open(PFile::ReadOnly)) {
  989.     PTRACE(1, "Cannot open file "" << chan->GetName() << """);
  990.     return;
  991.   }
  993.   PTRACE(1, "Playing file "" << chan->GetName() << """);
  994.   totalData = 0;
  995.   SetReadChannel(chan, TRUE);
  996. }
  998. void OGMChannel::CreateSilence(void * buffer, PINDEX amount)
  999. {
  1000.   if (!isPCM) 
  1001.     lastReadCount = 0;
  1002.   else {
  1003.     memset(buffer, 0, amount);
  1004.     lastReadCount = amount;
  1005.   }
  1006. }
  1008. BOOL OGMChannel::Read(void * buffer, PINDEX amount)
  1009. {
  1010.   PWaitAndSignal mutex(chanMutex);
  1012.   if (closed)
  1013.     return FALSE;
  1015.   BOOL doSilence = TRUE;
  1017.   if (silentCount > 0) {
  1018.     silentCount--;
  1019.   } else {
  1020.     if (GetBaseReadChannel() != NULL)
  1021.       doSilence = FALSE;
  1022.     else {
  1023.       PString * str = playQueue.Dequeue();
  1024.       if (str != NULL) {
  1025.         PFile * chan = new PFile(*str + ext);
  1026.         delete str;
  1027.         if (!chan->Open(PFile::ReadOnly)) {
  1028.           PTRACE(1, "Cannot open file "" << chan->GetName() << """);
  1029.           delete chan;
  1030.         } else {
  1031.           PTRACE(1, "Playing file "" << chan->GetName() << """);
  1032.           totalData = 0;
  1033.           SetReadChannel(chan, TRUE);
  1034.           doSilence = FALSE;
  1035.         } 
  1036.       }
  1037.     }
  1038.   }
  1040.   if (!doSilence) {
  1041.     if (PIndirectChannel::Read(buffer, amount))
  1042.       totalData += amount;
  1043.     else {
  1044.       PTRACE(1, "Finished playing " << totalData << " bytes");
  1045.       closed = TRUE;
  1046.       PIndirectChannel::Close();
  1047.       silentCount = 5;
  1048.       if (hangupTrigger) 
  1049.         conn.ClearCall();
  1050.       else if (recordTrigger) 
  1051.         conn.StartRecording();
  1052.       doSilence = TRUE;
  1053.     }
  1054.   }
  1056.   if (doSilence)
  1057.     CreateSilence(buffer, amount);
  1059.   //PThread::Current()->Sleep(amount / 8);
  1061.   return TRUE;
  1062. }
  1064. BOOL OGMChannel::Close()
  1065. {
  1066.   PWaitAndSignal mutex(chanMutex);
  1067.   closed = TRUE;
  1068.   PIndirectChannel::Close();
  1069.   return TRUE;
  1070. }
  1072. void OGMChannel::SetRecordTrigger()
  1073. {
  1074.   PWaitAndSignal mutex(chanMutex);
  1075.   recordTrigger = TRUE;
  1076.   if ((playQueue.GetSize() == 0) && (GetBaseReadChannel() == NULL))
  1077.     conn.StartRecording();
  1078. }
  1080. void OGMChannel::SetHangupTrigger()
  1081. {
  1082.   PWaitAndSignal mutex(chanMutex);
  1083.   hangupTrigger = TRUE;
  1084.   if (GetBaseReadChannel() == NULL)
  1085.     conn.ClearCall();
  1086. }
  1088. void OGMChannel::QueueFile(const PString & fn)
  1089. {
  1090.   PWaitAndSignal mutex(chanMutex);
  1091.   PTRACE(1, "Enqueueing file " << (fn + ext) << " for playing");
  1092.   playQueue.Enqueue(new PString(fn));
  1093. }
  1095. void OGMChannel::FlushQueue()
  1096. {
  1097.   PWaitAndSignal mutex(chanMutex);
  1099.   if (GetBaseReadChannel() != NULL) {
  1100.     PIndirectChannel::Close();
  1101.     if (hangupTrigger) 
  1102.       conn.ClearCall();
  1103.     else if (recordTrigger) 
  1104.       conn.StartRecording();
  1105.   }
  1107.   PString * str;
  1108.   for (;;) {
  1109.     str = playQueue.Dequeue();
  1110.     if (str == NULL)
  1111.       break;
  1112.     delete str;
  1113.   }
  1114. }
  1117. // End of File ///////////////////////////////////////////////////////////////