Subversion Repositories userdetect2

unit UD2_Obj;

interface

{$IF CompilerVersion >= 25.0}

{$LEGACYIFEND ON}

{$IFEND}

{$INCLUDE 'UserDetect2.inc'}

uses

  Windows, SysUtils, Classes, IniFiles, Contnrs, Dialogs, UD2_PluginIntf,

  UD2_PluginStatus, UD2_Utils;

type

  TUD2IdentificationEntry = class;

  TUD2Plugin = class(TObject)

  protected

    FDetectedIdentifications: TObjectList{<TUD2IdentificationEntry>};

  public

    // This flag will be set if "AutoOSNotSupportedCompatibility" of the INI manifest had to be enforced/used

    OSNotSupportedEnforced: boolean;

    PluginDLL: string;

    PluginGUID: TGUID;

    PluginName: WideString;

    PluginVendor: WideString;

    PluginVersion: WideString;

    IdentificationMethodName: WideString;

    // ONLY contains the non-failure status code of IdentificationStringW

    IdentificationProcedureStatusCode: UD2_STATUS;

    IdentificationProcedureStatusCodeDescribed: WideString;

    Time: Cardinal;

    function PluginGUIDString: string;

    property DetectedIdentifications: TObjectList{<TUD2IdentificationEntry>} read FDetectedIdentifications;

    destructor Destroy; override;

    constructor Create;

    function AddIdentification(IdStr: WideString): TUD2IdentificationEntry;

    function InvokeDynamicCheck(dynamicData: string): boolean;

    function GetDynamicRequestResult(dynamicData: string): TArrayOfString;

    function EqualsMethodNameOrGuid(idMethodNameOrGUID: string): boolean;

  end;

  TUD2IdentificationEntry = class(TObject)

  private

    FIdentificationString: WideString;

    FPlugin: TUD2Plugin;

    FDynamicDataUsed: boolean;

    FDynamicData: string;

  public

    property DynamicDataUsed: boolean read FDynamicDataUsed write FDynamicDataUsed;

    property DynamicData: string read FDynamicData write FDynamicData;

    property IdentificationString: WideString read FIdentificationString;

    property Plugin: TUD2Plugin read FPlugin;

    procedure GetIdNames(sl: TStrings);

    constructor Create(AIdentificationString: WideString; APlugin: TUD2Plugin);

  end;

  TUD2 = class(TObject)

  private

    {$IFDEF CHECK_FOR_SAME_PLUGIN_GUID}

    FGUIDLookup: TStrings;

    {$ENDIF}

  protected

    FLoadedPlugins: TObjectList{<TUD2Plugin>};

    FIniFile: TMemIniFile;

    FErrors: TStrings;

    FIniFileName: string;

  public

    property IniFileName: string read FIniFileName;

    property Errors: TStrings read FErrors;

    property LoadedPlugins: TObjectList{<TUD2Plugin>} read FLoadedPlugins;

    property IniFile: TMemIniFile read FIniFile;

    procedure GetAllDetectedIDs(outSL: TStrings);

    function FulfilsEverySubterm(idTerm: WideString; slIdNames: TStrings=nil): boolean;

    procedure CheckTerm(idTermAndCmd: string; commandSLout: TStrings; slIdNames: TStrings=nil);

    function FindPluginByMethodNameOrGuid(idMethodName: string): TUD2Plugin;

    procedure GetCommandList(ShortTaskName: string; outSL: TStrings);

    procedure HandlePluginDir(APluginDir, AFileMask: string);

    procedure GetTaskListing(outSL: TStrings);

    constructor Create(AIniFileName: string);

    destructor Destroy; override;

    function TaskExists(ShortTaskName: string): boolean;

    function ReadMetatagString(ShortTaskName, MetatagName: string; DefaultVal: string): string;

    function ReadMetatagBool(ShortTaskName, MetatagName: string; DefaultVal: string): boolean;

    function GetTaskName(AShortTaskName: string): string;

    class function GenericErrorLookup(grStatus: UD2_STATUS): string;

  end;

implementation

uses

  Math;

const

  cchBufferSize = 32768;

type

  TUD2PluginLoader = class(TThread)

  protected

    dllFile: string;

    lngID: LANGID;

    useDynamicData: boolean;

    dynamicData: WideString;

    procedure Execute; override;

    function HandleDLL: boolean;

  public

    pl: TUD2Plugin; // TODO: why do we need it?! can it be leaked if we use it for dynamic requests?

    Errors: TStringList;

    ResultIdentifiers: TArrayOfString;

    constructor Create(Suspended: boolean; DLL: string; alngid: LANGID; useDynamicData: boolean; dynamicData: WideString);

    destructor Destroy; override;

  end;

class function TUD2.GenericErrorLookup(grStatus: UD2_STATUS): string;

resourcestring

  LNG_STATUS_OK_UNSPECIFIED               = 'Success (Unspecified)';

  LNG_STATUS_OK_SINGLELINE                = 'Success (One identifier returned)';

  LNG_STATUS_OK_MULTILINE                 = 'Success (Multiple identifiers returned)';

  LNG_UNKNOWN_SUCCESS                     = 'Success (Unknown status code %s)';

  LNG_STATUS_NOTAVAIL_UNSPECIFIED         = 'Not available (Unspecified)';

  LNG_STATUS_NOTAVAIL_OS_NOT_SUPPORTED    = 'Not available (Operating system not supported)';

  LNG_STATUS_NOTAVAIL_HW_NOT_SUPPORTED    = 'Not available (Hardware not supported)';

  LNG_STATUS_NOTAVAIL_NO_ENTITIES         = 'Not available (No entities to identify)';

  LNG_STATUS_NOTAVAIL_WINAPI_CALL_FAILURE = 'Not available (A Windows API call failed. Message: %s)';

  LNG_STATUS_NOTAVAIL_ONLY_ACCEPT_DYNAMIC = 'Not available (Arguments required)';

  LNG_UNKNOWN_NOTAVAIL                    = 'Not available (Unknown status code %s)';

  LNG_STATUS_FAILURE_UNSPECIFIED          = 'Error (Unspecified)';

  LNG_STATUS_FAILURE_BUFFER_TOO_SMALL     = 'Error (The provided buffer is too small!)';

  LNG_STATUS_FAILURE_INVALID_ARGS         = 'Error (The function received invalid arguments!)';

  LNG_STATUS_FAILURE_PLUGIN_NOT_LICENSED  = 'Error (The plugin is not licensed)';

  LNG_STATUS_FAILURE_NO_RETURNED_VALUE    = 'Error (Plugin did not return a status)';

  LNG_STATUS_FAILURE_CATCHED_EXCEPTION    = 'Error (Catched unexpected Exception)';

  LNG_UNKNOWN_FAILED                      = 'Error (Unknown status code %s)';

  LNG_UNKNOWN_STATUS                      = 'Unknown status code with unexpected category: %s';

begin

       if UD2_STATUS_Equal(grStatus, UD2_STATUS_OK_UNSPECIFIED, false)               then result := LNG_STATUS_OK_UNSPECIFIED

  else if UD2_STATUS_Equal(grStatus, UD2_STATUS_OK_SINGLELINE, false)                then result := LNG_STATUS_OK_SINGLELINE

  else if UD2_STATUS_Equal(grStatus, UD2_STATUS_OK_MULTILINE, false)                 then result := LNG_STATUS_OK_MULTILINE

  else if UD2_STATUS_Equal(grStatus, UD2_STATUS_NOTAVAIL_UNSPECIFIED, false)         then result := LNG_STATUS_NOTAVAIL_UNSPECIFIED

  else if UD2_STATUS_Equal(grStatus, UD2_STATUS_NOTAVAIL_OS_NOT_SUPPORTED, false)    then result := LNG_STATUS_NOTAVAIL_OS_NOT_SUPPORTED

  else if UD2_STATUS_Equal(grStatus, UD2_STATUS_NOTAVAIL_HW_NOT_SUPPORTED, false)    then result := LNG_STATUS_NOTAVAIL_HW_NOT_SUPPORTED

  else if UD2_STATUS_Equal(grStatus, UD2_STATUS_NOTAVAIL_NO_ENTITIES, false)         then result := LNG_STATUS_NOTAVAIL_NO_ENTITIES

  else if UD2_STATUS_Equal(grStatus, UD2_STATUS_NOTAVAIL_WINAPI_CALL_FAILURE, false) then result := Format(LNG_STATUS_NOTAVAIL_WINAPI_CALL_FAILURE, [FormatOSError(grStatus.dwExtraInfo)])

  else if UD2_STATUS_Equal(grStatus, UD2_STATUS_NOTAVAIL_ONLY_ACCEPT_DYNAMIC, false) then result := LNG_STATUS_NOTAVAIL_ONLY_ACCEPT_DYNAMIC

  else if UD2_STATUS_Equal(grStatus, UD2_STATUS_FAILURE_UNSPECIFIED, false)          then result := LNG_STATUS_FAILURE_UNSPECIFIED

  else if UD2_STATUS_Equal(grStatus, UD2_STATUS_FAILURE_BUFFER_TOO_SMALL, false)     then result := LNG_STATUS_FAILURE_BUFFER_TOO_SMALL

  else if UD2_STATUS_Equal(grStatus, UD2_STATUS_FAILURE_INVALID_ARGS, false)         then result := LNG_STATUS_FAILURE_INVALID_ARGS

  else if UD2_STATUS_Equal(grStatus, UD2_STATUS_FAILURE_PLUGIN_NOT_LICENSED, false)  then result := LNG_STATUS_FAILURE_PLUGIN_NOT_LICENSED

  else if UD2_STATUS_Equal(grStatus, UD2_STATUS_FAILURE_NO_RETURNED_VALUE, false)    then result := LNG_STATUS_FAILURE_NO_RETURNED_VALUE

  else if UD2_STATUS_Equal(grStatus, UD2_STATUS_FAILURE_CATCHED_EXCEPTION, false)    then result := LNG_STATUS_FAILURE_CATCHED_EXCEPTION

  else if grStatus.wCategory = UD2_STATUSCAT_SUCCESS   then result := Format(LNG_UNKNOWN_SUCCESS,  [UD2_STATUS_FormatStatusCode(grStatus)])

  else if grStatus.wCategory = UD2_STATUSCAT_NOT_AVAIL then result := Format(LNG_UNKNOWN_NOTAVAIL, [UD2_STATUS_FormatStatusCode(grStatus)])

  else if grStatus.wCategory = UD2_STATUSCAT_FAILED    then result := Format(LNG_UNKNOWN_FAILED,   [UD2_STATUS_FormatStatusCode(grStatus)])

  else                                                      result := Format(LNG_UNKNOWN_STATUS,   [UD2_STATUS_FormatStatusCode(grStatus)]);

end;

{ TUD2Plugin }

function TUD2Plugin.PluginGUIDString: string;

begin

  result := UpperCase(GUIDToString(PluginGUID));

end;

function TUD2Plugin.AddIdentification(IdStr: WideString): TUD2IdentificationEntry;

begin

  result := TUD2IdentificationEntry.Create(IdStr, Self);

  DetectedIdentifications.Add(result);

end;

destructor TUD2Plugin.Destroy;

begin

  DetectedIdentifications.Free;

  inherited;

end;

constructor TUD2Plugin.Create;

begin

  inherited Create;

  FDetectedIdentifications := TObjectList{<TUD2IdentificationEntry>}.Create(true);

end;

function TUD2Plugin.InvokeDynamicCheck(dynamicData: string): boolean;

var

  ude: TUD2IdentificationEntry;

  i: integer;

  ids: TArrayOfString;

  id: string;

begin

  result := false;

  for i := 0 to FDetectedIdentifications.Count-1 do

  begin

    ude := FDetectedIdentifications.Items[i] as TUD2IdentificationEntry;

    if ude.dynamicDataUsed and (ude.dynamicData = dynamicData) then

    begin

      // The dynamic content was already evaluated (and therefore is already added in FDetectedIdentifications).

      Exit;

    end;

  end;

  SetLength(ids, 0);

  ids := GetDynamicRequestResult(dynamicData);

  for i := 0 to Length(ids)-1 do

  begin

    id := ids[i];

    ude := AddIdentification(id);

    ude.dynamicDataUsed := true;

    ude.dynamicData := dynamicData;

    result := true;

  end;

end;

function TUD2Plugin.GetDynamicRequestResult(dynamicData: string): TArrayOfString;

var

  lngID: LANGID;

  pll: TUD2PluginLoader;

begin

  lngID := GetSystemDefaultLangID;

  pll := TUD2PluginLoader.Create(false, PluginDLL, lngid, true, dynamicData);

  try

    pll.WaitFor;

    result := pll.ResultIdentifiers;

  finally

    pll.Free;

  end;

end;

function TUD2Plugin.EqualsMethodNameOrGuid(idMethodNameOrGUID: string): boolean;

begin

  result := SameText(IdentificationMethodName, idMethodNameOrGUID) or

            SameText(GUIDToString(PluginGUID), idMethodNameOrGUID)

end;

{ TUD2IdentificationEntry }

procedure TUD2IdentificationEntry.GetIdNames(sl: TStrings);

begin

  if DynamicDataUsed then

  begin

    sl.Add(Plugin.IdentificationMethodName+'('+DynamicData+'):'+IdentificationString);

    sl.Add(Plugin.PluginGUIDString+'('+DynamicData+'):'+IdentificationString);

  end

  else

  begin

    sl.Add(Plugin.IdentificationMethodName+':'+IdentificationString);

    sl.Add(Plugin.PluginGUIDString+':'+IdentificationString);

  end;

end;

constructor TUD2IdentificationEntry.Create(AIdentificationString: WideString;

  APlugin: TUD2Plugin);

begin

  inherited Create;

  FIdentificationString := AIdentificationString;

  FPlugin := APlugin;

end;

{ TUD2 }

procedure TUD2.HandlePluginDir(APluginDir, AFileMask: string);

Var

  SR: TSearchRec;

  path: string;

  pluginLoader: TUD2PluginLoader;

  tob: TObjectList;

  i: integer;

  {$IFDEF CHECK_FOR_SAME_PLUGIN_GUID}

  sPluginID, prevDLL: string;

  {$ENDIF}

  lngid: LANGID;

resourcestring

  LNG_PLUGINS_SAME_GUID = 'Attention: The plugin "%s" and the plugin "%s" have the same identification GUID. The latter will not be loaded.';

begin

  tob := TObjectList.Create;

  try

    tob.OwnsObjects := false;

    lngID := GetSystemDefaultLangID;

    path := APluginDir;

    if path <> '' then path := IncludeTrailingPathDelimiter(path);

    if FindFirst(path + AFileMask, 0, SR) = 0 then

    begin

      try

        repeat

          try

            tob.Add(TUD2PluginLoader.Create(false, path + sr.Name, lngid, false, ''));

          except

            on E: Exception do

            begin

              MessageDlg(E.Message, mtError, [mbOK], 0);

            end;

          end;

        until FindNext(SR) <> 0;

      finally

        FindClose(SR);

      end;

    end;

    for i := 0 to tob.count-1 do

    begin

      pluginLoader := tob.items[i] as TUD2PluginLoader;

      pluginLoader.WaitFor;

      Errors.AddStrings(pluginLoader.Errors);

      {$IFDEF CHECK_FOR_SAME_PLUGIN_GUID}

      if Assigned(pluginLoader.pl) then

      begin

        if not pluginLoader.pl.OSNotSupportedEnforced then

        begin

          sPluginID := GUIDToString(pluginLoader.pl.PluginGUID);

          prevDLL := FGUIDLookup.Values[sPluginID];

          if (prevDLL <> '') and (prevDLL <> pluginLoader.pl.PluginDLL) then

          begin

            Errors.Add(Format(LNG_PLUGINS_SAME_GUID, [prevDLL, pluginLoader.pl.PluginDLL]));

            pluginLoader.pl.Free;

          end

          else

          begin

            FGUIDLookup.Values[sPluginID] := pluginLoader.pl.PluginDLL;

            LoadedPlugins.Add(pluginLoader.pl);

          end;

        end;

      end;

      {$ENDIF}

      pluginLoader.Free;

    end;

  finally

    tob.free;

  end;

end;

destructor TUD2.Destroy;

begin

  FIniFile.Free;

  FLoadedPlugins.Free;

  {$IFDEF CHECK_FOR_SAME_PLUGIN_GUID}

  FGUIDLookup.Free;

  {$ENDIF}

  FErrors.Free;

end;

constructor TUD2.Create(AIniFileName: string);

begin

  FIniFileName := AIniFileName;

  FLoadedPlugins := TObjectList{<TUD2Plugin>}.Create(true);

  FIniFile := TMemIniFile.Create(IniFileName);

  {$IFDEF CHECK_FOR_SAME_PLUGIN_GUID}

  FGUIDLookup := TStringList.Create;

  {$ENDIF}

  FErrors := TStringList.Create;

end;

function TUD2.GetTaskName(AShortTaskName: string): string;

resourcestring

  LNG_NO_DESCRIPTION = '(%s)';

begin

  result := FIniFile.ReadString(AShortTaskName, 'Description', Format(LNG_NO_DESCRIPTION, [AShortTaskName]));

end;

procedure TUD2.GetTaskListing(outSL: TStrings);

var

  sl: TStringList;

  i: integer;

  desc: string;

begin

  sl := TStringList.Create;

  try

    FIniFile.ReadSections(sl);

    for i := 0 to sl.Count-1 do

    begin

      desc := GetTaskName(sl.Strings[i]);

      outSL.Values[sl.Strings[i]] := desc;

    end;

  finally

    sl.Free;

  end;

end;

function TUD2.TaskExists(ShortTaskName: string): boolean;

begin

  result := FIniFile.SectionExists(ShortTaskName);

end;

function TUD2.ReadMetatagString(ShortTaskName, MetatagName: string;

  DefaultVal: string): string;

begin

  result := IniFile.ReadString(ShortTaskName, MetatagName, DefaultVal);

end;

function TUD2.ReadMetatagBool(ShortTaskName, MetatagName: string;

  DefaultVal: string): boolean;

begin

  // DefaultVal is a string, because we want to allow an empty string, in case the

  // user wishes an Exception in case the string is not a valid boolean string

  result := BetterInterpreteBool(IniFile.ReadString(ShortTaskName, MetatagName, DefaultVal));

end;

(*

NAMING EXAMPLE: $CASESENSITIVE$ComputerName(dynXYZ):ABC&&User:John=calc.exe$RIOD$

        idTerm:       ComputerName(dynXYZ):ABC&&User:John

        idName:       ComputerName:ABC

        IdMethodName: ComputerName

        IdStr         ABC

        cmd:          calc.exe

        dynamicData:  dynXYZ

*)

procedure TUD2.GetAllDetectedIDs(outSL: TStrings);

var

  i, j: integer;

  pl: TUD2Plugin;

  ude: TUD2IdentificationEntry;

begin

  for i := 0 to LoadedPlugins.Count-1 do

  begin

    pl := LoadedPlugins.Items[i] as TUD2Plugin;

    for j := 0 to pl.DetectedIdentifications.Count-1 do

    begin

      ude := pl.DetectedIdentifications.Items[j] as TUD2IdentificationEntry;

      ude.GetIdNames(outSL);

    end;

  end;

end;

function TUD2.FulfilsEverySubterm(idTerm: WideString; slIdNames: TStrings=nil): boolean;

const

  CASE_SENSITIVE_FLAG = '$CASESENSITIVE$';

var

  x, a, b: TArrayOfString;

  i: integer;

  p: TUD2Plugin;

  idName: WideString;

  cleanUpStringList: boolean;

  caseSensitive: boolean;

  dynamicData: string;

  idMethodName: string;

begin

  cleanUpStringList := slIdNames = nil;

  try

    if cleanUpStringList then

    begin

      slIdNames := TStringList.Create;

      GetAllDetectedIDs(slIdNames);

    end;

    SetLength(x, 0);

    if Pos(':', idTerm) = 0 then

    begin

      // Exclude stuff like "Description"

      result := false;

      Exit;

    end;

    x := SplitString('&&', idTerm);

    result := true;

    for i := Low(x) to High(x) do

    begin

      idName := x[i];

      /// --- Start Dynamic Extension

      // xxxxxx ( xxxxx ):  xxxxxxxxxxxx

      // xxxxx  ( xx:xx ):  xxxxx:xxx(x)

      // xxxxxxxxxxxx    :  xxxxx(xxx)xx

      SetLength(a, 0);

      a := SplitString('(', idName);

      if (Length(a) >= 2) and (Pos(':', a[0]) = 0) then

      begin

        SetLength(b, 0);

        b := SplitString('):', a[1]);

        if Length(b) >= 2 then

        begin

          dynamicData := b[0];

          idMethodName := a[0];

          p := FindPluginByMethodNameOrGuid(idMethodName);

          if Assigned(p) then

          begin

            if p.InvokeDynamicCheck(dynamicData) then

            begin

              // Reload the identifications

              slIdNames.Clear;

              GetAllDetectedIDs(slIdNames);

            end;

          end;

        end;

      end;

      /// --- End Dynamic Extension

      if Pos(CASE_SENSITIVE_FLAG, idName) >= 1 then

      begin

        idName := StringReplace(idName, CASE_SENSITIVE_FLAG, '', [rfReplaceAll]);

        caseSensitive := true;

      end

      else

      begin

        caseSensitive := false;

      end;

      if (not caseSensitive and (slIdNames.IndexOf(idName) = -1)) or

         (caseSensitive and (IndexOf_CS(slIdNames, idName) = -1)) then

      begin

        result := false;

        break;

      end;

    end;

  finally

    if cleanUpStringList and Assigned(slIdNames) then

      slIdNames.Free;

  end;

end;

function TUD2.FindPluginByMethodNameOrGuid(idMethodName: string): TUD2Plugin;

var

  i: integer;

  p: TUD2Plugin;

begin

  result := nil;

  for i := 0 to LoadedPlugins.Count-1 do

  begin

    p := LoadedPlugins.Items[i] as TUD2Plugin;

    if p.EqualsMethodNameOrGuid(idMethodName) then

    begin

      result := p;

      Exit;

    end;

  end;

end;

procedure TUD2.GetCommandList(ShortTaskName: string; outSL: TStrings);

var

  i: integer;

  slSV, slIdNames: TStrings;

begin

  slIdNames := TStringList.Create;

  try

    GetAllDetectedIDs(slIdNames);

    slSV := TStringList.Create;

    try

      FIniFile.ReadSectionValues(ShortTaskName, slSV);

      for i := 0 to slSV.Count-1 do

      begin

        CheckTerm(slSV.Strings[i], outSL, slIdNames);

      end;

    finally

      slSV.Free;

    end;

  finally

    slIdNames.Free;

  end;

end;

procedure TUD2.CheckTerm(idTermAndCmd: string; commandSLout: TStrings; slIdNames: TStrings=nil);

var

  nameVal: TArrayOfString;

  idTerm, cmd: string;

  slIdNamesCreated: boolean;

begin

  slIdNamesCreated := false;

  try

    if not Assigned(slIdNames) then

    begin

      slIdNamesCreated := true;

      slIdNames := TStringList.Create;

      GetAllDetectedIDs(slIdNames);

    end;

    SetLength(nameVal, 0);

    // We are doing the interpretation of the line ourselves, because

    // TStringList.Values[] would not allow multiple command lines with the

    // same key (idTerm)

    // TODO xxx: big problem when we want to check environment variables, since our idTerm would contain '=' !

    nameVal := SplitString('=', idTermAndCmd);

    if Length(nameVal) < 2 then exit;

    idTerm := nameVal[0];

    cmd    := nameVal[1];

    if FulfilsEverySubterm(idTerm, slIdNames) then commandSLout.Add(cmd);

  finally

    if slIdNamesCreated then slIdNames.Free;

  end;

end;

{ TUD2PluginLoader }

procedure TUD2PluginLoader.Execute;

begin

  inherited;

  HandleDLL;

end;

constructor TUD2PluginLoader.Create(Suspended: boolean; DLL: string; alngid: LANGID; useDynamicData: boolean; dynamicData: WideString);

begin

  inherited Create(Suspended);

  dllfile := dll;

  pl := nil;

  Errors := TStringList.Create;

  lngid := alngid;

  self.useDynamicData := useDynamicData;

  Self.dynamicData := dynamicData;

end;

destructor TUD2PluginLoader.Destroy;

begin

  Errors.Free;

  inherited;

end;

function TUD2PluginLoader.HandleDLL: boolean;

var

  sIdentifier: WideString;

  buf: array[0..cchBufferSize-1] of WideChar;

  pluginInterfaceID: TGUID;

  dllHandle: Cardinal;

  fPluginInterfaceID: TFuncPluginInterfaceID;

  fPluginIdentifier: TFuncPluginIdentifier;

  fPluginNameW: TFuncPluginNameW;

  fPluginVendorW: TFuncPluginVendorW;

  fPluginVersionW: TFuncPluginVersionW;

  fIdentificationMethodNameW: TFuncIdentificationMethodNameW;

  fIdentificationStringW: TFuncIdentificationStringW;

  fDynamicIdentificationStringW: TFuncDynamicIdentificationStringW;

  fCheckLicense: TFuncCheckLicense;

  fDescribeOwnStatusCodeW: TFuncDescribeOwnStatusCodeW;

  statusCode: UD2_STATUS;

  i: integer;

  starttime, endtime, time: cardinal;

  bakErrorMode: DWORD;

  err: DWORD;

  function _ErrorLookup(statusCode: UD2_STATUS): WideString;

  var

    ret: BOOL;

    buf: array[0..cchBufferSize-1] of WideChar;

  begin

    if Assigned(fDescribeOwnStatusCodeW) then

    begin

      ZeroMemory(@buf, cchBufferSize);

      ret := fDescribeOwnStatusCodeW(@buf, cchBufferSize, statusCode, lngID);

      if ret then

      begin

        result := PWideChar(@buf);

        Exit;

      end;

    end;

    result := TUD2.GenericErrorLookup(statusCode);

  end;

  function _ApplyCompatibilityGUID: boolean;

  var

    iniConfig: TIniFile;

    sOverrideGUID: string;

    sPluginConfigFile: string;

  begin

    result := false;

    sPluginConfigFile := ChangeFileExt(dllFile, '.ini');

    if FileExists(sPluginConfigFile) then

    begin

      iniConfig := TIniFile.Create(sPluginConfigFile);

      try

        sOverrideGUID := iniConfig.ReadString('Compatibility', 'OverrideGUID', '');

        if sOverrideGUID <> '' then

        begin

          pl.PluginGUID := StringToGUID(sOverrideGUID);

          result := true;

        end;

      finally

        iniConfig.Free;

      end;

    end;

  end;

  function _AutoOSNotSupportedMode: integer;

  var

    iniConfig: TIniFile;

    sPluginConfigFile: string;

  begin

    result := 0;

    sPluginConfigFile := ChangeFileExt(dllFile, '.ini');

    if FileExists(sPluginConfigFile) then

    begin

      iniConfig := TIniFile.Create(sPluginConfigFile);

      try

        result := iniConfig.ReadInteger('Compatibility', 'AutoOSNotSupported', 0);

      finally

        iniConfig.Free;

      end;

    end;

  end;

  procedure _OverwriteStatusToOSNotSupported;

  begin

    pl := TUD2Plugin.Create;

    pl.PluginDLL := dllFile;

    statusCode := UD2_STATUS_NOTAVAIL_OS_NOT_SUPPORTED;

    pl.IdentificationProcedureStatusCode := statusCode;

    pl.IdentificationProcedureStatusCodeDescribed := _ErrorLookup(statusCode);

    (*

    if not _ApplyCompatibilityGUID then

    begin

      CreateGUID(pl.PluginGUID); // to avoid the "double GUID" error