retronetworking
/
yate
12
0
Fork 2
Code Issues Pull Requests Projects Releases Wiki Activity
yate/modules/ysipchan.cpp

1371 lines
37 KiB
C++
Raw Blame History

/**
* ysipchan.cpp
* This file is part of the YATE Project http://YATE.null.ro
*
* Yet Another Sip Channel
*
* Yet Another Telephony Engine - a fully featured software PBX and IVR
* Copyright (C) 2004 Null Team
*
* This program 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 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., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include <yatephone.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <fcntl.h>
/**
* we include also the sip stack headers
*/
#include <ysip.h>
using namespace TelEngine;
/* Yate Payloads for the AV profile */
static TokenDict dict_payloads[] = {
{ "mulaw", 0 },
{ "alaw", 8 },
{ "gsm", 3 },
{ "lpc10", 7 },
{ "slin", 11 },
{ "g726", 2 },
{ "g722", 9 },
{ "g723", 4 },
{ "g728", 15 },
{ "g729", 18 },
};
/* SDP Payloads for the AV profile */
static TokenDict dict_rtpmap[] = {
{ "PCMU/8000", 0 },
{ "PCMA/8000", 8 },
{ "GSM/8000", 3 },
{ "LPC/8000", 7 },
{ "L16/8000", 11 },
{ "G726-32/8000", 2 },
{ "G722/8000", 9 },
{ "G723/8000", 4 },
{ "G728/8000", 15 },
{ "G729/8000", 18 },
};
static Configuration s_cfg;
class SIPHandler : public MessageHandler
{
public:
SIPHandler(const char *name) : MessageHandler(name) { }
virtual bool received(Message &msg);
};
class HaltHandler : public MessageHandler
{
public:
HaltHandler(const char *name) : MessageHandler(name) { }
virtual bool received(Message &msg);
};
class StatusHandler : public MessageHandler
{
public:
StatusHandler(const char *name) : MessageHandler(name) { }
virtual bool received(Message &msg);
};
class SIPConnHandler : public MessageReceiver
{
public:
enum {
Ringing,
Answered,
Drop,
Masquerade,
};
virtual bool received(Message &msg, int id);
};
class YateUDPParty : public SIPParty
{
public:
YateUDPParty(int fd,struct sockaddr_in sin,int local);
~YateUDPParty();
virtual void transmit(SIPEvent* event);
virtual const char* getProtoName() const;
virtual bool setParty(const URI& uri);
protected:
int m_netfd;
struct sockaddr_in m_sin;
};
class YateSIPEndPoint;
class YateSIPEngine : public SIPEngine
{
public:
YateSIPEngine(YateSIPEndPoint* ep);
virtual bool buildParty(SIPMessage* message);
private:
YateSIPEndPoint* m_ep;
};
class YateSIPEndPoint : public Thread
{
public:
YateSIPEndPoint();
~YateSIPEndPoint();
bool Init(void);
// YateSIPConnection *findconn(int did);
// void terminateall(void);
void run(void);
bool incoming(SIPEvent* e, SIPTransaction* t);
void invite(SIPEvent* e, SIPTransaction* t);
void regreq(SIPEvent* e, SIPTransaction* t);
bool buildParty(SIPMessage* message, const char* host = 0, int port = 0);
inline YateSIPEngine* engine() const
{ return m_engine; }
inline int port() const
{ return m_port; }
inline int fd() const
{ return m_netfd; }
private:
int m_localport;
int m_port;
int m_netfd;
YateSIPEngine *m_engine;
};
class YateSIPConnection : public DataEndpoint
{
public:
enum {
Incoming,
Outgoing,
Established,
Cleared,
};
YateSIPConnection(Message& msg, SIPTransaction* tr);
YateSIPConnection(Message& msg, const String& uri);
~YateSIPConnection();
virtual void disconnected(bool final, const char *reason);
virtual const String& toString() const
{ return m_id; }
bool process(SIPEvent* ev);
void ringing(Message* msg = 0);
void answered(Message* msg = 0);
void doBye(SIPTransaction* t);
void doCancel(SIPTransaction* t);
void reInvite(SIPTransaction* t);
void hangup();
inline String id() const
{ return "sip/" + m_id; }
inline const SIPDialog& dialog() const
{ return m_id; }
inline const String& status() const
{ return m_status; }
inline void setStatus(const char *status, int state = -1)
{ m_status = status; if (state >= 0) m_state = state; }
inline void setReason(const char* str = "Request Terminated", int code = 487)
{ m_reason = str; m_reasonCode = code; }
inline void setTarget(const char *target = 0)
{ m_target = target; }
inline const String& getTarget() const
{ return m_target; }
inline SIPTransaction* getTransaction() const
{ return m_tr; }
inline const String& getHost() const
{ return m_host; }
inline int getPort() const
{ return m_port; }
static YateSIPConnection* find(const String& id);
static YateSIPConnection* find(const SIPDialog& id);
private:
void clearTransaction();
SDPBody* createSDP(const char* addr, const char* port, const char* formats, const char* format = 0);
SDPBody* createPasstroughSDP(Message &msg);
SDPBody* createRtpSDP(SIPMessage* msg, const char* formats);
SDPBody* createRtpSDP(bool start = false);
bool startRtp();
SIPTransaction* m_tr;
bool m_hungup;
bool m_byebye;
int m_state;
String m_reason;
int m_reasonCode;
SIPDialog m_id;
URI m_uri;
String m_target;
String m_status;
String m_rtpid;
String m_rtpAddr;
String m_rtpPort;
String m_rtpFormat;
String m_rtpLocal;
int m_rtpSession;
int m_rtpVersion;
String m_formats;
String m_host;
int m_port;
};
class SipMsgThread : public Thread
{
public:
SipMsgThread(SIPTransaction* tr, Message* msg)
: Thread("SipMsgThread"), m_tr(tr), m_msg(msg)
{ m_tr->ref(); m_id = m_tr->getCallID(); }
virtual void run();
virtual void cleanup();
bool route();
inline static int count()
{ return s_count; }
inline static int routed()
{ return s_routed; }
private:
SIPTransaction* m_tr;
Message* m_msg;
String m_id;
static int s_count;
static int s_routed;
};
class SIPPlugin : public Plugin
{
public:
SIPPlugin();
~SIPPlugin();
virtual void initialize();
inline YateSIPEndPoint* ep() const
{ return m_endpoint; }
private:
SIPConnHandler *m_handler;
YateSIPEndPoint *m_endpoint;
};
static void parseSDP(SDPBody* sdp, String& addr, String& port, String& formats)
{
const NamedString* c = sdp->getLine("c");
if (c) {
String tmp(*c);
if (tmp.startSkip("IN IP4")) {
tmp.trimBlanks();
// Handle the case media is muted
if (tmp == "0.0.0.0")
tmp.clear();
addr = tmp;
}
}
c = sdp->getLine("m");
if (c) {
String tmp(*c);
if (tmp.startSkip("audio")) {
int var = 0;
tmp >> var >> " RTP/AVP";
if (var > 0)
port = var;
String fmt;
bool defcodecs = s_cfg.getBoolValue("codecs","default",true);
while (tmp[0] == ' ') {
var = -1;
tmp >> " " >> var;
const char* payload = lookup(var,dict_payloads);
if (payload && s_cfg.getBoolValue("codecs",payload,defcodecs)) {
if (fmt)
fmt << ",";
fmt << payload;
}
}
formats = fmt;
}
}
}
static SIPPlugin plugin;
static ObjList s_calls;
static Mutex s_mutex;
YateUDPParty::YateUDPParty(int fd,struct sockaddr_in sin, int local)
: m_netfd(fd), m_sin(sin)
{
m_local = "localhost";
m_localPort = local;
m_party = inet_ntoa(m_sin.sin_addr);
m_partyPort = ntohs(m_sin.sin_port);
int s = ::socket(PF_INET,SOCK_DGRAM,IPPROTO_UDP);
if (s != -1) {
if (!::connect(s, (const sockaddr *)&m_sin, sizeof(m_sin))) {
struct sockaddr_in raddr;
socklen_t len = sizeof(raddr);
if (!::getsockname(s, (sockaddr *)&raddr, &len))
m_local = ::inet_ntoa(raddr.sin_addr);
}
::close(s);
}
Debug(DebugAll,"YateUDPParty local %s:%d party %s:%d",
m_local.c_str(),m_localPort,
m_party.c_str(),m_partyPort);
}
YateUDPParty::~YateUDPParty()
{
m_netfd = -1;
}
void YateUDPParty::transmit(SIPEvent* event)
{
Debug(DebugAll,"Sending to %s:%d",inet_ntoa(m_sin.sin_addr),ntohs(m_sin.sin_port));
::sendto(m_netfd,
event->getMessage()->getBuffer().data(),
event->getMessage()->getBuffer().length(),
0,
(struct sockaddr *) &m_sin,
sizeof(m_sin)
);
}
const char* YateUDPParty::getProtoName() const
{
return "UDP";
}
bool YateUDPParty::setParty(const URI& uri)
{
if (m_partyPort && m_party && s_cfg.getBoolValue("general","ignorevia"))
return true;
if (uri.getHost().null())
return false;
int port = uri.getPort();
if (port <= 0)
port = 5060;
struct hostent he, *res = 0;
int err = 0;
char buf[1024];
if (::gethostbyname_r(uri.getHost().safe(),&he,buf,sizeof(buf),&res,&err)) {
Debug("YateUDPParty",DebugWarn,"Error %d resolving name '%s' [%p]",
err,uri.getHost().safe(),this);
return false;
}
if (he.h_addrtype != AF_INET) {
Debug("YateUDPParty",DebugWarn,"Address family %d not supported yet [%p]",
he.h_addrtype,this);
return false;
}
m_sin.sin_family = he.h_addrtype;
m_sin.sin_addr.s_addr = *((u_int32_t*)he.h_addr_list[0]);
m_sin.sin_port = htons((short)port);
m_party = uri.getHost();
m_partyPort = port;
Debug("YateUDPParty",DebugInfo,"New party is %s:%d (%s:%d) [%p]",
m_party.c_str(),m_partyPort,
inet_ntoa(m_sin.sin_addr),ntohs(m_sin.sin_port),
this);
return true;
}
YateSIPEngine::YateSIPEngine(YateSIPEndPoint* ep)
: m_ep(ep)
{
addAllowed("INVITE");
addAllowed("BYE");
addAllowed("CANCEL");
if (s_cfg.getBoolValue("general","registrar"))
addAllowed("REGISTER");
}
bool YateSIPEngine::buildParty(SIPMessage* message)
{
return m_ep->buildParty(message);
}
YateSIPEndPoint::YateSIPEndPoint()
: Thread("YSIP EndPoint"), m_netfd(-1), m_engine(0)
{
m_netfd = -1;
Debug(DebugAll,"YateSIPEndPoint::YateSIPEndPoint() [%p]",this);
}
YateSIPEndPoint::~YateSIPEndPoint()
{
Debug(DebugAll,"YateSIPEndPoint::~YateSIPEndPoint() [%p]",this);
s_calls.clear();
// send any pending events
while (m_engine->process())
;
delete m_engine;
m_engine = 0;
}
bool YateSIPEndPoint::buildParty(SIPMessage* message, const char* host, int port)
{
if (message->isAnswer())
return false;
URI uri(message->uri);
if (!host) {
host = uri.getHost().safe();
if (port <= 0)
port = uri.getPort();
}
if (port <= 0)
port = 5060;
struct hostent he, *res = 0;
int err = 0;
char buf[1024];
if (::gethostbyname_r(host,&he,buf,sizeof(buf),&res,&err)) {
Debug(DebugWarn,"Error %d resolving name '%s'",err,host);
return false;
}
if (he.h_addrtype != AF_INET) {
Debug("YateUDPParty",DebugWarn,"Address family %d not supported yet [%p]",
he.h_addrtype,this);
return false;
}
struct sockaddr_in sin;
sin.sin_family = he.h_addrtype;
sin.sin_addr.s_addr = *((u_int32_t*)he.h_addr_list[0]);
sin.sin_port = htons((short)port);
Debug(DebugAll,"built addr: %d %s:%d",
sin.sin_family,inet_ntoa(sin.sin_addr),ntohs(sin.sin_port));
message->setParty(new YateUDPParty(m_netfd,sin,m_port));
return true;
}
bool YateSIPEndPoint::Init ()
{
/*
* This part have been taking from libiax after i have lost my sip driver for bayonne
*/
struct sockaddr_in sin;
int port = s_cfg.getIntValue("general","port",5060);
m_localport = port;
int flags;
if (m_netfd > -1) {
Debug(DebugInfo,"Already initialized.");
return 0;
}
m_netfd = ::socket(AF_INET, SOCK_DGRAM, IPPROTO_IP);
if (m_netfd < 0) {
Debug(DebugFail,"Unable to allocate UDP socket\n");
return -1;
}
int sinlen = sizeof(sin);
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = 0;
sin.sin_port = htons((short)port);
if (::bind(m_netfd, (struct sockaddr *) &sin, sinlen) < 0) {
Debug(DebugFail,"Unable to bind to preferred port. Using random one instead.");
}
if (::getsockname(m_netfd, (struct sockaddr *) &sin, (socklen_t *)&sinlen) < 0) {
::close(m_netfd);
m_netfd = -1;
Debug(DebugFail,"Unable to figure out what I'm bound to.");
}
if ((flags = ::fcntl(m_netfd, F_GETFL)) < 0) {
::close(m_netfd);
m_netfd = -1;
Debug(DebugFail,"Unable to retrieve socket flags.");
}
if (::fcntl(m_netfd, F_SETFL, flags | O_NONBLOCK) < 0) {
::close(m_netfd);
m_netfd = -1;
Debug(DebugFail,"Unable to set non-blocking mode.");
}
port = ntohs(sin.sin_port);
Debug(DebugInfo,"Started on port %d\n", port);
m_port = port;
m_engine = new YateSIPEngine(this);
return true;
}
void YateSIPEndPoint::run ()
{
fd_set fds;
struct timeval tv;
int retval;
char buf[1500];
struct sockaddr_in sin;
/* Watch stdin (fd 0) to see when it has input. */
for (;;)
{
FD_ZERO(&fds);
FD_SET(m_netfd, &fds);
/* Wait up to 20000 microseconds. */
tv.tv_sec = 0;
tv.tv_usec = 20000;
retval = select(m_netfd+1, &fds, NULL, NULL, &tv);
if (retval)
{
// we got the dates
int sinlen = sizeof(sin);
int res = ::recvfrom(m_netfd, buf, sizeof(buf)-1, 0, (struct sockaddr *) &sin,(socklen_t *) &sinlen);
if (res < 0) {
if (errno != EAGAIN) {
Debug(DebugFail,"Error on read: %s\n", strerror(errno));
}
} else {
// we got already the buffer and here we start to do "good" stuff
buf[res]=0;
m_engine->addMessage(new YateUDPParty(m_netfd,sin,m_port),buf,res);
// Output("res %d buf %s",res,buf);
}
}
// m_engine->process();
SIPEvent* e = m_engine->getEvent();
// hack: use a loop so we can use break and continue
for (; e; m_engine->processEvent(e),e = 0) {
if (!e->getTransaction())
continue;
YateSIPConnection* conn = static_cast<YateSIPConnection*>(e->getTransaction()->getUserData());
if (conn) {
if (conn->process(e)) {
delete e;
break;
}
else
continue;
}
if ((e->getState() == SIPTransaction::Trying) &&
!e->isOutgoing() && incoming(e,e->getTransaction())) {
delete e;
break;
}
}
}
}
bool YateSIPEndPoint::incoming(SIPEvent* e, SIPTransaction* t)
{
if (e->getTransaction()->isInvite())
invite(e,t);
else if (t->getMethod() == "BYE") {
YateSIPConnection* conn = YateSIPConnection::find(t->getCallID());
if (conn)
conn->doBye(t);
else
t->setResponse(481,"Call/Transaction Does Not Exist");
}
else if (t->getMethod() == "CANCEL") {
YateSIPConnection* conn = YateSIPConnection::find(t->getCallID());
if (conn)
conn->doCancel(t);
else
t->setResponse(481,"Call/Transaction Does Not Exist");
}
else if (t->getMethod() == "REGISTER")
regreq(e,t);
else
return false;
return true;
}
static int s_maxqueue = 5;
void YateSIPEndPoint::invite(SIPEvent* e, SIPTransaction* t)
{
if (Engine::exiting()) {
Debug(DebugWarn,"Dropping call, engine is exiting");
e->getTransaction()->setResponse(500, "Server Shutting Down");
return;
}
if (e->getMessage()->getParam("To","tag")) {
SIPDialog dlg(*e->getMessage());
YateSIPConnection* conn = YateSIPConnection::find(dlg);
if (conn)
conn->reInvite(t);
else {
Debug(DebugWarn,"Got re-INVITE for missing dialog");
e->getTransaction()->setResponse(481, "Call/Transaction Does Not Exist");
}
return;
}
int cnt = SipMsgThread::count();
if (cnt > s_maxqueue) {
Debug(DebugWarn,"Dropping call, there are already %d waiting",cnt);
e->getTransaction()->setResponse(503, "Service Unavailable");
return;
}
String callid(t->getCallID());
URI uri(t->getURI());
const HeaderLine* hl = e->getMessage()->getHeader("From");
URI from(hl ? *hl : String::empty());
Message *m = new Message("call.route");
m->addParam("driver","sip");
m->addParam("id","sip/" + callid);
m->addParam("caller",from.getUser());
m->addParam("called",uri.getUser());
m->addParam("sip_uri",uri);
m->addParam("sip_from",from);
m->addParam("sip_callid",callid);
m->addParam("sip_contact",e->getMessage()->getHeaderValue("Contact"));
m->addParam("sip_user-agent",e->getMessage()->getHeaderValue("User-Agent"));
SIPParty* party = e->getParty();
if (party) {
m->addParam("xsip_received",party->getPartyAddr());
m->addParam("xsip_rport",String(party->getPartyPort()));
}
if (e->getMessage()->body && e->getMessage()->body->isSDP()) {
String addr,port,formats;
parseSDP(static_cast<SDPBody*>(e->getMessage()->body),addr,port,formats);
if (addr) {
m->addParam("rtp_forward","possible");
m->addParam("rtp_addr",addr);
m->addParam("rtp_port",port);
m->addParam("formats",formats);
}
}
SipMsgThread *thr = new SipMsgThread(t,m);
if (!thr->startup()) {
Debug(DebugWarn,"Error starting routing thread %p ! [%p]",thr,this);
delete thr;
t->setResponse(500, "Server Internal Error");
}
}
void YateSIPEndPoint::regreq(SIPEvent* e, SIPTransaction* t)
{
if (Engine::exiting()) {
Debug(DebugWarn,"Dropping request, engine is exiting");
e->getTransaction()->setResponse(500, "Server Shutting Down");
return;
}
const HeaderLine* hl = e->getMessage()->getHeader("To");
if (!hl) {
e->getTransaction()->setResponse(400, "Bad Request");
return;
}
URI addr(*hl);
Message *m = new Message("user.register");
m->addParam("username",addr.getUser());
m->addParam("techno","sip");
m->addParam("data","sip/" + addr);
bool dereg = false;
hl = e->getMessage()->getHeader("Expires");
if (hl) {
m->addParam("expires",*hl);
if (*hl == "0") {
*m = "user.unregister";
dereg = true;
}
}
// Always OK deregistration attempts
if (Engine::dispatch(m) || dereg)
e->getTransaction()->setResponse(200, "OK");
else
e->getTransaction()->setResponse(404, "Not Found");
m->destruct();
}
static Mutex s_route;
int SipMsgThread::s_count = 0;
int SipMsgThread::s_routed = 0;
YateSIPConnection* YateSIPConnection::find(const String& id)
{
Debug("YateSIPConnection",DebugAll,"finding '%s'",id.c_str());
ObjList* l = s_calls.find(id);
return l ? static_cast<YateSIPConnection*>(l->get()) : 0;
}
YateSIPConnection* YateSIPConnection::find(const SIPDialog& id)
{
Debug("YateSIPConnection",DebugAll,"finding dialog '%s'",id.c_str());
ObjList* l = &s_calls;
for (; l; l = l->next()) {
YateSIPConnection* c = static_cast<YateSIPConnection*>(l->get());
if (c && (c->dialog() == id))
return c;
}
return 0;
}
// Incoming call constructor - after call.route but before call.execute
YateSIPConnection::YateSIPConnection(Message& msg, SIPTransaction* tr)
: m_tr(tr), m_hungup(false), m_byebye(true), m_state(Incoming),
m_rtpSession(0), m_rtpVersion(0), m_port(0)
{
Debug(DebugAll,"YateSIPConnection::YateSIPConnection(%p) [%p]",tr,this);
setReason();
s_mutex.lock();
m_tr->ref();
m_id = *m_tr->initialMessage();
m_host = m_tr->initialMessage()->getParty()->getPartyAddr();
m_port = m_tr->initialMessage()->getParty()->getPartyPort();
m_uri = m_tr->initialMessage()->getHeader("From");
m_uri.parse();
m_tr->setUserData(this);
s_calls.append(this);
s_mutex.unlock();
m_rtpAddr = msg.getValue("rtp_addr");
m_rtpPort = msg.getValue("rtp_port");
m_formats = msg.getValue("formats");
int q = m_formats.find(',');
m_rtpFormat = m_formats.substr(0,q);
Debug(DebugAll,"RTP addr '%s' port %s formats '%s' format '%s'",
m_rtpAddr.c_str(),m_rtpPort.c_str(),m_formats.c_str(),m_rtpFormat.c_str());
Message *ms = new Message("chan.startup");
ms->addParam("driver","sip");
ms->addParam("id",m_id);
String addr(m_host);
addr << ":" << m_port;
ms->addParam("address",addr);
ms->addParam("direction","incoming");
Engine::enqueue(ms);
}
// Outgoing call constructor - in call.execute handler
YateSIPConnection::YateSIPConnection(Message& msg, const String& uri)
: m_tr(0), m_hungup(false), m_byebye(true), m_state(Outgoing), m_uri(uri),
m_rtpSession(0), m_rtpVersion(0), m_port(0)
{
Debug(DebugAll,"YateSIPConnection::YateSIPConnection(%p,'%s') [%p]",
&msg,uri.c_str(),this);
setReason();
m_uri.parse();
SIPMessage* m = new SIPMessage("INVITE",uri);
m->complete(plugin.ep()->engine(),msg.getValue("caller"),msg.getValue("domain"));
m_host = m->getParty()->getPartyAddr();
m_port = m->getParty()->getPartyPort();
SDPBody* sdp = createPasstroughSDP(msg);
if (!sdp)
sdp = createRtpSDP(m,msg.getValue("formats"));
m->setBody(sdp);
m_tr = plugin.ep()->engine()->addMessage(m);
m->deref();
if (m_tr) {
m_tr->ref();
m_id = *m_tr->initialMessage();
m_tr->setUserData(this);
}
s_mutex.lock();
s_calls.append(this);
s_mutex.unlock();
Message *ms = new Message("chan.startup");
ms->addParam("driver","sip");
ms->addParam("id",m_id);
String addr(m_host);
addr << ":" << m_port;
ms->addParam("address",addr);
ms->addParam("direction","outgoing");
Engine::enqueue(ms);
}
YateSIPConnection::~YateSIPConnection()
{
Debug(DebugAll,"YateSIPConnection::~YateSIPConnection() [%p]",this);
Lock lock(s_mutex);
s_calls.remove(this,false);
hangup();
clearTransaction();
}
void YateSIPConnection::clearTransaction()
{
if (m_tr) {
m_tr->setUserData(0);
if (m_tr->isIncoming()) {
m_byebye = false;
m_tr->setResponse(m_reasonCode,m_reason.null() ? "Request Terminated" : m_reason.c_str());
}
m_tr->deref();
m_tr = 0;
}
}
void YateSIPConnection::hangup()
{
if (m_hungup)
return;
m_hungup = true;
Debug(DebugAll,"YateSIPConnection::hangup() state=%d trans=%p code=%d reason='%s' [%p]",
m_state,m_tr,m_reasonCode,m_reason.c_str(),this);
Message *msg = new Message("chan.hangup");
msg->addParam("driver","sip");
msg->addParam("id",id());
if (m_target)
msg->addParam("targetid",m_target);
Engine::enqueue(msg);
msg = 0;
switch (m_state) {
case Cleared:
clearTransaction();
return;
case Incoming:
if (m_tr) {
clearTransaction();
return;
}
break;
case Outgoing:
if (m_tr) {
SIPMessage* m = new SIPMessage("CANCEL",m_uri);
plugin.ep()->buildParty(m,m_host,m_port);
const SIPMessage* i = m_tr->initialMessage();
m->copyHeader(i,"Via");
m->copyHeader(i,"From");
m->copyHeader(i,"To");
m->copyHeader(i,"Call-ID");
String tmp;
tmp << i->getCSeq() << " CANCEL";
m->addHeader("CSeq",tmp);
plugin.ep()->engine()->addMessage(m);
m->deref();
}
break;
}
clearTransaction();
m_state = Cleared;
if (m_byebye) {
m_byebye = false;
SIPMessage* m = new SIPMessage("BYE",m_uri);
plugin.ep()->buildParty(m,m_host,m_port);
m->addHeader("Call-ID",m_id);
String tmp;
tmp << "<" << m_id.localURI << ">";
HeaderLine* hl = new HeaderLine("From",tmp);
hl->setParam("tag",m_id.localTag);
m->addHeader(hl);
tmp.clear();
tmp << "<" << m_id.remoteURI << ">";
hl = new HeaderLine("To",tmp);
hl->setParam("tag",m_id.remoteTag);
m->addHeader(hl);
plugin.ep()->engine()->addMessage(m);
m->deref();
}
disconnect();
}
// Creates a SDP from RTP address data present in message
SDPBody* YateSIPConnection::createPasstroughSDP(Message &msg)
{
String tmp = msg.getValue("rtp_forward");
msg.clearParam("rtp_forward");
if (!tmp.toBoolean())
return 0;
tmp = msg.getValue("rtp_port");
int port = tmp.toInteger();
String addr(msg.getValue("rtp_addr"));
if (port && addr) {
SDPBody* sdp = createSDP(addr,tmp,msg.getValue("formats"));
if (sdp)
msg.setParam("rtp_forward","accepted");
return sdp;
}
return 0;
}
// Creates an unstarted external RTP channel from remote addr and builds SDP from it
SDPBody* YateSIPConnection::createRtpSDP(SIPMessage* msg, const char* formats)
{
Message m("chan.rtp");
m.addParam("driver","sip");
m.addParam("id",id());
m.addParam("direction","bidir");
m.addParam("remoteip",msg->getParty()->getPartyAddr());
m.userData(static_cast<DataEndpoint *>(this));
if (Engine::dispatch(m)) {
m_rtpid = m.getValue("rtpid");
m_rtpLocal = m.getValue("localip",m_rtpLocal);
return createSDP(m_rtpLocal,m.getValue("localport"),formats);
}
return 0;
}
// Creates a started external RTP channel from remote addr and builds SDP from it
SDPBody* YateSIPConnection::createRtpSDP(bool start)
{
if (m_rtpAddr.null()) {
m_rtpid = "-";
return createSDP(m_rtpLocal,0,m_formats);
}
Message m("chan.rtp");
m.addParam("driver","sip");
m.addParam("id",id());
m.addParam("direction","bidir");
m.addParam("remoteip",m_rtpAddr);
if (start) {
m.addParam("remoteport",m_rtpPort);
m.addParam("format",m_rtpFormat);
}
m.userData(static_cast<DataEndpoint *>(this));
if (Engine::dispatch(m)) {
m_rtpid = m.getValue("rtpid");
m_rtpLocal = m.getValue("localip",m_rtpLocal);
if (start)
m_rtpFormat = m.getValue("format");
return createSDP(m_rtpLocal,m.getValue("localport"),m_formats,m_rtpFormat);
}
return 0;
}
// Starts an already created external RTP channel
bool YateSIPConnection::startRtp()
{
if (m_rtpid.null() || m_rtpid == "-")
return false;
Debug(DebugAll,"YateSIPConnection::startRtp() [%p]",this);
Message m("chan.rtp");
m.addParam("driver","sip");
m.addParam("id",id());
m.addParam("rtpid",m_rtpid);
m.addParam("direction","bidir");
m.addParam("remoteip",m_rtpAddr);
m.addParam("remoteport",m_rtpPort);
m.addParam("format",m_rtpFormat);
m.userData(static_cast<DataEndpoint *>(this));
return Engine::dispatch(m);
}
SDPBody* YateSIPConnection::createSDP(const char* addr, const char* port, const char* formats, const char* format)
{
Debug(DebugAll,"YateSIPConnection::createSDP('%s','%s','%s') [%p]",
addr,port,formats,this);
if (!addr)
return 0;
if (m_rtpSession)
++m_rtpVersion;
else
m_rtpVersion = m_rtpSession = Time::now() / 10000000000ULL;
String owner;
owner << "yate " << m_rtpSession << " " << m_rtpVersion << " IN IP4 " << addr;
if (!port) {
port = "1";
addr = "0.0.0.0";
}
String tmp;
tmp << "IN IP4 " << addr;
String frm(format ? format : formats);
if (frm.null())
frm = "alaw,mulaw";
ObjList* l = frm.split(',',false);
frm = "audio ";
frm << port << " RTP/AVP";
ObjList rtpmap;
ObjList* f = l;
bool defcodecs = s_cfg.getBoolValue("codecs","default",true);
for (; f; f = f->next()) {
String* s = static_cast<String*>(f->get());
if (s) {
int payload = s->toInteger(dict_payloads,-1);
if (payload >= 0) {
const char* map = lookup(payload,dict_rtpmap);
if (map && s_cfg.getBoolValue("codecs",*s,defcodecs)) {
frm << " " << payload;
String* tmp = new String("rtpmap:");
*tmp << payload << " " << map;
rtpmap.append(tmp);
}
}
}
}
delete l;
// always claim to support telephone events
frm << " 101";
rtpmap.append(new String("rtpmap:101 telephone-event/8000"));
SDPBody* sdp = new SDPBody;
sdp->addLine("v","0");
sdp->addLine("o",owner);
sdp->addLine("s","Session");
sdp->addLine("c",tmp);
sdp->addLine("t","0 0");
sdp->addLine("m",frm);
for (f = &rtpmap; f; f = f->next()) {
String* s = static_cast<String*>(f->get());
if (s)
sdp->addLine("a",*s);
}
rtpmap.clear();
return sdp;
}
void YateSIPConnection::disconnected(bool final, const char *reason)
{
Debug(DebugAll,"YateSIPConnection::disconnected() '%s' [%p]",reason,this);
if (reason)
setReason(reason);
setStatus("disconnected");
setTarget();
}
bool YateSIPConnection::process(SIPEvent* ev)
{
Debug(DebugInfo,"YateSIPConnection::process(%p) %s [%p]",
ev,SIPTransaction::stateName(ev->getState()),this);
m_id = *ev->getTransaction()->recentMessage();
if (ev->getState() == SIPTransaction::Cleared) {
if (m_tr) {
Lock lock(s_mutex);
Debug(DebugInfo,"YateSIPConnection clearing transaction %p [%p]",
m_tr,this);
m_tr->setUserData(0);
m_tr->deref();
m_tr = 0;
}
if (m_state != Established)
hangup();
return false;
}
if (!ev->getMessage() || ev->getMessage()->isOutgoing())
return false;
if (ev->getMessage()->body && ev->getMessage()->body->isSDP()) {
Debug(DebugInfo,"YateSIPConnection got SDP [%p]",this);
parseSDP(static_cast<SDPBody*>(ev->getMessage()->body),
m_rtpAddr,m_rtpPort,m_formats);
int q = m_formats.find(',');
m_rtpFormat = m_formats.substr(0,q);
Debug(DebugAll,"RTP addr '%s' port %s formats '%s' format '%s'",
m_rtpAddr.c_str(),m_rtpPort.c_str(),m_formats.c_str(),m_rtpFormat.c_str());
}
if (ev->getMessage()->isAnswer() && ((ev->getMessage()->code / 100) == 2)) {
setStatus("answered",Established);
Message *m = new Message("call.answered");
m->addParam("driver","sip");
m->addParam("id",id());
if (m_target)
m->addParam("targetid",m_target);
m->addParam("status","answered");
if (m_rtpPort && m_rtpAddr && !startRtp()) {
m->addParam("rtp_forward","yes");
m->addParam("rtp_addr",m_rtpAddr);
m->addParam("rtp_port",m_rtpPort);
m->addParam("formats",m_formats);
}
Engine::enqueue(m);
}
if (ev->getMessage()->isACK()) {
Debug(DebugInfo,"YateSIPConnection got ACK [%p]",this);
startRtp();
}
return false;
}
void YateSIPConnection::reInvite(SIPTransaction* t)
{
Debug(DebugAll,"YateSIPConnection::reInvite(%p) [%p]",t,this);
while (t->initialMessage()->body && t->initialMessage()->body->isSDP()) {
// accept re-INVITE only for local RTP, not for pass-trough
if (m_rtpid.null())
break;
String addr,port,formats;
parseSDP(static_cast<SDPBody*>(t->initialMessage()->body),addr,port,formats);
int q = formats.find(',');
String frm = formats.substr(0,q);
if (port.null() || frm.null())
break;
m_rtpAddr = addr;
m_rtpPort = port;
m_rtpFormat = frm;
m_formats = formats;
Debug(DebugAll,"New RTP addr '%s' port %s formats '%s' format '%s'",
m_rtpAddr.c_str(),m_rtpPort.c_str(),m_formats.c_str(),m_rtpFormat.c_str());
m_rtpid.clear();
setSource();
setConsumer();
SIPMessage* m = new SIPMessage(t->initialMessage(), 200, "OK");
SDPBody* sdp = createRtpSDP(true);
m->setBody(sdp);
t->setResponse(m);
m->deref();
return;
}
t->setResponse(488, "Not Acceptable Here");
}
void YateSIPConnection::doBye(SIPTransaction* t)
{
Debug(DebugAll,"YateSIPConnection::doBye(%p) [%p]",t,this);
t->setResponse(200,"OK");
m_byebye = false;
hangup();
}
void YateSIPConnection::doCancel(SIPTransaction* t)
{
Debug(DebugAll,"YateSIPConnection::doCancel(%p) [%p]",t,this);
if (m_tr) {
t->setResponse(200,"OK");
m_byebye = false;
clearTransaction();
disconnect("Cancelled");
}
else
t->setResponse(481,"Call/Transaction Does Not Exist");
}
void YateSIPConnection::ringing(Message* msg)
{
if (m_tr && (m_tr->getState() == SIPTransaction::Process)) {
SIPMessage* m = new SIPMessage(m_tr->initialMessage(), 180, "Ringing");
SDPBody* sdp = msg ? createPasstroughSDP(*msg) : 0;
m->setBody(sdp);
m_tr->setResponse(m);
m->deref();
}
setStatus("ringing");
}
void YateSIPConnection::answered(Message* msg)
{
if (m_tr && (m_tr->getState() == SIPTransaction::Process)) {
SIPMessage* m = new SIPMessage(m_tr->initialMessage(), 200, "OK");
SDPBody* sdp = msg ? createPasstroughSDP(*msg) : 0;
if (!sdp)
sdp = createRtpSDP();
m->setBody(sdp);
m_tr->setResponse(m);
m->deref();
}
setStatus("answered",Established);
}
bool SipMsgThread::route()
{
Debug(DebugAll,"Routing thread for %s [%p]",m_id.c_str(),this);
m_msg->retValue().clear();
bool ok = Engine::dispatch(m_msg) && !m_msg->retValue().null();
if (m_tr->getState() != SIPTransaction::Process) {
Debug(DebugInfo,"SIP call %s (%p) vanished while routing!",m_id.c_str(),m_tr);
return false;
}
if (ok) {
*m_msg = "call.execute";
m_msg->addParam("callto",m_msg->retValue());
m_msg->retValue().clear();
YateSIPConnection* conn = new YateSIPConnection(*m_msg,m_tr);
m_msg->userData(conn);
if (Engine::dispatch(m_msg)) {
Debug(DebugInfo,"Routing SIP call %s (%p) to '%s' [%p]",
m_id.c_str(),m_tr,m_msg->getValue("callto"),this);
conn->setStatus("routed");
conn->setTarget(m_msg->getValue("targetid"));
if (conn->getTarget().null()) {
Debug(DebugInfo,"Answering now SIP call %s [%p] because we have no targetid",
conn->id().c_str(),conn);
conn->answered();
}
else
m_tr->setResponse(183, "Session Progress");
conn->deref();
}
else {
Debug(DebugInfo,"Rejecting unconnected SIP call %s (%p) [%p]",
m_id.c_str(),m_tr,this);
m_tr->setResponse(500, "Server Internal Error");
conn->setStatus("rejected");
conn->destruct();
}
}
else {
Debug(DebugInfo,"Rejecting unrouted SIP call %s (%p) [%p]",
m_id.c_str(),m_tr,this);
m_tr->setResponse(404, "Not Found");
}
return ok;
}
void SipMsgThread::run()
{
s_route.lock();
s_count++;
s_route.unlock();
Debug(DebugAll,"Started routing thread for %s (%p) [%p]",
m_id.c_str(),m_tr,this);
m_tr->ref();
bool ok = route();
m_tr->deref();
s_route.lock();
s_count--;
if (ok)
s_routed++;
s_route.unlock();
}
void SipMsgThread::cleanup()
{
Debug(DebugAll,"Cleaning up routing thread for %s (%p) [%p]",
m_id.c_str(),m_tr,this);
delete m_msg;
m_tr->deref();
}
bool SIPHandler::received(Message &msg)
{
String dest(msg.getValue("callto"));
if (!dest.startSkip("sip/",false))
return false;
if (!msg.userData()) {
Debug(DebugWarn,"SIP call found but no data channel!");
return false;
}
YateSIPConnection* conn = new YateSIPConnection(msg,dest);
if (conn->getTransaction()) {
DataEndpoint *dd = static_cast<DataEndpoint *>(msg.userData());
if (dd && conn->connect(dd)) {
msg.addParam("targetid",conn->id());
conn->setTarget(msg.getValue("id"));
conn->deref();
return true;
}
}
conn->destruct();
return false;
}
bool SIPConnHandler::received(Message &msg, int id)
{
String callid;
switch (id) {
case Answered:
case Ringing:
callid = msg.getValue("targetid");
break;
case Drop:
case Masquerade:
callid = msg.getValue("id");
break;
default:
return false;
}
if (!callid.startSkip("sip/",false) || callid.null()) {
if (id == Drop) {
Debug("SIP",DebugInfo,"Dropping all calls");
s_calls.clear();
}
return false;
}
Lock lock(s_mutex);
YateSIPConnection* conn = YateSIPConnection::find(callid);
Debug("SIP",DebugInfo,"Connhandler lookup '%s' returned %p",
callid.c_str(),conn);
if (!conn)
return false;
switch (id) {
case Drop:
lock.drop();
conn->disconnect();
break;
case Masquerade:
msg.setParam("targetid",conn->getTarget());
msg = msg.getValue("message");
msg.clearParam("message");
msg.userData(conn);
return false;
case Ringing:
conn->ringing(&msg);
break;
case Answered:
conn->answered(&msg);
break;
default:
return false;
}
return true;
}
bool StatusHandler::received(Message &msg)
{
const char *sel = msg.getValue("module");
if (sel && ::strcmp(sel,"ysipchan") && ::strcmp(sel,"varchans"))
return false;
Lock lock(s_mutex);
String st("name=ysip,type=varchans,format=Status|Caller");
st << ";chans=" << s_calls.count() << ";";
ObjList *l = &s_calls;
bool first = true;
for (; l; l=l->next()) {
YateSIPConnection *c = static_cast<YateSIPConnection *>(l->get());
if (c) {
if (first)
first = false;
else
st << ",";
st << c->id() << "=" << c->status() << "|" << c->getHost() << ":" << c->getPort();
}
}
msg.retValue() << st << "\n";
return false;
}
bool HaltHandler::received(Message &msg)
{
// Clear calls early - give the endpoint a chance to do only minimal
// processing later in the destructor
s_calls.clear();
return false;
}
SIPPlugin::SIPPlugin()
: m_handler(0), m_endpoint(0)
{
Output("Loaded module SIP Channel");
}
SIPPlugin::~SIPPlugin()
{
Output("Unloading module SIP Channel");
}
void SIPPlugin::initialize()
{
Output("Initializing module SIP Channel");
s_cfg = Engine::configFile("ysipchan");
s_cfg.load();
if (!m_endpoint) {
m_endpoint = new YateSIPEndPoint();
if (!(m_endpoint->Init())) {
delete m_endpoint;
m_endpoint = 0;
return;
}
else
m_endpoint->startup();
}
if (!m_handler) {
m_handler = new SIPConnHandler;
Engine::install(new MessageRelay("call.ringing",m_handler,SIPConnHandler::Ringing));
Engine::install(new MessageRelay("call.answered",m_handler,SIPConnHandler::Answered));
Engine::install(new MessageRelay("call.drop",m_handler,SIPConnHandler::Drop));
Engine::install(new MessageRelay("chan.masquerade",m_handler,SIPConnHandler::Masquerade,10));
Engine::install(new SIPHandler("call.execute"));
Engine::install(new HaltHandler("engine.halt"));
Engine::install(new StatusHandler("engine.status"));
}
}
/* vi: set ts=8 sw=4 sts=4 noet: */
Reference in New Issue View Git Blame Copy Permalink