rtpSessionTable.cpp

   1 /*
   2  *  anytun
   3  *
   4  *  The secure anycast tunneling protocol (satp) defines a protocol used
   5  *  for communication between any combination of unicast and anycast
   6  *  tunnel endpoints.  It has less protocol overhead than IPSec in Tunnel
   7  *  mode and allows tunneling of every ETHER TYPE protocol (e.g.
   8  *  ethernet, ip, arp ...). satp directly includes cryptography and
   9  *  message authentication based on the methodes used by SRTP.  It is
  10  *  intended to deliver a generic, scaleable and secure solution for
  11  *  tunneling and relaying of packets of any protocol.
  12  *
  13  *
  14  *  Copyright (C) 2007 anytun.org <satp@wirdorange.org>
  15  *
  16  *  This program is free software; you can redistribute it and/or modify
  17  *  it under the terms of the GNU General Public License version 2
  18  *  as published by the Free Software Foundation.
  19  *
  20  *  This program is distributed in the hope that it will be useful,
  21  *  but WITHOUT ANY WARRANTY; without even the implied warranty of *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  *  GNU General Public License for more details.
  23  *
  24  *  You should have received a copy of the GNU General Public License
  25  *  along with this program (see the file COPYING included with this
  26  *  distribution); if not, write to the Free Software Foundation, Inc.,
  27  *  59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  28  */
  29 #include "threadUtils.hpp"
  30 #include "datatypes.h"
  31
  32 #include "rtpSessionTable.h"
  33
  34 RtpSessionTable* RtpSessionTable::inst = NULL;
  35 Mutex RtpSessionTable::instMutex;
  36 RtpSessionTable& gRtpSessionTable = RtpSessionTable::instance();
  37
  38
  39 RtpSessionTable& RtpSessionTable::instance()
  40 {
  41   Lock lock(instMutex);
  42   static instanceCleaner c;
  43   if(!inst)
  44     inst = new RtpSessionTable();
  45
  46   return *inst;
  47 }
  48
  49 RtpSessionTable::RtpSessionTable()
  50 {
  51 }
  52
  53 RtpSessionTable::~RtpSessionTable()
  54 {
  55 }
  56
  57 void RtpSessionTable::delSession(const std::string & call_id)
  58 {
  59   Lock lock(mutex_);
  60
  61   RtpSessionMap::iterator it = map_.find(call_id);
  62   if(it!=map_.end())
  63     delete it->second;
  64
  65   map_.erase(it);
  66 }
  67
  68 RtpSession& RtpSessionTable::getOrNewSession(const std::string & call_id, bool& is_new)
  69 {
  70   Lock lock(mutex_);
  71   return getOrNewSessionUnlocked(call_id, is_new);
  72 }
  73
  74 RtpSession& RtpSessionTable::getOrNewSessionUnlocked(const std::string & call_id, bool& is_new)
  75 {
  76   is_new = false;
  77   RtpSessionMap::iterator it = map_.find(call_id);
  78   if(it!=map_.end())
  79     return *(it->second);
  80
  81   is_new = true;
  82   std::pair<RtpSessionMap::iterator, bool> ret = map_.insert(RtpSessionMap::value_type(call_id, NULL));
  83   ret.first->second = new RtpSession(ret.first->first);
  84   return *(ret.first->second);
  85 }
  86
  87 RtpSession& RtpSessionTable::getSession(const std::string & call_id)
  88 {
  89   RtpSessionMap::iterator it = map_.find(call_id);
  90   if(it!=map_.end())
  91     return *(it->second);
  92
  93   throw std::runtime_error("session not found");
  94 }
  95
  96 RtpSessionMap::iterator RtpSessionTable::getBeginUnlocked()
  97 {
  98   return map_.begin();
  99 }
 100
 101 RtpSessionMap::iterator RtpSessionTable::getEndUnlocked()
 102 {
 103   return map_.end();
 104 }
 105
 106 void RtpSessionTable::clear()
 107 {
 108   Lock lock(mutex_);
 109         map_.clear();
 110 }
 111
 112 bool RtpSessionTable::empty()
 113 {
 114   Lock lock(mutex_);
 115         return map_.empty();
 116 }
 117
 118 Mutex& RtpSessionTable::getMutex()
 119 {
 120   return mutex_;
 121 }