processor.h

Go to the documentation of this file.

/*
 *
 * Inter Asterisk Exchange 2
 * 
 * The core routine which determines the processing of packets for one call.
 * 
 * Open Phone Abstraction Library (OPAL)
 *
 * Copyright (c) 2005 Indranet Technologies Ltd.
 *
 * The contents of this file are subject to the Mozilla Public License
 * Version 1.0 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 * the License for the specific language governing rights and limitations
 * under the License.
 *
 * The Original Code is Open Phone Abstraction Library.
 *
 * The Initial Developer of the Original Code is Indranet Technologies Ltd.
 *
 * The author of this code is Derek J Smithies
 *
 * 
 *  $Log: processor.h,v $
 *  Revision 1.16  2007/04/19 06:17:21  csoutheren
 *  Fixes for precompiled headers with gcc
 *
 *  Revision 1.15  2007/01/23 02:08:25  dereksmithies
 *  Handle Vnak frames correctly. handle iseqno and oseqno correctly.
 *
 *  Revision 1.14  2007/01/17 03:48:13  dereksmithies
 *  Tidy up comments, remove leaks, improve reporting of packet types.
 *
 *  Revision 1.13  2007/01/16 03:17:42  dereksmithies
 *  tidyup of comments. Remove unused variables.
 *  Guarantee that media frames are sent with a monotonically increasing timestamp
 *
 *  Revision 1.12  2007/01/11 03:02:15  dereksmithies
 *  Remove the previous audio buffering code, and switch to using the jitter
 *  buffer provided in Opal. Reduce the verbosity of the log mesasges.
 *
 *  Revision 1.11  2006/09/22 00:33:19  csoutheren
 *  Changed PAtomicInteger to BOOL
 *
 *  Revision 1.10  2006/09/11 03:08:51  dereksmithies
 *  Add fixes from Stephen Cook (sitiveni@gmail.com) for new patches to
 *  improve call handling. Notably, IAX2 call transfer. Many thanks.
 *  Thanks also to the Google summer of code for sponsoring this work.
 *
 *  Revision 1.9  2006/08/09 03:46:39  dereksmithies
 *  Add ability to register to a remote Asterisk box. The iaxProcessor class is split
 *  into a callProcessor and a regProcessor class.
 *  Big thanks to Stephen Cook, (sitiveni@gmail.com) for this work.
 * 
 *  Revision 1.8  2006/06/16 01:47:08  dereksmithies
 *  Get the OnHold features of IAX2 to work correctly.
 *  Thanks to Stephen Cook, (sitiveni@gmail.com) for this work.
 *
 *  Revision 1.7  2005/09/05 01:19:43  dereksmithies
 *  add patches from Adrian Sietsma to avoid multiple hangup packets at call end,
 *  and stop the sending of ping/lagrq packets at call end. Many thanks.
 *
 *  Revision 1.6  2005/08/26 03:07:38  dereksmithies
 *  Change naming convention, so all class names contain the string "IAX2"
 *
 *  Revision 1.5  2005/08/25 03:26:06  dereksmithies
 *  Add patch from Adrian Sietsma to correctly set the packet timestamps under windows.
 *  Many thanks.
 *
 *  Revision 1.4  2005/08/24 04:56:25  dereksmithies
 *  Add code from Adrian Sietsma to send FullFrameTexts and FullFrameDtmfs to
 *  the remote end.  Many Thanks.
 *
 *  Revision 1.3  2005/08/24 01:38:38  dereksmithies
 *  Add encryption, iax2 style. Numerous tidy ups. Use the label iax2, not iax
 *
 *  Revision 1.2  2005/08/04 08:14:17  rjongbloed
 *  Fixed Windows build under DevStudio 2003 of IAX2 code
 *
 *  Revision 1.1  2005/07/30 07:01:32  csoutheren
 *  Added implementation of IAX2 (Inter Asterisk Exchange 2) protocol
 *  Thanks to Derek Smithies of Indranet Technologies Ltd. for
 *  writing and contributing this code
 *
 *
 *
 *
 *
 *
 *
 */

#ifndef PROCESSOR_H
#define PROCESSOR_H

#ifndef _PTLIB_H
#include <ptlib.h>
#endif

#include <opal/connection.h>

#include <iax2/frame.h>
#include <iax2/iedata.h>
#include <iax2/remote.h>
#include <iax2/safestrings.h>
#include <iax2/sound.h>

class IAX2EndPoint;
class IAX2Connection;
class IAX2ThreadHelper;


class IAX2WaitingForAck : public PObject
{
  PCLASSINFO(IAX2WaitingForAck, PObject);

 public:
  enum ResponseToAck {
    RingingAcked   = 0,  
    AcceptAcked    = 1,  
    AuthRepAcked   = 2,  
    AnswerAcked    = 3   
  };
  
  IAX2WaitingForAck();
  
  void Assign(IAX2FullFrame *f, ResponseToAck _response);
  
  BOOL MatchingAckPacket(IAX2FullFrame *f);
  
  ResponseToAck GetResponse() { return response; }
  
  PString GetResponseAsString() const;
  
  virtual void PrintOn(ostream & strm) const;
  
  void ZeroValues();
  
 private:
  DWORD timeStamp;
  
  PINDEX seqNo;
  
  ResponseToAck response;
};


class IAX2Processor : public PThread
{
  PCLASSINFO(IAX2Processor, PObject);
  
 public:
  IAX2Processor(IAX2EndPoint & ep);

  virtual ~IAX2Processor();
  
  IAX2SequenceNumbers & GetSequenceInfo() { return sequence; }
  
  IAX2Encryption & GetEncryptionInfo() { return encryption; }
  
  void IncomingEthernetFrame (IAX2Frame *frame);
  
  virtual void PrintOn(ostream & strm) const = 0;
  
  IAX2EndPoint & GetEndPoint() { return endpoint; };
  
  void SetCallToken(const PString & newToken);
  
  PString GetCallToken();
  
  IAX2Remote & GetRemoteInfo() { return remote; }
  
  const PTimeInterval & GetCallStartTick() { return callStartTick; }
  
  void Main();
  
  BOOL IsStatusQueryEthernetFrame(IAX2Frame *frame);
  
  void SetSpecialPackets(BOOL newValue) { specialPackets = newValue; }
  
  void Terminate();
  
  void Activate();

 protected:
 
  IAX2EndPoint      & endpoint;
 
  PTimeInterval callStartTick;
  
  IAX2Remote remote;
  
  void StartNoResponseTimer(PINDEX msToWait = 60000);
   
  void StopNoResponseTimer() { noResponseTimer.Stop(); }
  
  PTimer noResponseTimer;
  
  void CleanPendingLists() { activate.Signal(); }
  
  IAX2WaitingForAck nextTask;
  
  PSyncPoint activate;
  
  BOOL endThread;
  
  IAX2Encryption encryption;
  
  IAX2SequenceNumbers sequence;
  
  IAX2FrameList frameList;
  
  SafeString callToken;
  
  virtual void OnNoResponseTimeout() = 0;
  
  enum DefinedNoResponseTimePeriod {
    NoResponseTimePeriod = 5000 
  };
  
  BOOL      IsHandlingSpecialPackets() { return specialPackets; };

  BOOL       specialPackets;
  
  virtual void ProcessLists() = 0;  
  
  virtual void ProcessFullFrame(IAX2FullFrame & fullFrame) = 0;
  
  virtual void ProcessIaxCmdLagRq(IAX2FullFrameProtocol *src);
  
  virtual void ProcessIaxCmdLagRp(IAX2FullFrameProtocol *src);
  
  virtual void ProcessIaxCmdVnak(IAX2FullFrameProtocol *src);
  
  virtual void ProcessIaxCmdPing(IAX2FullFrameProtocol *src);
  
  virtual void ProcessIaxCmdPong(IAX2FullFrameProtocol *src); 
  
  BOOL ProcessOneIncomingEthernetFrame();
  
  PAtomicInteger controlFramesSent;
  
  PAtomicInteger controlFramesRcvd;
  
  void IncControlFramesSent() { ++controlFramesSent; }
  
  void IncControlFramesRcvd() { ++controlFramesRcvd; }
  
  virtual void ProcessNetworkFrame(IAX2MiniFrame * src) = 0;  

  /* A frame of FullFrameProtocol type is labelled as AST_FRAME_IAX in the
     asterisk souces, It will contain 0, 1, 2 or more Information Elements
     (Ie) in the data section. This processor is used to do things that are
     common to registration and call handling.

  This method will eat/delete the supplied frame. Return TRUE on success,
  FALSE on failure.*/
  virtual BOOL ProcessNetworkFrame(IAX2FullFrameProtocol * src);
  
  void TransmitFrameToRemoteEndpoint(IAX2Frame *src);

  void TransmitFrameToRemoteEndpoint(IAX2FullFrame *src,
             IAX2WaitingForAck::ResponseToAck response  
             );

  void TransmitFrameNow(IAX2Frame *src);
  
  void TransmitFrameToRemoteEndpoint(IAX2FullFrameProtocol *src);
  
  BOOL Authenticate(IAX2FullFrameProtocol *reply, 
                    PString & password 
        );
        
  IAX2IeData ieData;
  
  void SendAckFrame(IAX2FullFrame *inReplyTo);

  void SendVnakFrame(IAX2FullFrame *inReplyTo);
  
  void SendUnsupportedFrame(IAX2FullFrame *inReplyTo);
  
 private:
#ifdef DOC_PLUS_PLUS

  void OnNoResponseTimeoutStart(PTimer &, INT);
#else
  PDECLARE_NOTIFIER(PTimer, IAX2Processor, OnNoResponseTimeoutStart);
#endif 

 protected:
  DWORD currentSoundTimeStamp;
};

#endif // PROCESSOR_H

---