static APIRET PipeQueryEventSem(HEV *SemHandle, ULONG *ulPostCt)
{
APIRET rc;
rc = DosQueryEventSem(*SemHandle, ulPostCt);
if (rc == ERROR_INVALID_HANDLE)
{
rc = DosOpenEventSem(0, SemHandle);
if (!rc)
rc = DosQueryEventSem(*SemHandle, ulPostCt);
}
return rc;
}
void thread1(ULONG ulArg)
{
int i;
ULONG ulPostCt;
APIRET apiret;
DosQueryEventSem((HEV)ulArg, &ulPostCt);
printf("The event semaphore post count is %d\n", (int)ulPostCt);
for (i = 0; i < 4; i++) {
apiret = DosWaitEventSem((HEV)ulArg, SEM_INDEFINITE_WAIT);
printf("DosWaitEventSem (indefinite wait) returned %d\n", (int)apiret);
}
return;
}
void thread2(ULONG ulArg)
{
int i;
ULONG ulPostCt;
APIRET apiret;
DosQueryEventSem((HEV)ulArg, &ulPostCt);
printf("The event semaphore post count is %d\n", (int)ulPostCt);
/* note the one extra DosWaitEventSem in the loop */
/* the last one should time out */
for (i = 0; i < 5; i++) {
apiret = DosWaitEventSem((HEV)ulArg, 5000); /* 5 seconds */
printf("DosWaitEventSem (timed wait) returned %d\n", (int)apiret);
}
return;
}
static
void listen_event( grPMSurface* surface,
int event_mask,
grEvent* grevent )
{
ULONG ulRequestCount;
(void) event_mask; /* ignored for now */
/* the listen_event function blocks until there is an event to process */
DosWaitEventSem( surface->event_lock, SEM_INDEFINITE_WAIT );
DosQueryEventSem( surface->event_lock, &ulRequestCount );
*grevent = surface->event;
DosResetEventSem( surface->event_lock, &ulRequestCount );
return;
}
VOID _System threadMouMovMgr(ULONG ul) {
ULONG ulPost;
POINTL ptl;
INT i;
ULONG covrd; // numero corrente spostamenti mouse da traiettoria impostata
ULONG cstops; // numero di movimenti volontari mouse necessari per
// cancellare movimento automatico
if (DosCreateEventSem(NULL, &g.mou.hev, DC_SEM_SHARED, 0)) {
stlrlog(IDERR_CREATESERVEVSEM);
return;
} /* endif */
DosSetPriority(PRTYS_THREAD, PRTYC_TIMECRITICAL, 31, 0);
for (;;) {
restart: // label su cui punta quando esce dal loop interno
g.is.mousebtn &= ~MOVEMOUPTR;
covrd = 0;
DosWaitEventSem(g.mou.hev, SEM_INDEFINITE_WAIT);
cstops = (o.mou.moveSteps & 0x2f) >> 3;
for (i = 0; i < o.mou.moveSteps; ++i) {
WinQueryPointerPos(HWND_DESKTOP, &ptl);
// se il mouse Š stato spostato dall'utente x 3 volte
if (memcmp(&ptl, &g.mou.ptc, sizeof(POINTL)) && ++covrd > cstops)
break;
g.mou.wr.cx += g.mou.dp.x;
g.mou.wr.cy += g.mou.dp.y;
g.mou.ptc.x = (LONG)(g.mou.wr.cx >> 16);
g.mou.ptc.y = (LONG)(g.mou.wr.cy >> 16);
WinSetPointerPos(HWND_DESKTOP, g.mou.ptc.x, g.mou.ptc.y);
DosSleep(1);
// se semaforo Š stato resettato perch‚ il puntatore del mouse deve
// essere spostato su una finestra differente ricomincia dall'inizio
DosQueryEventSem(g.mou.hev, &ulPost);
if (!ulPost) goto restart;
} /* endfor */
DosResetEventSem(g.mou.hev, &ulPost);
g.mou.hwndNew = g.mou.hwnd = NULLHANDLE;
} /* endfor */
DosCloseEventSem(g.mou.hev);
}
void TThreads::suspend() {
shutDownFlag=1;
TID localTID=mouseThreadID;
if (localTID != 0xFFFF) DosWaitThread(&localTID,DCWW_WAIT);
// cerr << " MouseThread has ended\n";
ULONG count;
assert(! DosQueryEventSem(TThreads::hevKeyboard2,&count));
if (!count)
assert(! DosPostEventSem(TThreads::hevKeyboard2)); // Make sure the thread is running.
localTID=keyboardThreadID;
DosWaitThread(&localTID,DCWW_WAIT);
// cerr << " KeyboardThread has ended\n";
assert(!DosCloseMutexSem(hmtxMouse1));
assert(!DosCloseEventSem(hevKeyboard2));
assert(!DosCloseEventSem(hevKeyboard1));
assert(!DosCloseEventSem(hevMouse2));
assert(!DosCloseEventSem(hevMouse1));
assert(!DosCloseMuxWaitSem(hmuxMaster));
if (tiled->mouseHandle != 0xFFFF) MouClose(tiled->mouseHandle); // This doesn't work, the mouseThread uses the handle.
assert(! DosFreeMem(tiled)); // Better not, dito
}
VOID PostEventSemaphore (ULONG Known_key_number)
{
// Чтобы сообщить о нажатии клавиши, можно включить событийный семафор,
// который должен быть создан внешним приложением (например, в одном из
// потоков Nice). Задаем название семафора.
CHAR Semaphore_name[256] = "";
switch (Known_key_number)
{
case MMK_POWER: strcpy (Semaphore_name, MMK_POWER_SEMAPHORE_NAME ); break;
case MMK_SLEEP: strcpy (Semaphore_name, MMK_SLEEP_SEMAPHORE_NAME ); break;
case MMK_MAIL_READER: strcpy (Semaphore_name, MMK_MAIL_READER_SEMAPHORE_NAME ); break;
case MMK_MEDIA_PLAYER: strcpy (Semaphore_name, MMK_MEDIA_PLAYER_SEMAPHORE_NAME ); break;
case MMK_PAGE_LEFT: strcpy (Semaphore_name, MMK_PAGE_LEFT_SEMAPHORE_NAME ); break;
case MMK_PAGE_RIGHT: strcpy (Semaphore_name, MMK_PAGE_RIGHT_SEMAPHORE_NAME ); break;
default: return;
}
// Включаем семафор.
if (Semaphore_name[0] != 0)
{
HEV Semaphore = NULLHANDLE; ULONG Post_count = 0;
if (DosOpenEventSem (Semaphore_name, &Semaphore) == NO_ERROR &&
DosQueryEventSem (Semaphore, &Post_count) == NO_ERROR)
{
APIRET RC = DosPostEventSem (Semaphore);
}
if (Semaphore != NULLHANDLE) DosClose (Semaphore);
}
// Возврат.
return;
}
// syslogdtcp( )
//
// Entry into syslogdipc.cpp to setup and start UDP listening
//
void syslogdtcp( )
{
bool firststart = TRUE;
int msgrecv;
int seterr;
int i;
char recv_buffer[1024];
char *ptr_recv_buffer = recv_buffer;
// setup for running, if error bug out - don't worry about main
// will timeout waiting for TCPSEM1.
seterr = setuptcp( );
if(seterr)
{
if(seterr == 1)
{
psock_errno( NULL );
closetcp( );
}
if(seterr == 3) printf("DosGetSharedMem failed\n");
}
// main working loop **********************
while(TRUE)
{
// Just my play. Set SEM1 (SYSLOGD is waiting), delay 1 sec
// (let SYSLOGD reset), and start now FALSE - continue -
// sleep 1.5 sec for SEM sets or thread will shutdown
if(firststart)
{
DosPostEventSem(hevTCPSEM1); // tell main I am up!!
DosSleep(1500);
firststart = FALSE;
}
// clear recv_buffer
for(i = 0; i < 1024; i++) recv_buffer[i] = 0;
msgrecv = recv(tcpsocket, ptr_recv_buffer, 1024, 0); // read socket
// have a message msgrecv > 0 and not blocked
if(msgrecv > 0 && prgoptions->securemode)
{
if(DosRequestMutexSem(mtxMEMMUX, 60000L) != 0)
{
printf("SYSLOGTCP: Timeout waiting for MUX\n");
}
else
{
if(pShareMem->slotstat[pShareMem->index])
{
printf("SYSLOGTCP: Buffer full!!\n");
stats.tcpoverflows++;
}
else
{
// clear the slot
strnset(pShareMem->data[pShareMem->index], '\0 ',
sizeof(pShareMem->data[pShareMem->index]));
// write message into slot replace any character < 32 or > 126
// with a space RFC 3164 characters must be in this range
for(i = 0; i < strlen(recv_buffer); i++)
{
if(((int)recv_buffer[i] < 32) || ((int)recv_buffer[i] > 126))
pShareMem->data[pShareMem->index][i] = ' ';
else pShareMem->data[pShareMem->index][i] = recv_buffer[i];
}
// set flag slot has message
pShareMem->slotstat[pShareMem->index] = 1;
++pShareMem->index; // increment index to next slot
++stats.systcprecvmsg;
// ++tcpatcount;
// if reached top of buffer reset index to 0 or bottom
if(pShareMem->index == (BUFFER_SLOTS)) pShareMem->index = 0;
DosPostEventSem(hevIDLESEM); // wakeup MAIN if IDE
}
DosReleaseMutexSem(mtxMEMMUX);
}
} // end of msg recv
// check for shutdown signal from main
DosQueryEventSem(hevTCPSEM2, &TCPSEM2Ct);
if(TCPSEM2Ct && !firststart)
{
DosResetEventSem(hevTCPSEM1, &TCPSEM1Ct);
closetcp( );
}
// sleep 1 minute if blocked so do not suckup the CPU
if(!prgoptions->securemode) DosSleep(60000L);
} //$* end working loop
} //$* end of syslogdtcp
