1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
|
/*
* Oreka -- A media capture and retrieval platform
*
* Copyright (C) 2005, orecx LLC
*
* http://www.orecx.com
*
* This program is free software, distributed under the terms of
* the GNU General Public License.
* Please refer to http://www.gnu.org/copyleft/gpl.html
*
*/
#ifndef __RTPSESSION_H__
#define __RTPSESSION_H__
#include <log4cxx/logger.h>
#include "RtpSession.h"
#include "Rtp.h"
#include <map>
#include "ace/OS_NS_sys_time.h"
#include "ace/Singleton.h"
#include "PacketHeaderDefs.h"
using namespace log4cxx;
class Sip302MovedTemporarilyInfo
{
public:
Sip302MovedTemporarilyInfo();
void ToString(CStdString& string);
struct in_addr m_senderIp;
struct in_addr m_receiverIp;
CStdString m_from;
CStdString m_to;
CStdString m_contact;
CStdString m_callId;
CStdString m_fromDomain;
CStdString m_toDomain;
CStdString m_contactDomain;
CStdString m_fromName;
CStdString m_toName;
CStdString m_contactName;
};
typedef boost::shared_ptr<Sip302MovedTemporarilyInfo> Sip302MovedTemporarilyInfoRef;
class SipInviteInfo
{
public:
SipInviteInfo();
void ToString(CStdString& string);
struct in_addr m_senderIp;
struct in_addr m_receiverIp;
struct in_addr m_fromRtpIp;
char m_senderMac[6];
char m_receiverMac[6];
CStdString m_fromRtpPort;
CStdString m_from;
CStdString m_to;
CStdString m_callId;
CStdString m_requestUri;
bool m_validated; // true when an RTP stream has been seen for the INVITE
bool m_attrSendonly; // true if the SDP has a:sendonly
std::map<CStdString, CStdString> m_extractedFields;
CStdString m_telephoneEventPayloadType;
bool m_telephoneEventPtDefined;
CStdString m_fromDomain;
CStdString m_toDomain;
CStdString m_fromName;
CStdString m_toName;
CStdString m_userAgent;
time_t m_recvTime;
};
typedef boost::shared_ptr<SipInviteInfo> SipInviteInfoRef;
class SipFailureMessageInfo
{
public:
SipFailureMessageInfo();
virtual void ToString(CStdString& string);
virtual void ToString(CStdString& string, SipInviteInfoRef inviteInfo);
struct in_addr m_senderIp;
struct in_addr m_receiverIp;
char m_senderMac[6];
char m_receiverMac[6];
CStdString m_callId;
CStdString m_errorCode;
CStdString m_errorString;
};
typedef boost::shared_ptr<SipFailureMessageInfo> SipFailureMessageInfoRef;
class SipByeInfo
{
public:
SipByeInfo();
void ToString(CStdString& string);
CStdString m_callId;
struct in_addr m_senderIp;
struct in_addr m_receiverIp;
CStdString m_from;
CStdString m_to;
CStdString m_fromDomain;
CStdString m_toDomain;
CStdString m_fromName;
CStdString m_toName;
};
typedef boost::shared_ptr<SipByeInfo> SipByeInfoRef;
class Sip200OkInfo
{
public:
Sip200OkInfo();
void ToString(CStdString& string);
CStdString m_callId;
bool m_hasSdp;
struct in_addr m_mediaIp;
CStdString m_mediaPort;
struct in_addr m_senderIp;
struct in_addr m_receiverIp;
CStdString m_from;
CStdString m_to;
};
typedef boost::shared_ptr<Sip200OkInfo> Sip200OkInfoRef;
class SipSessionProgressInfo
{
public:
SipSessionProgressInfo();
void ToString(CStdString& string);
CStdString m_callId;
struct in_addr m_mediaIp;
CStdString m_mediaPort;
struct in_addr m_senderIp;
struct in_addr m_receiverIp;
CStdString m_from;
CStdString m_to;
};
typedef boost::shared_ptr<SipSessionProgressInfo> SipSessionProgressInfoRef;
//=============================================================
class EndpointInfo
{
public:
CStdString m_extension;
CStdString m_latestCallId;
struct in_addr m_ip;
};
typedef boost::shared_ptr<EndpointInfo> EndpointInfoRef;
// ============================================================
class RtpSession
{
public:
#define PROT_RAW_RTP "RawRtp"
#define PROT_SIP "Sip"
#define PROT_SKINNY "Skinny"
#define PROT_UNKN "Unkn"
typedef enum{ProtRawRtp, ProtSip, ProtSkinny, ProtUnkn} ProtocolEnum;
static int ProtocolToEnum(CStdString& protocol);
static CStdString ProtocolToString(int protocolEnum);
RtpSession(CStdString& trackingId);
void Stop();
void Start();
bool AddRtpPacket(RtpPacketInfoRef& rtpPacket);
void ReportSipBye(SipByeInfoRef& bye);
void ReportSipInvite(SipInviteInfoRef& invite);
void ReportSipErrorPacket(SipFailureMessageInfoRef& info);
void ReportRtcpSrcDescription(RtcpSrcDescriptionPacketInfoRef& rtcpInfo);
bool OrkUidMatches(CStdString &oUid);
bool PartyMatches(CStdString &party);
bool NativeCallIdMatches(CStdString &callid);
void UpdateMetadataSkinny();
void ReportSkinnyCallInfo(SkCallInfoStruct*, IpHeaderStruct* ipHeader);
CStdString GetOrkUid();
void MarkAsOnDemand();
bool Stopped();
CStdString m_capturePort;
CStdString m_trackingId;
CStdString m_ipAndPort; // IP address and UDP port of one side of the RTP session, serves as a key for session storage and retrieval. Not necessarily the same as the capturePort (capturePort is usually the client (phone) IP+port)
struct in_addr m_rtpIp; // IP address of one side of the RTP session
CStdString m_callId;
SipInviteInfoRef m_invite;
ACE_Time_Value m_creationDate; // When the session is first created
time_t m_beginDate; // When the session has seen a few RTP packets
time_t m_lastUpdated;
ProtocolEnum m_protocol;
CStdString m_localParty;
CStdString m_remoteParty;
CStdString m_localEntryPoint;
CStdString m_localPartyName;
CStdString m_remotePartyName;
bool m_localPartyReported;
bool m_remotePartyReported;
bool m_rtcpLocalParty;
bool m_rtcpRemoteParty;
CaptureEvent::DirectionEnum m_direction;
int m_numRtpPackets;
struct in_addr m_endPointIp; // only used for Skinny
int m_skinnyPassThruPartyId;
ACE_Time_Value m_skinnyLastCallInfoTime;
int m_skinnyLineInstance;
bool m_onHold;
bool m_keep;
bool m_nonLookBackSessionStarted;
bool m_onDemand;
std::list<CStdString> m_otherIpAndPortMappings;
private:
void ProcessMetadataSip(RtpPacketInfoRef&);
void ProcessMetadataSipIncoming();
void ProcessMetadataSipOutgoing();
void UpdateMetadataSip(RtpPacketInfoRef& rtpPacket, bool);
void ProcessMetadataRawRtp(RtpPacketInfoRef&);
void ProcessMetadataSkinny(RtpPacketInfoRef& rtpPacket);
void ReportMetadata();
void GenerateOrkUid();
void HandleRtpEvent(RtpPacketInfoRef& rtpPacket);
void RecordRtpEvent();
bool MatchesSipDomain(CStdString& domain);
bool MatchesReferenceAddresses(struct in_addr inAddr);
bool IsInSkinnyReportingList(CStdString item);
RtpPacketInfoRef m_lastRtpPacket;
RtpPacketInfoRef m_lastRtpPacketSide1;
RtpPacketInfoRef m_lastRtpPacketSide2;
//RtpRingBuffer m_rtpRingBuffer;
struct in_addr m_invitorIp;
int m_invitorTcpPort;
struct in_addr m_inviteeIp;
int m_inviteeTcpPort;
char m_invitorMac[6];
char m_inviteeMac[6];
struct in_addr m_localIp;
struct in_addr m_remoteIp;
char m_localMac[6];
char m_remoteMac[6];
//struct in_addr m_localMac;
//struct in_addr m_remoteMac;
LoggerPtr m_log;
bool m_started;
bool m_stopped;
CStdString m_orkUid;
bool m_hasDuplicateRtp;
unsigned int m_highestRtpSeqNumDelta;
double m_minRtpSeqDelta;
double m_minRtpTimestampDelta;
TcpAddressList m_rtpAddressList;
std::list<SipInviteInfoRef> m_invites;
std::map<CStdString, CStdString> m_tags;
bool m_sessionTelephoneEventPtDefined;
CStdString m_telephoneEventPayloadType;
unsigned short m_currentRtpEvent;
unsigned int m_currentRtpEventTs;
unsigned int m_currentDtmfDuration;
unsigned int m_currentDtmfVolume;
unsigned int m_currentSeqNo;
unsigned int m_lastEventEndSeqNo;
};
typedef boost::shared_ptr<RtpSession> RtpSessionRef;
//===================================================================
class RtpSessions
{
public:
RtpSessions();
void Stop(RtpSessionRef& session);
void StopAll();
void ReportSipInvite(SipInviteInfoRef& invite);
void ReportSipBye(SipByeInfoRef& bye);
void ReportSkinnyCallInfo(SkCallInfoStruct*, IpHeaderStruct* ipHeader);
void ReportSkinnyStartMediaTransmission(SkStartMediaTransmissionStruct*, IpHeaderStruct* ipHeader);
void ReportSkinnyStopMediaTransmission(SkStopMediaTransmissionStruct*, IpHeaderStruct* ipHeader);
void ReportSkinnyOpenReceiveChannelAck(SkOpenReceiveChannelAckStruct*);
void SetEndpointExtension(CStdString& extension, struct in_addr* endpointIp, CStdString& callId);
void ReportSkinnyLineStat(SkLineStatStruct*, IpHeaderStruct* ipHeader);
void ReportSkinnySoftKeyHold(SkSoftKeyEventMessageStruct* skEvent, IpHeaderStruct* ipHeader);
void ReportSkinnySoftKeyResume(SkSoftKeyEventMessageStruct* skEvent, IpHeaderStruct* ipHeader);
void ReportRtpPacket(RtpPacketInfoRef& rtpPacket);
bool ReportRtcpSrcDescription(RtcpSrcDescriptionPacketInfoRef& rtcpInfo);
void ReportSipErrorPacket(SipFailureMessageInfoRef& sipError);
void ReportSip200Ok(Sip200OkInfoRef info);
void ReportSipSessionProgress(SipSessionProgressInfoRef& info);
void ReportSip302MovedTemporarily(Sip302MovedTemporarilyInfoRef& info);
void Hoover(time_t now);
EndpointInfoRef GetEndpointInfo(struct in_addr endpointIp);
CStdString StartCapture(CStdString& party);
void StartCaptureOrkuid(CStdString& orkuid);
CStdString StartCaptureNativeCallId(CStdString& nativecallid);
CStdString PauseCaptureNativeCallId(CStdString& nativecallid);
CStdString PauseCapture(CStdString& party);
void PauseCaptureOrkuid(CStdString& orkuid);
CStdString StopCapture(CStdString& party);
void StopCaptureOrkuid(CStdString& orkuid);
CStdString StopCaptureNativeCallId(CStdString& nativecallid);
void SaveLocalPartyMap(CStdString& oldparty, CStdString& newparty);
CStdString GetLocalPartyMap(CStdString& oldlocalparty);
private:
void CraftMediaAddress(CStdString& mediaAddress, struct in_addr ipAddress, unsigned short udpPort);
RtpSessionRef findByMediaAddress(struct in_addr ipAddress, unsigned short udpPort);
RtpSessionRef findByEndpointIp(struct in_addr endpointIpAddr, int passThruPartyId = 0);
RtpSessionRef findNewestByEndpointIp(struct in_addr endpointIpAddr);
RtpSessionRef findByEndpointIpUsingIpAndPort(struct in_addr endpointIpAddr);
RtpSessionRef findByEndpointIpAndLineInstance(struct in_addr endpointIpAddr, int lineInstance);
bool ChangeCallId(RtpSessionRef& session, unsigned int newId);
void SetMediaAddress(RtpSessionRef& session, struct in_addr mediaIp, unsigned short mediaPort);
void MapOtherMediaAddress(RtpSessionRef& session, CStdString& ipAndPort);
CStdString GenerateSkinnyCallId(struct in_addr endpointIp, unsigned int callId);
void UpdateEndpointWithCallInfo(SkCallInfoStruct* callInfo, IpHeaderStruct* ipHeader);
void UpdateSessionWithCallInfo(SkCallInfoStruct*, RtpSessionRef&);
bool TrySkinnySession(RtpPacketInfoRef& rtpPacket, EndpointInfoRef&);
std::map<CStdString, RtpSessionRef> m_byIpAndPort;
std::map<CStdString, RtpSessionRef> m_byCallId;
std::map<unsigned int, EndpointInfoRef> m_endpoints;
std::map<CStdString, CStdString> m_localPartyMap;
LoggerPtr m_log;
AlphaCounter m_alphaCounter;
};
typedef ACE_Singleton<RtpSessions, ACE_Thread_Mutex> RtpSessionsSingleton;
#endif
|
