///////////////////////////////////////////////////////////////
// SendCommandToEngine
//
//////////////////////////////////////////////////////////////
Command::Dpt_Error AlarmStatus::SendCommandToEngine( DPT_TAG_T hba, String_List** output )
{
Dpt_Error err;
switch ( alarmCmd )
{
case On:
// If the alarm is not disabled then we can send
// down the alarm on message.
if ( !alarmDisabled )
{
err |= engine->Send( MSG_ALARM_ON, hba );
if ( !err.Is_Error() ) { alarmOn = 1; }
}
else
{
//(**output).add_Item( STR_CANT_DO_ALARM );
}
err |= GetAlarmStatus( hba , output );
break;
case Off:
// If the alarm is not disabled then we can send
// down the alarm off message.
if ( !alarmDisabled )
{
err |= engine->Send( MSG_ALARM_OFF, hba );
if ( !err.Is_Error() ) { alarmOn = 0; }
}
else
{
//(**output).add_Item( STR_CANT_DO_ALARM );
}
err |= GetAlarmStatus( hba , output );
break;
case Enable:
err |= EnableAlarm( Enable, hba );
err |= GetAlarmStatus( hba , output );
break;
case Disable:
err |= EnableAlarm( Disable, hba );
err |= GetAlarmStatus( hba , output );
break;
case Status:
err |= GetAlarmStatus( hba , output );
break;
}
return( err );
}
bool
RegisterTheOneAlarmObserver(AlarmObserver* aObserver)
{
MOZ_ASSERT(!InSandbox());
MOZ_ASSERT(!sAlarmObserver);
sAlarmObserver = aObserver;
RETURN_PROXY_IF_SANDBOXED(EnableAlarm(), false);
}
// Usage: process-wrapper
// <timeout_sec> <kill_delay_sec> <stdout file> <stderr file>
// [cmdline]
int main(int argc, char *argv[]) {
if (argc <= 5) {
DIE("Not enough cmd line arguments to process-wrapper");
}
// Parse the cmdline args to get the timeout and redirect files.
argv++;
double timeout;
if (sscanf(*argv++, "%lf", &timeout) != 1) {
DIE("timeout_sec is not a real number.");
}
if (sscanf(*argv++, "%lf", &global_kill_delay) != 1) {
DIE("kill_delay_sec is not a real number.");
}
char *stdout_path = *argv++;
char *stderr_path = *argv++;
if (strcmp(stdout_path, "-")) {
// Redirect stdout and stderr.
int fd_out = open(stdout_path, O_WRONLY|O_CREAT|O_TRUNC, 0666);
if (fd_out == -1) {
DIE("Could not open %s for stdout", stdout_path);
}
if (dup2(fd_out, STDOUT_FILENO) == -1) {
DIE("dup2 failed for stdout");
}
CHECK_CALL(close(fd_out));
}
if (strcmp(stderr_path, "-")) {
int fd_err = open(stderr_path, O_WRONLY|O_CREAT|O_TRUNC, 0666);
if (fd_err == -1) {
DIE("Could not open %s for stderr", stderr_path);
}
if (dup2(fd_err, STDERR_FILENO) == -1) {
DIE("dup2 failed for stderr");
}
CHECK_CALL(close(fd_err));
}
global_pid = fork();
if (global_pid < 0) {
DIE("Fork failed");
} else if (global_pid == 0) {
// In child.
if (setsid() == -1) {
DIE("Could not setsid from child");
}
ClearSignalMask();
// Force umask to include read and execute for everyone, to make
// output permissions predictable.
umask(022);
execvp(argv[0], argv); // Does not return.
DIE("execvpe %s failed", argv[0]);
} else {
// In parent.
InstallSignalHandler(SIGALRM);
InstallSignalHandler(SIGTERM);
InstallSignalHandler(SIGINT);
EnableAlarm(timeout);
int status = WaitChild(global_pid, argv[0]);
// The child is done, but may have grandchildren.
kill(-global_pid, SIGKILL);
if (global_signal > 0) {
// Don't trust the exit code if we got a timeout or signal.
UnHandle(global_signal);
raise(global_signal);
} else if (WIFEXITED(status)) {
exit(WEXITSTATUS(status));
} else {
int sig = WTERMSIG(status);
UnHandle(sig);
raise(sig);
}
}
}
j_result_t CXlClient::OnHandleRead(J_AsioDataBase *pAsioData)
{
if (m_ioCmdState == CXlProtocol::xl_init_state)
{
pAsioData->ioCall = J_AsioDataBase::j_read_e;
CXlHelper::MakeNetData(pAsioData, m_readBuff, sizeof(CXlProtocol::CmdHeader));
m_ioCmdState = CXlProtocol::xl_read_head_state;
}
else if (m_ioCmdState == CXlProtocol::xl_read_head_state)
{
CXlProtocol::CmdHeader cmdHeader = *((CXlProtocol::CmdHeader *)m_readBuff);
//J_OS::LOGINFO("%d ", cmdHeader.cmd);
//if (cmdHeader.length > 1000)
//{
// J_OS::LOGINFO("");
//}
CXlHelper::MakeNetData(pAsioData, m_readBuff + sizeof(CXlProtocol::CmdHeader), cmdHeader.length + sizeof(CXlProtocol::CmdTail));
pAsioData->ioCall = J_AsioDataBase::j_read_e;
m_ioCmdState = CXlProtocol::xl_read_data_state;
}
else if (m_ioCmdState == CXlProtocol::xl_read_data_state)
{
CXlClientCmdData *pCmdData = (CXlClientCmdData *)m_readBuff;
switch (pCmdData->cmdHeader.cmd)
{
case CXlProtocol::xlc_login:
OnLogin(*pCmdData);
break;
case CXlProtocol::xlc_logout:
OnLogout(*pCmdData);
break;
case CXlProtocol::xlc_heart_beat:
OnHeartBeat(*pCmdData);
break;
case CXlProtocol::xlc_real_play:
SaveRequest(*pCmdData, pCmdData->cmdHeader.flag == CXlProtocol::xl_ctrl_start);
pCmdData->cmdRealPlay.pBuffer = &m_ringBuffer;
JoDataBus->Request(pCmdData->cmdRealPlay.hostId, this, *pCmdData);
break;
case CXlProtocol::xlc_vod_play:
case CXlProtocol::xlc_vod_download:
SaveRequest(*pCmdData, pCmdData->cmdHeader.flag == CXlProtocol::xl_ctrl_start);
pCmdData->cmdStartVod.pBuffer = &m_ringBuffer;
JoDataBus->Request(pCmdData->cmdStartVod.hostId, this, *pCmdData);
break;
case CXlProtocol::xlc_real_alarm:
EnableAlarm(*pCmdData, pCmdData->cmdHeader.flag == CXlProtocol::xl_ctrl_start);
break;
case CXlProtocol::xlc_trans_context:
break;
case CXlProtocol::xlc_upload_file:
break;
default:
//assert(false);
SendRequest(*pCmdData);
break;
}
CXlHelper::MakeNetData(pAsioData, m_readBuff, sizeof(CXlProtocol::CmdHeader));
pAsioData->ioCall = J_AsioDataBase::j_read_e;
m_ioCmdState = CXlProtocol::xl_read_head_state;
}
return J_OK;
}
