Discussion :

[bluesnr]

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

[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].

[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

[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......

[Lung]

Essais ca :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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;

[/dev/null]

+1

[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

[Lung]

Moi, je recherchais l'expression "OK " dans la chaine résultat :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
if Pos('OK ', szResult) > 0 then
   // C'est OK
else
   // C'est pas ok

[bluesnr]

ok ca marche nikel
merci beaucoup

[/dev/null]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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...