1 files changed, 194 insertions, 0 deletions
diff --git a/src/rtpSession.cpp b/src/rtpSession.cpp
new file mode 100644
index 0000000..a65ab5f
--- /dev/null
+++ b/src/rtpSession.cpp
@@ -0,0 +1,194 @@
+/*
+ * anytun
+ *
+ * The secure anycast tunneling protocol (satp) defines a protocol used
+ * for communication between any combination of unicast and anycast
+ * tunnel endpoints.  It has less protocol overhead than IPSec in Tunnel
+ * mode and allows tunneling of every ETHER TYPE protocol (e.g.
+ * ethernet, ip, arp ...). satp directly includes cryptography and
+ * message authentication based on the methodes used by SRTP.  It is
+ * intended to deliver a generic, scaleable and secure solution for
+ * tunneling and relaying of packets of any protocol.
+ *
+ *
+ * Copyright (C) 2007 anytun.org <satp@wirdorange.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program (see the file COPYING included with this
+ * distribution); if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "rtpSession.h"
+
+#include "anyrtpproxy/callIdQueue.h"
+
+RtpSession::RtpSession(const std::string& call_id) : in_sync_(false), call_id_(call_id) , dead_(false), complete_(false), 
+                                                     local_addr_("") , local_port1_(0), local_port2_(0),
+                                                     remote_addr1_(""), remote_addr2_(""), remote_port1_(0), remote_port2_(0),seen1_(false), seen2_(false)
+{  
+}
+
+void RtpSession::reinit()
+{
+  gCallIdQueue.push(call_id_);
+}
+
+bool RtpSession::isDead()
+{
+  Lock lock(mutex_);
+  return (dead_ && in_sync_);
+}
+
+bool RtpSession::isDead(bool d)
+{
+  Lock Lock(mutex_);
+  return dead_ = d;
+}
+
+bool RtpSession::isComplete()
+{
+  Lock lock(mutex_);
+  return complete_;
+}
+
+bool RtpSession::isComplete(bool c)
+{
+  Lock lock(mutex_);
+  return complete_ = c;
+}
+
+std::string RtpSession::getLocalAddr()
+{
+  Lock lock(mutex_);
+  return local_addr_;
+}
+
+RtpSession& RtpSession::setLocalAddr(std::string a)
+{
+  Lock lock(mutex_);
+  in_sync_ = false;
+  local_addr_ = a;
+  return *this;
+}
+
+bool RtpSession::getSeen1()
+{
+  Lock lock(mutex_);
+  return seen1_;
+}
+
+RtpSession& RtpSession::setSeen1()
+{
+  Lock lock(mutex_);
+  //in_sync_ = false;
+  seen1_ = true;
+  return *this;
+}
+
+bool RtpSession::getSeen2()
+{
+  Lock lock(mutex_);
+  return seen2_;
+}
+
+RtpSession& RtpSession::setSeen2()
+{
+  Lock lock(mutex_);
+  //in_sync_ = false;
+  seen2_ = true;
+  return *this;
+}
+
+u_int16_t RtpSession::getLocalPort1()
+{
+  Lock lock(mutex_);
+  return local_port1_;
+}
+
+RtpSession& RtpSession::setLocalPort1(u_int16_t p)
+{
+  Lock lock(mutex_);
+  in_sync_ = false;
+  local_port1_ = p;
+  return *this;
+}
+
+u_int16_t RtpSession::getLocalPort2()
+{
+  Lock lock(mutex_);
+  return local_port2_;
+}
+
+RtpSession& RtpSession::setLocalPort2(u_int16_t p)
+{
+  Lock lock(mutex_);
+  in_sync_ = false;
+  local_port2_ = p;
+  return *this;
+}
+
+u_int16_t RtpSession::getRemotePort1()
+{
+  Lock lock(mutex_);
+  return remote_port1_;
+}
+
+RtpSession& RtpSession::setRemotePort1(u_int16_t p)
+{
+  Lock lock(mutex_);
+  in_sync_ = false;
+  remote_port1_ = p;
+  return *this;
+}
+
+std::string RtpSession::getRemoteAddr1()
+{
+  Lock lock(mutex_);
+  return remote_addr1_;
+}
+
+RtpSession& RtpSession::setRemoteAddr1(std::string a)
+{
+  Lock lock(mutex_);
+  in_sync_ = false;
+  remote_addr1_ = a;
+  return *this;
+}
+
+u_int16_t RtpSession::getRemotePort2()
+{
+  Lock lock(mutex_);
+  return remote_port2_;
+}
+
+RtpSession& RtpSession::setRemotePort2(u_int16_t p)
+{
+  Lock lock(mutex_);
+  in_sync_ = false;
+  remote_port2_ = p;
+  return *this;
+}
+
+std::string RtpSession::getRemoteAddr2()
+{
+  Lock lock(mutex_);
+  return remote_addr2_;
+}
+
+RtpSession& RtpSession::setRemoteAddr2(std::string a)
+{
+  Lock lock(mutex_);
+  in_sync_ = false;
+  remote_addr2_ = a;
+  return *this;
+}