bool SIPB2BTransactionManager::onRouteResponse(
const OSS::SIP::SIPMessage::Ptr& pRequest,
const OSS::SIP::SIPTransportSession::Ptr& pTransport,
SIPB2BTransaction::Ptr pTransaction,
OSS::IPAddress& target)
{
/// This method requires the application layer to determine
/// the target address of the response.
if (_useSourceAddressForResponses || pTransport->isReliableTransport())
{
target = pTransport->getRemoteAddress();
return true;
}
else
{
SIPB2BHandler::Ptr pHandler = findHandler(pRequest);
if (pHandler)
{
return pHandler->onRouteResponse(pRequest, pTransport, pTransaction, target);
}
else if (_pDefaultHandler)
{
return _pDefaultHandler->onRouteResponse(pRequest, pTransport, pTransaction, target);
}
return false;
}
}
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");
}
void ProtocolInterpreter::onCommand(std::string const &command,
std::string const &arguments) {
size_t commandLength;
Handler const *handler = findHandler(command, commandLength);
if (handler == nullptr) {
DS2LOG(Packet, "handler for command '%s' unknown", command.c_str());
//
// The handler couldn't be found, we don't support this packet.
//
_session->sendError(kErrorUnsupported);
return;
}
std::string extra;
if (commandLength != command.length()) {
//
// Command has part of the argument, LLDB doesn't use separators :(
//
extra = command.substr(commandLength);
}
extra += arguments;
if (extra.find_first_of("*}") != std::string::npos) {
extra = Unescape(extra);
DS2LOG(Packet, "args='%.*s'", static_cast<int>(extra.length()), &extra[0]);
}
(handler->handler->*handler->callback)(*handler, extra);
}
void CCTouchDispatcher::removeDelegate(CCTouchDelegate *pDelegate)
{
if (pDelegate == NULL)
{
return;
}
if (! m_bLocked)
{
forceRemoveDelegate(pDelegate);
}
else
{
/* If pHandler is contained in m_pHandlersToAdd, if so remove it from m_pHandlersToAdd and retrun.
* Refer issue #752(cocos2d-x)
*/
CCTouchHandler *pHandler = findHandler(m_pHandlersToAdd, pDelegate);
if (pHandler)
{
m_pHandlersToAdd->removeObject(pHandler);
return;
}
ccCArrayAppendValue(m_pHandlersToRemove, pDelegate);
m_bToRemove = true;
}
}
THREAD_CTL* CPPLIB( fs_lookup ) // LOOK THRU FS ENTRIES FOR LAST, THREAD_CTL
( RW_DTREG** a_last ) // - addr[ ptr to last WATCOM entry ]
{
_RTCTL rt_ctl( 0 ); // - fake R/T control
FsExcRec excrec; // - system exception record
DISPATCH_EXC dispatch; // - dispatch control
RW_DTREG* last; // - last WATCOM R/W block
RW_DTREG *ctl; // R/W block (based fs:0)
THREAD_CTL* retn; // PGM THREAD (first WATCOM .EXE, .DLL active)
THREAD_CTL* base; // PGM THREAD (call base)
#ifdef SYSIND_REGISTRATION
#define LIST_END 0 // - link-list ending
#else
#define LIST_END (void*)(-1L)// - link-list ending
#endif
CPPLIB( dispatch_dummy )( &dispatch, &rt_ctl );
excrec.code = EXCREC_CODE;
excrec.flags = EXCREC_FLAGS;
excrec.rec = 0;
excrec.addr = 0;
excrec.parm_count = EXCREC_PARM_COUNT;
excrec.object = 0;
excrec.dispatch = &dispatch;
last = 0;
retn = 0;
for( ctl = FsTop(); ctl != LIST_END; ctl = ctl->base.prev ) {
#ifdef FS_REGISTRATION
uint_8* handler = findHandler( (uint_8*)ctl->base.handler );
if( handler[5] == 'W'
&& handler[6] == 'A'
&& handler[7] == 'T'
&& handler[8] == 'C'
&& handler[9] == 'O'
&& handler[10] == 'M' ) {
#endif
if( EXC_HAND_CATCH
== (*ctl->base.handler)( &excrec, 0, 0, 0 ) ) {
last = ctl;
base = dispatch.rtc->thr;
if( base->flags.executable ) {
retn = base;
}
}
#ifdef FS_REGISTRATION
}
#endif
}
if( retn == 0 ) {
retn = dispatch.rtc->thr;
if( retn == 0 ) {
retn = &_RWD_ThreadData;
}
}
*a_last = last;
return retn;
}
void SIPB2BTransactionManager::onProcessResponseBody(
SIPMessage::Ptr& pRequest,
SIPB2BTransaction::Ptr pTransaction)
{
SIPB2BHandler::Ptr pHandler = findHandler(getBodyType(pRequest));
if (pHandler)
{
return pHandler->onProcessResponseBody(pRequest, pTransaction);
}
else if (_pDefaultHandler)
{
return _pDefaultHandler->onProcessResponseBody(pRequest, pTransaction);
}
}
bool SIPB2BTransactionManager::onClientTransactionCreated(
const SIPMessage::Ptr& pRequest, SIPB2BTransaction::Ptr pTransaction)
{
SIPB2BHandler::Ptr pHandler = findHandler(pRequest);
if (pHandler)
{
return pHandler->onClientTransactionCreated(pRequest, pTransaction);
}
else if (_pDefaultHandler)
{
return _pDefaultHandler->onClientTransactionCreated(pRequest, pTransaction);
}
return false;
}
SIPMessage::Ptr SIPB2BTransactionManager::onTransactionCreated(
const SIPMessage::Ptr& pRequest, SIPB2BTransaction::Ptr pTransaction)
{
SIPB2BHandler::Ptr pHandler = findHandler(pRequest);
if (pHandler)
{
return pHandler->onTransactionCreated(pRequest, pTransaction);
}
else if (_pDefaultHandler)
{
return _pDefaultHandler->onTransactionCreated(pRequest, pTransaction);
}
return pRequest->createResponse(405, "No Corresponding Handler");
}
void SIPB2BTransactionManager::onProcessClientResponse(
SIPMessage::Ptr& pResponse,
SIPB2BTransaction::Ptr pTransaction)
{
SIPB2BHandler::Ptr pHandler = findHandler(pResponse);
if (pHandler)
{
pHandler->onProcessClientResponse(pResponse, pTransaction);
}
else if (_pDefaultHandler)
{
_pDefaultHandler->onProcessClientResponse(pResponse, pTransaction);
}
}
void SIPB2BTransactionManager::onProcessResponseInbound(
SIPMessage::Ptr& pResponse,
SIPB2BTransaction::Ptr pTransaction)
{
SIPB2BHandler::Ptr pHandler = findHandler(pResponse);
if (pHandler)
{
return pHandler->onProcessResponseInbound(pResponse, pTransaction);
}
else if (_pDefaultHandler)
{
return _pDefaultHandler->onProcessResponseInbound(pResponse, pTransaction);
}
}
void SIPB2BTransactionManager::onTransactionError(
OSS::SIP::SIPTransaction::Error e,
SIPMessage::Ptr pErrorResponse,
SIPB2BTransaction::Ptr pTransaction)
{
SIPB2BHandler::Ptr pHandler = findHandler(pTransaction->serverRequest());
if (pHandler)
{
return pHandler->onTransactionError(e, pErrorResponse, pTransaction);
}
else if (_pDefaultHandler)
{
return _pDefaultHandler->onTransactionError(e, pErrorResponse, pTransaction);
}
}
void SIPB2BTransactionManager::onClientTransactionError(
OSS::SIP::SIPTransaction::Error e,
SIPMessage::Ptr pErrorResponse,
SIPB2BTransaction::Ptr pTransaction)
{
SIPB2BHandler::Ptr pHandler = findHandler(pErrorResponse);
if (pHandler)
{
pHandler->onClientTransactionError(e, pErrorResponse, pTransaction);
}
else if (_pDefaultHandler)
{
_pDefaultHandler->onClientTransactionError(e, pErrorResponse, pTransaction);
}
}
/**
* Loop through all handles. Upon detection of a handle signalled by poll(), its
* corresponding event handler is fetched and invoked.
*/
static void dispatchSignalledHandles(const struct pollfd* fds, size_t noOfHandles)
{
size_t i = 0;
for(i = 0; i < noOfHandles; ++i) {
/* Detect all signalled handles. */
if((POLLRDNORM | POLLERR) & fds[i].revents) {
/* This handle is signalled -> find and invoke its corresponding event handler. */
EventHandler* signalledHandler = findHandler(fds[i].fd);
if(NULL != signalledHandler){
signalledHandler-> handleEvent(signalledHandler->instance);
}
}
}
}
SIPMessage::Ptr SIPB2BTransactionManager::onInvokeLocalHandler(
const OSS::SIP::SIPMessage::Ptr& pRequest,
const OSS::SIP::SIPTransportSession::Ptr& pTransport,
SIPB2BTransaction::Ptr pTransaction)
{
SIPB2BHandler::Ptr pHandler = findHandler(pRequest);
if (pHandler)
{
return pHandler->onInvokeLocalHandler(pRequest, pTransport, pTransaction);
}
else if (_pDefaultHandler)
{
return _pDefaultHandler->onInvokeLocalHandler(pRequest, pTransport, pTransaction);
}
return pRequest->createResponse(405, "No Corresponding Handler");
}
bool SIPB2BTransactionManager::onRouteClientTransaction(
SIPMessage::Ptr& pRequest,
SIPB2BTransaction::Ptr pTransaction,
OSS::IPAddress& localInterface,
OSS::IPAddress& target)
{
SIPB2BHandler::Ptr pHandler = findHandler(pRequest);
if (pHandler)
{
return pHandler->onRouteClientTransaction(pRequest, pTransaction, localInterface, target);
}
else if (_pDefaultHandler)
{
return _pDefaultHandler->onRouteClientTransaction(pRequest, pTransaction, localInterface, target);
}
return false;
}
bool ProtocolInterpreter::registerHandler(Handler const &handler) {
if (handler.command.empty() || handler.handler == nullptr ||
handler.callback == nullptr)
return false;
size_t commandLength;
if (findHandler(handler.command, commandLength))
return false;
_handlers.push_back(handler);
// We need to sort the handlers vector.
std::sort(_handlers.begin(), _handlers.end(),
[](Handler const &a, Handler const &b) -> bool {
return (a.command < b.command);
});
return true;
}
SIPMessage::Ptr SIPB2BTransactionManager::onRouteTransaction(
SIPMessage::Ptr& pRequest,
SIPB2BTransaction::Ptr pTransaction,
OSS::IPAddress& localInterface,
OSS::IPAddress& target)
{
SIPB2BHandler::Ptr pHandler = findDomainRouter(pRequest);
if (pHandler)
{
bool handled = false;
SIPMessage::Ptr result = pHandler->onRouteTransaction(pRequest, pTransaction, localInterface, target, handled);
if (handled)
return result;
}
pHandler = findHandler(pRequest);
if (pHandler)
{
SIPMessage::Ptr result = pHandler->onRouteTransaction(pRequest, pTransaction, localInterface, target);
//
// _postRouteCallback is currently set by
// the SBCStaticRouter class that allows static router
// to bypass the results of the javascript layer.
//
if (_postRouteCallback)
return _postRouteCallback(pRequest, result, pTransaction, localInterface, target);
return result;
}
else if (_pDefaultHandler)
{
SIPMessage::Ptr result = _pDefaultHandler->onRouteTransaction(pRequest, pTransaction, localInterface, target);
//
// _postRouteCallback is currently set by
// the SBCStaticRouter class that allows static router
// to bypass the results of the javascript layer.
//
if (_postRouteCallback)
return _postRouteCallback(pRequest, result, pTransaction, localInterface, target);
return result;
}
return pRequest->createResponse(405, "No Corresponding Handler");
}
void SIPB2BTransactionManager::handleAckFor2xxTransaction(
const OSS::SIP::SIPMessage::Ptr& pMsg,
const OSS::SIP::SIPTransportSession::Ptr& pTransport)
{
SIPB2BHandler::Ptr pHandler = findHandler(SIPB2BHandler::TYPE_INVITE);
if (pHandler)
{
if (_threadPool.schedule(boost::bind(&SIPB2BHandler::onProcessAckFor2xxRequest, pHandler, pMsg, pTransport)) == -1)
{
OSS::log_error(pMsg->createContextId(true) + "No available thread to handle SIPB2BTransactionManager::handleAckFor2xxTransaction");
}
}
else if (_pDefaultHandler)
{
if (_threadPool.schedule(boost::bind(&SIPB2BHandler::onProcessAckFor2xxRequest, _pDefaultHandler, pMsg, pTransport)) == -1)
{
OSS::log_error(pMsg->createContextId(true) + "No available thread to handle SIPB2BTransactionManager::handleAckFor2xxTransaction");
}
}
}
void TimeWarpNode::updateTopics(const ros::master::V_TopicInfo& topics)
{
const char* vis_type = ros::message_traits::DataType<visualization_msgs::MarkerArray>::value();
for(ros::master::V_TopicInfo::const_iterator it = topics.begin(); it != topics.end(); ++it)
{
const ros::master::TopicInfo& info = *it;
if(info.datatype == vis_type)
{
if(info.name.substr(0, 5) == "/vis/")
continue;
int idx = findHandler(info.name);
if(idx != -1)
continue;
ROS_WARN("Creating handler for topic '%s'", info.name.c_str());
m_handlers.push_back(
new SmartTopicHandler<visualization_msgs::MarkerArray>(&m_nh, info.name)
);
}
}
}
Windows::Window* WindowManager::addNewSubWindow<Windows::nBottomBarWindow>(windowPtr& windowRef){
Windows::Window* ret = nullptr;
if(auto wHnd = windowRef.lock())
static_cast<Windows::nCursesDisplayWindow*>(findHandler(windowRef).get())->addElement(ret = d_factory->createWindow("CursesWindowBottom", windowRef));
return ret;
}
void handleInvokeReply(RemoteOpHeader *h, Node srv, Stream str)
{
State *state;
anticipateGC(64 * 1024 + 2 * StreamLength(str));
state = (State *)OIDFetch(h->ss);
if (ISNIL(state) || !RESDNT(state->firstThing)) {
/*
* We probably gc'd this state because we couldn't find any references
* to it. Find it and send it this reply.
*/
Stream newstr;
RewindStream(str);
newstr = StealStream(str);
findAndSendTo(h->ss, newstr);
} else {
TRACE(rinvoke, 3, ("InvokeReply received"));
assert(!ISNIL(state));
assert(RESDNT(state->firstThing));
assert(ISetMember(allProcesses, (int)state));
TRACE(process, 5, ("Resetting nsoid in state %#x", state));
state->nsoid = nooid;
state->nstoid = nooid;
if (h->status) {
TRACE(rinvoke, 0, ("Obsolete remote invocation return code"));
h->option1 = 2;
}
if (h->option1) {
/*
* We are supposed to propagate a failure.
*/
TRACE(rinvoke, 1, ("Remote invocation raised %s",
h->option1 == 1 ? "failure" :
h->option1 == 2 ? "unavailable" :
"unknown"));
if (!findHandler(state, h->option1 - 1, (Object)JNIL)) {
if (!debugInteractively) {
state = processDone(state, h->option1);
} else {
char buf[80];
sprintf(buf, "Remote invocation raised %s",
h->option1 == 1 ? "failure" :
h->option1 == 2 ? "unavailable" :
"unknown");
if (debug(state, buf)) {
/*
* debug returns 1 when we shouldn't run the state no more.
*/
state = 0;
}
}
}
if (state) makeReady(state);
} else if (RESDNT(state->op->flags) &&
BROKEN(state->op->flags) && isBroken(state->op)) {
if (returnToBrokenObject(state)) {
/* nothing to do */
} else {
makeReady(state);
}
} else {
extractNVars(str, -1, (int *)state->sp, &state->ep, &state->et, srv);
makeReady(state);
}
}
TRACE(rinvoke, 4, ("Invoke return handled"));
inhibit_gc--;
}
SIPB2BHandler::Ptr SIPB2BTransactionManager::findHandler(const OSS::SIP::SIPMessage::Ptr& pMsg) const
{
return findHandler(getMessageType(pMsg));
}
