CIRDriver::~CIRDriver()
{
DEBUG("~CIRDriver\n");
ResetPort();
KillThread(&IRThreadHandle,&IRThreadEvent);
KillThread(&DaemonThreadHandle,&DaemonThreadEvent);
if(hDataReadyEvent) CloseHandle(hDataReadyEvent);
}
/*
================
idThread::Event_TerminateThread
================
*/
void idThread::Event_TerminateThread( int num )
{
idThread *thread;
thread = GetThread( num );
KillThread( num );
}
void CIRDriver::ResetPort(void)
{
DEBUG("Resetting port\n");
KillThread(&IRThreadHandle,&IRThreadEvent);
KillThread(&DaemonThreadHandle,&DaemonThreadEvent);
if(ov.hEvent) {
CloseHandle(ov.hEvent);
ov.hEvent=NULL;
}
if(hPort) {
CloseHandle(hPort);
hPort=NULL;
}
}
void C_thread::CreateThread(E_PRIORITY priority){
quit_request = false;
KillThread();
status = STATUS_STARTING;
RThread1 *tp = new(true) RThread1;
tp->owner = (C_thread_access*)this;
#ifndef __SYMBIAN_3RD__
tp->gd = GetGlobalData();
#endif
imp = tp;
//make unique thread name
Cstr_w tname; tname<<L"Thread-" <<GetTickTime();
tp->Create(TPtrC((const word*)(const wchar*)tname, tname.Length()), ThreadProcThunk, 8192, NULL, tp);
TThreadPriority pr;
switch(priority){
case PRIORITY_VERY_LOW: pr = EPriorityMuchLess; break;
case PRIORITY_LOW: pr = EPriorityLess; break;
default: assert(0);
case PRIORITY_NORMAL: pr = EPriorityNormal; break;
case PRIORITY_HIGH: pr = EPriorityMore; break;
case PRIORITY_VERY_HIGH:
//pr = EPriorityRealTime;
pr = EPriorityAbsoluteHigh;
break;
}
tp->SetPriority(pr);
tp->Resume();
}
CDealCMDThread::~CDealCMDThread(void)
{
m_bSafeExit = TRUE;
while(m_bThreadRolling)
Sleep(1);
KillThread();
}
void CCreditsDlg::OnDestroy()
{
KillThread();
delete m_pDC;
m_pDC = NULL;
delete m_image;
m_image = NULL;
CDialog::OnDestroy();
}
Cserver::~Cserver()
{
KillThread(&ServerThreadHandle,&ServerThreadEvent);
for(int i=0;i<MAX_CLIENTS;i++)
{
if(clients[i]!=INVALID_SOCKET)
{
DEBUG("closing socket %d\n",i);
closesocket(clients[i]);
}
}
if(server!=INVALID_SOCKET)
{
closesocket(server);
DEBUG("Server socket closed.\n");
}
WSACleanup();
}
void PauseThread(THREAD *pstThd)
{
WORD wSaveReadTimeout;
WORD wSaveWriteTimeout;
BYTE bySaveFlags3;
DCB stComDCB;
GetDCB(&stIOctlInst,pstThd->hCom,&stComDCB);
wSaveReadTimeout = stComDCB.ReadTimeout;
wSaveWriteTimeout = stComDCB.WrtTimeout;
bySaveFlags3 = stComDCB.Flags3;
stComDCB.ReadTimeout = 1;
stComDCB.WrtTimeout = 1;
stComDCB.Flags3 = F3_WAIT_NONE;
SendDCB(&stIOctlInst,pstThd->hCom,&stComDCB);
KillThread(pstThd);
stComDCB.WrtTimeout = wSaveWriteTimeout;
stComDCB.ReadTimeout = wSaveReadTimeout;
stComDCB.Flags3 = bySaveFlags3;
SendDCB(&stIOctlInst,pstThd->hCom,&stComDCB);
}
RFFEAnalyzer::~RFFEAnalyzer() {
KillThread();
}
/*
================
idThread::Event_TerminateThread
================
*/
void idThread::Event_TerminateThread( int num ) {
KillThread( num );
}
/*
================
idThread::Event_KillThread
================
*/
void idThread::Event_KillThread( const char *name ) {
KillThread( name );
}
void Receive::deinit() {
KillThread(exitEvent,threadHandle);
LWEXT_Close();
}
IRAnalyzer::~IRAnalyzer()
{
KillThread();
}
int ServerQAction(int *addr, short *port, int *op, int *flags, int *jobid,
void *p1, void *p2, void *p3, void *p4, void *p5, void *p6, void *p7, void *p8)
{
int status;
switch (*op)
{
case SrvRemoveLast:
{
status = RemoveLast();
break;
}
case SrvAbort:
{
ServerSetDetailProc(0);
KillThread();
AbortJob(GetCurrentJob());
ReleaseCurrentJob();
SetCurrentJob(0);
if (*(int *)p1)
{
SrvJob *job;
while ((job = NextJob(0)) != 0)
AbortJob(job);
}
status = StartThread();
break;
}
case SrvAction:
{
SrvActionJob job;
job.h.addr = MdsGetClientAddr();
job.h.port = *port;
job.h.op = *op;
job.h.length = sizeof(job);
job.h.flags = *flags;
job.h.jobid = *jobid;
job.tree = strcpy(malloc(strlen((char *)p1)+1),(char *)p1);
job.shot = *(int *)p2;
job.nid = *(int *)p3;
status = QJob((SrvJob *)&job);
break;
}
case SrvClose:
{
SrvCloseJob job;
job.h.addr = MdsGetClientAddr();
job.h.port = *port;
job.h.op = *op;
job.h.length = sizeof(job);
job.h.flags = *flags;
job.h.jobid = *jobid;
status = QJob((SrvJob *)&job);
break;
}
case SrvCreatePulse:
{
SrvCreatePulseJob job;
job.h.addr = MdsGetClientAddr();
job.h.port = *port;
job.h.op = *op;
job.h.length = sizeof(job);
job.h.flags = *flags;
job.h.jobid = *jobid;
job.tree = strcpy(malloc(strlen((char *)p1)+1),(char *)p1);
job.shot = *(int *)p2;
status = QJob((SrvJob *)&job);
break;
}
case SrvSetLogging:
{
Logging = *(int *)p1;
break;
}
case SrvCommand:
{
SrvCommandJob job;
job.h.addr = MdsGetClientAddr();
job.h.port = *port;
job.h.op = *op;
job.h.length = sizeof(job);
job.h.flags = *flags;
job.h.jobid = *jobid;
job.table = strcpy(malloc(strlen((char *)p1)+1),(char *)p1);
job.command = strcpy(malloc(strlen((char *)p2)+1),(char *)p2);
status = QJob((SrvJob *)&job);
break;
}
case SrvMonitor:
{
SrvMonitorJob job;
job.h.addr = MdsGetClientAddr();
job.h.port = *port;
job.h.op = *op;
job.h.length = sizeof(job);
job.h.flags = *flags;
job.h.jobid = *jobid;
job.tree = strcpy(malloc(strlen((char *)p1)+1),(char *)p1);
job.shot = *(int *)p2;
job.phase = *(int *)p3;
job.nid = *(int *)p4;
job.on = *(int *)p5;
job.mode = *(int *)p6;
job.server = strcpy(malloc(strlen((char *)p7)+1),(char *)p7);
job.status = *(int *)p8;
status = QJob((SrvJob *)&job);
break;
}
case SrvShow:
{
status = ShowCurrentJob((struct descriptor_xd *)p1);
break;
}
case SrvStop:
{
printf("%s, Server stop requested\n",Now());
exit(0);
break;
}
}
return status;
}
int RAD_Thread::StopAndWait(unsigned int delay)
{
if(!m_StartStopLock.Acquire(5000, __FILE__, __LINE__))
return -1;
// Check state to see whether it could be stopped
if(m_handle == 0) {
radlog(L_WARN, "[RAD_Thread] '%s' already stopped",
m_ThreadName.c_str());
m_StartStopLock.Release(__FILE__, __LINE__);
return -1;
}
m_bShouldWatch = false; // prevent from watching-dogged
if(!IsStopped())
RequestStop();
DEBUG("[RAD_Thread] Requested termination of '%s', "
"waiting %u msec for end", m_ThreadName.c_str(), delay);
// wait for the thread to stop if it is still running
rad_assert(m_Alive != ASUnused);
bool isKilled = false;
if(m_Alive == ASAlive) {
bool ret = m_StartStopLock.Wait(delay, __FILE__, __LINE__);
if(ret == false) {
radlog(L_WARN, "[RAD_Thread] '%s' did not end within %u msec",
m_ThreadName.c_str(), delay);
KillThread(9); // 9 - SIGKILL
m_Alive = ASStop;
isKilled = true;
}
}
rad_assert(m_Alive == ASStop || m_Alive == ASDead);
// join the thread to deallocate thread resources
#ifdef RAD_OS_WIN32
if(WaitForSingleObject((HANDLE)m_handle, INFINITE) != WAIT_OBJECT_0) {
radlog(L_ERROR|L_CONS, "[RAD_Thread] Failed to join: %s",
RAD_Util::GetLastErrDesc("WaitForSingleObject").c_str());
m_StartStopLock.Release(__FILE__, __LINE__);
return -1;
}
DWORD dwExitCode;
if(!GetExitCodeThread((HANDLE)m_handle, &dwExitCode)) {
radlog(L_ERROR|L_CONS, "[RAD_Thread] %s",
RAD_Util::GetLastErrDesc("GetExitCodeThread").c_str());
m_StartStopLock.Release(__FILE__, __LINE__);
return -1;
}
if(!CloseHandle((HANDLE)m_handle)) {
radlog(L_ERROR|L_CONS, "[RAD_Thread] %s",
RAD_Util::GetLastErrDesc("CloseHandle").c_str());
m_StartStopLock.Release(__FILE__, __LINE__);
return -1;
}
Reset();
m_StartStopLock.Release(__FILE__, __LINE__);
return dwExitCode;
#else
void* retcode;
if(pthread_join((pthread_t)m_handle, &retcode)) {
radlog(L_ERROR|L_CONS, "[RAD_Thread] %s",
RAD_Util::GetLastErrDesc("pthread_join").c_str());
m_StartStopLock.Release(__FILE__, __LINE__);
return -1;
}
Reset();
m_StartStopLock.Release(__FILE__, __LINE__);
return (isKilled ? 9 : (int)retcode);
#endif
}
void Receive::deinit()
{
KillThread(exitEvent,threadHandle);
m_pKsVCPropSet.Release();
}
ManchesterAnalyzer::~ManchesterAnalyzer()
{
KillThread();
}
HD44780Analyzer::~HD44780Analyzer()
{
KillThread();
}
PWMAnalyzer::~PWMAnalyzer()
{
KillThread();
}
N64Analyzer::~N64Analyzer()
{
KillThread();
}
LINAnalyzer::~LINAnalyzer()
{
KillThread();
}
void SendReceiveData::deinit() {
KillThread(exitEvent,threadHandle);
}
I2sAnalyzer::~I2sAnalyzer()
{
KillThread();
}
JtagAnalyzer::~JtagAnalyzer()
{
KillThread();
}
PS2KeyboardAnalyzer::~PS2KeyboardAnalyzer()
{
KillThread();
}
SerialAnalyzer::~SerialAnalyzer()
{
KillThread();
}
bool CIRDriver::InitPort(CIRConfig *cfg, bool daemonize)
{
struct ir_remote *tmp;
if(cfg==NULL) return false;
DEBUG("Initializing port...\n");
KillThread(&IRThreadHandle,&IRThreadEvent);
KillThread(&DaemonThreadHandle,&DaemonThreadEvent);
cbuf_start=cbuf_end=0;
if(ov.hEvent)
{
SetEvent(ov.hEvent); // singal it
Sleep(100); // wait a tiny bit
CloseHandle(ov.hEvent); // and close it
ov.hEvent=NULL;
}
if(hPort)
{
SetCommMask(hPort,0); // stop any waiting on the port
Sleep(100); // wait a tiny bit
CloseHandle(hPort); // and close it
hPort=NULL;
}
if((hPort=CreateFile(
cfg->port,GENERIC_READ | GENERIC_WRITE,
0,0,OPEN_EXISTING,FILE_FLAG_OVERLAPPED,0))==INVALID_HANDLE_VALUE)
{
hPort=NULL;
return false;
}
DCB dcb;
if(!GetCommState(hPort,&dcb))
{
CloseHandle(hPort);
hPort=NULL;
return false;
}
if (cfg->animax) dcb.fDtrControl=DTR_CONTROL_ENABLE; //set DTR high, the animax receiver needs this for power
else
dcb.fDtrControl=DTR_CONTROL_DISABLE; // set the transmit LED to off initially.
dcb.fRtsControl=RTS_CONTROL_ENABLE;
dcb.BaudRate = cfg->speed;
devicetype = cfg->devicetype;
virtpulse = cfg->virtpulse;
if(!SetCommState(hPort,&dcb))
{
CloseHandle(hPort);
hPort=NULL;
DEBUG("SetCommState failed.\n");
return false;
}
tmp=global_remotes;
while (tmp!=NULL) {
if (!(tmp->flags&SPECIAL_TRANSMITTER)) tmp->transmitter=cfg->transmittertype;
tmp=tmp->next;
}
SetTransmitPort(hPort,cfg->transmittertype);
if(cfg->sense==-1)
{
/* Wait for receiver to settle (since we just powered it on) */
Sleep(1000);
DWORD state;
if(!GetCommModemStatus(hPort,&state))
{
CloseHandle(hPort);
hPort=NULL;
return false;
}
sense=(state & MS_RLSD_ON) ? 1 : 0;
DEBUG("Sense set to %d\n",sense);
}
else
sense=cfg->sense;
if((ov.hEvent=CreateEvent(NULL,TRUE,FALSE,NULL))==NULL)
{
CloseHandle(hPort);
hPort=NULL;
return false;
}
/* Start the thread */
/* THREAD_PRIORITY_TIME_CRITICAL combined with the REALTIME_PRIORITY_CLASS */
/* of this program results in the highest priority (26 out of 31) */
if((IRThreadHandle=
AfxBeginThread(IRThread,(void *)this,THREAD_PRIORITY_TIME_CRITICAL))==NULL)
{
CloseHandle(hPort);
CloseHandle(ov.hEvent);
hPort=ov.hEvent=NULL;
return false;
}
if(daemonize)
{
/* Start the thread */
/* THREAD_PRIORITY_IDLE combined with the REALTIME_PRIORITY_CLASS */
/* of this program still results in a really high priority. (16 out of 31) */
if((DaemonThreadHandle=
AfxBeginThread(DaemonThread,(void *)this,THREAD_PRIORITY_IDLE))==NULL)
{
KillThread(&IRThreadHandle,&IRThreadEvent);
CloseHandle(hPort);
CloseHandle(ov.hEvent);
hPort=ov.hEvent=NULL;
return false;
}
}
DEBUG("Port initialized.\n");
return true;
}
AcuriteAnalyzer::~AcuriteAnalyzer()
{
KillThread();
}
SimpleParallelAnalyzer::~SimpleParallelAnalyzer()
{
KillThread();
}
AtmelSWIAnalyzer::~AtmelSWIAnalyzer()
{
KillThread();
}
