NetInTask.h

Go to the documentation of this file.

//
// Copyright (C) 2021 SIP Spectrum, Inc. www.sipspectrum.com  
//  
// Copyright (C) 2006-2016 SIPez LLC.  All rights reserved.
//
// Copyright (C) 2004-2006 SIPfoundry Inc.
// Licensed by SIPfoundry under the LGPL license.
//
// Copyright (C) 2004-2006 Pingtel Corp.  All rights reserved.
// Licensed to SIPfoundry under a Contributor Agreement.
//
// $$


#ifndef _INCLUDED_NETINTASK_H /* [ */
#define _INCLUDED_NETINTASK_H

#include "rtcp/RtcpConfig.h"

// SYSTEM INCLUDES

// APPLICATION INCLUDES
#include "os/OsTask.h"
#include "os/OsLock.h"
#include "os/OsSocket.h"
#include "os/OsRWMutex.h"
#include "os/OsMutex.h"
#include "mp/MpTypes.h"
#include "mp/MpRtpBuf.h"
#include "mp/MpMisc.h"

// DEFINES
#define IP_HEADER_SIZE  20    
#define UDP_HEADER_SIZE 8     
#define ETHERNET_MTU    1500  
#define UDP_MTU  (ETHERNET_MTU - IP_HEADER_SIZE - UDP_HEADER_SIZE)
#define RTP_MTU  (UDP_MTU-12) 
#define RTCP_MTU (UDP_MTU-12)

#define RTP_DIR_IN  1
#define RTP_DIR_OUT 2
#define RTP_DIR_NEW 4

// MACROS
// EXTERNAL FUNCTIONS
// EXTERNAL VARIABLES
// CONSTANTS
#define NET_TASK_MAX_MSG_LEN sizeof(netInTaskMsg)
#define NET_TASK_MAX_FD_PAIRS 300

// FORWARD DECLARATIONS
class MprFromNet;
class OsConnectionSocket;
class OsServerSocket;
class OsSocket;
class OsNotification;
struct rtpSession;

// STRUCTS
struct rtpSession {
    uint8_t vpxcc; 
    uint8_t mpt;   
    RtpSeq seq;
    RtpTimestamp timestamp;
    RtpSRC ssrc;
    OsSocket* socket;
    int dir;
    uint32_t packets;
    uint32_t octets;
    uint16_t cycles;
};

struct netInTaskMsg {
    OsSocket* pRtpSocket;
    OsSocket* pRtcpSocket;
    MprFromNet* fwdTo;
    OsNotification* notify;
    int fdRtp;
    int fdRtcp;
};

#ifndef INCLUDE_RTCP /* [ */
struct __MprRtcpStats {
   RtpSRC ssrc;
   short seqNumCycles;
   uint16_t highSeqNum;
};

// TYPEDEFS

typedef struct __MprRtcpStats  MprRtcpStats;
typedef struct __MprRtcpStats* MprRtcpStatsPtr;
#endif /* INCLUDE_RTCP ] */

typedef struct rtpSession *rtpHandle;

// FORWARD DECLARATIONS
extern uint32_t rand_timer32();
extern rtpHandle StartRtpSession(OsSocket* socket, int direction, char type);
extern void FinishRtpSession(rtpHandle h);

class NetInTask : public OsTask
{

/* //////////////////////////// PUBLIC //////////////////////////////////// */
public:

   static const int DEF_NET_IN_TASK_PRIORITY;      
   static const int DEF_NET_IN_TASK_OPTIONS;       
   static const int DEF_NET_IN_TASK_STACKSIZE;     

/* ============================ CREATORS ================================== */


   static NetInTask* getNetInTask();

   static NetInTask* createNetInTask();

   OsStatus destroy();

   virtual ~NetInTask();


/* ============================ MANIPULATORS ============================== */


   virtual int run(void* pArg);

   OsStatus addNetInputSources(OsSocket* pRtpSocket,
                               OsSocket* pRtcpSocket,
                               MprFromNet* fwdTo,
                               OsNotification* note);

   OsStatus removeNetInputSources(MprFromNet* fwdTo, OsNotification* note);


/* ============================ ACCESSORS ================================= */



/* ============================ INQUIRY =================================== */



/* //////////////////////////// PROTECTED ///////////////////////////////// */
protected:

   // Static data members used to enforce Singleton behavior
   static NetInTask* spInstance;    
   static OsRWMutex  sLock;         

   OsRWMutex         sInstanceLock; 

   OsConnectionSocket* mpWriteSocket;
   OsConnectionSocket* mpReadSocket;
   int                 mCmdPort;    
   OsMutex             mEventMutex;

   netInTaskMsg        mFdPairs[NET_TASK_MAX_FD_PAIRS];
   int                 mNumFdPairs;

   int                 mNumFlushed;
   int                 mFlushedLimit;
   bool                mUseInstanceLock;

   NetInTask(
      int prio    = DEF_NET_IN_TASK_PRIORITY,      
      int options = DEF_NET_IN_TASK_OPTIONS,       
      int stack   = DEF_NET_IN_TASK_STACKSIZE);    

   static OsRWMutex& getStaticLockObj() { return sLock; }
   OsRWMutex& getLockObj() { if (mUseInstanceLock) return sInstanceLock; else return sLock; }

   OsStatus get1Msg(OsSocket* pRxpSkt, MprFromNet* fwdTo, bool isRtcp, int ostc);
   int findPoisonFds(int pipeFD);

/* //////////////////////////// PRIVATE /////////////////////////////////// */
private:

   NetInTask(const NetInTask& rNetInTask);

   NetInTask& operator=(const NetInTask& rhs);

};

#endif /* _INCLUDED_NETINTASKH ] */