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.
451 lines
11 KiB
451 lines
11 KiB
/*
|
|
* $Id$
|
|
*
|
|
* Copyright (C) 2002-2003 Fhg Fokus
|
|
* Copyright (C) 2006 iptego GmbH
|
|
*
|
|
* 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
|
|
*
|
|
* For a license to use the ser 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
|
|
*/
|
|
|
|
#include "AmSessionContainer.h"
|
|
#include "AmPlugIn.h"
|
|
#include "AmApi.h"
|
|
#include "AmConfig.h"
|
|
#include "AmUtils.h"
|
|
#include <assert.h>
|
|
#include <sys/types.h>
|
|
#include <unistd.h>
|
|
#include "sems.h"
|
|
|
|
// AmSessionContainer methods
|
|
|
|
AmSessionContainer* AmSessionContainer::_SessionContainer=0;
|
|
|
|
AmSessionContainer::AmSessionContainer()
|
|
: _run_cond(false)
|
|
{
|
|
}
|
|
|
|
AmSessionContainer* AmSessionContainer::instance()
|
|
{
|
|
if(!_SessionContainer)
|
|
_SessionContainer = new AmSessionContainer();
|
|
|
|
return _SessionContainer;
|
|
}
|
|
|
|
void AmSessionContainer::on_stop()
|
|
{
|
|
}
|
|
|
|
void AmSessionContainer::run()
|
|
{
|
|
|
|
while(1){
|
|
|
|
_run_cond.wait_for();
|
|
|
|
// Let some time for the Sessions
|
|
// to stop by themselves
|
|
sleep(5);
|
|
|
|
ds_mut.lock();
|
|
DBG("Session cleaner starting its work\n");
|
|
|
|
try {
|
|
SessionQueue n_sessions;
|
|
|
|
while(!d_sessions.empty()){
|
|
|
|
AmSession* cur_session = d_sessions.front();
|
|
d_sessions.pop();
|
|
|
|
ds_mut.unlock();
|
|
|
|
if(cur_session->is_stopped() && cur_session->detached.get()){
|
|
|
|
DBG("session %p has been destroyed'\n",(void*)cur_session->_pid);
|
|
delete cur_session;
|
|
}
|
|
else {
|
|
DBG("session %p still running\n",(void*)cur_session->_pid);
|
|
n_sessions.push(cur_session);
|
|
}
|
|
|
|
ds_mut.lock();
|
|
}
|
|
|
|
swap(d_sessions,n_sessions);
|
|
|
|
}catch(std::exception& e){
|
|
ERROR("exception caught in session cleaner: %s\n", e.what());
|
|
throw; /* throw again as this is fatal (because unlocking the mutex fails!! */
|
|
}catch(...){
|
|
ERROR("unknown exception caught in session cleaner!\n");
|
|
throw; /* throw again as this is fatal (because unlocking the mutex fails!! */
|
|
}
|
|
|
|
bool more = !d_sessions.empty();
|
|
ds_mut.unlock();
|
|
|
|
DBG("Session cleaner finished\n");
|
|
if(!more)
|
|
_run_cond.set(false);
|
|
}
|
|
}
|
|
|
|
void AmSessionContainer::stopAndQueue(AmSession* s)
|
|
{
|
|
ds_mut.lock();
|
|
|
|
DBG("session cleaner about to stop %s\n",
|
|
s->getLocalTag().c_str());
|
|
|
|
s->stop();
|
|
d_sessions.push(s);
|
|
_run_cond.set(true);
|
|
|
|
ds_mut.unlock();
|
|
}
|
|
|
|
void AmSessionContainer::destroySession(AmSession* s)
|
|
{
|
|
destroySession(s->getLocalTag());
|
|
}
|
|
|
|
void AmSessionContainer::destroySession(const string& local_tag)
|
|
{
|
|
as_mut.lock();
|
|
|
|
SessionMapIter sess_it = a_sessions.find(local_tag);
|
|
if(sess_it != a_sessions.end()){
|
|
|
|
AmSession* sess = sess_it->second;
|
|
as_id_lookup.erase(sess->getCallID() + sess->getRemoteTag());
|
|
a_sessions.erase(sess_it);
|
|
|
|
stopAndQueue(sess);
|
|
DBG("session stopped and queued for deletion (#sessions=%u)\n",
|
|
(unsigned int)a_sessions.size());
|
|
}
|
|
else {
|
|
DBG("could not remove session: id not found\n");
|
|
}
|
|
|
|
as_mut.unlock();
|
|
}
|
|
|
|
AmSession* AmSessionContainer::getSession(const string& callid, const string& remote_tag)
|
|
{
|
|
DictIter it = as_id_lookup.find(callid+remote_tag);
|
|
if(it == as_id_lookup.end()){
|
|
//ERROR("could not find session (callid='%s'; remote_tag='%s')\n",
|
|
// callid.c_str(),remote_tag.c_str());
|
|
return NULL;
|
|
}
|
|
|
|
return getSession(it->second);
|
|
}
|
|
|
|
AmSession* AmSessionContainer::getSession(const string& local_tag)
|
|
{
|
|
SessionMapIter it = a_sessions.find(local_tag);
|
|
if(it == a_sessions.end()){
|
|
//ERROR("could not find session (local_tag='%s')\n",local_tag.c_str());
|
|
return NULL;
|
|
}
|
|
|
|
return it->second;
|
|
}
|
|
|
|
AmSession* AmSessionContainer::startSessionUAC(AmSipRequest& req, AmArg* session_params) {
|
|
AmSession* session = NULL;
|
|
as_mut.lock();
|
|
try {
|
|
if((session = createSession(req, session_params)) != 0){
|
|
session->dlg.updateStatusFromLocalRequest(req); // sets local tag as well
|
|
session->setCallgroup(req.from_tag);
|
|
|
|
session->setNegotiateOnReply(true);
|
|
if (int err = session->sendInvite(req.hdrs)) {
|
|
ERROR("INVITE could not be sent: error code = %d.\n",
|
|
err);
|
|
delete session;
|
|
as_mut.unlock();
|
|
return NULL;
|
|
}
|
|
session->start();
|
|
|
|
addSession_unsafe(req.callid,"",req.from_tag,session);
|
|
// session does not get its own INVITE
|
|
// session->postEvent(new AmSipRequestEvent(req));
|
|
}
|
|
}
|
|
catch(const AmSession::Exception& e){
|
|
ERROR("%i %s\n",e.code,e.reason.c_str());
|
|
AmSipDialog::reply_error(req,e.code,e.reason);
|
|
}
|
|
catch(const string& err){
|
|
ERROR("startSession: %s\n",err.c_str());
|
|
AmSipDialog::reply_error(req,500,err);
|
|
}
|
|
catch(...){
|
|
ERROR("unexpected exception\n");
|
|
AmSipDialog::reply_error(req,500,"unexpected exception");
|
|
}
|
|
as_mut.unlock();
|
|
return session;
|
|
}
|
|
|
|
void AmSessionContainer::startSessionUAS(AmSipRequest& req)
|
|
{
|
|
as_mut.lock();
|
|
try {
|
|
|
|
AmSession* session = getSession(req.callid,req.from_tag);
|
|
if( session ){
|
|
|
|
// it's a forked-and-merged INVITE
|
|
// reply 482 Loop detected
|
|
throw AmSession::Exception(482, "Loop detected");
|
|
}
|
|
else {
|
|
// Call-ID and From-Tag are unknown: it's a new session
|
|
AmSession* session;
|
|
if((session = createSession(req)) != 0){
|
|
|
|
// update session's local tag (ID) if not already set
|
|
session->setLocalTag();
|
|
const string& local_tag = session->getLocalTag();
|
|
// by default each session is in its own callgroup
|
|
session->setCallgroup(local_tag);
|
|
session->start();
|
|
|
|
addSession_unsafe(req.callid,req.from_tag,local_tag,session);
|
|
session->postEvent(new AmSipRequestEvent(req));
|
|
}
|
|
}
|
|
}
|
|
catch(const AmSession::Exception& e){
|
|
ERROR("%i %s\n",e.code,e.reason.c_str());
|
|
AmSipDialog::reply_error(req,e.code,e.reason);
|
|
}
|
|
catch(const string& err){
|
|
ERROR("startSession: %s\n",err.c_str());
|
|
AmSipDialog::reply_error(req,500,err);
|
|
}
|
|
catch(...){
|
|
ERROR("unexpected exception\n");
|
|
AmSipDialog::reply_error(req,500,"unexpected exception");
|
|
}
|
|
as_mut.unlock();
|
|
}
|
|
|
|
|
|
bool AmSessionContainer::postEvent(const string& callid,
|
|
const string& remote_tag,
|
|
AmEvent* event)
|
|
{
|
|
// DBG("postEvent: callid = %s; remote_tag = %s\n",
|
|
// callid.c_str(),remote_tag.c_str());
|
|
|
|
as_mut.lock();
|
|
AmSession* s = getSession(callid,remote_tag);
|
|
|
|
if(!s){
|
|
as_mut.unlock();
|
|
delete event;
|
|
return false;
|
|
}
|
|
|
|
s->postEvent(event);
|
|
as_mut.unlock();
|
|
|
|
return true;
|
|
}
|
|
|
|
bool AmSessionContainer::postEvent(const string& local_tag,
|
|
AmEvent* event)
|
|
{
|
|
// DBG("postEvent: local_tag = %s\n",local_tag.c_str());
|
|
as_mut.lock();
|
|
AmSession* s = getSession(local_tag);
|
|
|
|
if (s != NULL) {
|
|
s->postEvent(event);
|
|
as_mut.unlock();
|
|
return true;
|
|
}
|
|
as_mut.unlock();
|
|
|
|
// try session factories
|
|
AmSessionFactory* sf = AmPlugIn::instance()->getFactory4App(local_tag);
|
|
if (sf != NULL) {
|
|
sf->postEvent(event);
|
|
return true;
|
|
}
|
|
|
|
delete event;
|
|
return false;
|
|
}
|
|
|
|
AmSession* AmSessionContainer::createSession(AmSipRequest& req,
|
|
AmArg* session_params)
|
|
{
|
|
|
|
if (AmConfig::SessionLimit &&
|
|
AmConfig::SessionLimit <= a_sessions.size()) {
|
|
DBG("session_limit %d reached. Not creating session.\n",
|
|
AmConfig::SessionLimit);
|
|
throw AmSession::Exception(AmConfig::SessionLimitErrCode, AmConfig::SessionLimitErrReason);
|
|
}
|
|
|
|
if(req.cmd.empty()){
|
|
throw string("AmSessionContainer::createSession: req.cmd is empty!\n");
|
|
}
|
|
else if(req.cmd == "sems"){
|
|
switch (AmConfig::AppSelect) {
|
|
case AmConfig::App_RURIUSER:
|
|
req.cmd = req.user;
|
|
break;
|
|
case AmConfig::App_APPHDR:
|
|
req.cmd = getHeader(req.hdrs, APPNAME_HDR);
|
|
break;
|
|
case AmConfig::App_RURIPARAM:
|
|
req.cmd = get_header_param(req.r_uri, "app");
|
|
break;
|
|
case AmConfig::App_MAPPING:
|
|
{
|
|
req.cmd = "";
|
|
for (AmConfig::AppMappingVector::iterator it =
|
|
AmConfig::AppMapping.begin();
|
|
it != AmConfig::AppMapping.end(); it++){
|
|
if (!regexec(&it->first, req.r_uri.c_str(), 0, NULL, 0)) {
|
|
DBG("match of r_uri '%s' to application %s\n",
|
|
req.r_uri.c_str(), it->second.c_str());
|
|
req.cmd = it->second;
|
|
break;
|
|
}
|
|
}
|
|
} break;
|
|
case AmConfig::App_SPECIFIED:
|
|
req.cmd = AmConfig::Application;
|
|
break;
|
|
}
|
|
if (req.cmd.empty()) {
|
|
string ex = "Unknown Application";
|
|
throw ex;
|
|
}
|
|
}
|
|
|
|
AmSessionFactory* state_factory = AmPlugIn::instance()->getFactory4App(req.cmd);
|
|
if(!state_factory) {
|
|
ERROR("application '%s' not found !\n", req.cmd.c_str());
|
|
throw string("application '" + req.cmd + "' not found !");
|
|
}
|
|
|
|
AmSession* session = NULL;
|
|
if (req.method == "INVITE") {
|
|
if (NULL != session_params)
|
|
session = state_factory->onInvite(req, *session_params);
|
|
else
|
|
session = state_factory->onInvite(req);
|
|
} else if (req.method == "REFER") {
|
|
if (NULL != session_params)
|
|
session = state_factory->onRefer(req, *session_params);
|
|
else
|
|
session = state_factory->onRefer(req);
|
|
}
|
|
|
|
if(!session) {
|
|
// State creation failed:
|
|
// application denied session creation
|
|
// or there was an error.
|
|
//
|
|
// let's hope the createState function has replied...
|
|
// ... and do nothing !
|
|
|
|
DBG("onInvite returned NULL\n");
|
|
return 0;
|
|
}
|
|
|
|
//state_factory->configureSession(session);
|
|
//session->checkSessionExpires(req);
|
|
|
|
return session;
|
|
}
|
|
|
|
bool AmSessionContainer::addSession_unsafe(const string& callid,
|
|
const string& remote_tag,
|
|
const string& local_tag,
|
|
AmSession* session)
|
|
{
|
|
if(getSession(callid,remote_tag))
|
|
return false;
|
|
|
|
if (!remote_tag.empty())
|
|
as_id_lookup[callid+remote_tag] = local_tag;
|
|
|
|
return addSession_unsafe(local_tag,session);
|
|
}
|
|
|
|
bool AmSessionContainer::addSession_unsafe(const string& local_tag,
|
|
AmSession* session)
|
|
{
|
|
if(getSession(local_tag))
|
|
return false;
|
|
|
|
//DBG("a_sessions['%s'] = session\n",local_tag.c_str());
|
|
a_sessions[local_tag] = session;
|
|
return true;
|
|
}
|
|
|
|
bool AmSessionContainer::addSession(const string& callid,
|
|
const string& remote_tag,
|
|
const string& local_tag,
|
|
AmSession* session)
|
|
{
|
|
as_mut.lock();
|
|
bool ret = addSession_unsafe(callid,remote_tag,local_tag,session);
|
|
as_mut.unlock();
|
|
return ret;
|
|
}
|
|
|
|
bool AmSessionContainer::addSession(const string& local_tag,
|
|
AmSession* session)
|
|
{
|
|
as_mut.lock();
|
|
bool ret = addSession_unsafe(local_tag,session);
|
|
as_mut.unlock();
|
|
return ret;
|
|
}
|
|
|
|
int AmSessionContainer::getSize()
|
|
{
|
|
int res=0;
|
|
as_mut.lock();
|
|
res = a_sessions.size();
|
|
as_mut.unlock();
|
|
|
|
return res;
|
|
}
|