Shell-Befehle ausführen

FredAffe · Hält's aus hier Beiträge: 6

Erstma hallo zusammen!

Ich bin also auf ein Problem gestossen bei der Programmierung von einem Tool, das direkt den Befehl "net send" ausführt.

Das ist ein Systembefehl von Windows NT der Nachrichten direkt an andere sendet. Zum Vereinfachen wollte ich ein Tool schreiben.

Das sieht also so aus:

ein TEdit für den Computernamen/die IP (CName)
ein TEdit für die Nachricht (NText)
ein TButton zum Senden

Jetzt hab ich nur noch das Problem, dass ich nicht weiß, wie man auf Knopfdruck den Befehl ausführen lässt:

"c:\winnt\net send {CName} "{NText}" "

Wäre echt nett, wenn ihr mir helfen könntet.

_________________
Boh schon so spät...
Ich muss weg!

toms · Beiträge: 1099 Erhaltene Danke: 2

Hi,

Du könntest auch die entsprechenden API Funktionen aufrufen:

markieren

Quelltext

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:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:

NetSend(dest, Source, Msg: string): Longint; overload;
type
  TNetMessageBufferSendFunction = function(servername, msgname, fromname: PWideChar;
    buf: PWideChar; buflen: Cardinal): Longint;
  stdcall;
var
  NetMessageBufferSend: TNetMessageBufferSendFunction;
  SourceWideChar: PWideChar;
  DestWideChar: PWideChar;
  MessagetextWideChar: PWideChar;
  Handle: THandle;
begin
  Handle := LoadLibrary('NETAPI32.DLL');
  if Handle = 0 then
  begin
    Result := GetLastError;
    Exit;
  end;
    @NetMessageBufferSend := GetProcAddress(Handle, 'NetMessageBufferSend');
  if @NetMessageBufferSend = nil then
  begin
    Result := GetLastError;
    Exit;
  end;

  MessagetextWideChar := nil;
  SourceWideChar      := nil;
  DestWideChar        := nil;

  try
    GetMem(MessagetextWideChar, Length(Msg) * SizeOf(WideChar) + 1);
    GetMem(DestWideChar, 20 * SizeOf(WideChar) + 1);
    StringToWideChar(Msg, MessagetextWideChar, Length(Msg) * SizeOf(WideChar) + 1);
    StringToWideChar(Dest, DestWideChar, 20 * SizeOf(WideChar) + 1);

    if Source = '' then
      Result := NetMessageBufferSend(nil, DestWideChar, nil,
        MessagetextWideChar, Length(Msg) * SizeOf(WideChar) + 1)
    else
    begin
      GetMem(SourceWideChar, 20 * SizeOf(WideChar) + 1);
      StringToWideChar(Source, SourceWideChar, 20 * SizeOf(WideChar) + 1);
      Result := NetMessageBufferSend(nil, DestWideChar, SourceWideChar,
        MessagetextWideChar, Length(Msg) * SizeOf(WideChar) + 1);
      FreeMem(SourceWideChar);
    end;
  finally
    FreeMem(MessagetextWideChar);
    FreeLibrary(Handle);
  end;
end;

function NetSend(Dest, Msg: string): Longint; overload;
begin
  Result := NetSend(Dest, '', Msg);
end;

function NetSend(Msg: string): Longint; overload;
begin
  Result := NetSend('', '', Msg);
end;



procedure TForm1.Button1Click(Sender: TObject);
const
  NERR_BASE = 2100;
  NERR_NameNotFound = NERR_BASE + 173;
  NERR_NetworkError = NERR_BASE + 36;
  NERR_Success = 0;
var
  Res: Longint;
  sMsg: string;
begin
  Res := NetSend('LoginName', 'Your Message...');
  case Res of
    ERROR_ACCESS_DENIED: sMsg := 'user does not have access to the requested information.';
    ERROR_INVALID_PARAMETER: sMsg := 'The specified parameter is invalid.';
    ERROR_NOT_SUPPORTED: sMsg := 'This network request is not supported.';
    NERR_NameNotFound: sMsg := 'The user name could not be found.';
    NERR_NetworkError: sMsg := 'A general failure occurred in the network hardware.';
    NERR_Success: sMsg := 'Message sent!';
  end;
  ShowMessage(sMsg);
end;

FredAffe · Hält's aus hier Beiträge: 6

Jojo, funktioniert.

Aber das dauert so fürchterlich lange bis der die Nachricht versendet, kann man da nich was machen?

_________________
Boh schon so spät...
Ich muss weg!

Alfons-G · Verfasst: Do 20.06.02 19:19

Einen Programmaufruf über WinAPI kannst Du so machen:
(frei nach Swiss Delphi Center)

markieren

Quelltext

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:

With ShellExecuteEx: 
***************************************************** 

uses shellapi; 

{...} 

procedure TForm1.Button1Click(Sender: TObject); 

 Var 
   exInfo: TShellExecuteInfo; 
   exitcode: DWORD; 
 Begin 
   FillChar( exInfo, Sizeof(exInfo), 0 ); 
   With exInfo Do Begin 
     cbSize:= Sizeof( exInfo ); // required! 
     fMask := SEE_MASK_NOCLOSEPROCESS or SEE_MASK_FLAG_DDEWAIT; 
     Wnd   := Handle;  // forms handle 
     lpVerb:= 'open'; 
     lpFile:= Pchar('C:\WinNT\net' );
     lpParameters:= PChar('Send ' + Empfaenger + DeinText);
     nShow := SW_SHOWNORMAL 
   End; 
   If ShellExecuteEx( @exInfo ) Then Begin 
      While GetExitCodeProcess( exinfo.hProcess, exitcode ) 
            and (exitcode = STILL_ACTIVE) 
      Do 
        Application.Processmessages; 
      CloseHandle( exinfo.hProcess ); 
   End 
   Else 
     ShowMessage(SysErrorMessage( GetLastError )); 
    showmessage('ended'); 
  end;

Auf diese Art kannst Du (fast) alle Programme ausführen, welche unter Windows lauffähig sind.

:idea:

_________________
Alfons Grünewald

Phoenix · Verfasst: Di 25.06.02 12:54

Oder noch einfacher:

markieren

Quelltext

1:
2:
3:
4:
5:
6:
7:
8:

uses ShellApi;

procedure NetSend(Empfaenger, Message : String);
begin
   shellexecute(self.handle, pChar('open'), pChar('net'),
          pChar('send ' + Empfaenger + ' ' + Message),
          NIL, SW_SHOWNORMAL);
end;

Das ganze muss allerdings auf einem Form liegen. Im Prinzip wird damit einfach der 'net send User Blafasel' - Befehl an die Shell übergeben und dort ausgeführt.

Ich habe einen kleinen Net Sender geschrieben der im Prinzip nur aus einer Listbox mit Empfängern, einem Editfeld und einem Button besteht und pro Aufruf zwei oder maximal drei Zeilen Code beinhaltet, das schwierigste war die Empfängerverwaltung in der Stringlist

Wenn gewünscht ne PM, dann rück ich auch gerne den Quellcode raus.

Viele Grüße,

Sebastian

Moderiert von Tino: Absätze entfernt.

_________________
Sebastian P.R. Gingter

a.C.k · Verfasst: Di 29.10.02 17:38

hi Phoenix,
habe deine Procedure probiert zu testen, aber mein Delphi kommt mit "self.handle" nicht zurecht.
Weist du, woran das liegt

_________________
Wer nicht gerne denkt, sollte wenigstens von Zeit zu Zeit seine Vorurteile neu gruppieren.

Ehemaliges Mitglied Erhaltene Danke: 1

Ja, ich weiß es! Ich weiß es!

Die Funktion weiß ganz einfach nicht, was "self" ist.
Abhilfe #1: du deklarierst sie als Form-bezogene Prozedur (privat, public):

markieren

Quelltext

1:	procedure TFORM1.NetSend(Empfaenger, Message : String);

Abhilfe #2: du gibst den Namen den Form direkt an:

markieren

Quelltext

1:	shellexecute(FORM1.handle, pChar('open'), pChar('net'),

Abhilfe #3: der IMHO beste Weg, du gibst das Fenster-Handle auch als Parameter der Prozedur an:

markieren

Quelltext

1:
2:
3:

procedure NetSend(wnd: HWND; Empfaenger, Message : String);
begin
  shellexecute(wnd,...

Übrigens gibt es von Forenmitgliedern bereits fertige Programme für diesen Zweck, zum Teil sogar mit Source.
Aber ich finde es trotzdem nett, dass man mir erklärt, was "net send" ist ... :twisted:

	Mitgliederliste
	Gruppen
	Das Team
	Richtlinien
	Synonyme