mirror of https://github.com/sipwise/sems.git
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
343 lines
9.0 KiB
343 lines
9.0 KiB
/*
|
|
* Copyright (C) 2002-2003 Fhg Fokus
|
|
*
|
|
* This file is part of SEMS, a free SIP media server.
|
|
*
|
|
* SEMS is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version. This program is released under
|
|
* the GPL with the additional exemption that compiling, linking,
|
|
* and/or using OpenSSL is allowed.
|
|
*
|
|
* For a license to use the SEMS software under conditions
|
|
* other than those described here, or to purchase support for this
|
|
* software, please contact iptel.org by e-mail at the following addresses:
|
|
* info@iptel.org
|
|
*
|
|
* SEMS 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; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
/** @file AmB2BSession.h */
|
|
#ifndef AmB2BSession_h
|
|
#define AmB2BSession_h
|
|
|
|
#include "AmSession.h"
|
|
#include "AmSipDialog.h"
|
|
#include "sip/hash.h"
|
|
|
|
#define MAX_RELAY_STREAMS 3 // voice, video, rtt
|
|
|
|
enum { B2BTerminateLeg,
|
|
B2BConnectLeg,
|
|
B2BSipRequest,
|
|
B2BSipReply,
|
|
B2BMsgBody };
|
|
|
|
/** \brief base class for event in B2B session */
|
|
struct B2BEvent: public AmEvent
|
|
{
|
|
B2BEvent(int ev_id)
|
|
: AmEvent(ev_id)
|
|
{}
|
|
};
|
|
|
|
/** \brief base class for SIP event in B2B session */
|
|
struct B2BSipEvent: public B2BEvent
|
|
{
|
|
bool forward;
|
|
|
|
B2BSipEvent(int ev_id, bool forward)
|
|
: B2BEvent(ev_id),
|
|
forward(forward)
|
|
{}
|
|
};
|
|
|
|
/** \brief SIP request in B2B session */
|
|
struct B2BSipRequestEvent: public B2BSipEvent
|
|
{
|
|
AmSipRequest req;
|
|
|
|
B2BSipRequestEvent(const AmSipRequest& req, bool forward)
|
|
: B2BSipEvent(B2BSipRequest,forward),
|
|
req(req)
|
|
{ }
|
|
};
|
|
|
|
/** \brief SIP reply in B2B session */
|
|
struct B2BSipReplyEvent: public B2BSipEvent
|
|
{
|
|
AmSipReply reply;
|
|
string trans_method;
|
|
|
|
B2BSipReplyEvent(const AmSipReply& reply, bool forward,
|
|
string trans_method)
|
|
: B2BSipEvent(B2BSipReply,forward),
|
|
reply(reply), trans_method(trans_method)
|
|
{ }
|
|
};
|
|
|
|
/** \brief trigger connecting the callee leg in B2B session */
|
|
struct B2BConnectEvent: public B2BEvent
|
|
{
|
|
string remote_party;
|
|
string remote_uri;
|
|
|
|
string content_type;
|
|
string body;
|
|
string hdrs;
|
|
|
|
bool relayed_invite;
|
|
unsigned int r_cseq;
|
|
|
|
B2BConnectEvent(const string& remote_party,
|
|
const string& remote_uri)
|
|
: B2BEvent(B2BConnectLeg),
|
|
remote_party(remote_party),
|
|
remote_uri(remote_uri),
|
|
relayed_invite(false),
|
|
r_cseq(0)
|
|
{}
|
|
};
|
|
|
|
/**
|
|
* \brief Base class for Sessions in B2BUA mode.
|
|
*
|
|
* It has two legs as independent sessions:
|
|
* Callee- and caller-leg.
|
|
*/
|
|
class AmB2BSession: public AmSession
|
|
{
|
|
public:
|
|
enum B2BMode {
|
|
B2BMode_Transparent, // relay message bodies
|
|
B2BMode_SDPFilter // reconstruct SDP
|
|
};
|
|
|
|
protected:
|
|
/** local tag of the other leg */
|
|
string other_id;
|
|
|
|
/** Tell if the session should
|
|
* process SIP request itself
|
|
* or only relay them (B2B mode).
|
|
*/
|
|
bool sip_relay_only;
|
|
|
|
B2BMode b2b_mode;
|
|
bool a_leg;
|
|
|
|
/**
|
|
* Requests which have been relayed
|
|
* from the other leg and sent as SIP
|
|
*/
|
|
TransMap relayed_req;
|
|
|
|
/** Requests received for relaying */
|
|
std::map<int,AmSipRequest> recvd_req;
|
|
|
|
/** CSeq of the INVITE that established this call */
|
|
unsigned int est_invite_cseq;
|
|
unsigned int est_invite_other_cseq;
|
|
auto_ptr<AmSdp> invite_sdp;
|
|
|
|
/** content-type of established session */
|
|
string established_content_type;
|
|
/** body of established session */
|
|
string established_body;
|
|
/** hash of body (from o-line) */
|
|
uint32_t body_hash;
|
|
/** save current session description (SDP) */
|
|
virtual void saveSessionDescription(const string& content_type, const string& body);
|
|
/** @return whether session has changed */
|
|
virtual bool updateSessionDescription(const string& content_type, const string& body);
|
|
|
|
/** reset relation with other leg */
|
|
virtual void clear_other();
|
|
|
|
/** Relay one event to the other side. @return 0 on success */
|
|
virtual int relayEvent(AmEvent* ev);
|
|
|
|
/** send a relayed SIP Request */
|
|
void relaySip(const AmSipRequest& req);
|
|
|
|
/** send a relayed SIP Reply */
|
|
void relaySip(const AmSipRequest& orig, const AmSipReply& reply);
|
|
|
|
/** Terminate our leg and forget the other. */
|
|
virtual void terminateLeg();
|
|
|
|
/** Terminate the other leg and forget it.*/
|
|
virtual void terminateOtherLeg();
|
|
|
|
|
|
/** @see AmSession */
|
|
virtual void updateUACTransCSeq(unsigned int old_cseq, unsigned int new_cseq);
|
|
|
|
void onSipRequest(const AmSipRequest& req);
|
|
void onSipReply(const AmSipReply& reply,
|
|
int old_dlg_status, const string& trans_method);
|
|
void onInvite2xx(const AmSipReply& reply);
|
|
|
|
void onSessionTimeout();
|
|
void onNoAck(unsigned int cseq);
|
|
|
|
/** send re-INVITE with established session description
|
|
* @return 0 on success
|
|
*/
|
|
int sendEstablishedReInvite();
|
|
|
|
/** do session refresh */
|
|
bool refresh(int flags = 0);
|
|
|
|
/** @see AmEventQueue */
|
|
void process(AmEvent* event);
|
|
|
|
/** B2BEvent handler */
|
|
virtual void onB2BEvent(B2BEvent* ev);
|
|
|
|
/** handle BYE on other leg */
|
|
virtual void onOtherBye(const AmSipRequest& req);
|
|
|
|
/**
|
|
* Reply received from other leg has been replied
|
|
* @return true if reply was processed (should be absorbed)
|
|
* @return false if reply was not processed
|
|
*/
|
|
virtual bool onOtherReply(const AmSipReply& reply);
|
|
|
|
/** filter body ( b2b_mode == SDPFilter */
|
|
virtual int filterBody(string& content_type, string& body,
|
|
AmSdp& filter_sdp, bool is_a2b);
|
|
|
|
/** filter SDP body ( b2b_mode == SDPFilter */
|
|
virtual int filterBody(AmSdp& sdp, bool is_a2b);
|
|
|
|
AmB2BSession();
|
|
AmB2BSession(const string& other_local_tag);
|
|
|
|
virtual ~AmB2BSession();
|
|
|
|
/** flag to enable RTP relay mode */
|
|
bool rtp_relay_enabled;
|
|
/** force symmetric RTP */
|
|
bool rtp_relay_force_symmetric_rtp;
|
|
|
|
|
|
/** RTP streams which receive from our side and are used
|
|
for relaying RTP from the other side */
|
|
AmRtpStream** relay_rtp_streams;
|
|
/** number of relay RTP streams */
|
|
unsigned int relay_rtp_streams_cnt;
|
|
/** fd of the other streams' sockets (to remove from
|
|
RtpReceiver at end of relaying) */
|
|
int other_stream_fds[MAX_RELAY_STREAMS];
|
|
/** clear our and the other side's RTP streams from RTPReceiver */
|
|
void clearRtpReceiverRelay();
|
|
/** update remote connection in relay_streams */
|
|
void updateRelayStreams(const string& content_type, const string& body,
|
|
AmSdp& parser_sdp);
|
|
/** replace connection with our address */
|
|
bool replaceConnectionAddress(const string& content_type, const string& body,
|
|
string& r_body);
|
|
|
|
public:
|
|
void set_sip_relay_only(bool r);
|
|
B2BMode getB2BMode() const;
|
|
|
|
/** set RTP relay mode enabled for initial INVITE */
|
|
void enableRtpRelay(const AmSipRequest& initial_invite_req);
|
|
/** set RTP relay mode enabled */
|
|
void enableRtpRelay();
|
|
/** set RTP relay mode disabled */
|
|
void disableRtpRelay();
|
|
/** link RTP streams of other_session to our streams */
|
|
void setupRelayStreams(AmB2BSession* from_session);
|
|
bool getRtpRelayEnabled() const { return rtp_relay_enabled; }
|
|
bool getRtpRelayForceSymmetricRtp() const { return rtp_relay_force_symmetric_rtp; }
|
|
};
|
|
|
|
class AmB2BCalleeSession;
|
|
|
|
/** \brief Caller leg of a B2B session */
|
|
class AmB2BCallerSession: public AmB2BSession
|
|
{
|
|
public:
|
|
enum CalleeStatus {
|
|
None=0,
|
|
NoReply,
|
|
Ringing,
|
|
Connected
|
|
};
|
|
|
|
private:
|
|
// Callee Status
|
|
CalleeStatus callee_status;
|
|
|
|
int reinviteCaller(const AmSipReply& callee_reply);
|
|
|
|
protected:
|
|
AmSipRequest invite_req;
|
|
virtual void createCalleeSession();
|
|
int relayEvent(AmEvent* ev);
|
|
|
|
/** Tell if the session should
|
|
* relay early media SDPs to
|
|
* caller leg
|
|
*/
|
|
bool sip_relay_early_media_sdp;
|
|
|
|
public:
|
|
AmB2BCallerSession();
|
|
virtual ~AmB2BCallerSession();
|
|
|
|
CalleeStatus getCalleeStatus() { return callee_status; }
|
|
void setCalleeStatus(CalleeStatus c) { callee_status = c; }
|
|
|
|
virtual AmB2BCalleeSession* newCalleeSession();
|
|
|
|
void connectCallee(const string& remote_party,
|
|
const string& remote_uri,
|
|
bool relayed_invite = false);
|
|
|
|
const AmSipRequest& getOriginalRequest() { return invite_req; }
|
|
|
|
// @see AmSession
|
|
void onSessionStart(const AmSipRequest& req);
|
|
void onCancel();
|
|
|
|
// @see AmB2BSession
|
|
void terminateLeg();
|
|
void terminateOtherLeg();
|
|
void onB2BEvent(B2BEvent* ev);
|
|
|
|
AmSipRequest* getInviteReq() { return &invite_req; }
|
|
|
|
void set_sip_relay_early_media_sdp(bool r);
|
|
|
|
/** initialize RTP relay mode, if rtp_relay_enabled
|
|
must be called *before* callee_session is started
|
|
*/
|
|
void initializeRTPRelay(AmB2BCalleeSession* callee_session);
|
|
};
|
|
|
|
/** \brief Callee leg of a B2B session */
|
|
class AmB2BCalleeSession: public AmB2BSession
|
|
{
|
|
public:
|
|
AmB2BCalleeSession(const string& other_local_tag);
|
|
AmB2BCalleeSession(const AmB2BCallerSession* caller);
|
|
|
|
virtual ~AmB2BCalleeSession();
|
|
|
|
void onB2BEvent(B2BEvent* ev);
|
|
};
|
|
|
|
#endif
|