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
 */

#ifndef OPAL_IAX2_PROCESSOR_H
#define OPAL_IAX2_PROCESSOR_H

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

#include <opal_config.h>

#if OPAL_IAX2

#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);
  
  PBoolean 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();
  
  PBoolean IsStatusQueryEthernetFrame(IAX2Frame *frame);
  
  void SetSpecialPackets(PBoolean newValue) { specialPackets = newValue; }
  
  void Terminate();
  
  void Activate();

  virtual PBoolean IncomingMessageOutOfOrder(IAX2FullFrame *ff)= 0;

  void ReportLists(PString & answer);

 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;
  
  PBoolean endThread;
  
  IAX2Encryption encryption;
  
  IAX2SequenceNumbers sequence;
  
  IAX2ActiveFrameList frameList;
  
  SafeString callToken;
  
  virtual void OnNoResponseTimeout() = 0;
  
  enum DefinedNoResponseTimePeriod {
    NoResponseTimePeriod = 5000 
  };
  
  PBoolean      IsHandlingSpecialPackets() { return specialPackets; };

  PBoolean       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); 
  
  PBoolean ProcessOneIncomingEthernetFrame();
  
  atomic<uint32_t> controlFramesSent;
  
  atomic<uint32_t> 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 PBoolean ProcessNetworkFrame(IAX2FullFrameProtocol * src);
  
  void TransmitFrameToRemoteEndpoint(IAX2Frame *src);

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

  void TransmitFrameNow(IAX2Frame *src);
  
  void TransmitFrameToRemoteEndpoint(IAX2FullFrameProtocol *src);
  
  PBoolean 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 // OPAL_IAX2

#endif // OPAL_IAX2_PROCESSOR_H