int main(int argc, char* argv[])
{
// All osPrintf output should go to the console until the log file is initialized.
enableConsoleOutput(true);
UtlString argString;
for (int argIndex = 1; argIndex < argc; argIndex++)
{
bool usageExit = false;
int valueExit = 1;
argString = argv[argIndex];
NameValueTokenizer::frontBackTrim(&argString, "\t ");
if (argString.compareTo("-h") == 0)
{
usageExit = true;
valueExit = 0;
}
if (argString.compareTo("-v") == 0)
{
osPrintf("sipxsupervisor %s\n\n", VERSION);
return 0;
}
else
{
// Unknown argument.
usageExit = true;
}
if (usageExit)
{
osPrintf("usage: %s [-h] [-v]\n", argv[0]);
osPrintf(" -h Print this help and exit.\n");
osPrintf(" -v Print version number.\n");
return valueExit;
}
}
// Write this process's pid into the supervisor pidfile
writePidToFile();
return supervisorMain(true);
}
int main(int argc, char* argv[])
{
enableConsoleOutput(FALSE) ;
// Get the top level suite from the registry
CppUnit::Test *suite = CppUnit::TestFactoryRegistry::getRegistry().makeTest();
// Adds the test to the list of tests to run
CppUnit::TextUi::TestRunner runner ;
runner.addTest(suite) ;
// Change the default outputter to a compiler error format outputter
runner.setOutputter(new CppUnit::CompilerOutputter(&runner.result(), std::cerr)) ;
// Run the tests.
bool wasSuccessful = runner.run() ;
// Return error code 1 if one of the tests failed.
return wasSuccessful ? 0 : 1 ;
}
int main(int argc, char* argv[])
{
int provisioningAgentPort = 8110;
int watchdogRpcServerPort = 8092;
ACDServer* pAcdServer;
// Disable osPrintf's
enableConsoleOutput(false);
UtlString argString;
for (int argIndex = 1; argIndex < argc; argIndex++) {
osPrintf("arg[%d]: %s\n", argIndex, argv[argIndex]);
argString = argv[argIndex];
NameValueTokenizer::frontBackTrim(&argString, "\t ");
if (argString.compareTo("-v") == 0) {
enableConsoleOutput(true);
osPrintf("Version: %s (%s)\n", PACKAGE_VERSION, PACKAGE_REVISION);
return(1);
}
else if (argString.compareTo("-c") == 0) {
// Enable osPrintf's
enableConsoleOutput(true);
}
else if (argString.compareTo("-d") == 0) {
// Switch ACDServer PRI_DEBUG to PRI_NOTICE
gACD_DEBUG = PRI_NOTICE;
}
else if (argString.compareTo("-P") == 0) {
argString = argv[++argIndex];
provisioningAgentPort = atoi(argString.data());
}
else if (argString.compareTo("-W") == 0) {
argString = argv[++argIndex];
watchdogRpcServerPort = atoi(argString.data());
}
else {
enableConsoleOutput(true);
osPrintf("usage: %s [-v] [-c] [-d] [-P port] [-W wport]\nwhere:\n -v Provides the software version\n"
" -c Enables console output of log and debug messages\n"
" -d Changes ACDServer DEBUG logging to run at NOTICE level\n"
" -P port Specifies the provisioning interface port number\n"
" -W wport Specifies the Watchdog interface port number\n",
argv[0]);
return(1);
}
}
// Create the ACDServer and get to work.
pAcdServer = new ACDServer(provisioningAgentPort, watchdogRpcServerPort);
// Loop forever until signaled to shut down
while (!Os::UnixSignals::instance().isTerminateSignalReceived() && !gShutdownFlag) {
OsTask::delay(2000);
}
// Shut down the ACDServer.
delete pAcdServer;
// Flush the log file
Os::Logger::instance().flush();
// Say goodnight Gracie...
// Use _exit to avoid the atexit() processing which will cause the
// destruction of static objects...yet there are still threads out
// there using those static objects. This prevents core dumps
// due to those threads accessing the static objects post destruction.
//
// --Woof!
_exit(0);
/*NOTREACHED*/
return 0 ; // To appease the compiler gods
}
virtual void setUp()
{
enableConsoleOutput(0);
mpMediaFactory = sipXmediaFactoryFactory(NULL);
}
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 supervisorMain(bool bOriginalSupervisor)
{
// Create forked process which will do nothing unless parent dies. Parent continues with initialization.
forkSupervisorInWaiting();
// Drop privileges down to the specified user & group
const char * sipxpbxuser = SipXecsService::User();
const char * sipxpbxgroup = SipXecsService::Group();
if (NULL == sipxpbxuser || 0 == strlen(sipxpbxuser))
{
osPrintf("sipXsupervisor: Failed to setuid(%s), username not defined.\n",
sipxpbxuser);
return 2;
}
if (NULL == sipxpbxgroup || 0 == strlen(sipxpbxgroup))
{
osPrintf("sipXsupervisor: Failed to setgid(%s), groupname not defined.\n",
sipxpbxgroup);
return 2;
}
struct group * grp = getgrnam(sipxpbxgroup);
if (NULL == grp)
{
if (0 != errno)
{
osPrintf("getgrnam(%s) failed, errno = %d.",
sipxpbxgroup, errno);
}
else
{
osPrintf(
"sipXsupervisor: getgrnam(%s) failed, user does not exist.",
sipxpbxgroup);
}
return 3;
}
struct passwd * pwd = getpwnam(sipxpbxuser);
if (NULL == pwd)
{
if (0 != errno)
{
osPrintf("getpwnam(%s) failed, errno = %d.",
sipxpbxuser, errno);
}
else
{
osPrintf(
"sipXsupervisor: getpwnam(%s) failed, user does not exist.",
sipxpbxuser);
}
return 3;
}
// Change group first, cause once user is changed this cannot be done.
if (0 != setgid(grp->gr_gid))
{
osPrintf("sipXsupervisor: setgid(%d) failed, errno = %d.",
(int)grp->gr_gid, errno);
return 4;
}
if (0 != setuid(pwd->pw_uid))
{
osPrintf("sipXsupervisor: setuid(%d) failed, errno = %d.",
(int)pwd->pw_uid, errno);
return 4;
}
# if 0
// Only output problems. This keeps the startup output clean.
osPrintf("sipXsupervisor: Dropped privileges with setuid(%s)/setgid(%s).",
sipxpbxuser, sipxpbxgroup);
#endif
OsMsgQShared::setQueuePreference(OsMsgQShared::QUEUE_UNLIMITED);
// Block all signals in this the main thread
// Any threads created after this will have all signals masked.
OsTask::blockSignals();
// Create a new task to wait for signals. Only that task
// will ever see a signal from the outside.
SignalTask* signalTask = new SignalTask();
signalTask->start() ;
// All osPrintf output should go to the console until the log file is initialized.
enableConsoleOutput(true);
// Initialize the log file.
Os::LoggerHelper::instance().processName = "Supervisor";
UtlString logFile = SipXecsService::Path(SipXecsService::LogDirType, "sipxsupervisor.log");
Os::LoggerHelper::instance().initialize(PRI_DEBUG, logFile.data());
if (!bOriginalSupervisor)
{
Os::Logger::instance().log(FAC_SUPERVISOR, PRI_CRIT,
"Restarting sipxsupervisor after unexpected shutdown");
}
Os::Logger::instance().log(FAC_SUPERVISOR, PRI_NOTICE,
">>>>> Starting sipxsupervisor version %s",
VERSION);
// Now that the log file is initialized, stop sending osPrintf to the console.
// All relevant log messages from this point on must use Os::Logger::instance().log().
enableConsoleOutput(false);
fflush(NULL); // Flush all output so children don't get a buffer of output
// Open the supervisor configuration file
OsConfigDb supervisorConfiguration;
OsPath supervisorConfigPath = SipXecsService::Path(SipXecsService::ConfigurationDirType,
CONFIG_SETTINGS_FILE);
if (OS_SUCCESS != supervisorConfiguration.loadFromFile(supervisorConfigPath.data()))
{
Os::Logger::instance().log(FAC_SUPERVISOR,PRI_WARNING,
"Failed to open supervisor configuration file at '%s'",
supervisorConfigPath.data()
);
}
// Set logging based on the supervisor configuration - TODO change default to "NOTICE" ?
OsSysLogPriority logPri = SipXecsService::setLogPriority(supervisorConfiguration, SUPERVISOR_PREFIX, PRI_INFO );
Os::Logger::instance().setLoggingPriorityForFacility(FAC_ALARM, logPri);
// Open the domain configuration file
OsConfigDb domainConfiguration;
OsPath domainConfigPath = SipXecsService::domainConfigPath();
if (OS_SUCCESS != domainConfiguration.loadFromFile(domainConfigPath.data()))
{
Os::Logger::instance().log(FAC_SUPERVISOR,PRI_ERR,
"Failed to open domain configuration '%s'",
domainConfigPath.data()
);
}
// @TODO const char* managementIpBindAddress;
int managementPortNumber;
managementPortNumber = domainConfiguration.getPort(SipXecsService::DomainDbKey::SUPERVISOR_PORT);
if (PORT_NONE == managementPortNumber)
{
Os::Logger::instance().log(FAC_SUPERVISOR,PRI_WARNING,
"%s not configured in '%s', using default: %d",
SipXecsService::DomainDbKey::SUPERVISOR_PORT,
domainConfigPath.data(), DEFAULT_SUPERVISOR_PORT
);
managementPortNumber=DEFAULT_SUPERVISOR_PORT;
}
else if (PORT_DEFAULT == managementPortNumber)
{
Os::Logger::instance().log(FAC_SUPERVISOR,PRI_NOTICE,"%s set to default: %d",
SipXecsService::DomainDbKey::SUPERVISOR_PORT, DEFAULT_SUPERVISOR_PORT
);
managementPortNumber=DEFAULT_SUPERVISOR_PORT;
}
UtlSList allowedPeers;
UtlString configHosts;
domainConfiguration.get(SipXecsService::DomainDbKey::CONFIG_HOSTS, configHosts);
if (!configHosts.isNull())
{
UtlString hostName;
for (int hostIndex = 0;
NameValueTokenizer::getSubField(configHosts.data(), hostIndex, ", \t", &hostName);
hostIndex++)
{
// Found at least one config hostname.
if (!allowedPeers.contains(&hostName))
{
Os::Logger::instance().log(FAC_SUPERVISOR,PRI_DEBUG,
"%s value '%s'",
SipXecsService::DomainDbKey::CONFIG_HOSTS,
hostName.data()
);
allowedPeers.insert(new UtlString(hostName));
}
}
}
else
{
Os::Logger::instance().log(FAC_SUPERVISOR,PRI_ERR,
"%s not configured in '%s'",
SipXecsService::DomainDbKey::CONFIG_HOSTS, domainConfigPath.data()
);
}
UtlString superHost;
supervisorConfiguration.get(SUPERVISOR_HOST, superHost);
if (!superHost.isNull())
{
if (!allowedPeers.contains(&superHost))
{
allowedPeers.insert(new UtlString(superHost));
}
}
else
{
Os::Logger::instance().log(FAC_SUPERVISOR,PRI_ERR,
"%s not configured in '%s'",
SUPERVISOR_HOST, supervisorConfigPath.data()
);
}
if (allowedPeers.isEmpty())
{
Os::Logger::instance().log(FAC_SUPERVISOR,PRI_ERR,
"No configuration peers configured.");
}
if (!cAlarmServer::getInstance()->init())
{
Os::Logger::instance().log(FAC_SUPERVISOR, PRI_ERR,
"sipXsupervisor failed to init AlarmServer");
}
// Initialize management interfaces on the TLS socket
OsSSLServerSocket serverSocket(50, managementPortNumber /*@TODO managementIpBindAddress */);
HttpServer httpServer(&serverSocket); // set up but don't start https server
XmlRpcDispatch xmlRpcDispatcher(&httpServer); // attach xml-rpc service to https
pSipxRpcImpl = new SipxRpc(&xmlRpcDispatcher, allowedPeers); // register xml-rpc methods
HttpFileAccess fileAccessService(&httpServer, pSipxRpcImpl); // attach file xfer to https
if (serverSocket.isOk())
{
Os::Logger::instance().log(FAC_SUPERVISOR, PRI_DEBUG, "Starting Management HTTP Server");
httpServer.start();
}
else
{
Os::Logger::instance().log(FAC_SUPERVISOR, PRI_ERR, "Management listening socket failure");
}
// Read the process definitions.
UtlString processDefinitionDirectory =
SipXecsService::Path(SipXecsService::DataDirType, "process.d");
SipxProcessManager* processManager = SipxProcessManager::getInstance();
processManager->instantiateProcesses(processDefinitionDirectory);
// 3.0 had different process def files. The only important thing in them is the
// state of the services. Transfer this state to the new process def files.
upgradeFrom3_0();
doWaitLoop();
// Successful run.
return 0;
}
