Communication Inter-Processus (IPC) pour Windows avec C

Si votre vieux C application dispose d'une pompe de message (car il a une INTERFACE utilisateur) peut-être le principe le plus simple moyen pour vérifier si il est vivant ou pas est IsHungAppWindow() fonction et Windows va faire les choses pour vous.

Si ce n'est pas votre cas et que vous avez besoin de la CIB il existe de nombreuses options, cela dépend de quel type de mécanisme IPC vous souhaitez utiliser. Ici je vais énumérer quelques ressources.

Pour une vue d'ensemble de l'IPC techniques: http://msdn.microsoft.com/en-us/library/windows/desktop/aa365574(v=vs. 85).aspx

Quelques exemples:

• MSMQ: http://msdn.microsoft.com/en-us/library/windows/desktop/ms705205(v=vs. 85).aspx
• Canaux nommés: http://msdn.microsoft.com/en-us/library/windows/desktop/aa365590(v=vs. 85).aspx et http://msdn.microsoft.com/en-us/library/windows/desktop/aa365592(v=vs. 85).aspx
• Mémoire partagée: http://msdn.microsoft.com/en-us/library/windows/desktop/aa366551(v=vs. 85).aspx

MODIFIER

Je pense qu'un petit exemple permettra de clarifier beaucoup plus que des tonnes de mots. Dans cet exemple je vais utiliser la mémoire partagée, mais vous pouvez utiliser celui que vous préférez (et vous vous sentez plus à l'aise avec). Il est non testé donc veuillez utiliser comme référence.

Le processus du MONITEUR, doit être lancé en premier.

VOID CALLBACK CheckItIsAlive(PVOID lpParam, BOOLEAN TimerOrWaitFired)
{
static int volatile latestMagicNumber = 0;
int currentMagicNumber = 0;
CopyMemory(&currentMagicNumber, lpParam, sizeof(int));
if (currentMagicNumber != latestMagicNumber)
latestMagicNumber = currentMagicNumber;
else
{
//Do something, it's hanged
}
}
void main()
{
//Shared memory used to communicate with the other process
HANDLE mappedFile = CreateFileMapping(INVALID_HANDLE_VALUE,
NULL, PAGE_READWRITE, 0, sizeof(int), "Global\\MyActivityMonitor");
LPVOID pSharedMemory = MapViewOfFile(mappedFile,
FILE_MAP_READ, 0, 0, sizeof(int));
//Thread used to check activity
HANDLE queue = CreateTimerQueue();
HANDLE hTimer = NULL;
CreateTimerQueueTimer(&hTimer, queue, 
(WAITORTIMERCALLBACK)CheckItIsAlive, pSharedMemory,
0, 5000, WT_EXECUTEDEFAULT);
//Do your work here...
//Clean up
DeleteTimerQueue(queue);
UnmapViewOfFile(pSharedMemory);
CloseHandle(mappedFile);
}

Le processus SURVEILLÉ, il va signal de son activité pour le processus du Moniteur.

VOID CALLBACK NotifyImAlive(PVOID lpParam, BOOLEAN TimerOrWaitFired)
{
static int volatile counter = 1;
int tick = counter++;
CopyMemory(lpParam, &tick, sizeof(int));
}
void main()
{
//Shared memory used to communicate with the other process
HANDLE mappedFile = OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE,
"Global\\MyActivityMonitor");
LPVOID pSharedMemory = MapViewOfFile(mappedFile,
FILE_MAP_WRITE, 0, 0, sizeof(int));
//Thread used to signal activity
HANDLE queue = CreateTimerQueue();
HANDLE hTimer = NULL;
CreateTimerQueueTimer(&hTimer, queue, 
(WAITORTIMERCALLBACK)NotifyImAlive, pSharedMemory,
0, 5000, WT_EXECUTEINTIMERTHREAD);
//Do your work here...
//Clean up
DeleteTimerQueue(queue);
UnmapViewOfFile(pSharedMemory);
CloseHandle(mappedFile);
}

De mémoire partagée est un très léger de ressources et vous pouvez utiliser ce que vous préférez pour votre chronomètres (si le timing n'est pas une exigence stricte, vous pouvez faire une sorte de repos de traitement. Personnellement, j'aime cette cause vous n'aurez pas besoin de verrouiller n'importe quel thread, et probablement que vous avez un délai d'inactivité thread de traitement).

Fonctions de minuterie sont pris en charge à partir de Windows 2000, assurez-vous que _WIN32_WINNT macro est définie avec 0x0500 (ou plus).

Additif

Je n'ai pas mentionné dans la liste, car ils n'existent que dans les plus récentes versions de système d'exploitation, mais vous pouvez même l'utiliser les variables de condition. Windows 8 va prendre en charge un très utile WaitOnAddress fonction, mais c'est quand même l'avenir je pense donc que vous ne pouvez pas l'utiliser.

Ce qui semble être un autre cas d'aller sur quelque chose de très long chemin à cause d'un manque de familiarité avec la plate-forme que vous avez affaire.

Si tous vous avez besoin de savoir comme vous le dites dans votre commentaire est de savoir si ou non votre programme est vivant donc vous pouvez le tuer, vous n'avez même pas à distance besoin de la CIB.

Au début du programme que vous souhaitez surveiller:

HANDLE hMutex = CreateMutex(NULL, FALSE, _T("MyMagicKey"));
WaitForSingleObject(hMutex, INFINITE);

Dans le "chien de garde" du programme, vous vérifiez si les autres utilitaire est vivant comme ceci:

HANDLE hMutex = OpenMutex(SYNCHRONIZE, FALSE, _T("MyMagicKey"));
if (hMutex == NULL && GetLastError() == ERROR_FILE_NOT_FOUND)
//The app being watched is already dead
else
//whatever you want

Il existe une demi-douzaine d'autres solutions qui s'appliquent tout aussi bien (ou mieux). Si votre chien de garde est le seul qui ait jamais crée de l'application qui va être surveillés, vous pouvez attendre sur le HANDLE de CreateProcess (ou ShellExecuteEx).