void testAccessors() { OsConfigDb *pDb = new OsConfigDb(); // the get() method is tested by testManipulators() // test the getNext() method // // We put the following block in its own scope so that the UtlString // references (stored in "name" and "value") are released as a side effect // of going out of scope. Otherwise, it will look like a memory leak. { UtlString name; UtlString value; pDb->set("Key3", "Value3"); // add several entries (not in pDb->set("Key2", "Value2"); // alphabetical or reverse alphabetical pDb->set("Key4", "Value4"); // order pDb->set("Key1", "Value1"); CPPUNIT_ASSERT_MESSAGE("verify that the database is not empty", !pDb->isEmpty()); CPPUNIT_ASSERT_MESSAGE("has four entries", pDb->numEntries()==4); OsStatus res = pDb->getNext("", name, value); // call getNext("", ...) CPPUNIT_ASSERT_MESSAGE("verify that Key1/Value1", res == OS_SUCCESS && name.compareTo("Key1") == 0 && // is returned value.compareTo("Value1") == 0); res = pDb->getNext("Key1", name, value); CPPUNIT_ASSERT_MESSAGE("call getNext(\"Key1\", ...)", res == OS_SUCCESS && // verify that Key2/Value2 name.compareTo("Key2") == 0 && // is returned value.compareTo("Value2") == 0); res = pDb->getNext("Key2", name, value); CPPUNIT_ASSERT_MESSAGE("call getNext(\"Key2\", ...)", res == OS_SUCCESS && // verify that Key3/Value3 name.compareTo("Key3") == 0 && // is returned value.compareTo("Value3") == 0); res = pDb->getNext("Key3", name, value); CPPUNIT_ASSERT_MESSAGE("call getNext(\"Key3\", ...)", res == OS_SUCCESS && name.compareTo("Key4") == 0 && value.compareTo("Value4") == 0); res = pDb->getNext("Key4", name, value); CPPUNIT_ASSERT_MESSAGE("call getNext(\"Key4\", ...)", res == OS_NO_MORE_DATA && name.compareTo("") == 0 && value.compareTo("") == 0); res = pDb->getNext("XXX", name, value); CPPUNIT_ASSERT_MESSAGE("call getNext with a key not in the database and verify", res == OS_NOT_FOUND && name.compareTo("") == 0 && // that empty strings are value.compareTo("") == 0); // returned for the next name // and value pair. delete pDb; // delete the database name.remove(0); value.remove(0); } }
// Read config information. void SipRedirectorRegDB::readConfig(OsConfigDb& configDb) { configDb.get("MAPPING_FILE", mMappingFileName); }
void PluginHooks::readConfig(const OsConfigDb& configDb) { OsSysLog::add(FAC_KERNEL, PRI_DEBUG, "PluginHooks::readConfig mFactory = '%s', mPrefix = '%s'", mFactory.data(), mPrefix.data()); // Move any existing hooks from the current configured list to // a temporary holding list. UtlSList existingHooks; UtlContainable* existingHook; UtlSortedListIterator nextHook(mConfiguredHooks); while ((existingHook = nextHook())) { existingHooks.append(mConfiguredHooks.removeReference(existingHook)); } // the mConfiguredHooks list is now empty // Walk the current configuration, // any existing hook is moved back to the mConfiguredHooks list, // newly configured hooks are added, // each configured hook is called to read its own configuration. UtlString hookPrefix(mPrefix); hookPrefix.append(HOOK_LIB_PREFIX); OsConfigDb allHooks; OsSysLog::add(FAC_KERNEL, PRI_DEBUG, "PluginHooks::readConfig looking up hooks '%s'", hookPrefix.data() ); if (OS_SUCCESS == configDb.getSubHash(hookPrefix, allHooks)) // any hooks configured for prefix? { UtlString lastHook; UtlString hookName; UtlString hookLibrary; // walk each hook and attempt to load and configure it for ( lastHook = ""; OS_SUCCESS == allHooks.getNext(lastHook, hookName, hookLibrary); (lastHook = hookName, hookName.remove(0), hookLibrary.remove(0)) ) { ConfiguredHook* thisHook; if (NULL == (thisHook = dynamic_cast<ConfiguredHook*>(existingHooks.remove(&hookName)))) { // not an existing hook, so create a new one thisHook = ConfiguredHook::newHook(hookName, mFactory, hookLibrary); } else { // this is a pre-existing hook; check to see that the library has not changed. if (! thisHook->isLibrary(hookLibrary)) { // the library for thisHook has changed, so delete and recreate it with the new one. delete thisHook; thisHook = ConfiguredHook::newHook(hookName, mFactory, hookLibrary); } } if (thisHook) { // put the hook onto the list of active hooks mConfiguredHooks.insert(thisHook); // (re)configure the hook thisHook->readConfig(mPrefix, configDb); } } } else { OsSysLog::add(FAC_KERNEL, PRI_INFO, "PluginHooks: no '%s' hooks configured", mPrefix.data() ); } // discard any hooks that are no longer in the configuration existingHooks.destroyAll(); }
int main(int argc, char* argv[]) { const char* configFileName = "siptest-config"; int proxyTcpPort; int proxyUdpPort; int proxyTlsPort; OsConfigDb configDb; // siptest uses osPrintf for output, so we have to un-suppress it. enableConsoleOutput(TRUE); if(configDb.loadFromFile(configFileName) == OS_SUCCESS) { osPrintf("Found config file: %s\n", configFileName); } else { configDb.set("SIP_TEST_UDP_PORT", "3000"); configDb.set("SIP_TEST_TCP_PORT", "3000"); configDb.set("SIP_TEST_TLS_PORT", "3001"); if(configDb.storeToFile(configFileName) == OS_SUCCESS) { osPrintf("Could not write config file: %s\n", configFileName); } } proxyUdpPort = configDb.getPort("SIP_TEST_UDP_PORT") ; proxyTcpPort = configDb.getPort("SIP_TEST_TCP_PORT") ; proxyTlsPort = configDb.getPort("SIP_TEST_TLS_PORT") ; UtlBoolean commandStatus = CommandProcessor::COMMAND_SUCCESS; char buffer[1024]; char* commandLine; CommandProcessor processor; SipLineMgr* lineMgr = new SipLineMgr(); SipRefreshMgr* refreshMgr = new SipRefreshMgr(); lineMgr->startLineMgr(); lineMgr->initializeRefreshMgr( refreshMgr ); SipUserAgent* sipUA = new SipUserAgent( proxyTcpPort ,proxyUdpPort ,proxyTlsPort ,NULL // default publicAddress ,NULL // default defaultUser ,NULL // default defaultSipAddress ,NULL // default sipProxyServers ,NULL // default sipDirectoryServers ,NULL // default sipRegistryServers ,NULL // default authenicateRealm ,NULL // default authenticateDb ,NULL // default authorizeUserIds ,NULL // default authorizePasswords ,lineMgr ); sipUA->allowMethod(SIP_REGISTER_METHOD); sipUA->allowMethod(SIP_SUBSCRIBE_METHOD); sipUA->allowMethod(SIP_NOTIFY_METHOD); sipUA->start(); sipUA->startMessageLog(); osPrintf( "SIP logging Started\n" ); refreshMgr->init( sipUA ); CommandMsgProcessor* msgProc = new CommandMsgProcessor(sipUA); msgProc->start(); processor.registerCommand("help", new HelpCommand(&processor)); processor.registerCommand("?", new HelpCommand(&processor)); processor.registerCommand("history", new HistoryCommand(&processor)); processor.registerCommand("send", new SipSendCommand(sipUA)); processor.registerCommand("lsend", new SipLSendCommand()); processor.registerCommand("get", new HttpGetCommand()); processor.registerCommand("respond", new RespondCommand(msgProc)); processor.registerCommand("rt", new RespondTemplate(msgProc)); processor.registerCommand("rrespond", new ResendResponse(msgProc)); processor.registerCommand("log", new SipLogCommand(*sipUA)); processor.registerCommand("auth", new AuthCommand(lineMgr)); processor.registerCommand("sleep", new SleepCommand()); processor.registerCommand("quit", new ExitCommand()); processor.registerCommand("exit", new ExitCommand()); //Initialization UtlBoolean doPrompt = isatty(STDIN_FILENO); if ( doPrompt ) { printf("Enter command or help/? for help\n"); printf("SIPdriver: "); } for ( commandStatus = CommandProcessor::COMMAND_SUCCESS; ( commandStatus < CommandProcessor::COMMAND_FAILED_EXIT && commandStatus != CommandProcessor::COMMAND_SUCCESS_EXIT && (commandLine = fgets(buffer,1024,stdin)) ); ) { //printf("GOT command line:\"%s\"\n", commandLine); commandStatus = processor.executeCommand(commandLine); //printf("command status: %d exit status: %d\n", commandStatus, //CommandProcessor::COMMAND_SUCCESS_EXIT); if ( doPrompt ) { printf("SIPdriver: "); } } delete msgProc; delete sipUA; return CommandProcessor::COMMAND_SUCCESS_EXIT != commandStatus; }
int proxy() { int proxyTcpPort; int proxyUdpPort; int proxyTlsPort; UtlString bindIp; int maxForwards; UtlString domainName; UtlString proxyRecordRoute; UtlString routeName; UtlString authScheme; UtlString ipAddress; OsSocket::getHostIp(&ipAddress); OsPath ConfigfileName = SipXecsService::Path(SipXecsService::ConfigurationDirType, CONFIG_SETTINGS_FILE); OsConfigDb configDb; if(OS_SUCCESS != configDb.loadFromFile(ConfigfileName)) { exit(1); } // Initialize the OsSysLog... initSysLog(&configDb); std::set_terminate(catch_global); configDb.get(CONFIG_SETTING_BIND_IP, bindIp); if ((bindIp.isNull()) || !OsSocket::isIp4Address(bindIp)) { bindIp = "0.0.0.0"; } Os::Logger::instance().log(FAC_SIP, PRI_INFO, "%s: %s", CONFIG_SETTING_BIND_IP, bindIp.data()); osPrintf("%s: %s", CONFIG_SETTING_BIND_IP, bindIp.data()); UtlString hostname; configDb.get("SIPX_PROXY_HOST_NAME", hostname); if (!hostname.isNull()) { // bias the selection of SRV records so that if the name of this host is an alternative, // it wins in any selection based on random weighting. SipSrvLookup::setOwnHostname(hostname); } Os::Logger::instance().log(FAC_SIP, PRI_INFO, "SIPX_PROXY_HOST_NAME : %s", hostname.data()); proxyUdpPort = configDb.getPort("SIPX_PROXY_UDP_PORT"); if (!portIsValid(proxyUdpPort)) { proxyUdpPort = 5060; } Os::Logger::instance().log(FAC_SIP, PRI_INFO, "SIPX_PROXY_UDP_PORT : %d", proxyUdpPort); proxyTcpPort = configDb.getPort("SIPX_PROXY_TCP_PORT") ; if (!portIsValid(proxyTcpPort)) { proxyTcpPort = 5060; } Os::Logger::instance().log(FAC_SIP, PRI_INFO, "SIPX_PROXY_TCP_PORT : %d", proxyTcpPort); proxyTlsPort = configDb.getPort("SIPX_PROXY_TLS_PORT") ; if (!portIsValid(proxyTlsPort)) { proxyTlsPort = 5061; } Os::Logger::instance().log(FAC_SIP, PRI_INFO, "SIPX_PROXY_TLS_PORT : %d", proxyTlsPort); configDb.get("SIPX_PROXY_MAX_FORWARDS", maxForwards); if(maxForwards <= 0) maxForwards = SIP_DEFAULT_MAX_FORWARDS; Os::Logger::instance().log(FAC_SIP, PRI_INFO, "SIPX_PROXY_MAX_FORWARDS : %d", maxForwards); osPrintf("SIPX_PROXY_MAX_FORWARDS : %d\n", maxForwards); int branchTimeout = -1; configDb.get("SIPX_PROXY_BRANCH_TIMEOUT", branchTimeout); if(branchTimeout < 4) { branchTimeout = 24; } int defaultExpires; int defaultSerialExpires; configDb.get("SIPX_PROXY_DEFAULT_EXPIRES", defaultExpires); configDb.get("SIPX_PROXY_DEFAULT_SERIAL_EXPIRES", defaultSerialExpires); if(defaultExpires <= 0 ) { defaultExpires = DEFAULT_SIP_TRANSACTION_EXPIRES; } else if(defaultExpires > DEFAULT_SIP_TRANSACTION_EXPIRES) { Os::Logger::instance().log(FAC_SIP, PRI_WARNING, "SipXproxymain::proxy " "large default expires value: %d NOT RECOMMENDED", defaultExpires); } if(defaultSerialExpires <= 0 || defaultSerialExpires >= defaultExpires) { defaultSerialExpires = DEFAULT_SIP_SERIAL_EXPIRES; } Os::Logger::instance().log(FAC_SIP, PRI_INFO, "SIPX_PROXY_DEFAULT_EXPIRES : %d", defaultExpires); osPrintf("SIPX_PROXY_DEFAULT_EXPIRES : %d\n", defaultExpires); Os::Logger::instance().log(FAC_SIP, PRI_INFO, "SIPX_PROXY_DEFAULT_SERIAL_EXPIRES : %d", defaultSerialExpires); osPrintf("SIPX_PROXY_DEFAULT_SERIAL_EXPIRES : %d\n", defaultSerialExpires); UtlString hostAliases; configDb.get("SIPX_PROXY_HOST_ALIASES", hostAliases); if(hostAliases.isNull()) { hostAliases = ipAddress; char portBuf[20]; sprintf(portBuf, ":%d", proxyUdpPort); hostAliases.append(portBuf); if(!routeName.isNull()) { hostAliases.append(" "); hostAliases.append(routeName); char portBuf[20]; sprintf(portBuf, ":%d", proxyUdpPort); hostAliases.append(portBuf); } Os::Logger::instance().log(FAC_SIP, PRI_NOTICE, "SIPX_PROXY_HOST_ALIASES not configured" " using implied value: %s", hostAliases.data()); } Os::Logger::instance().log(FAC_SIP, PRI_INFO, "SIPX_PROXY_HOST_ALIASES : %s", hostAliases.data()); UtlString enableCallStateObserverSetting; configDb.get(CONFIG_SETTING_CALL_STATE, enableCallStateObserverSetting); bool enableCallStateLogObserver; if ( (enableCallStateObserverSetting.isNull()) || ((0 == enableCallStateObserverSetting.compareTo("disable", UtlString::ignoreCase))) ) { enableCallStateLogObserver = false; } else if (0 == enableCallStateObserverSetting.compareTo("enable", UtlString::ignoreCase)) { enableCallStateLogObserver = true; } else { enableCallStateLogObserver = false; Os::Logger::instance().log(FAC_SIP, PRI_ERR, "SipXproxymain:: invalid configuration value for " CONFIG_SETTING_CALL_STATE " '%s' - should be 'enable' or 'disable'", enableCallStateObserverSetting.data() ); } Os::Logger::instance().log(FAC_SIP, PRI_INFO, CONFIG_SETTING_CALL_STATE " : %s", enableCallStateLogObserver ? "ENABLE" : "DISABLE" ); UtlString callStateLogFileName; if (enableCallStateLogObserver) { configDb.get(CONFIG_SETTING_CALL_STATE_LOG, callStateLogFileName); if (callStateLogFileName.isNull()) { callStateLogFileName = CALL_STATE_LOG_FILE_DEFAULT; } Os::Logger::instance().log(FAC_SIP, PRI_INFO, CONFIG_SETTING_CALL_STATE_LOG " : %s", callStateLogFileName.data()); } // Check if CSE logging should go into a database UtlString enableCallStateDbObserverSetting; configDb.get(CONFIG_SETTING_CALL_STATE_DB, enableCallStateDbObserverSetting); bool enableCallStateDbObserver; if ( (enableCallStateDbObserverSetting.isNull()) || ((0 == enableCallStateDbObserverSetting.compareTo("disable", UtlString::ignoreCase))) ) { enableCallStateDbObserver = false; } else if (0 == enableCallStateDbObserverSetting.compareTo("enable", UtlString::ignoreCase)) { enableCallStateDbObserver = true; } else { enableCallStateDbObserver = false; Os::Logger::instance().log(FAC_SIP, PRI_ERR, "SipAuthProxyMain:: invalid configuration value for %s " " '%s' - should be 'enable' or 'disable'", CONFIG_SETTING_CALL_STATE_DB, enableCallStateDbObserverSetting.data() ); } Os::Logger::instance().log(FAC_SIP, PRI_INFO, "%s : %s", CONFIG_SETTING_CALL_STATE_DB, enableCallStateDbObserver ? "ENABLE" : "DISABLE" ); UtlString callStateDbHostName; UtlString callStateDbName; UtlString callStateDbUserName; UtlString callStateDbDriver; if (enableCallStateDbObserver) { configDb.get(CONFIG_SETTING_CALL_STATE_DB_HOST, callStateDbHostName); if (callStateDbHostName.isNull()) { callStateDbHostName = CALL_STATE_DATABASE_HOST; } Os::Logger::instance().log(FAC_SIP, PRI_INFO, "%s : %s", CONFIG_SETTING_CALL_STATE_DB_HOST, callStateDbHostName.data()); configDb.get(CONFIG_SETTING_CALL_STATE_DB_NAME, callStateDbName); if (callStateDbName.isNull()) { callStateDbName = CALL_STATE_DATABASE_NAME; } Os::Logger::instance().log(FAC_SIP, PRI_INFO, "%s : %s", CONFIG_SETTING_CALL_STATE_DB_NAME, callStateDbName.data()); configDb.get(CONFIG_SETTING_CALL_STATE_DB_USER, callStateDbUserName); if (callStateDbUserName.isNull()) { callStateDbUserName = CALL_STATE_DATABASE_USER; } Os::Logger::instance().log(FAC_SIP, PRI_INFO, "%s : %s", CONFIG_SETTING_CALL_STATE_DB_USER, callStateDbUserName.data()); configDb.get(CONFIG_SETTING_CALL_STATE_DB_DRIVER, callStateDbDriver); if (callStateDbDriver.isNull()) { callStateDbDriver = CALL_STATE_DATABASE_DRIVER; } Os::Logger::instance().log(FAC_SIP, PRI_INFO, "%s : %s", CONFIG_SETTING_CALL_STATE_DB_DRIVER, callStateDbDriver.data()); } // Select logging method - database takes priority over XML file if (enableCallStateLogObserver && enableCallStateDbObserver) { enableCallStateLogObserver = false; Os::Logger::instance().log(FAC_SIP, PRI_WARNING, "SipXproxymain:: both XML and database call state " "logging was enabled - turning off XML log, only use database logging"); } // Set the maximum amount of time that TCP connections can // stay around when they are not used. int staleTcpTimeout = 3600; UtlString staleTcpTimeoutStr; // Check for missing parameter or empty value configDb.get("SIPX_PROXY_STALE_TCP_TIMEOUT", staleTcpTimeoutStr); if (staleTcpTimeoutStr.isNull()) { staleTcpTimeout = 3600; } else { // get the parameter value as an integer configDb.get("SIPX_PROXY_STALE_TCP_TIMEOUT", staleTcpTimeout); } if(staleTcpTimeout <= 0) staleTcpTimeout = -1; else if(staleTcpTimeout < 180) staleTcpTimeout = 180; Os::Logger::instance().log(FAC_SIP, PRI_INFO, "SIPX_PROXY_STALE_TCP_TIMEOUT : %d", staleTcpTimeout); osPrintf("SIPX_PROXY_STALE_TCP_TIMEOUT : %d\n", staleTcpTimeout); int maxNumSrvRecords = -1; configDb.get("SIPX_PROXY_DNSSRV_MAX_DESTS", maxNumSrvRecords); Os::Logger::instance().log(FAC_SIP, PRI_INFO, "SIPX_PROXY_DNSSRV_MAX_DESTS : %d", maxNumSrvRecords); // If explicitly set to a valid number if(maxNumSrvRecords > 0) { osPrintf("SIPX_PROXY_DNSSRV_MAX_DESTS : %d\n", maxNumSrvRecords); } else { maxNumSrvRecords = 4; } int dnsSrvTimeout = -1; //seconds configDb.get("SIPX_PROXY_DNSSRV_TIMEOUT", dnsSrvTimeout); Os::Logger::instance().log(FAC_SIP, PRI_INFO, "SIPX_PROXY_DNSSRV_TIMEOUT : %d", dnsSrvTimeout); // If explicitly set to a valid number if(dnsSrvTimeout > 0) { osPrintf("SIPX_PROXY_DNSSRV_TIMEOUT : %d\n", dnsSrvTimeout); } else { dnsSrvTimeout = 4; } // This is an obnoxious special option to work around a // problem with Sonus gateways. The Sonus proxy or redirect // server gives a list of possible gateways to recurse in a // 300 response. It does not assign any Q values so the proxy // gets the impression that it should fork them all in parallel. // When this option is enabled we recurse only the one with the // highest Q value. UtlString recurseOnlyOne300String; configDb.get("SIPX_PROXY_SPECIAL_300", recurseOnlyOne300String); recurseOnlyOne300String.toLower(); UtlBoolean recurseOnlyOne300 = FALSE; if(recurseOnlyOne300String.compareTo("enable") == 0) { recurseOnlyOne300 = TRUE; Os::Logger::instance().log(FAC_SIP, PRI_INFO, "SIPX_PROXY_SPECIAL_300 : ENABLE"); osPrintf("SIPX_PROXY_SPECIAL_300 : ENABLE\n"); } OsPath fileName = SipXecsService::Path(SipXecsService::ConfigurationDirType, FORWARDING_RULES_FILENAME); ForwardRules forwardingRules; OsFile ruleFile(fileName); if(ruleFile.exists()) { if(OS_SUCCESS != forwardingRules.loadMappings(fileName)) { Os::Logger::instance().log(FAC_SIP, PRI_WARNING, "WARNING: Failed to load: %s", fileName.data()); osPrintf("WARNING: Failed to load: %s\n", fileName.data()); } } else { // forwardingrules.xml is not readable; no processing is possible. Os::Logger::instance().log(FAC_SIP, PRI_CRIT, "forwarding rules '%s' not found -- exiting", fileName.data()); exit(1); } #ifdef TEST_PRINT { // scope the test stuff SipMessage foo; const char* uri = "sip:10.1.20.3:5100"; const char* method = SIP_ACK_METHOD; const char* eventType = SIP_EVENT_CONFIG; foo.setRequestData(method, uri, //uri, "sip:[email protected]", // fromField, "\"lajdflsdk ff\"<sip:[email protected]>", // toField, "lkadsj902387", // callId, 123, // CSeq, "sip:10.1.1.123");// contactUrl // Set the event type foo.setHeaderValue(SIP_EVENT_FIELD, eventType, // event type 0); Url msgUrl(uri); UtlString routeTo; UtlString routeType; bool authRequired; OsStatus routeStatus = forwardingRules.getRoute(msgUrl, foo, routeTo, routeType, authRequired); Url msgRouteToUri(routeTo); osPrintf("Message:\n\tmethod: %s\n\turi: %s\n\tevent: %s\nRouted:\n\tstring: %s\n\turi: %s\n\ttype: %s\n", method, uri, eventType, routeTo.data(), msgRouteToUri.toString().data(), routeType.data()); if(routeStatus != OS_SUCCESS) osPrintf("forwardingRules.getRoute returned: %d\n", routeStatus); } #endif // TEST_PRINT // Start the sip stack SipUserAgent* pSipUserAgent = new SipUserAgent( proxyTcpPort, proxyUdpPort, proxyTlsPort, NULL, // public IP address (not used in proxy) NULL, // default user (not used in proxy) bindIp, NULL, // outbound proxy NULL, // directory server NULL, // registry server NULL, // auth realm NULL, // auth DB NULL, // auth user IDs NULL, // auth passwords NULL, // line mgr SIP_DEFAULT_RTT, // first resend timeout FALSE, // default to proxy transaction SIPUA_DEFAULT_SERVER_UDP_BUFFER_SIZE, // socket layer read buffer size SIPUA_DEFAULT_SERVER_OSMSG_QUEUE_SIZE, // OsServerTask message queue size FALSE, // Use Next Available Port TRUE, // Perform message checks TRUE, // Use symmetric signaling SipUserAgent::HANDLE_OPTIONS_AUTOMATICALLY); if (!pSipUserAgent->isOk()) { Os::Logger::instance().log(FAC_SIP, PRI_EMERG, "SipUserAgent reported a problem, setting shutdown flag..."); gShutdownFlag = TRUE; } pSipUserAgent->setDnsSrvTimeout(dnsSrvTimeout); pSipUserAgent->setMaxSrvRecords(maxNumSrvRecords); pSipUserAgent->setUserAgentHeaderProperty("sipXecs/sipXproxy"); pSipUserAgent->setMaxForwards(maxForwards); pSipUserAgent->setDefaultExpiresSeconds(defaultExpires); pSipUserAgent->setDefaultSerialExpiresSeconds(defaultSerialExpires); pSipUserAgent->setMaxTcpSocketIdleTime(staleTcpTimeout); pSipUserAgent->setHostAliases(hostAliases); pSipUserAgent->setRecurseOnlyOne300Contact(recurseOnlyOne300); // Do not start the SipUserAgent until its message listeners are // set up by the creation of the SipRouter below. UtlString buffer; // Create the CSE observer, either writing to file or database SipXProxyCseObserver* cseObserver = NULL; CallStateEventWriter* pEventWriter = NULL; if (enableCallStateLogObserver) { // Set up the call state event log file pEventWriter = new CallStateEventWriter_XML(callStateLogFileName.data()); } else if (enableCallStateDbObserver) { pEventWriter = new CallStateEventWriter_DB(callStateDbName.data(), callStateDbHostName.data(), callStateDbUserName, callStateDbDriver); } if (pEventWriter) { // get the identifier for this observer int protocol = OsSocket::UDP; UtlString domainName; int port; pSipUserAgent->getViaInfo(protocol, domainName, port); char portString[12]; sprintf(portString,":%d", port); domainName.append(portString); // and start the observer cseObserver = new SipXProxyCseObserver(*pSipUserAgent, domainName, pEventWriter); cseObserver->start(); } else { // Only log error if any event logging was enabled if (enableCallStateLogObserver || enableCallStateDbObserver) { Os::Logger::instance().log(FAC_SIP, PRI_ERR, "SipAuthProxyMain:: EventWriter could not be allocated" ); enableCallStateLogObserver = false; enableCallStateDbObserver = false; } } // Create a router to route stuff either // to a local server or on out to the real world SipRouter* pRouter = new SipRouter(*pSipUserAgent, forwardingRules, configDb); // Start the router running pRouter->start(); // Do not exit, let the proxy do its stuff while( !gShutdownFlag ) { OsTask::delay(1000); } // This is a server task so gracefully shutdown the // router task by deleting it. delete pRouter ; // Stop the SipUserAgent. pSipUserAgent->shutdown(); // And delete it, too. delete pSipUserAgent ; // flush and close the call state event log if (enableCallStateLogObserver || enableCallStateDbObserver) { if (cseObserver) { delete cseObserver; } if (pEventWriter) { delete pEventWriter; } } // End the singleton threads. OsTimerTask::destroyTimerTask(); OsStunAgentTask::releaseInstance(); return 0 ; }
virtual void readConfig(OsConfigDb& configDb) { configDb.get("BEHAVIOR", mBehavior ); }