SipStack.hxx

Go to the documentation of this file.

#if !defined(RESIP_SIPSTACK_HXX)
#define RESIP_SIPSTACK_HXX
 
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
 
#include <set>
#include <iosfwd>
 
#include "rutil/CongestionManager.hxx"
#include "rutil/FdSetIOObserver.hxx"
#include "rutil/TimeLimitFifo.hxx"
#include "rutil/Mutex.hxx"
#include "rutil/TransportType.hxx"
#include "rutil/BaseException.hxx"
#include "resip/stack/TransactionController.hxx"
#include "resip/stack/TransportSelector.hxx"
#include "resip/stack/SecurityTypes.hxx"
#include "resip/stack/StatisticsManager.hxx"
#include "resip/stack/TuSelector.hxx"
#include "resip/stack/WsConnectionValidator.hxx"
#include "resip/stack/WsCookieContextFactory.hxx"
#include "rutil/dns/DnsStub.hxx"
 
#include <memory>
#include <utility>
 
#define RESIP_SIPSTACK_HAVE_FDPOLL 1
 
namespace resip
{
 
class ApplicationMessage;
class Data;
class DnsThread;
class Message;
class Security;
class SipMessage;
class StatisticsManager;
class Tuple;
class Uri;
class TransactionControllerThread;
class TransportSelectorThread;
class TransactionUser;
class AsyncProcessHandler;
class Compression;
class FdPollGrp;
 
class SipStackOptions
{
   public:
      SipStackOptions()
         : mSecurity(0), mExtraNameserverList(0),
           mAsyncProcessHandler(0), mStateless(false),
           mSocketFunc(0), mCompression(0), mPollGrp(0),
           mUseDnsVip(false)
      {
      }
 
      Security* mSecurity;
      const DnsStub::NameserverList* mExtraNameserverList;
      AsyncProcessHandler* mAsyncProcessHandler;
      bool mStateless;
      AfterSocketCreationFuncPtr mSocketFunc;
      Compression *mCompression;
      FdPollGrp* mPollGrp;
      bool mUseDnsVip;
};
 
 
 
class SipStack : public FdSetIOObserver
{
   public:
      SipStack(const SipStackOptions& options);
 
      SipStack(Security* security=0,
               const DnsStub::NameserverList& additional = DnsStub::EmptyNameserverList,
               AsyncProcessHandler* handler = 0,
               bool stateless=false,
               AfterSocketCreationFuncPtr socketFunc = 0,
               Compression *compression = 0,
               FdPollGrp* pollGrp = 0,
               bool useDnsVip = false);
 
      virtual ~SipStack();
 
      void run();
 
      void shutdown();
 
      void shutdownAndJoinThreads();
 
      void onReload();
 
      void reloadCertificates();
 
      class Exception final : public BaseException
      {
         public:
            Exception(const Data& msg, const Data& file, const int line)
               : BaseException(msg, file, line) {}
 
            const char* name() const noexcept override { return "SipStack::Exception"; }
      };
 
      void setTransportSipMessageLoggingHandler(std::shared_ptr<Transport::SipMessageLoggingHandler> handler);
 
      void addTransportSipMessageLoggingHandler(std::shared_ptr<Transport::SipMessageLoggingHandler> handler);
 
      Transport* addTransport(TransportType protocol,
                              int port,
                              IpVersion version=V4,
                              StunSetting stun=StunDisabled,
                              const Data& ipInterface = Data::Empty,
                              const Data& sipDomainname = Data::Empty, // only used for TLS based stuff
                              const Data& privateKeyPassPhrase = Data::Empty,
                              SecurityTypes::SSLType sslType = SecurityTypes::DynamicTLS,
                              unsigned transportFlags = 0,
                              const Data& certificateFilename = "", 
                              const Data& privateKeyFilename = "",
                              SecurityTypes::TlsClientVerificationMode cvm = SecurityTypes::None,
                              bool useEmailAsSIP = false,
                              std::shared_ptr<WsConnectionValidator> = nullptr,
                              std::shared_ptr<WsCookieContextFactory> = nullptr,
                              const Data& netNs = Data::Empty
                             );
 
      void addTransport(std::unique_ptr<Transport> transport);
 
      void removeTransport(unsigned int transportKey);
 
      Fifo<TransactionMessage>& stateMacFifo();
 
      void addAlias(const Data& domain, int port);
 
      void removeAlias(const Data& domain, int port);
 
      bool isMyDomain(const Data& domain, int port) const;
 
      bool isMyPort(int port) const;
 
      static Data getHostname();
 
      static Data getHostAddress();
 
      const Uri& getUri() const;
 
      void send(const SipMessage& msg, TransactionUser* tu=0);
 
      void send(std::unique_ptr<SipMessage> msg, TransactionUser* tu = 0);
      
      void sendTo(std::unique_ptr<SipMessage> msg, const Uri& uri, TransactionUser* tu=0);
      void sendTo(std::unique_ptr<SipMessage> msg, const Tuple& tuple, TransactionUser* tu=0);
 
      void sendTo(const SipMessage& msg, const Uri& uri, TransactionUser* tu=0);
 
      void sendTo(const SipMessage& msg, const Tuple& tuple,
                  TransactionUser* tu=0);
 
      void sendOverExistingConnection(const SipMessage& msg, const Tuple& tuple,
                                      TransactionUser* tu=0);
 
      void post(std::unique_ptr<ApplicationMessage> message,
                unsigned int secondsLater,
                TransactionUser* tu=0);
 
      void postMS(std::unique_ptr<ApplicationMessage> message,
                  unsigned int ms,
                  TransactionUser* tu=0);
 
      void post(std::unique_ptr<ApplicationMessage> message,
                std::chrono::duration<double> interval,
                TransactionUser* tu=0);
 
      void post(std::unique_ptr<ApplicationMessage> message);
 
      void post(const ApplicationMessage& message);
 
      void post(const ApplicationMessage& message, unsigned int secondsLater,
                TransactionUser* tu=0);
 
      void postMS(const ApplicationMessage& message, unsigned int ms,
                  TransactionUser* tu=0);
 
      void post(const ApplicationMessage& message,
                std::chrono::duration<double> interval,
                TransactionUser* tu=0);
 
      void abandonServerTransaction(const Data& tid);
 
      void cancelClientInviteTransaction(const Data& tid, const Tokens* reasons);
 
      bool hasMessage() const;
      
      SipMessage* receive(); 
 
      Message* receiveAny(); 
 
      /*
       * Handler is notified when a message is posted to the default
       * application receive queue. (Fetching using receive() above).
       * This handler is called from SipStack's thread, and can
       * be used to "wake-up" the application's thread.
       */
      void setFallbackPostNotify(AsyncProcessHandler *handler);
 
      RESIP_DEPRECATED(virtual void buildFdSet(FdSet& fdset));
 
      RESIP_DEPRECATED(virtual void process(FdSet& fdset));
 
      bool process(unsigned int timeoutMs);
 
      inline FdPollGrp* getPollGrp() {return mPollGrp;} 
 
      virtual unsigned int getTimeTillNextProcessMS();
 
      virtual void processTimers();
 
      void setStatisticsInterval(unsigned long seconds);
 
      void zeroOutStatistics();
 
      bool pollStatistics();
 
      void setExternalStatsHandler(ExternalStatsHandler *handler)
      {
         mStatsManager.setExternalStatsHandler(handler);
      }
 
      const StatisticsManager* getStatisticsManager() {return(&mStatsManager);}
 
      EncodeStream& dump(EncodeStream& strm) const;
 
      Security* getSecurity() const;
 
      void registerTransactionUser(TransactionUser&, const bool front = false);
 
      void requestTransactionUserShutdown(TransactionUser&);
 
      void unregisterTransactionUser(TransactionUser&);
 
      void registerMarkListener(MarkListener* listener);
 
      void unregisterMarkListener(MarkListener* listener);
 
      DnsStub& getDnsStub() const;
 
      void setEnumSuffixes(const std::vector<Data>& suffixes);
 
      void setEnumDomains(const std::map<Data,Data>& domains);
 
      void clearDnsCache();
 
      void logDnsCache();
 
      void getDnsCacheDump(std::pair<unsigned long, unsigned long> key, GetDnsCacheDumpHandler* handler);
 
      void reloadDnsServers();
 
      volatile bool& statisticsManagerEnabled();
      const bool statisticsManagerEnabled() const;
 
      bool getFixBadDialogIdentifiers() const 
      {
         return mTransactionController->mFixBadDialogIdentifiers;
      }
 
      void setFixBadDialogIdentifiers(bool pFixBadDialogIdentifiers) 
      {
         mTransactionController->mFixBadDialogIdentifiers = pFixBadDialogIdentifiers;
      }
 
      inline bool getFixBadCSeqNumbers() const
      {
         return mTransactionController->getFixBadCSeqNumbers();
      }
 
      inline void setFixBadCSeqNumbers(bool pFixBadCSeqNumbers)
      {
         mTransactionController->setFixBadCSeqNumbers(pFixBadCSeqNumbers);
      }
 
      bool setUdpOnlyOnNumeric(bool value)
      {
         return mTransactionController->transportSelector().setUdpOnlyOnNumeric(value);
      }
 
      bool getUdpOnlyOnNumeric() const
      {
         return mTransactionController->transportSelector().getUdpOnlyOnNumeric();
      }
 
      void setContentLengthChecking(bool check)
      {
         SipMessage::checkContentLength=check;
      }
 
      void setCongestionManager ( CongestionManager *manager )
      {
         mTransactionController->setCongestionManager(manager);
         mTuSelector.setCongestionManager(manager);
         if(mCongestionManager)
         {
            mCongestionManager->unregisterFifo(&mTUFifo);
         }
         mCongestionManager=manager;
         if(mCongestionManager)
         {
            mCongestionManager->registerFifo(&mTUFifo);
         }
      }
 
      CongestionManager* getCongestionManager() { return mCongestionManager; }
 
      Compression &getCompression() { return *mCompression; }
 
      void terminateFlow(const resip::Tuple& flow);
      void enableFlowTimer(const resip::Tuple& flow);
 
      // Will call the AfterSocketCreationFuncPtr that was provided at SIPStack creation
      // time to all sockets that match the passed in type.  Use UNKNOWN_TRANSPORT
      // in order to call for all transport types.
      // The stack thread(s) must be running when this is called.
      // Can be used to update QOS to a new value on existing sockets, without needing
      // to restart the SipStack.
      // Note:  DNS sockets are not currently supported
      void invokeAfterSocketCreationFunc(TransportType type = UNKNOWN_TRANSPORT);
 
   private:
      // WATCHOUT: can only be called once (just like constructor)
      void init(const SipStackOptions& options);
 
      void checkAsyncProcessHandler();
 
      FdPollGrp* mPollGrp;
      bool mPollGrpIsMine;
 
      Security* mSecurity;
 
      DnsStub* mDnsStub;
      DnsThread* mDnsThread;
 
      Compression* mCompression;
 
      AsyncProcessHandler* mAsyncProcessHandler;
      bool mInterruptorIsMine;
 
      SipStack(const SipStack& copy);
 
      SipStack& operator=(const SipStack& rhs);         
      
      TimeLimitFifo<Message> mTUFifo;
      CongestionManager* mCongestionManager;
 
      TuSelector mTuSelector;
 
      mutable Mutex mAppTimerMutex;
      
      TuSelectorTimerQueue  mAppTimers;
 
      StatisticsManager mStatsManager;
 
      TransactionController* mTransactionController;
 
      TransactionControllerThread* mTransactionControllerThread;
      TransportSelectorThread* mTransportSelectorThread;
      bool mInternalThreadsRunning;
      bool mProcessingHasStarted; 
 
      typedef std::unordered_map<Data, unsigned int> DomainsMap;
      DomainsMap mDomains;  // Second item (unsigned int) is for reference counting
      Uri mUri;
      mutable Mutex mDomainsMutex;  // Protects both mDomains and mUri, since they are related
 
      std::map<int, unsigned int> mPorts;  // Second item (unsigned int) is for reference counting
      mutable Mutex mPortsMutex;
 
      // Used to ensure new Transport additions will always succeed without needing to ask 
      // TransportSelector if add will be valid and introduce locking
      // Note:  We could add a Mutex here and add thread safe accesor methods to transport pointers 
      //        as a convience to API users
      typedef std::map<Tuple, Transport*> NonSecureTransportMap;
      NonSecureTransportMap mNonSecureTransports;
      typedef std::map<TransportSelector::TlsTransportKey, Transport*> SecureTransportMap;
      SecureTransportMap mSecureTransports;
 
      bool mShuttingDown;
      mutable Mutex mShutdownMutex;
      volatile bool mStatisticsManagerEnabled;
 
      AfterSocketCreationFuncPtr mSocketFunc;
 
      unsigned int mNextTransportKey;
 
      Transport::SipMessageLoggingHandlerList mTransportSipMessageLoggingHandlers;
 
      friend class Executive;
      friend class StatelessHandler;
      friend class StatisticsManager;
      friend class TestDnsResolver;
      friend class TestFSM;
      friend class TransactionState;
      friend class TransactionController;
      friend class TuSelector;
};
 
EncodeStream& operator<<(EncodeStream& strm, const SipStack& stack);
 
inline void
SipStack::sendOverExistingConnection(const SipMessage& msg, const Tuple& tuple,
                                     TransactionUser* tu)
{
   resip_assert(tuple.mFlowKey);
   Tuple tup(tuple);
   tup.onlyUseExistingConnection = true;
   sendTo(msg, tuple, tu);
}
 
}
 
#endif
 
/* ====================================================================
 * The Vovida Software License, Version 1.0
 *
 * Copyright (c) 2026, SIP Spectrum, Inc. http://sipspectrum.com
 * Copyright (c) 2000 Vovida Networks, Inc.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. The names "VOCAL", "Vovida Open Communication Application Library",
 *    and "Vovida Open Communication Application Library (VOCAL)" must
 *    not be used to endorse or promote products derived from this
 *    software without prior written permission. For written
 *    permission, please contact vocal@vovida.org.
 *
 * 4. Products derived from this software may not be called "VOCAL", nor
 *    may "VOCAL" appear in their name, without prior written
 *    permission of Vovida Networks, Inc.
 *
 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND
 * NON-INFRINGEMENT ARE DISCLAIMED.  IN NO EVENT SHALL VOVIDA
 * NETWORKS, INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT DAMAGES
 * IN EXCESS OF $1,000, NOR FOR ANY INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
 * DAMAGE.
 *
 * ====================================================================
 *
 * This software consists of voluntary contributions made by Vovida
 * Networks, Inc. and many individuals on behalf of Vovida Networks,
 * Inc.  For more information on Vovida Networks, Inc., please see
 * <http://www.vovida.org/>.
 *
 * vi: set shiftwidth=3 expandtab:
 */