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)); }