src/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-2008 Othmar Gsenger, Erwin Nindl,
  15  *                          Christian Pointner <satp@wirdorange.org>
  16  *
  17  *  This file is part of Anytun.
  18  *
  19  *  Anytun is free software: you can redistribute it and/or modify
  20  *  it under the terms of the GNU General Public License version 3 as
  21  *  published by the Free Software Foundation.
  22  *
  23  *  Anytun is distributed in the hope that it will be useful,
  24  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  25  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  26  *  GNU General Public License for more details.
  27  *
  28  *  You should have received a copy of the GNU General Public License
  29  *  along with anytun.  If not, see <http://www.gnu.org/licenses/>.
  30  */
  31 #include "threadUtils.hpp"
  32 #include "datatypes.h"
  33
  34 #include "rtpSessionTable.h"
  35
  36 RtpSessionTable* RtpSessionTable::inst = NULL;
  37 Mutex RtpSessionTable::instMutex;
  38 RtpSessionTable& gRtpSessionTable = RtpSessionTable::instance();
  39
  40
  41 RtpSessionTable& RtpSessionTable::instance()
  42 {
  43   Lock lock(instMutex);
  44   static instanceCleaner c;
  45   if(!inst)
  46     inst = new RtpSessionTable();
  47
  48   return *inst;
  49 }
  50
  51 RtpSessionTable::RtpSessionTable()
  52 {
  53 }
  54
  55 RtpSessionTable::~RtpSessionTable()
  56 {
  57 }
  58
  59 void RtpSessionTable::delSession(const std::string & call_id)
  60 {
  61   Lock lock(mutex_);
  62
  63   RtpSessionMap::iterator it = map_.find(call_id);
  64   if(it!=map_.end())
  65     delete it->second;
  66
  67   map_.erase(it);
  68 }
  69
  70 RtpSession& RtpSessionTable::getOrNewSession(const std::string & call_id, bool& is_new)
  71 {
  72   Lock lock(mutex_);
  73   return getOrNewSessionUnlocked(call_id, is_new);
  74 }
  75
  76 RtpSession& RtpSessionTable::getOrNewSessionUnlocked(const std::string & call_id, bool& is_new)
  77 {
  78   is_new = false;
  79   RtpSessionMap::iterator it = map_.find(call_id);
  80   if(it!=map_.end())
  81     return *(it->second);
  82
  83   is_new = true;
  84   std::pair<RtpSessionMap::iterator, bool> ret = map_.insert(RtpSessionMap::value_type(call_id, NULL));
  85   ret.first->second = new RtpSession(ret.first->first);
  86   return *(ret.first->second);
  87 }
  88
  89 RtpSession& RtpSessionTable::getSession(const std::string & call_id)
  90 {
  91   RtpSessionMap::iterator it = map_.find(call_id);
  92   if(it!=map_.end())
  93     return *(it->second);
  94
  95   throw std::runtime_error("session not found");
  96 }
  97
  98 RtpSessionMap::iterator RtpSessionTable::getBeginUnlocked()
  99 {
 100   return map_.begin();
 101 }
 102
 103 RtpSessionMap::iterator RtpSessionTable::getEndUnlocked()
 104 {
 105   return map_.end();
 106 }
 107
 108 void RtpSessionTable::clear()
 109 {
 110   Lock lock(mutex_);
 111         map_.clear();
 112 }
 113
 114 bool RtpSessionTable::empty()
 115 {
 116   Lock lock(mutex_);
 117         return map_.empty();
 118 }
 119
 120 Mutex& RtpSessionTable::getMutex()
 121 {
 122   return mutex_;
 123 }