Comment tester la présence de machine ?

Version imprimable

22/04/2005, 16h17
bluesnr

Comment tester la présence de machine ?

Bonjour à tous

J'ai créer une application qui vérifie une température dans une salle et qui arrete les machines de la salle si la temperature est trop élevée.
Une socket serveur ecoute un port sur tous les PC à arrêter.

Dans la partie que j'ai developpé, j'utilise une socket cliente pour envoyer un message au serveurs ce qui arrete le pc. (je sais pas si je suis tres clair)

Mon probleme est que je doit vérifier que la machine est bien arrêtée et je n'ai pas d'idée. Je voudrai juste savoir si l'IP est accessible ou pas. Est-ce qu'il existe des methodes toute faites ou est-ce qu'une fonctionnalité de la socket peut me le dire???

j'utilise delphi4
Merci d'avance
22/04/2005, 16h19
MD Software

Fait un ping sur chaque adresse ip. Si tu n'as pas de réponses, c'est qu'il est éteint [ou que le réseau est par terre, mais là, de toute façon, tu e peux pas le savoir].
22/04/2005, 16h24
bluesnr

j'ai vu un sujet la dessus un peu plus bas mais je ne comprend absolument rien... Si qq'1 pouvait m'expliquer vite fait la demarche a suivre

merci d'avance
22/04/2005, 16h37
bluesnr

est-ce qu'il est possible d'avoir un retour d'une commande DOS.
J'execute deja un fichier BAT mais je sais pas si c'est possible d'avoir un retour de l'execution d'un fichier bat...
Si quelqu'un l'a dja fait......

Essais ca :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
procedure GetConsoleText(Command:String; var Result:String);
const
     LENBUFF = 512; // Augmente le si tu as des problèmes
var
   hReadPipe, hWritePipe: THandle;
   sa : TSecurityAttributes;
   si : TStartupInfo;
   pi : TProcessInformation;
   lpBuffer    : array[0..LENBUFF] of char;
   BytesRead   : Cardinal;
   BytesToRead : integer;
begin
     sa.nLength              := sizeof( sa );
     sa.lpSecurityDescriptor := nil;
     sa.bInheritHandle       := True;
 
     if not CreatePipe( hReadPipe, hWritePipe, @sa, 0 ) then begin
        Application.MessageBox( pChar('Error creation Pipe' ), 'Error',IDOK );
        exit;
     end;
 
     FillChar( si, sizeof(si), 0 );
     si.cb          := sizeof( si );
     si.dwFlags     := STARTF_USESHOWWINDOW or STARTF_USESTDHANDLES;
     si.wShowWindow := SW_HIDE;
     si.hStdInput   := 0;
     si.hStdOutput  := hWritePipe;
     si.hStdError   := hWritePipe;
 
     if not CreateProcess( nil, pChar( Command ), nil, nil, true, 0, nil, nil, si, pi ) then begin
        Application.MessageBox( pChar('Error executing command' ), 'Error', IDOK );
        CloseHandle( hReadPipe );
        CloseHandle( hWritePipe );
        exit;
     end;
 
     CloseHandle( hWritePipe );
     BytesToRead := LENBUFF;
     BytesRead := 0;
 
    Result := '';
     While (True) do begin
           lpBuffer := '';
           ReadFile( hReadPipe, lpBuffer, BytesToRead, BytesRead, nil );
           if BytesRead=0 then Break;
           Result := Result + StrPas(lpBuffer);
     end;
 
     WaitForSingleObject( pi.hProcess, INFINITE );
     CloseHandle( pi.hProcess );
     CloseHandle( hReadPipe );
end;

:wink:

22/04/2005, 16h42
/dev/null

:D
+1
22/04/2005, 16h55
bluesnr

merci pour ta methode, meme je ne la comprend pas du tout...
mais apres, comment est-ce que je peux analyser le retour?
car il me sort:

Envoi d'une requete de ping sur ....:
reponse de 192.168.15.248: octet=30 temps<10ms TTL=128
avec 10 lignes de reponse.

Est-ce que je peux lui dire que si le texte contient "perdus=0" ou "reponse de" alors c'est bon???

DSL si je suis vraiment trop nul en delphi mais je debute et j'ai vraiment besoin de vos conseils...

merci
22/04/2005, 17h02
Lung
Moi, je recherchais l'expression "OK " dans la chaine résultat :
Code:

1 2 3 4 if Pos('OK ', szResult) > 0 then // C'est OK else // C'est pas ok
:wink:
22/04/2005, 17h11
bluesnr

ok ca marche nikel
merci beaucoup

Ben en fait... ce message, du coup, est pour Lung et pour toi ;) (J'ai réécrit la source en utilisant les bonnes idées de Lung ;) ). Je n'avais pas vue que Lung utilisait une procedure en fait :'(.

Tu devras déclarer une constante SPipe qui contiendras la taille du Buffer.
Voilà le code

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
Function RunSpyStdOut(Const Commande:String; Var Out:String): Integer;
Var
   Start   : TStartupInfo       ;
   Process : TProcessInformation;
   Sa      : TSecurityAttributes;
   PipeOut,
   PipeIn ,
   Readed  : Cardinal;
   Buffer  : String  ;
   WhatApen: DWord;
 
begin
  RunSpyStdOut := -1;
  // Choix de la taille du Buffer...
  SetLength(Buffer, SPipe);
 
  // Initialisation des attributs de sécurité
  FillChar (Sa, SizeOf(Sa), #0);
  Sa.nLength              := SizeOf (Sa);
  Sa.bInheritHandle       := TRUE;
 
  // Création du Pipe
  if not CreatePipe(PipeIn, PipeOut, @Sa, SPipe) then
     Exit;
 
  // Paramétrage du lancemant de l'application
  FillChar(Start,SizeOf(Start),#0);
  Start.cb          := SizeOf(Start);
  Start.dwFlags     := STARTF_USESTDHANDLES Or STARTF_USESHOWWINDOW;
  Start.hStdOutput  := PipeOut;
  Start.wShowWindow := SW_HIDE;
 
  // Création du Processus pour l'application
  If not CreateProcess(Nil,
                       PChar(Commande),
                       Nil, Nil,
                       True,
                       0, Nil, Nil,
                       Start,Process) Then Begin
                         CloseHandle(Pipein);
                         CloseHandle(PipeOut);
                         Exit;
                       End;
  // OK...
  // On peut, et on doit, fermer le handle d'écriture du pipe.
  // 1 - Parceque de toute façon on ne va rien écrire dedans.
  // 2 - Parceque si non la fontion ReadFile risque de rester bloquer car un
  //     Handle est toujours ouvert à la fermeture de l'pplication dont on
  //     récupaire la sortie standard.
  CloseHandle (PipeOut);
 
  Repeat
    //   Quoi qu'il se passe, on va lire le flux du pipe car, s'il est plein,
    // la fonction d'écriture de la console dans le pipe ne rend pas la main
    // au programme apellant.
    // Si le pipe est plein, le programme ne reprend jamais la main !!!
    ReadFile(PipeIn, Buffer[1], SPipe, Readed, nil);
    Out:=Out+copy(Buffer,1,Readed);
 
    // ...on va patienté quelque miliseconde.
 
    WhatApen := WaitForSingleObject(Process.hProcess, 125);
    Application.ProcessMessages;
  until WhatApen = WAIT_OBJECT_0;
 
  GetExitCodeProcess(Process.hProcess, WhatApen);
  CloseHandle(PipeIn);
  CloseHandle(Process.hProcess);
  RunSpyStdOut:=WhatApen;
End;

Et il suffit de verifier si la valeur de retour est 0 ou 1... ;)