added rtpsession seen
[anytun.git] / rtpSession.cpp
bloba32049b76c2dc56695f54986911764cd997d77ad
1 /*
2 * anytun
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.
14 * Copyright (C) 2007 anytun.org <satp@wirdorange.org>
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.
20 * This program is distributed in the hope that it will be useful,
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 * GNU General Public License for more details.
25 * You should have received a copy of the GNU General Public License
26 * along with this program (see the file COPYING included with this
27 * distribution); if not, write to the Free Software Foundation, Inc.,
28 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
31 #include "rtpSession.h"
33 #include "anyrtpproxy/callIdQueue.h"
35 RtpSession::RtpSession(const std::string& call_id) : in_sync_(false), call_id_(call_id) , dead_(false), complete_(false),
36 local_addr_("") , local_port1_(0), local_port2_(0),
37 remote_addr1_(""), remote_addr2_(""), remote_port1_(0), remote_port2_(0),seen1_(false), seen2_(false)
41 void RtpSession::reinit()
43 Lock lock(mutex_);
45 gCallIdQueue.push(call_id_);
48 bool RtpSession::isDead()
50 Lock lock(mutex_);
51 return (dead_ && in_sync_);
54 bool RtpSession::isDead(bool d)
56 Lock Lock(mutex_);
57 return dead_ = d;
60 bool RtpSession::isComplete()
62 Lock lock(mutex_);
63 return complete_;
66 bool RtpSession::isComplete(bool c)
68 Lock lock(mutex_);
69 return complete_ = c;
72 std::string RtpSession::getLocalAddr()
74 Lock lock(mutex_);
75 return local_addr_;
78 RtpSession& RtpSession::setLocalAddr(std::string a)
80 Lock lock(mutex_);
81 in_sync_ = false;
82 local_addr_ = a;
83 return *this;
86 bool RtpSession::getSeen1()
88 Lock lock(mutex_);
89 return seen1_;
92 RtpSession& RtpSession::setSeen1()
94 Lock lock(mutex_);
95 //in_sync_ = false;
96 seen1_ = true;
97 return *this;
100 bool RtpSession::getSeen2()
102 Lock lock(mutex_);
103 return seen2_;
106 RtpSession& RtpSession::setSeen2()
108 Lock lock(mutex_);
109 //in_sync_ = false;
110 seen2_ = true;
111 return *this;
114 u_int16_t RtpSession::getLocalPort1()
116 Lock lock(mutex_);
117 return local_port1_;
120 RtpSession& RtpSession::setLocalPort1(u_int16_t p)
122 Lock lock(mutex_);
123 in_sync_ = false;
124 local_port1_ = p;
125 return *this;
128 u_int16_t RtpSession::getLocalPort2()
130 Lock lock(mutex_);
131 return local_port2_;
134 RtpSession& RtpSession::setLocalPort2(u_int16_t p)
136 Lock lock(mutex_);
137 in_sync_ = false;
138 local_port2_ = p;
139 return *this;
142 u_int16_t RtpSession::getRemotePort1()
144 Lock lock(mutex_);
145 return remote_port1_;
148 RtpSession& RtpSession::setRemotePort1(u_int16_t p)
150 Lock lock(mutex_);
151 in_sync_ = false;
152 remote_port1_ = p;
153 return *this;
156 std::string RtpSession::getRemoteAddr1()
158 Lock lock(mutex_);
159 return remote_addr1_;
162 RtpSession& RtpSession::setRemoteAddr1(std::string a)
164 Lock lock(mutex_);
165 in_sync_ = false;
166 remote_addr1_ = a;
167 return *this;
170 u_int16_t RtpSession::getRemotePort2()
172 Lock lock(mutex_);
173 return remote_port2_;
176 RtpSession& RtpSession::setRemotePort2(u_int16_t p)
178 Lock lock(mutex_);
179 in_sync_ = false;
180 remote_port2_ = p;
181 return *this;
184 std::string RtpSession::getRemoteAddr2()
186 Lock lock(mutex_);
187 return remote_addr2_;
190 RtpSession& RtpSession::setRemoteAddr2(std::string a)
192 Lock lock(mutex_);
193 in_sync_ = false;
194 remote_addr2_ = a;
195 return *this;