static SIPB2BHandler::MessageType getBodyType(const SIPMessage::Ptr& pRequest)
{
std::string cseq = pRequest->hdrGet("cseq");
if (cseq.empty())
return SIPB2BHandler::TYPE_INVALID;
OSS::string_to_upper(cseq);
if (OSS::string_ends_with(cseq, "INVITE") ||
OSS::string_ends_with(cseq, "UPDATE") ||
OSS::string_ends_with(cseq, "ACK") ||
OSS::string_ends_with(cseq, "PRACK"))
{
if (pRequest->getBody().empty())
return SIPB2BHandler::TYPE_INVALID;
std::string contentType = pRequest->hdrGet("content-type");
OSS::string_to_lower(contentType);
if (contentType != "application/sdp")
return SIPB2BHandler::TYPE_INVALID;
return SIPB2BHandler::TYPE_SDP;
}
return SIPB2BHandler::TYPE_INVALID;
}
SIPMessage::Ptr SIPB2BTransactionManager::onAuthenticateTransaction(
const SIPMessage::Ptr& pRequest, SIPB2BTransaction::Ptr pTransaction)
{
std::string maxForwards = pRequest->hdrGet("max-forwards");
if (maxForwards.empty())
{
maxForwards = "70";
}
int maxF = OSS::string_to_number<int>(maxForwards.c_str());
if (maxF == 0)
{
return pRequest->createResponse(SIPMessage::CODE_483_TooManyHops);
}
--maxF;
pRequest->hdrRemove("max-forwards");
pRequest->hdrSet("Max-Forwards", OSS::string_from_number(maxF).c_str());
SIPB2BHandler::Ptr pHandler = findHandler(pRequest);
if (pHandler)
{
return pHandler->onAuthenticateTransaction(pRequest, pTransaction);
}
else if (_pDefaultHandler)
{
return _pDefaultHandler->onAuthenticateTransaction(pRequest, pTransaction);
}
return pRequest->createResponse(405, "No Corresponding Handler");
}
static SIPB2BHandler::MessageType getMessageType(const SIPMessage::Ptr& pRequest)
{
std::string cseq = pRequest->hdrGet("cseq");
if (cseq.empty())
return SIPB2BHandler::TYPE_INVALID;
OSS::string_to_upper(cseq);
if (OSS::string_ends_with(cseq, "INVITE"))
return SIPB2BHandler::TYPE_INVITE;
else if (OSS::string_ends_with(cseq, "REGISTER"))
return SIPB2BHandler::TYPE_REGISTER;
else if (OSS::string_ends_with(cseq, "BYE"))
return SIPB2BHandler::TYPE_BYE;
else if (OSS::string_ends_with(cseq, "CANCEL"))
return SIPB2BHandler::TYPE_CANCEL;
else if (OSS::string_ends_with(cseq, "EXEC"))
return SIPB2BHandler::TYPE_EXEC;
else if (OSS::string_ends_with(cseq, "INFO"))
return SIPB2BHandler::TYPE_INFO;
else if (OSS::string_ends_with(cseq, "OPTIONS"))
return SIPB2BHandler::TYPE_OPTIONS;
else if (OSS::string_ends_with(cseq, "PRACK"))
return SIPB2BHandler::TYPE_PRACK;
else if (OSS::string_ends_with(cseq, "PUBLISH"))
return SIPB2BHandler::TYPE_PUBLISH;
else if (OSS::string_ends_with(cseq, "SUBSCRIBE"))
return SIPB2BHandler::TYPE_SUBSCRIBE;
else if (OSS::string_ends_with(cseq, "MESSAGE"))
return SIPB2BHandler::TYPE_MESSAGE;
else if (OSS::string_ends_with(cseq, "NOTIFY"))
return SIPB2BHandler::TYPE_NOTIFY;
else if (OSS::string_ends_with(cseq, "REFER"))
return SIPB2BHandler::TYPE_REFER;
else if (OSS::string_ends_with(cseq, "UPDATE"))
return SIPB2BHandler::TYPE_UPDATE;
else if (pRequest->isRequest())
return SIPB2BHandler::TYPE_ANY;
return SIPB2BHandler::TYPE_INVALID;
}
void SIPTransaction::onReceivedMessage(SIPMessage::Ptr pMsg, SIPTransportSession::Ptr pTransport)
{
OSS::mutex_lock lock(_mutex);
bool isAck = pMsg->isRequest("ACK");
if (pMsg->isRequest() && !_pInitialRequest && !isAck)
_pInitialRequest = pMsg;
if (_logId.empty())
_logId = pMsg->createContextId(true);
if (!_transport)
_transport = pTransport;
if (!_localAddress.isValid())
_localAddress = pTransport->getLocalAddress();
if (!_remoteAddress.isValid())
_remoteAddress = pTransport->getRemoteAddress();
if (SIPXOR::isEnabled() && !_isXOREncrypted)
{
std::string isXOR;
_isXOREncrypted = pMsg->getProperty("xor", isXOR) && isXOR == "1";
}
if (isParent())
{
std::ostringstream logMsg;
logMsg << _logId << "<<< " << pMsg->startLine()
<< " LEN: " << pTransport->getLastReadCount()
<< " SRC: " << _remoteAddress.toIpPortString()
<< " DST: " << _localAddress.toIpPortString()
<< " EXT: " << "[" << pTransport->getExternalAddress() << "]"
<< " FURI: " << pMsg->hdrGet("from")
<< " ENC: " << _isXOREncrypted
<< " PROT: " << pTransport->getTransportScheme();
OSS::log_information(logMsg.str());
if (OSS::log_get_level() >= OSS::PRIO_DEBUG)
OSS::log_debug(pMsg->createLoggerData());
}
//
// If this is a request and is not an ACK, then the parent IST fsm must always handle it
//
if (isParent() && pMsg->isRequest() && !isAck)
{
_fsm->onReceivedMessage(pMsg, pTransport);
}
else if (!pMsg->isRequest() || isAck)
{
//
// This is a response or an ACK and the transaction could have branched out
//
if (!isParent())
{
_fsm->onReceivedMessage(pMsg, pTransport);
}
else
{
SIPTransaction::Ptr pBranch = findBranch(pMsg);
if (pBranch)
pBranch->onReceivedMessage(pMsg, pTransport);
else
_fsm->onReceivedMessage(pMsg, pTransport);
}
}
}
void SIPFSMDispatch::onReceivedMessage(SIPMessage::Ptr pMsg, SIPTransportSession::Ptr pTransport)
{
if (!pTransport->isEndpoint() && pTransport->getLastReadCount() < MIN_DATAGRAM_SIZE && !pTransport->isReliableTransport())
{
//
// datagram is too short to be a SIP Message
// Bailing out. Take note that streamed connection
// can split SIP messages to smaller frames
// and the last frame can be smaller than MIN_DATAGRAM_SIZE
// so we do not impose a limit for streams
//
return;
}
try
{
pMsg->parse();
}
catch(OSS::Exception e)
{
std::ostringstream logMsg;
logMsg << "Incoming message failed to be parsed - " << e.message()
<< " LEN: " << pTransport->getLastReadCount()
<< " SRC: " << pTransport->getRemoteAddress().toIpPortString();
OSS::log_warning(logMsg.str());
return;
}
std::string id;
if (!pMsg->getTransactionId(id))
return; // don't throw here
// we don't have control over what we receive from the transport
SIPTransaction::Ptr trn;
SIPTransaction::Type transactionType = SIPTransaction::TYPE_UNKNOWN;
if (pMsg->isRequest())
{
if (OSS::string_caseless_starts_with(pMsg->startLine(), "invite"))
{
transactionType = SIPTransaction::TYPE_IST;
if (_istBlocker.has(id))
{
OSS_LOG_WARNING("Blocked request retransmission - " << pMsg->startLine());
return;
}
trn = _ist.findTransaction(pMsg, pTransport);
}
else if (OSS::string_caseless_starts_with(pMsg->startLine(), "ack"))
{
//
// ACK for error responses will get matched to a transaction
//
transactionType = SIPTransaction::TYPE_IST;
trn = _ist.findTransaction(pMsg, pTransport, false);
}
else
{
transactionType = SIPTransaction::TYPE_NIST;
trn = _nist.findTransaction(pMsg, pTransport);
}
}
else if (!pMsg->isRequest())
{
std::string cseq;
cseq = pMsg->hdrGet(OSS::SIP::HDR_CSEQ);
if (OSS::string_caseless_ends_with(cseq, "invite"))
{
transactionType = SIPTransaction::TYPE_ICT;
trn = _ict.findTransaction(pMsg, pTransport, false);
}
else
{
transactionType = SIPTransaction::TYPE_NICT;
trn = _nict.findTransaction(pMsg, pTransport, false);
}
}
if (trn)
{
std::ostringstream logMsg;
if (!trn->getLogId().empty())
{
logMsg << trn->getLogId() << "Found Transaction " << trn->getId();
OSS::log_debug(logMsg.str());
}
else
{
trn->setLogId(pMsg->createContextId(true));
logMsg << trn->getLogId() << "Transaction " << trn->getId() << " CREATED";
OSS::log_information(logMsg.str());
}
}
if (!trn)
{
//
// We did not get a transaction, check if this is an ack and find the IST ACK transaction
//
if (transactionType == SIPTransaction::TYPE_IST && pMsg->isRequest("ACK"))
{
//
// No IST is existing in the ackable Pool.
// Report this ACK as orphaned to the UA CORE
//
if (_ackOr2xxTransactionHandler)
_ackOr2xxTransactionHandler(pMsg, pTransport);
}
else if (transactionType == SIPTransaction::TYPE_ICT && pMsg->is2xx())
{
if (_ackOr2xxTransactionHandler)
_ackOr2xxTransactionHandler(pMsg, pTransport);
}
else
{
std::ostringstream logMsg;
logMsg << pMsg->createContextId(true) << "Unable to match incoming request to a transaction - "
<< pMsg->startLine();
OSS::log_warning(logMsg.str());
}
}
else
{
if (!trn->transportService())
{
//
// This is a newly created transaction
//
trn->transportService() = &_transport;
trn->transport() = pTransport;
}
trn->onReceivedMessage(pMsg, pTransport);
}
}