Programm als bestimmter Nutzer starten

[Schokohase]

Warum sollte da etwas kaputt gehen?

Unicode-Delphi (alles ab Delphi 2009):

string ist ein Alias für UnicodeString .
PChar ist ein Alias für PWideChar .

ANSI-Delphi (alles vor Delphi 2009):

string ist ein Alias für AnsiString .
PChar ist ein Alias für PAnsiChar .

[KodeZwerg]

Danke Euch Drei, nun ists angekommen. Super Erklärung, das hilft sehr!

[himitsu]

Zitat von himitsu:

String -> PChar -> WinApi
AnsiString -> PAnsiChar -> WinApiA
WideString/UnicodeString -> PWideChar -> WinApiW

Darum auch immer nur das Passende zusammen verwenden.
Ansonsten muß der String ANSI-Unicode entsprechend gecastet werden.

Beispiel:
String (AnsiString) mit PAnsiChar ging in Delphi vor 2009,
aber aber 2009 passt String (UnicodeString) und PAnsiChar nicht mehr.

Hätte man früher aber die "richtigen" Typen zusammen verwendet, dann würde es mit Umstellung auf Unicode keine Probleme geben.

[Moombas]

Ich war blind = Ich habe die Übergabe des Arbeitsverzeichnisses an die falsche Stelle übergeben -.-

[Moombas]

Eine kleine Ergänzung:

Bekomme ich aus der Funktion irgendwie folgende Informationen:

TStartupInfo
TProcessInformation

Delphi-Quellcode:

//Prozess als bestimmten Benutzer starten (Hilfsaufruf)
procedure TTools.startasSU(exe, param : string);
var
  User              : WideString;
  PW                : WideString;
  err               : DWORD;
begin
  User := 'yyy';
  PW   := 'xxx';
  err  := CreateProcessAsLogon(User, PW, exe, param, '');
  if err <> 0 then
    ShowMessage(SysErrorMessage(err));
    CreateProcess(
end;

Ich möchte das gestartete Programm an anderer Stelle ggf. beenden, daher bräuchte ich die Informationen, außer ihr habt eine bessere Idee.

Aktuell würde ich dies über folgende Lösung machen:

Starten:

Delphi-Quellcode:

var
  SI: TStartupInfo;
  PI: TProcessInformation;
begin

  FillChar(SI, SizeOf(TStartupInfo), 0);
  SI.cb := SizeOf(TStartupInfo);
  if CreateProcess(nil, 'NOTEPAD.EXE', nil, nil, False, 0, nil, nil, SI, PI) then
  begin
    AppPID := PI.dwProcessId;
    CloseHandle(PI.hProcess);
    CloseHandle(PI.hThread);
  end;

Beenden:

Delphi-Quellcode:

  function EnumWindowsProc(hWnd: HWND; lParam: LPARAM): BOOL; stdcall;
  begin
    TList(lParam).Add(Pointer(hWnd));
    Result := True;
  end;

  procedure Wait(MilliSeconds: DWORD);
  var
    Stop: DWORD;
  begin
    Stop := GetTickCount + MilliSeconds;
    while Stop > GetTickCount do
    begin
      Sleep(100);
      Application.ProcessMessages;
    end;
  end;

var
  List: TList;
  I: Integer;
  ProcessId: DWORD;
  ThreadId: DWORD;
  ProcessHandle: THandle;
  ExitCode: DWORD;
begin

  if AppPID <> 0 then
  begin
    List := TList.Create;
    try
      EnumWindows(@EnumWindowsProc, LPARAM(List));
      for I := 0 to List.Count - 1 do
      begin
        ThreadId := GetWindowThreadProcessId(HWND(List.Items[I]), ProcessId);
        if ProcessId = AppPID then
        begin
          SendMessageTimeout(HWND(List.Items[I]), WM_SYSCOMMAND, SC_CLOSE, 0, SMTO_ABORTIFHUNG, 500, DWORD(nil^));
          Wait(3000);
          if IsWindow(HWND(List.Items[I])) then
          begin
            PostThreadMessage(ThreadId, WM_QUIT, 0, 0);
            Wait(3000);
            ProcessHandle := OpenProcess(PROCESS_ALL_ACCESS, False, ProcessId);
            if ProcessHandle <> 0 then
            begin
              GetExitCodeProcess(ProcessHandle, ExitCode);
              TerminateProcess(ProcessHandle, ExitCode);
              CloseHandle(ProcessHandle);
            end;
          end;
          Break;
        end;
      end;
    finally
      List.Free;
    end;
  end;

Code von Sprint

[DieDolly]

Ich antworte nicht auf dein Problem aber auf etwas anderes.

Zitat:

procedure TTools.startasSU(exe, param : string);

Mich würde zu sehr interessieren, wie du TTools implementiert hast. Ich sehe, dass du die Starter verwendest. Du arbeitest also vermutlich nicht in einer großen Firma oder so.
Wenn TTools bei dir eine Klasse ist von der du eine Instanz erstellen musst empfehle ich dir, das zu einem Record umzuschreiben. Etwa so

Delphi-Quellcode:

type
 TTools = record
 public
  class procedure startasSU(exe, param : string); static;
 end;

implementation

class procedure TTools.startasSU(exe, param : string);
begin

end;

Aufruf dann überall über TTools.startasSU() .

[Schokohase]

@DieDolly

Warum zwanghaft ein Record?

Eine Klasse kann auch eine class procedure haben und der Aufruf ist gleich.

Es gibt allerdings einen Vorteil: Man kann eine Klasse vererben und dadurch eben erweitern. Bei einem Record geht das nicht.

[HolgerX]

Hmm..

[OT]

Zitat von DieDolly:

Delphi-Quellcode:

type
 TTools = record
 public
  class procedure startasSU(exe, param : string); static;
 end;

implementation

class procedure TTools.startasSU(exe, param : string);
begin

end;

Wieso nen Record ?

Delphi-Quellcode:

//oder
 TTools = class
 public
  class procedure startasSU(exe, param : string); static;
 end;

Ne class geht doch auch

[OT]

(Mist zu langsam.... )

[Moombas]

Delphi-Quellcode:

type
  TTools = class(TForm)

Ggf. hätte ich es einfach wie HolgerX/Schokohase aufrufen können. Nun aber bitte BTT

[DieDolly]

Zitat:

Ne class geht doch auch

Muss man dann nicht eine Instanz davon erstellen? Mit einem Record fällt das jedenfalls weg.