Services Windows et Threads

Bonjour,

Voici mon probl=E8me :
J'ai une application Windows d=E9velopp=E9 en PowerBuilder (le drame....)
que je souhaite passer en Service, mais pas avec un truc a la srvany
ou autre car j'ai besoin de faire un "arret" propre de mon service, et
en plus, mon service doit en lancer ou arreter d'autre...

Alors pour resoudre ce probl=E8me, j'ai d=E9velopp=E9 une DLL en C qui me
permet d'utiliser les API Win32 pour d=E9clarer une serie de Threads qui
r=E9ponde au norme de Windows NT pour =EAtre vu comme un service (install=
=E9
avec InstSrv du toolkit).

Tout fonctionne =E0 merveille pour une instance de ce service.
Le probl=E8me, cette application dois =EAtre lanc=E9 6 fois, avec un passage
d'argument qui sera different a chaque fois :
MON_SERVICE_SRV1 : mon_exe.exe SRV1
MON_SERVICE_SRV2 : mon_exe.exe SRV2
MON_SERVICE_SRV3 : mon_exe.exe SRV3
MON_SERVICE_SRV4 : mon_exe.exe SRV4
MON_SERVICE_SRV5 : mon_exe.exe SRV5
MON_SERVICE_SRV6 : mon_exe.exe SRV6

Bon, je lance SRV1, =E7a marche... le 2 impecable, le 3 nickel... je me
dis tout marche impecable ;-)
Je lance le 4......... et la rien.....
Je stop le 3, je lance le 4 impecable....
En fait, apr=E8s plusieurs essai, je ne peut en lancer QUE 3 en m=EAme
temps!!!!!
Alors, ma question c'ets pourquoi ?? et comment =E9viter ce probl=E8me!!!

J'ai essay=E9 de copier 6 fois dans des dossiers differents l'exe et la
dll, mais le probl=E8me reste le m=EAme.

Comment peut-t-il y avoir un lien entre mes differents services ?
Je vous donne les source de ma DLL; dites moi si vous voyez un truc
anormal....
Dans PowerBuilder, je lance d=E9s le d=E9but de l'appli un
InitServiceThread
R=E9guli=E8rement (toute les secondes) je test TestServiceThread
Quand l'arret est demand=E9 (STOP_PENDING) j'arrete mon application
powerbuilder, et =E0 la fin de l'arret, j'appel DoneServiceThread
__________________________________________________________
HANDLE hThreadSynchro =3D NULL; // Flag
synchro d'arr=EAt du Thread
HANDLE ThreadHandleSynchro =3D NULL; // Handle du
thread synchro
HANDLE hThreadService =3D NULL; // Flag
Controleur de service
HANDLE ThreadHandleService =3D NULL; // Handle du
thread service
HANDLE hThreadDispatcher =3D NULL;
HANDLE hThreadStop =3D NULL;
SERVICE_STATUS ssStatus; // current status of
the service
SERVICE_STATUS_HANDLE sshStatusHandle;
DWORD dwGlobalErr;

BOOL far pascal TestServiceThread(){
return(hThreadSynchro !=3D (HANDLE)NULL);
}

VOID far pascal DoneServiceThread(){
if (hThreadSynchro !=3D (HANDLE)NULL)
SetEvent(hThreadSynchro);
if (hThreadService !=3D (HANDLE)NULL)
SetEvent(hThreadService);
if (hThreadDispatcher !=3D (HANDLE)NULL)
SetEvent(hThreadDispatcher);
if (hThreadStop !=3D (HANDLE)NULL)
SetEvent(hThreadStop);
}

VOID far pascal InitServiceThread(CHAR far *pszAppName){
hThreadSynchro =3D CreateEvent(NULL, TRUE, FALSE, NULL);
ThreadHandleSynchro =3D (HANDLE)_beginthread(ThreadSynchro, 4096,
pszAppName); // ResetEvent hThreadSynchro
}

VOID ThreadSynchro(CHAR far *pszAppName){
DWORD dwWait;
ThreadHandleService =3D
(HANDLE)_beginthread(ThreadServiceCtrlDispatcher, 4096, pszAppName);
if (hThreadSynchro !=3D (HANDLE)NULL) dwWait =3D
WaitForSingleObject(hThreadSynchro, INFINITE); // wait indefinitely
if (hThreadSynchro !=3D (HANDLE)NULL) CloseHandle(hThreadSynchro);
hThreadSynchro =3D NULL;
return;
}

VOID ThreadServiceCtrlDispatcher(CHAR far *pszAppName){
DWORD dwWait;
SERVICE_TABLE_ENTRY DispatchTable[] =3D {{NULL,
(LPSERVICE_MAIN_FUNCTION)ServiceMain},{NULL,NULL}};
DispatchTable->lpServiceName =3D pszAppName;
if (!StartServiceCtrlDispatcher(DispatchTable)) {/
*StopService("Erreur StartServiceCtrlDispatcher.");*/ }
hThreadDispatcher =3D CreateEvent(NULL, TRUE, FALSE, NULL);
if (hThreadDispatcher !=3D (HANDLE)NULL) dwWait =3D
WaitForSingleObject(hThreadDispatcher, INFINITE); // wait indefinitely
if (hThreadDispatcher !=3D (HANDLE)NULL)
CloseHandle(hThreadDispatcher);
hThreadDispatcher =3D (HANDLE)NULL;
return;
}

VOID ServiceMain(DWORD dwArgc, LPTSTR *lpszArgv){
DWORD dwWait;
sshStatusHandle =3D RegisterServiceCtrlHandler(*lpszArgv,
(LPHANDLER_FUNCTION)ServiceCtrl);
if (!sshStatusHandle) goto cleanup;
ssStatus.dwServiceType =3D
SERVICE_WIN32_OWN_PROCESS; // SERVICE_STATUS members that don't
change in example
ssStatus.dwServiceSpecificExitCode =3D 0;
if (!ReportStatusToSCMgr(SERVICE_START_PENDING , NO_ERROR, 1,
3000)) goto cleanup;
hThreadService =3D CreateEvent(NULL, TRUE, FALSE, NULL);
if (hThreadService =3D=3D (HANDLE)NULL) goto cleanup;
if (!ReportStatusToSCMgr(SERVICE_START_PENDING, NO_ERROR, 2,
3000)) goto cleanup;
if (!ReportStatusToSCMgr(SERVICE_RUNNING, NO_ERROR, 0, 0)) goto
cleanup;
dwWait =3D WaitForSingleObject(hThreadService, INFINITE); //
wait indefinitely
cleanup:
if (hThreadService !=3D (HANDLE)NULL) CloseHandle(hThreadService);
hThreadService =3D NULL;
if ((HANDLE)sshStatusHandle !=3D (HANDLE)NULL)
(VOID)ReportStatusToSCMgr(SERVICE_STOPPED, dwGlobalErr, 0, 0);
return;
}

VOID ServiceCtrl(DWORD dwCtrlCode){
DWORD dwWait;
DWORD dwState =3D SERVICE_RUNNING;
unsigned short i;
switch(dwCtrlCode) {
case SERVICE_CONTROL_PAUSE: // Pause the service if it is
running. non impl=E9ment=E9
break;
case SERVICE_CONTROL_CONTINUE: // Resume the paused service.
non impl=E9ment=E9
break;
case SERVICE_CONTROL_STOP: {// Stop the service.
dwState =3D SERVICE_STOP_PENDING;
if ((HANDLE)sshStatusHandle !=3D (HANDLE)NULL)
ReportStatusToSCMgr(SERVICE_STOP_PENDING, NO_ERROR, 1,
5000); // waithint
hThreadStop =3D CreateEvent(NULL, TRUE, FALSE,
NULL); // no name
if (hThreadSynchro !=3D (HANDLE)NULL)
SetEvent(hThreadSynchro);
for( i=3D2; i<20; i++){
if (hThreadStop !=3D (HANDLE)NULL) dwWait =3D
WaitForSingleObject(hThreadStop, 3000);
if (hThreadStop !=3D (HANDLE)NULL) {
CloseHandle(hThreadStop);
hThreadStop =3D NULL;
break;
}
else
ReportStatusToSCMgr(SERVICE_STOP_PENDING,NO_ERROR,i,5000); // On
informe le SCM qu'on est toujours en train de travailler
}
}
break;

case SERVICE_CONTROL_INTERROGATE:// Update the service status.
break;

default: // invalid control code
break;
}
// send a status response.
if (dwState !=3D SERVICE_STOP_PENDING) if((HANDLE)sshStatusHandle !=3D
(HANDLE)NULL) ReportStatusToSCMgr(dwState, NO_ERROR, 0, 0);
return;
}

BOOL ReportStatusToSCMgr(DWORD dwCurrentState, DWORD dwWin32ExitCode,
DWORD dwCheckPoint, DWORD dwWaitHint){
BOOL fResult =3D FALSE;
if ((HANDLE)sshStatusHandle !=3D (HANDLE)NULL){ // Disable control
requests until the service is started.
if (dwCurrentState =3D=3D SERVICE_START_PENDING)
ssStatus.dwControlsAccepted =3D 0;
else ssStatus.dwControlsAccepted =3D SERVICE_ACCEPT_STOP;
ssStatus.dwCurrentState =3D dwCurrentState;
ssStatus.dwWin32ExitCode =3D dwWin32ExitCode;
ssStatus.dwCheckPoint =3D dwCheckPoint;
ssStatus.dwWaitHint =3D dwWaitHint;
if (!(fResult =3D SetServiceStatus(sshStatusHandle, &ssStatus)))
{}
Sleep(100);
}
return fResult;
}
____________________________________________________