void ComponentConfig::Init(const std::string& sComponent, const std::string& sConfig, bool bCreate)
{
m_pImpl->m_sComponent = sComponent;
m_pImpl->m_sConfig = sConfig;
m_pImpl->m_sFileName = Runtime::Inst().GetComponentHome(sComponent) + "/" + sConfig;
ReloadConfig(bCreate);
}
void VideoPlayer::ReloadConfig()
{
if (!(config->get("SPEED")=="NORMAL" || config->get("SPEED")=="SLOW" || config->get("SPEED")=="VERYSLOW" ))
{
config->reportFileDamaged();
ReloadConfig();
return;
}
if (!(config->get("MIRRORED")=="TRUE" || config->get("MIRRORED")=="FALSE"))
{
config->reportFileDamaged();
ReloadConfig();
return;
}
dic.ReloadConfig();
ResetVideoPlayer();
}
void ContentQuotaScheduler::Reset(ContentManagerCfg *m_inconfig)
{
ReloadConfig(m_inconfig);
daily_count = max_daily_rid_num;
minute_count = max_minute_rid_num;
unsigned int time_now = ContentManager::get_epoch_time();
last_minute = time_now;
last_day = time_now;
active_daily_total = 0;
active_minute_count = 0;
vip_minute_total = 0;
vip_daily_total = 0;
LOG4CPLUS_INFO(g_logger, "Scheduler: reseted.");
}
bool GAccountService::Init(rapidxml::xml_node<char>* node)
{
rapidxml::xml_node<char>* accFileNode = node->first_node("AccountFile");
if (nullptr == accFileNode)
return false;
_accountsFilename = accFileNode->value();
if (!LoadAccountsFromFile(_accountsFilename))
return false;
rapidxml::xml_node<char>* reloadableNode = node->first_node("Reloadable");
if (nullptr == reloadableNode || !ReloadConfig(reloadableNode))
return false;
return true;
}
VideoPlayer::VideoPlayer(ConfigData* data, QWidget *parent) :
QWidget(parent),
ui(new Ui::VideoPlayer),
player(0,QMediaPlayer::VideoSurface),
Mirrored(false),
config(data),
dic(config)
{
ui->setupUi(this);
//Setup QMediaPlayer
QVBoxLayout* layout= new QVBoxLayout;
player.setVideoOutput(&videoWidget);
layout->addWidget(&videoWidget);
ui->PlayWidget->setLayout(layout);
//SetupQMediaPlayer Ends
ReloadConfig();
//debugPlay();
}
WiiFishController::WiiFishController(FishMaster* fm, Camera* cam, SimpleSetup* setup, PropertyTree& ptree, StereoCamera* sc)
: fm(fm)
, cam(cam)
, stereoCam(sc)
, setup(setup)
, ptree(ptree)
, curCamIdx(-1)
, speed(0)
, direction(0)
, jaw(0)
, up(false)
, down(false)
, left(false)
, right(false)
, forward(false)
, back(false)
{
ptree.PropertiesChangedEvent().Attach(*this);
ReloadConfig();
SetKeyBindings();
}
int TDaemon::WorkProc()
{
struct sigaction sigact;
sigset_t sigset;
int signo;
int status;
// сигналы об ошибках в программе будут обрататывать более тщательно
// указываем что хотим получать расширенную информацию об ошибках
sigact.sa_flags = SA_SIGINFO;
// задаем функцию обработчик сигналов
sigact.sa_sigaction = SelfDebug;
sigemptyset(&sigact.sa_mask);
// установим наш обработчик на сигналы
sigaction(SIGFPE, &sigact, 0); // ошибка FPU
sigaction(SIGILL, &sigact, 0); // ошибочная инструкция
sigaction(SIGSEGV,&sigact, 0); // ошибка доступа к памяти
sigaction(SIGBUS, &sigact, 0); // ошибка шины, при обращении к физической памяти
sigemptyset(&sigset);
// блокируем сигналы которые будем ожидать
// сигнал остановки процесса пользователем
sigaddset(&sigset, SIGQUIT);
// сигнал для остановки процесса пользователем с терминала
sigaddset(&sigset, SIGINT);
// сигнал запроса завершения процесса
sigaddset(&sigset, SIGTERM);
// пользовательский сигнал который мы будем использовать для обновления конфига
sigaddset(&sigset, SIGHUP);
sigprocmask(SIG_BLOCK, &sigset, NULL);
// Установим максимальное кол-во дискрипторов которое можно открыть
SetFdLimit(FD_LIMIT);
// запишем в лог, что наш демон стартовал
//WriteLog("%s [DAEMON] Started\n", getTime());
DaemonFunction();
// цикл ожидания сообщений
while(1)
{
// ждем указанных сообщений
sigwait(&sigset, &signo);
switch(signo)
{
// если это сообщение обновления конфига
case SIGHUP:
status = ReloadConfig();
if (status != 0)
{
WriteLog("%s [DAEMON] Reload config failed: %s\n", getTime(),strerror(errno));
}
else
{
WriteLog("%s [DAEMON] Reload config OK\n", getTime());
}
break;
case SIGQUIT:
case SIGINT:
case SIGTERM:
default:
WriteLog("%s [DAEMON] Received signal %d\n", getTime(),signo);
WriteLog("%s [DAEMON] Stopped\n", getTime());
return CHILD_NEED_TERMINATE;
}
}
WriteLog("%s [DAEMON] Stopped\n", getTime());
// вернем код не требующим перезапуска
return CHILD_NEED_TERMINATE;
}
DolphinAnalytics::DolphinAnalytics()
{
ReloadConfig();
MakeBaseBuilder();
}
void CAccountApp::Run()
{
TRACESVR("AccountServer starts running ...\n");
int iRes = 0;
m_uiLoopTimes = 0;
while (true)
{
NowTimeSingleton::Instance()->RefreshNowTime();
NowTimeSingleton::Instance()->RefreshNowTimeVal();
if (ms_iAppCmd == APPCMD_STOP_SERVICE)
{
TRACESVR("Receive Command: APPCMD_STOP_SERVICE\n");
return;
}
if (ms_iAppCmd == APPCMD_RELOAD_CONFIG)
{
TRACESVR("Receive Command: APPCMD_RELOAD_CONFIG. \n");
ReloadConfig();
ms_iAppCmd = APPCMD_NOTHING_TODO;
}
if (ms_iAppCmd == APPCMD_QUIT_SERVICE)
{
TRACESVR("Receive Command: APPCMD_QUIT_SERVICE\n");
break;
}
const int MAX_MSG_COUNT_PER_COUNT = 10;
int iRecvMsgCount = 0;
while (true)
{
int iNewMsgCount = 0;
for (int i = 0; i < AccountMsgTransceiver->GetCodeQueueNum(); i++)
{
iRes = HandleMsgIn(CSProtocolEngine, GAME_SERVER_LOTUSACCOUNT, i);
if (iRes == 0)
{
iNewMsgCount++;
}
}
iRes = HandleMsgIn(SSProtocolEngine, GAME_SERVER_WORLD);
if (iRes == 0)
{
iNewMsgCount++;
}
// 没有数据, 或者数据超出处理限制, 暂停处理数据
iRecvMsgCount += iNewMsgCount;
if (iNewMsgCount == 0 || iRecvMsgCount >= MAX_MSG_COUNT_PER_COUNT)
{
break;
}
}
usleep(MAIN_LOOP_SLEEP);
m_uiLoopTimes++;
// 清理超时的cache结点，主循环1万次清理一次
if (TIMES_TO_CLEAR_CACHE == m_uiLoopTimes)
{
ClearCache();
m_uiLoopTimes = 0; // 重新计数
}
}
}
int WorkProc() {
struct sigaction sigact;
sigset_t sigset;
int signo;
int status;
// сигналы об ошибках в программе будут обрататывать более тщательно
// указываем что хотим получать расширенную информацию об ошибках
sigact.sa_flags = SA_SIGINFO;
// задаем функцию обработчик сигналов
sigact.sa_sigaction = signal_error;
sigemptyset(&sigact.sa_mask);
// установим наш обработчик на сигналы
sigaction(SIGFPE, &sigact, 0); // ошибка FPU
sigaction(SIGILL, &sigact, 0); // ошибочная инструкция
sigaction(SIGSEGV, &sigact, 0); // ошибка доступа к памяти
sigaction(SIGBUS, &sigact, 0); // ошибка шины, при обращении к физической памяти
sigemptyset(&sigset);
// блокируем сигналы которые будем ожидать
// сигнал остановки процесса пользователем
sigaddset(&sigset, SIGQUIT);
// сигнал для остановки процесса пользователем с терминала
sigaddset(&sigset, SIGINT);
// сигнал запроса завершения процесса
sigaddset(&sigset, SIGTERM);
// пользовательский сигнал который мы будем использовать для обновления конфига
sigaddset(&sigset, SIGUSR1);
sigprocmask(SIG_BLOCK, &sigset, NULL);
// Установим максимальное кол-во дискрипторов которое можно открыть
SetFdLimit(FD_LIMIT);
// запишем в лог, что наш демон стартовал
WriteLog("[DAEMON] Started\n");
// запускаем все рабочие потоки
status = InitWorkThread();
if (status != -1) {
// цикл ожижания сообщений
for (; ;) {
// ждем указанных сообщений
sigwait(&sigset, &signo);
// если то сообщение обновления конфига
if (signo == SIGUSR1) {
// обновим конфиг
status = ReloadConfig();
if (status == 0) {
WriteLog("[DAEMON] Reload config failed\n");
}
else {
WriteLog("[DAEMON] Reload config OK\n");
}
}
else // если какой-либо другой сигнал, то выйдим из цикла
{
break;
}
}
// остановим все рабочеи потоки и корректно закроем всё что надо
DestroyWorkThread();
}
else {
WriteLog("[DAEMON] Create work thread failed\n");
}
WriteLog("[DAEMON] Stopped\n");
// вернем код не требующим перезапуска
return CHILD_NEED_TERMINATE;
}
void ParseMemBus(void)
{ /*This function handles EVERYTHING passed to us via membus. It's truly vast.*/
#define BusDataIs(x) !strncmp(x, BusData, strlen(x))
char BusData[MEMBUS_MSGSIZE];
if (!BusRunning) return;
if (!MemBus_Read(BusData, true))
{
return;
}
/*If we got a signal over the membus.*/
if (BusDataIs(MEMBUS_CODE_RESET))
{
if (ReloadConfig())
{
MemBus_Write(MEMBUS_CODE_ACKNOWLEDGED " " MEMBUS_CODE_RESET, true);
}
else
{
MemBus_Write(MEMBUS_CODE_FAILURE " " MEMBUS_CODE_RESET, true);
}
}
else if (BusDataIs(MEMBUS_CODE_OBJSTART) || BusDataIs(MEMBUS_CODE_OBJSTOP))
{
unsigned LOffset = strlen((BusDataIs(MEMBUS_CODE_OBJSTART) ? MEMBUS_CODE_OBJSTART " " : MEMBUS_CODE_OBJSTOP " "));
char *TWorker = BusData + LOffset;
ObjTable *CurObj = LookupObjectInTable(TWorker);
char TmpBuf[MEMBUS_MSGSIZE], *MCode = MEMBUS_CODE_FAILURE;
ReturnCode DidWork;
if (LOffset >= strlen(BusData) || BusData[LOffset] == ' ')
{ /*No argument?*/
snprintf(TmpBuf, sizeof TmpBuf, "%s %s", MEMBUS_CODE_BADPARAM, BusData);
MemBus_Write(TmpBuf, true);
return;
}
if (CurObj)
{ /*If we ask to start a HaltCmdOnly command, run the stop command instead, because that's all that we use.*/
DidWork = ProcessConfigObject(CurObj, (BusDataIs(MEMBUS_CODE_OBJSTART) && !CurObj->Opts.HaltCmdOnly), false);
snprintf(TmpBuf, sizeof TmpBuf, "Manual %s of object %s %s%s", (BusDataIs(MEMBUS_CODE_OBJSTART) ? "start" : "stop"),
CurObj->ObjectID, (DidWork ? "succeeded" : "failed"), ((DidWork == WARNING) ? " with a warning" : ""));
WriteLogLine(TmpBuf, true);
}
else
{
DidWork = FAILURE;
}
switch (DidWork)
{
case SUCCESS:
MCode = MEMBUS_CODE_ACKNOWLEDGED;
break;
case WARNING:
MCode = MEMBUS_CODE_WARNING;
break;
case FAILURE:
MCode = MEMBUS_CODE_FAILURE;
break;
}
snprintf(TmpBuf, sizeof TmpBuf, "%s %s %s",
MCode, (BusDataIs(MEMBUS_CODE_OBJSTART) ? MEMBUS_CODE_OBJSTART : MEMBUS_CODE_OBJSTOP), TWorker);
MemBus_Write(TmpBuf, true);
}
else if (BusDataIs(MEMBUS_CODE_CFMERGE) || BusDataIs(MEMBUS_CODE_CFUMERGE))
{
const char *const MainCode = BusDataIs(MEMBUS_CODE_CFMERGE) ? MEMBUS_CODE_CFMERGE : MEMBUS_CODE_CFUMERGE;
const char *MemBusReturnCode = NULL;
const int LOffset = strlen(MainCode) + (sizeof " " - 1);
const char *Filename = BusData + LOffset;
switch (BusDataIs(MEMBUS_CODE_CFMERGE) ? MergeImportLine(Filename) : UnmergeImportLine(Filename))
{
case SUCCESS:
MemBusReturnCode = MEMBUS_CODE_ACKNOWLEDGED;
break;
case WARNING:
MemBusReturnCode = MEMBUS_CODE_WARNING;
break;
default:
MemBusReturnCode = MEMBUS_CODE_FAILURE;
break;
}
char OutBuf[MEMBUS_MSGSIZE];
snprintf(OutBuf, sizeof OutBuf, "%s %s %s", MemBusReturnCode, MainCode, Filename);
MemBus_Write(OutBuf, true);
}
else if (BusDataIs(MEMBUS_CODE_LSOBJS))
{ /*Done for mostly third party stuff.*/
int Inc = 0;
char OutBuf[MEMBUS_MSGSIZE];
unsigned char *BinWorker = (void*)OutBuf;
ObjTable *Worker = ObjectTable;
unsigned TPID = 0;
const unsigned Length = strlen(MEMBUS_CODE_LSOBJS " " MEMBUS_LSOBJS_VERSION) + 1;
for (; Worker->Next; Worker = Worker->Next)
{
const struct _RLTree *RLWorker = Worker->ObjectRunlevels;
if (strlen(BusData) > strlen(MEMBUS_CODE_LSOBJS) &&
strcmp(BusData + strlen(MEMBUS_CODE_LSOBJS " "), Worker->ObjectID) != 0)
{ /*Allow for getting status of just one object.*/
continue;
}
if (!Worker->Opts.HasPIDFile || !(TPID = ReadPIDFile(Worker)))
{
TPID = Worker->ObjectPID;
}
/*We need a version for this protocol, because relevant options can change with updates.
* Not all options are here, because some are not really useful.*/
strncpy(OutBuf, MEMBUS_CODE_LSOBJS " " MEMBUS_LSOBJS_VERSION, Length);
BinWorker = (unsigned char*)OutBuf + Length;
*BinWorker++ = (Worker->Started && !Worker->Opts.HaltCmdOnly);
*BinWorker++ = ObjectProcessRunning(Worker);
*BinWorker++ = Worker->Enabled;
*BinWorker++ = Worker->TermSignal;
*BinWorker++ = Worker->ReloadCommandSignal;
memcpy(BinWorker, &Worker->UserID, sizeof(int));
memcpy((BinWorker += sizeof(int)), &Worker->GroupID, sizeof(int));
memcpy((BinWorker += sizeof(int)), &Worker->Opts.StopMode, sizeof(enum _StopMode));
memcpy((BinWorker += sizeof(enum _StopMode)), &TPID, sizeof(int));
memcpy((BinWorker += sizeof(int)), &Worker->StartedSince, sizeof(int));
memcpy(BinWorker + sizeof(int), &Worker->Opts.StopTimeout, sizeof(int));
MemBus_BinWrite(OutBuf, MEMBUS_MSGSIZE, true);
snprintf(OutBuf, sizeof OutBuf, "%s %s", Worker->ObjectID, Worker->ObjectDescription);
MemBus_Write(OutBuf, true);
*OutBuf = '\0';
BinWorker = (void*)OutBuf;
/*Write it over binary now.*/
if (Worker->Opts.RawDescription) *BinWorker++ = COPT_RAWDESCRIPTION;
if (Worker->Opts.HaltCmdOnly) *BinWorker++ = COPT_HALTONLY;
if (Worker->Opts.Persistent) *BinWorker++ = COPT_PERSISTENT;
#ifndef NOMMU
if (Worker->Opts.Fork) *BinWorker++ = COPT_FORK;
if (Worker->Opts.ForkScanOnce) *BinWorker++ = COPT_FORKSCANONCE;
#endif /*NOMMU*/
if (Worker->Opts.IsService) *BinWorker++ = COPT_SERVICE;
if (Worker->Opts.AutoRestart) *BinWorker++ = COPT_AUTORESTART;
if (Worker->Opts.ForceShell) *BinWorker++ = COPT_FORCESHELL;
if (Worker->Opts.NoStopWait) *BinWorker++ = COPT_NOSTOPWAIT;
if (Worker->Opts.Exec) *BinWorker++ = COPT_EXEC;
if (Worker->Opts.PivotRoot) *BinWorker++ = COPT_PIVOTROOT;
if (Worker->Opts.RunOnce) *BinWorker++ = COPT_RUNONCE;
if (Worker->Opts.NoTrack) *BinWorker++ = COPT_NOTRACK;
if (Worker->Opts.StartFailIsCritical) *BinWorker++ = COPT_STARTFAILCRITICAL;
if (Worker->Opts.StopFailIsCritical) *BinWorker++ = COPT_STOPFAILCRITICAL;
*BinWorker = 0;
MemBus_BinWrite(OutBuf, MEMBUS_MSGSIZE, true);
/*Now onto exit status mapping.*/
snprintf(OutBuf, sizeof OutBuf, MEMBUS_CODE_LSOBJS " MXS");
BinWorker = (void*)(OutBuf + sizeof MEMBUS_CODE_LSOBJS " MXS" + 1);
for (Inc = 0; Worker->ExitStatuses[Inc].Value != 3 && Inc < sizeof Worker->ExitStatuses / sizeof Worker->ExitStatuses[0]; ++Inc)
{ /*Found one.*/
*BinWorker++ = Worker->ExitStatuses[Inc].Value;
*BinWorker++ = Worker->ExitStatuses[Inc].ExitStatus;
}
BinWorker = (void*)(OutBuf + sizeof MEMBUS_CODE_LSOBJS " MXS");
*BinWorker = Inc;
MemBus_BinWrite(OutBuf, MEMBUS_MSGSIZE, true);
/**We know we're going to the runlevels now because we only send this one chunk before we ever do.**/
if (RLWorker)
{
for (; RLWorker->Next; RLWorker = RLWorker->Next)
{ /*Send all runlevels.*/
snprintf(OutBuf, sizeof OutBuf, "%s %s %s %s", MEMBUS_CODE_LSOBJS,
MEMBUS_LSOBJS_VERSION, Worker->ObjectID, RLWorker->RL);
MemBus_Write(OutBuf, true);
}
}
}
/*This says we are done.*/
MemBus_Write(MEMBUS_CODE_ACKNOWLEDGED " " MEMBUS_CODE_LSOBJS, true);
return;
}
else if (BusDataIs(MEMBUS_CODE_GETRL))
{
char TmpBuf[MEMBUS_MSGSIZE];
snprintf(TmpBuf, sizeof TmpBuf, MEMBUS_CODE_GETRL " %s", CurRunlevel);
MemBus_Write(TmpBuf, true);
}
else if (BusDataIs(MEMBUS_CODE_OBJENABLE) || BusDataIs(MEMBUS_CODE_OBJDISABLE))
{
Bool EnablingThis = (BusDataIs(MEMBUS_CODE_OBJENABLE) ? true : false);
unsigned LOffset = strlen(EnablingThis ? MEMBUS_CODE_OBJENABLE " " : MEMBUS_CODE_OBJDISABLE " ");
char *OurSignal = EnablingThis ? MEMBUS_CODE_OBJENABLE : MEMBUS_CODE_OBJDISABLE;
char *TWorker = BusData + LOffset;
ObjTable *CurObj = LookupObjectInTable(TWorker);
char TmpBuf[MEMBUS_MSGSIZE];
ReturnCode DidWork = FAILURE;
if (LOffset >= strlen(BusData) || BusData[LOffset] == ' ')
{ /*No argument?*/
snprintf(TmpBuf, sizeof TmpBuf, "%s %s", MEMBUS_CODE_BADPARAM, BusData);
MemBus_Write(TmpBuf, true);
return;
}
if (!CurObj)
{
snprintf(TmpBuf, sizeof TmpBuf, "%s %s %s", MEMBUS_CODE_FAILURE, OurSignal, TWorker);
MemBus_Write(TmpBuf, true);
return;
}
CurObj->Enabled = (EnablingThis ? true : false);
DidWork = EditConfigValue(CurObj->ConfigFile, TWorker, "ObjectEnabled", EnablingThis ? "true" : "false");
switch (DidWork)
{
case SUCCESS:
snprintf(TmpBuf, sizeof TmpBuf, "%s %s", MEMBUS_CODE_ACKNOWLEDGED, BusData);
break;
case WARNING:
snprintf(TmpBuf, sizeof TmpBuf, "%s %s", MEMBUS_CODE_WARNING, BusData);
break;
case FAILURE:
snprintf(TmpBuf, sizeof TmpBuf, "%s %s", MEMBUS_CODE_FAILURE, BusData);
break;
default:
snprintf(TmpBuf, sizeof TmpBuf, "%s %s", MEMBUS_CODE_FAILURE, BusData);
break;
}
MemBus_Write(TmpBuf, true);
}
else if (BusDataIs(MEMBUS_CODE_RUNLEVEL))
{
unsigned LOffset = strlen(MEMBUS_CODE_RUNLEVEL " ");
char *TWorker = BusData + LOffset;
char TmpBuf[MEMBUS_MSGSIZE];
if (LOffset >= strlen(BusData) || BusData[LOffset] == ' ')
{ /*No argument?*/
snprintf(TmpBuf, sizeof TmpBuf, "%s %s", MEMBUS_CODE_BADPARAM, BusData);
MemBus_Write(TmpBuf, true);
return;
}
if (ObjRL_ValidRunlevel(TWorker))
{
/*Tell them everything is OK, because we don't want to wait the whole time for the runlevel to start up.*/
snprintf(TmpBuf, sizeof TmpBuf, "%s %s %s", MEMBUS_CODE_ACKNOWLEDGED, MEMBUS_CODE_RUNLEVEL, TWorker);
MemBus_Write(TmpBuf, true);
}
else
{
snprintf(TmpBuf, sizeof TmpBuf, "%s %s %s", MEMBUS_CODE_FAILURE, MEMBUS_CODE_RUNLEVEL, TWorker);
MemBus_Write(TmpBuf, true);
return;
}
snprintf(TmpBuf, sizeof TmpBuf, CONSOLE_COLOR_CYAN "Changing runlevel to \"%s\"...\n" CONSOLE_ENDCOLOR, TWorker);
WriteLogLine(TmpBuf, true);
printf("%s", TmpBuf);
if (!SwitchRunlevels(TWorker)) /*Switch to it.*/
{
char TmpBuf[1024];
snprintf(TmpBuf, sizeof TmpBuf, "Failed to switch to runlevel \"%s\".", TWorker);
SpitError(TmpBuf);
WriteLogLine(TmpBuf, true);
}
else
{
snprintf(TmpBuf, sizeof TmpBuf, CONSOLE_COLOR_GREEN "Switched to runlevel \"%s\"." CONSOLE_ENDCOLOR, TWorker);
puts(TmpBuf);
WriteLogLine(TmpBuf, true);
}
}
else if (BusDataIs(MEMBUS_CODE_OBJRLS))
{
char *Worker = NULL;
char ObjectID[MAX_DESCRIPT_SIZE], SpecRunlevel[MAX_DESCRIPT_SIZE];
enum ObjRLS { OBJRLS_CHECK, OBJRLS_ADD, OBJRLS_DEL } Mode;
int LOffset = 0, Inc = 0;
char OutBuf[MEMBUS_MSGSIZE] = { '\0' };
ObjTable *CurObj = NULL;
char *RunlevelText = NULL;
unsigned RequiredRLTLength = 0;
struct _RLTree *RLWorker = NULL;
if (BusDataIs(MEMBUS_CODE_OBJRLS_CHECK)) LOffset = sizeof MEMBUS_CODE_OBJRLS_CHECK " " - 1, Mode = OBJRLS_CHECK;
else if (BusDataIs(MEMBUS_CODE_OBJRLS_ADD)) LOffset = sizeof MEMBUS_CODE_OBJRLS_ADD " " - 1, Mode = OBJRLS_ADD;
else if (BusDataIs(MEMBUS_CODE_OBJRLS_DEL)) LOffset = sizeof MEMBUS_CODE_OBJRLS_DEL " " - 1, Mode = OBJRLS_DEL;
else return;
Worker = BusData + LOffset;
for (; Worker[Inc] != ' ' && Worker[Inc] != '\0' && Inc < sizeof ObjectID - 1; ++Inc)
{ /*Get the object ID.*/
ObjectID[Inc] = Worker[Inc];
}
ObjectID[Inc] = '\0';
if ((Worker += Inc) == '\0')
{ /*Malformed.*/
snprintf(OutBuf, sizeof OutBuf, "%s %s", MEMBUS_CODE_BADPARAM, BusData);
MemBus_Write(OutBuf, true);
return;
}
++Worker; /*Past the space.*/
for (Inc = 0; Worker[Inc] != '\0' && Inc < sizeof SpecRunlevel - 1; ++Inc)
{ /*Get the runlevel.*/
SpecRunlevel[Inc] = Worker[Inc];
}
SpecRunlevel[Inc] = '\0';
if (!(CurObj = LookupObjectInTable(ObjectID)))
{ /*Object sent to us doesn't exist.*/
snprintf(OutBuf, sizeof OutBuf, "%s %s", MEMBUS_CODE_FAILURE, BusData);
MemBus_Write(OutBuf, true);
return;
}
/*Now process the commands.*/
switch (Mode)
{
case OBJRLS_CHECK:
snprintf(OutBuf, sizeof OutBuf, MEMBUS_CODE_OBJRLS_CHECK " %s %s %d",
ObjectID, SpecRunlevel, ObjRL_CheckRunlevel(SpecRunlevel, CurObj, true));
MemBus_Write(OutBuf, true);
return;
case OBJRLS_ADD:
/*Add the runlevel in memory.*/
if (!ObjRL_CheckRunlevel(SpecRunlevel, CurObj, false))
{
ObjRL_AddRunlevel(SpecRunlevel, CurObj);
}
else
{
snprintf(OutBuf, sizeof OutBuf, MEMBUS_CODE_FAILURE " %s", BusData);
MemBus_Write(OutBuf, true);
}
break;
case OBJRLS_DEL:
if (!ObjRL_DelRunlevel(SpecRunlevel, CurObj))
{
snprintf(OutBuf, sizeof OutBuf, "%s %s", MEMBUS_CODE_FAILURE, BusData);
MemBus_Write(OutBuf, true);
return;
}
break;
default:
break;
}
/*File editing. We already returned if we were just checking, so I won't handle that here.*/
if (CurObj->ObjectRunlevels)
{
for (RLWorker = CurObj->ObjectRunlevels; RLWorker->Next; RLWorker = RLWorker->Next)
{
RequiredRLTLength += strlen(RLWorker->RL) + 2;
}
++RequiredRLTLength; /*For the null terminator.*/
*(RunlevelText = malloc(RequiredRLTLength)) = '\0'; /*I'm only going to say this once.
* This is a Linux program. In Linux programs, most of the time, even if something is wrong,
* malloc will NEVER return NULL. I will not dirty up my code with a hundred thousand
* checks for a value that will never come to pass.*/
for (RLWorker = CurObj->ObjectRunlevels; RLWorker->Next; RLWorker = RLWorker->Next)
{
strncat(RunlevelText, RLWorker->RL, RequiredRLTLength - 1);
strncat(RunlevelText, " ", 1);
}
/*Get rid of the space at the end.*/
RunlevelText[strlen(RunlevelText) - 1] = '\0';
}
if (Mode == OBJRLS_ADD)
{
if (!EditConfigValue(CurObj->ConfigFile, CurObj->ObjectID, "ObjectRunlevels", RunlevelText))
{
const int Length = MAX_LINE_SIZE + strlen(RunlevelText);
char *TrickyBuf = malloc(Length);
/*Special trick to attempt to add the ObjectRunlevels attribute.*/
snprintf(TrickyBuf, Length, "%s\n\tObjectRunlevels=%s",
CurObj->Enabled ? "true" : "false", RunlevelText);
if (!EditConfigValue(CurObj->ConfigFile, CurObj->ObjectID, "ObjectEnabled", TrickyBuf))
{ /*Darn, we can't even do it the sneaky way!*/
free(TrickyBuf);
free(RunlevelText);
snprintf(OutBuf, sizeof OutBuf, MEMBUS_CODE_FAILURE " %s", BusData);
MemBus_Write(OutBuf, true);
return;
}
free(TrickyBuf);
}
}
else
{ /*OBJRLS_DEL*/
/*Delete the line.*/
if (!EditConfigValue(CurObj->ConfigFile, CurObj->ObjectID, "ObjectRunlevels",
CurObj->ObjectRunlevels ? RunlevelText : NULL))
{ /*If we pass NULL to EditConfigValue(), it means we want to DELETE that line.*/
if (RunlevelText) free(RunlevelText);
snprintf(OutBuf, sizeof OutBuf, MEMBUS_CODE_FAILURE " %s", BusData);
MemBus_Write(OutBuf, true);
return;
}
}
if (RunlevelText) free(RunlevelText), RunlevelText = NULL;
snprintf(OutBuf, sizeof OutBuf, MEMBUS_CODE_ACKNOWLEDGED " %s", BusData);
MemBus_Write(OutBuf, true);
return;
}
/*Power functions that close everything first.*/
else if (BusDataIs(MEMBUS_CODE_HALT) || BusDataIs(MEMBUS_CODE_POWEROFF) || BusDataIs(MEMBUS_CODE_REBOOT))
{
unsigned LOffset = 0, Signal = OSCTL_REBOOT;
char *TWorker = NULL, *MSig = NULL;
char TmpBuf[MEMBUS_MSGSIZE];
if (BusDataIs(MEMBUS_CODE_HALT))
{
LOffset = strlen(MEMBUS_CODE_HALT " ");
Signal = OSCTL_HALT;
MSig = MEMBUS_CODE_HALT;
}
else if (BusDataIs(MEMBUS_CODE_POWEROFF))
{
LOffset = strlen(MEMBUS_CODE_POWEROFF " ");
Signal = OSCTL_POWEROFF;
MSig = MEMBUS_CODE_POWEROFF;
}
else if (BusDataIs(MEMBUS_CODE_REBOOT))
{
LOffset = strlen(MEMBUS_CODE_REBOOT " ");
Signal = OSCTL_REBOOT;
MSig = MEMBUS_CODE_REBOOT;
}
TWorker = BusData + LOffset;
if (LOffset >= strlen(BusData) || BusData[LOffset] == ' ')
{ /*No argument? Just do the action.*/
snprintf(TmpBuf, sizeof TmpBuf, "%s %s", MEMBUS_CODE_ACKNOWLEDGED, MSig);
MemBus_Write(TmpBuf, true);
while (!MemBus_Read(TmpBuf, true)) usleep(100); /*Wait to be told they received it.*/
LaunchShutdown(Signal);
return;
}
if (strchr(TWorker, ':') && strchr(TWorker, '/'))
{
char MsgBuf[MAX_LINE_SIZE];
const char *HType = NULL;
Bool H;
Bool M;
Bool S;
if (HaltParams.HaltMode != -1)
{/*Don't let us schedule two shutdowns.*/
snprintf(TmpBuf, sizeof TmpBuf, "%s %s", MEMBUS_CODE_FAILURE, BusData);
MemBus_Write(TmpBuf, true);
return;
}
if (sscanf(TWorker, "%u:%u:%u %u/%u/%u", &HaltParams.TargetHour, &HaltParams.TargetMin,
&HaltParams.TargetSec, &HaltParams.TargetMonth, &HaltParams.TargetDay, &HaltParams.TargetYear) != 6)
{
SpitError("Invalid time signature for HALT/REBOOT/POWEROFF over membus.\n"
"Please report to Epoch. This is probably a bug.");
snprintf(TmpBuf, sizeof TmpBuf, "%s %s", MEMBUS_CODE_BADPARAM, BusData);
MemBus_Write(TmpBuf, true);
return;
}
H = HaltParams.TargetHour >= 10;
M = HaltParams.TargetMin >= 10;
S = HaltParams.TargetSec >= 10;
++HaltParams.JobID;
HaltParams.HaltMode = Signal;
snprintf(TmpBuf, sizeof TmpBuf, "%s %s", MEMBUS_CODE_ACKNOWLEDGED, BusData);
MemBus_Write(TmpBuf, true);
if (Signal == OSCTL_HALT) HType = "halt";
else if (Signal == OSCTL_POWEROFF) HType = "poweroff";
else if (Signal == OSCTL_REBOOT) HType = "reboot";
snprintf(MsgBuf, sizeof MsgBuf, "System is going down for %s at %s%u:%s%u:%s%u %u/%u/%u!",
HType, H?"":"0", HaltParams.TargetHour, M?"":"0", HaltParams.TargetMin, S?"":"0",
HaltParams.TargetSec, HaltParams.TargetMonth, HaltParams.TargetDay, HaltParams.TargetYear);
EmulWall(MsgBuf, false);
return;
}
else
{
SpitError("Time signature doesn't even contain a semicolon and a slash!\n"
"This is probably a bug, please report to Epoch.");
snprintf(TmpBuf, sizeof TmpBuf, "%s %s", MEMBUS_CODE_BADPARAM, BusData);
MemBus_Write(TmpBuf, true);
return;
}
}
else if (BusDataIs(MEMBUS_CODE_ABORTHALT))
{
char MsgBuf[MAX_LINE_SIZE];
const Bool H = HaltParams.TargetHour >= 10;
const Bool M = HaltParams.TargetMin >= 10;
const Bool S = HaltParams.TargetSec >= 10;
if (HaltParams.HaltMode != -1)
{
HaltParams.HaltMode = -1; /*-1 does the real cancellation.*/
}
else
{ /*Nothing scheduled?*/
MemBus_Write(MEMBUS_CODE_FAILURE " " MEMBUS_CODE_ABORTHALT, true);
return;
}
snprintf(MsgBuf, sizeof MsgBuf, "%s %s%u:%s%u:%s%u %u/%u/%u %s", "The shutdown scheduled for",
H?"":"0", HaltParams.TargetHour, M?"":"0", HaltParams.TargetMin, S?"":"0", HaltParams.TargetSec,
HaltParams.TargetMonth, HaltParams.TargetDay, HaltParams.TargetYear,
"has been aborted.");
EmulWall(MsgBuf, false);
MemBus_Write(MEMBUS_CODE_ACKNOWLEDGED " " MEMBUS_CODE_ABORTHALT, true);
return;
}
/*Ctrl-Alt-Del control.*/
else if (BusDataIs(MEMBUS_CODE_CADOFF))
{
if (!reboot(OSCTL_DISABLE_CTRLALTDEL))
{
MemBus_Write(MEMBUS_CODE_ACKNOWLEDGED " " MEMBUS_CODE_CADOFF, true);
}
else
{
MemBus_Write(MEMBUS_CODE_FAILURE " " MEMBUS_CODE_CADOFF, true);
}
}
else if (BusDataIs(MEMBUS_CODE_CADON))
{
if (!reboot(OSCTL_ENABLE_CTRLALTDEL))
{
MemBus_Write(MEMBUS_CODE_ACKNOWLEDGED " " MEMBUS_CODE_CADON, true);
}
else
{
MemBus_Write(MEMBUS_CODE_FAILURE " " MEMBUS_CODE_CADON, true);
}
}
else if (BusDataIs(MEMBUS_CODE_SENDPID))
{
char TmpBuf[MEMBUS_MSGSIZE];
unsigned LOffset = strlen(MEMBUS_CODE_SENDPID " ");
const char *TWorker = BusData + LOffset;
const ObjTable *TmpObj = NULL;
if (LOffset >= strlen(BusData) || BusData[LOffset] == ' ')
{ /*No argument?*/
snprintf(TmpBuf, sizeof TmpBuf, "%s %s", MEMBUS_CODE_BADPARAM, BusData);
MemBus_Write(TmpBuf, true);
return;
}
if (!(TmpObj = LookupObjectInTable(TWorker)) || !TmpObj->Started)
{ /*Bad argument?*/
snprintf(TmpBuf, sizeof TmpBuf, "%s %s", MEMBUS_CODE_FAILURE, BusData);
MemBus_Write(TmpBuf, true);
return;
}
snprintf(TmpBuf, sizeof TmpBuf, "%s %s %u", MEMBUS_CODE_SENDPID, TWorker,
(TmpObj->Opts.HasPIDFile ? ReadPIDFile(TmpObj) : TmpObj->ObjectPID));
MemBus_Write(TmpBuf, true);
}
else if (BusDataIs(MEMBUS_CODE_KILLOBJ) || BusDataIs(MEMBUS_CODE_OBJRELOAD))
{
char TmpBuf[MEMBUS_MSGSIZE];
unsigned LOffset = (BusDataIs(MEMBUS_CODE_KILLOBJ) ? strlen(MEMBUS_CODE_KILLOBJ " ")
: strlen(MEMBUS_CODE_OBJRELOAD " "));
const char *TWorker = BusData + LOffset;
ObjTable *TmpObj = NULL;
if (LOffset >= strlen(BusData) || BusData[LOffset] == ' ')
{ /*No argument?*/
snprintf(TmpBuf, sizeof TmpBuf, "%s %s", MEMBUS_CODE_BADPARAM, BusData);
MemBus_Write(TmpBuf, true);
return;
}
if (!(TmpObj = LookupObjectInTable(TWorker)) || !TmpObj->Started)
{ /*Bad argument?*/
snprintf(TmpBuf, sizeof TmpBuf, "%s %s", MEMBUS_CODE_FAILURE, BusData);
MemBus_Write(TmpBuf, true);
return;
}
if (BusDataIs(MEMBUS_CODE_KILLOBJ))
{
/*Attempt to send SIGKILL to the PID.*/
if (!TmpObj->ObjectPID ||
kill((TmpObj->Opts.HasPIDFile ? ReadPIDFile(TmpObj) : TmpObj->ObjectPID), SIGKILL) != 0)
{
snprintf(TmpBuf, sizeof TmpBuf, "%s %s", MEMBUS_CODE_FAILURE, BusData);
}
else
{
snprintf(TmpBuf, sizeof TmpBuf, "%s %s", MEMBUS_CODE_ACKNOWLEDGED, BusData);
TmpObj->Started = false; /*Mark it as stopped now that it's dead.*/
TmpObj->ObjectPID = 0; /*Erase the PID.*/
TmpObj->StartedSince = 0;
}
MemBus_Write(TmpBuf, true);
}
else
{
ReturnCode RV = SUCCESS;
const char *MCode = MEMBUS_CODE_ACKNOWLEDGED, *RMsg = NULL;
char LogOut[MAX_LINE_SIZE];
if (TmpObj->ObjectReloadCommand == NULL && TmpObj->ReloadCommandSignal == 0)
{
snprintf(TmpBuf, sizeof TmpBuf, "%s %s", MEMBUS_CODE_FAILURE, BusData);
MemBus_Write(TmpBuf, true);
return;
}
RV = ProcessReloadCommand(TmpObj, false);
switch (RV)
{
case SUCCESS:
MCode = MEMBUS_CODE_ACKNOWLEDGED;
RMsg = "succeeded";
break;
case WARNING:
MCode = MEMBUS_CODE_WARNING;
RMsg = "succeeded with a warning";
break;
case FAILURE:
MCode = MEMBUS_CODE_FAILURE;
RMsg = "failed";
break;
default:
break;
}
snprintf(TmpBuf, sizeof TmpBuf, "%s %s", MCode, BusData);
MemBus_Write(TmpBuf, true);
snprintf(LogOut, MAX_LINE_SIZE, "Reload of object %s %s.", TWorker, RMsg);
WriteLogLine(LogOut, true);
}
}
else if (BusDataIs(MEMBUS_CODE_RXD))
{ /*Restart Epoch from disk, but saves object states and whatnot.
* Done mainly so we can unmount the filesystem after someone updates /sbin/epoch.*/
/**We set this so when we come back we'll know if we are doing a regular reexec.**/
setenv("EPOCHRXDMEMBUS", "1", true);
ReexecuteEpoch();
}
/*Something we don't understand. Send BADPARAM.*/
else
{
char TmpBuf[MEMBUS_MSGSIZE];
snprintf(TmpBuf, sizeof TmpBuf, "%s %s", MEMBUS_CODE_BADPARAM, BusData);
MemBus_Write(TmpBuf, true);
}
}
void WiiFishController::Handle(PropertiesChangedEventArg arg) {
// Read camera configuration...
ReloadConfig();
logger.info << "Load configuration " << logger.end;
}
MI_Result Initialize()
{
MI_Result r;
static size_t nbufsize = 256;
g_batch = Batch_New(64);
if (!g_batch)
return MI_RESULT_SERVER_LIMITS_EXCEEDED;
g_dirpath = (char*)Batch_Get(g_batch, nbufsize);
g_logfilepath = (char*)Batch_Get(g_batch, nbufsize);
if (!g_logfilepath || !g_dirpath)
{
r = MI_RESULT_SERVER_LIMITS_EXCEEDED;
goto error;
}
sprintf(g_dirpath, dirformat, gethomedir(), "indicationlog");
if (Isdir(g_dirpath) == PAL_FALSE)
{
if (Mkdir(g_dirpath, 0777) != 0)
{
r = MI_RESULT_FAILED;
goto error;
}
}
sprintf(g_logfilepath, filenameformat, g_dirpath, "provider", "log");
#if !defined(_MSC_VER)
{
//
// Delete file if larger than certain size
//
struct stat buf;
if (stat(g_logfilepath, &buf) == 0)
{
if ( (unsigned long)buf.st_size > 0x800000UL )
File_Remove(g_logfilepath);
}
}
#endif
g_logfile = File_Open(g_logfilepath, "a+");
if (!g_logfile)
{
r = MI_RESULT_FAILED;
goto error;
}
Config_Initialize(&cfgTest_Indication);
Config_Initialize(&cfgL_IndicationC1);
Config_Initialize(&cfgL_IndicationC2);
Config_Initialize(&cfgL_IndicationC3);
Config_Initialize(&cfgR_IndicationC1);
Config_Initialize(&cfgR_IndicationC2);
Config_Initialize(&cfgR_IndicationC3);
Config_Initialize(&cfgTest_Class);
Config_Initialize(&cfgL_LifecycleC1);
Config_Initialize(&cfgL_LifecycleC2);
Config_Initialize(&cfgR_LifecycleC1);
Config_Initialize(&cfgR_LifecycleC2);
ReloadConfig();
LOGMSG(("\r\n\r\n\r\n\r\n==================================================="));
LOGMSG(("Initialize"));
return MI_RESULT_OK;
error:
if (g_logfile)
{
File_Close(g_logfile);
g_logfile = NULL;
}
if (g_batch)
{
Batch_Delete(g_batch);
g_batch = NULL;
}
return r;
}
