library bgexec;

type
  BOOL    = LongBool;
  DWORD   = LongWord;
  THandle = LongWord;
  PByte   = ^Byte;
  UINT    = LongWord;

  PStartupInfo = ^TStartupInfo;
  _STARTUPINFOA = record
    cb: DWORD;
    lpReserved: Pointer;
    lpDesktop: Pointer;
    lpTitle: Pointer;
    dwX: DWORD;
    dwY: DWORD;
    dwXSize: DWORD;
    dwYSize: DWORD;
    dwXCountChars: DWORD;
    dwYCountChars: DWORD;
    dwFillAttribute: DWORD;
    dwFlags: DWORD;
    wShowWindow: Word;
    cbReserved2: Word;
    lpReserved2: PByte;
    hStdInput: THandle;
    hStdOutput: THandle;
    hStdError: THandle;
  end;
  {$EXTERNALSYM _STARTUPINFOA}
  TStartupInfo = _STARTUPINFOA;
  STARTUPINFO = _STARTUPINFOA;
  {$EXTERNALSYM STARTUPINFO}


  PSecurityAttributes = ^TSecurityAttributes;
  _SECURITY_ATTRIBUTES = record
    nLength: DWORD;
    lpSecurityDescriptor: Pointer;
    bInheritHandle: BOOL;
  end;
  {$EXTERNALSYM _SECURITY_ATTRIBUTES}
  TSecurityAttributes = _SECURITY_ATTRIBUTES;
  SECURITY_ATTRIBUTES = _SECURITY_ATTRIBUTES;
  {$EXTERNALSYM SECURITY_ATTRIBUTES}


  PProcessInformation = ^TProcessInformation;
  _PROCESS_INFORMATION = record
    hProcess: THandle;
    hThread: THandle;
    dwProcessId: DWORD;
    dwThreadId: DWORD;
  end;
  {$EXTERNALSYM _PROCESS_INFORMATION}
  TProcessInformation = _PROCESS_INFORMATION;
  PROCESS_INFORMATION = _PROCESS_INFORMATION;
  {$EXTERNALSYM PROCESS_INFORMATION}


const
  INFINITE = DWORD($FFFFFFFF);     { Infinite timeout }
  {$EXTERNALSYM INFINITE}

  STATUS_TIMEOUT = $00000102;
  {$EXTERNALSYM STATUS_TIMEOUT}

  WAIT_TIMEOUT = STATUS_TIMEOUT;
  {$EXTERNALSYM WAIT_TIMEOUT}


const
  kernel32 = 'kernel32.dll';

function CloseHandle(hObject: THandle): BOOL; stdcall;
  external kernel32 name 'CloseHandle';
{$EXTERNALSYM CloseHandle}

function CreateProcess(lpApplicationName: PChar; lpCommandLine: PChar;
  lpProcessAttributes, lpThreadAttributes: PSecurityAttributes;
  bInheritHandles: BOOL; dwCreationFlags: DWORD; lpEnvironment: Pointer;
  lpCurrentDirectory: PChar; const lpStartupInfo: TStartupInfo;
  var lpProcessInformation: TProcessInformation): BOOL; stdcall;
  external kernel32 name 'CreateProcessA';
{$EXTERNALSYM CreateProcess}

function TerminateProcess(hProcess: THandle; uExitCode: UINT): BOOL; stdcall;
  external kernel32 name 'TerminateProcess';
{$EXTERNALSYM TerminateProcess}

function GetExitCodeProcess(hProcess: THandle; var lpExitCode: DWORD): BOOL; stdcall;
  external kernel32 name 'GetExitCodeProcess';
{$EXTERNALSYM GetExitCodeProcess}

function WaitForSingleObject(hHandle: THandle; dwMilliseconds: DWORD): DWORD; stdcall;
  external kernel32 name 'WaitForSingleObject';
{$EXTERNALSYM WaitForSingleObject}

const           
  TerminateExitCode = UINT(-1);
  
//function ExecCmd(lpCmdLine: PChar; var lpExitCode: DWORD;
//                 dwTimeOut: DWORD = INFINITE; bTerminate: BOOL = FALSE): BOOL; stdcall;
function ExecCmd(lpCmdLine: PChar; var lpExitCode: DWORD;
                 dwTimeOut: DWORD = INFINITE; bTerminate: BOOL = FALSE): BOOL; cdecl;
var
  xProcessInformation: TProcessInformation;
  xStartupInfo: TStartupInfo;
  xWaitResult: DWORD;
begin
  Result := FALSE;

  xProcessInformation.hProcess    := 0;
  xProcessInformation.hThread     := 0;
  xProcessInformation.dwProcessId := 0;
  xProcessInformation.dwThreadId  := 0;

  xStartupInfo.cb              := SizeOf(xStartupInfo);
  xStartupInfo.lpReserved      := nil;
  xStartupInfo.lpDesktop       := nil;
  xStartupInfo.lpTitle         := nil;
  xStartupInfo.dwX             := 0;
  xStartupInfo.dwY             := 0;
  xStartupInfo.dwXSize         := 0;
  xStartupInfo.dwYSize         := 0;
  xStartupInfo.dwXCountChars   := 0;
  xStartupInfo.dwYCountChars   := 0;
  xStartupInfo.dwFillAttribute := 0;
  xStartupInfo.dwFlags         := 0;
  xStartupInfo.wShowWindow     := 0;
  xStartupInfo.cbReserved2     := 0;
  xStartupInfo.lpReserved2     := nil;
  xStartupInfo.hStdInput       := 0;
  xStartupInfo.hStdOutput      := 0;
  xStartupInfo.hStdError       := 0;

  if CreateProcess(nil, lpCmdLine, nil, nil, TRUE, 0, nil, nil,
                   xStartupInfo, xProcessInformation) then
  begin
    xWaitResult := WaitForSingleObject(xProcessInformation.hProcess, dwTimeOut);

    GetExitCodeProcess(xProcessInformation.hProcess, lpExitCode);

    Result := xWaitResult <> WAIT_TIMEOUT;

    if not Result and bTerminate then
      TerminateProcess(xProcessInformation.hProcess, TerminateExitCode);

    CloseHandle(xProcessInformation.hThread);
    CloseHandle(xProcessInformation.hProcess);
  end;
end;

exports
  ExecCmd;

begin
end.