WebSVN – userdetect2 – Diff – /trunk/UserDetect2/UD2_Obj.pas


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, UD2_Parsing;
 
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(conds: TUD2TDFConditionArray; slIdNames: TStrings=nil): boolean; overload;
    function FulfilsEverySubterm(idTerm: WideString; slIdNames: TStrings=nil): boolean; overload;
    function CheckTerm(idTermAndCmd: string; slIdNames: TStrings=nil): TUD2CommandArray;
    function FindPluginByMethodNameOrGuid(idMethodName: string): TUD2Plugin;
    function GetCommandList(ShortTaskName: string): TUD2CommandArray;
    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);
var
  cond: TUD2TDFCondition;
begin
  cond.idMethodName := Plugin.IdentificationMethodName;
  cond.idStr := IdentificationString;
  cond.dynamicDataUsed := DynamicDataUsed;
  cond.dynamicData := DynamicData;
  sl.Add(UD2_CondToStr(cond));
 
 
  cond.idMethodName := Plugin.PluginGUIDString;
  sl.Add(UD2_CondToStr(cond));
 
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(conds: TUD2TDFConditionArray; slIdNames: TStrings=nil): boolean;
begin
  result := FulfilsEverySubterm(UD2_CondsToStr(conds), slIdNames);
end;
 
function TUD2.FulfilsEverySubterm(idTerm: WideString; slIdNames: TStrings=nil): boolean;
 
 
var
 
  i: integer;
  p: TUD2Plugin;
 
  cleanUpStringList: boolean;
  conds: TUD2TDFConditionArray;
  cond: TUD2TDFCondition;
  idName: string;
begin
  cleanUpStringList := slIdNames = nil;
  try
    if cleanUpStringList then
    begin
      slIdNames := TStringList.Create;
      GetAllDetectedIDs(slIdNames);
    end;
 
 
 
 
    conds := UD2P_ParseConditions(idTerm);
 
 
 
 
    result := true;
    for i := Low(conds) to High(conds) do
    begin
      cond := conds[i];
 
 
 
 
 
 
 
 
      if cond.dynamicDataUsed then
 
      begin
 
 
 
 
 
 
 
        p := FindPluginByMethodNameOrGuid(cond.idMethodName);
        if Assigned(p) then
        begin
          if p.InvokeDynamicCheck(cond.dynamicData) then
          begin
            // Reload the identifications
            slIdNames.Clear;
            GetAllDetectedIDs(slIdNames);
          end;
        end;
      end;
 
 
 
 
 
 
 
      idName := UD2_CondToStr(cond);
 
 
 
 
 
 
      if (not cond.caseSensitive and (slIdNames.IndexOf(idName) = -1)) or
         (cond.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;
 
function TUD2.GetCommandList(ShortTaskName: string): TUD2CommandArray;
var
  i, j, l: integer;
  slSV, slIdNames: TStrings;
  tmpCmds: TUD2CommandArray;
begin
  SetLength(result, 0);
  SetLength(tmpCmds, 0);
 
  slIdNames := TStringList.Create;
  try
    GetAllDetectedIDs(slIdNames);
 
    slSV := TStringList.Create;
    try
      FIniFile.ReadSectionValues(ShortTaskName, slSV);
      for i := 0 to slSV.Count-1 do
      begin
        tmpCmds := CheckTerm(slSV.Strings[i], slIdNames);
        for j := Low(tmpCmds) to High(tmpCmds) do
        begin
          l := Length(result);
          SetLength(result, l+1);
          result[l] := tmpCmds[j];
        end;
      end;
    finally
      slSV.Free;
    end;
  finally
    slIdNames.Free;
  end;
end;
 
function TUD2.CheckTerm(idTermAndCmd: string; slIdNames: TStrings=nil): TUD2CommandArray;
var
 
 
  slIdNamesCreated: boolean;
  ent: TUD2TDFEntry;
begin
  SetLength(result, 0);
 
  slIdNamesCreated := false;
  try
    if not Assigned(slIdNames) then
    begin
      slIdNamesCreated := true;
      slIdNames := TStringList.Create;
      GetAllDetectedIDs(slIdNames);
    end;
 
 
 
    if not UD2P_ParseTdfLine(idTermAndCmd, ent) then Exit;
    if FulfilsEverySubterm(ent.ids, slIdNames) then
    begin
 
 
 
      result := ent.commands;
    end;
 
 
  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
    end;
    *)
    pl.OSNotSupportedEnforced := true; // to avoid the "double GUID" error
    result := true;
  end;
 
resourcestring
  LNG_DLL_NOT_LOADED = 'Plugin DLL "%s" could not be loaded: %s';
  LNG_METHOD_NOT_FOUND = 'Method "%s" not found in plugin "%s". The DLL is probably not a valid plugin DLL.';
  LNG_INVALID_PLUGIN = 'The plugin "%s" is not a valid plugin for this application.';
  LNG_METHOD_FAILURE = 'Error "%s" at method "%s" of plugin "%s".';
  LNG_EXCEPTION = 'Fatal error while loading "%s" (%s: %s)';
begin
  result := false;
  startTime := GetTickCount;
 
  try
    bakErrorMode := 0;
    UD2_SetThreadErrorMode(SEM_FAILCRITICALERRORS, Pointer(bakErrorMode));
    try
      dllHandle := LoadLibrary(PChar(dllFile));
      if dllHandle = 0 then
      begin
        err := GetLastError;
 
        if ((_AutoOSNotSupportedMode = 1) and ((err = ERROR_DLL_NOT_FOUND) or (err = ERROR_PROC_NOT_FOUND))) or
           (_AutoOSNotSupportedMode >= 2) then
        begin
          _OverwriteStatusToOSNotSupported;
          Exit;
        end;
 
        Errors.Add(Format(LNG_DLL_NOT_LOADED, [dllFile, SysErrorMessage(err)]));
        Exit;
      end;
      try
        @fPluginInterfaceID := GetProcAddress(dllHandle, mnPluginInterfaceID);
        if not Assigned(fPluginInterfaceID) then
        begin
          Errors.Add(Format(LNG_METHOD_NOT_FOUND, [mnPluginInterfaceID, dllFile]));
          Exit;
        end;
        pluginInterfaceID := fPluginInterfaceID();
        if not IsEqualGUID(pluginInterfaceID, GUID_USERDETECT2_IDPLUGIN_V1) then
        begin
          Errors.Add(Format(LNG_INVALID_PLUGIN, [dllFile]));
          Exit;
        end;
 
        fDynamicIdentificationStringW := nil;
        fIdentificationStringW := nil;
        if useDynamicData then
        begin
          @fDynamicIdentificationStringW := GetProcAddress(dllHandle, mnDynamicIdentificationStringW);
          if not Assigned(fDynamicIdentificationStringW) then
          begin
            // TODO xxx: Darf hier ein fataler Fehler entstehen, obwohl dieses Szenario nur durch die INI file auftreten kann?
            // TODO (allgemein): In der Modulübersicht soll auch gezeigt werden, ob dieses Modul dynamischen Content erlaubt.
            // TODO (allgemein): doku
            Errors.Add(Format(LNG_METHOD_NOT_FOUND, [mnDynamicIdentificationStringW, dllFile]));
            Exit;
          end;
        end
        else
        begin
          @fIdentificationStringW := GetProcAddress(dllHandle, mnIdentificationStringW);
          if not Assigned(fIdentificationStringW) then
          begin
            Errors.Add(Format(LNG_METHOD_NOT_FOUND, [mnIdentificationStringW, dllFile]));
            Exit;
          end;
        end;
 
        @fPluginNameW := GetProcAddress(dllHandle, mnPluginNameW);
        if not Assigned(fPluginNameW) then
        begin
          Errors.Add(Format(LNG_METHOD_NOT_FOUND, [mnPluginNameW, dllFile]));
          Exit;
        end;
 
        @fPluginVendorW := GetProcAddress(dllHandle, mnPluginVendorW);
        if not Assigned(fPluginVendorW) then
        begin
          Errors.Add(Format(LNG_METHOD_NOT_FOUND, [mnPluginVendorW, dllFile]));
          Exit;
        end;
 
        @fPluginVersionW := GetProcAddress(dllHandle, mnPluginVersionW);
        if not Assigned(fPluginVersionW) then
        begin
          Errors.Add(Format(LNG_METHOD_NOT_FOUND, [mnPluginVersionW, dllFile]));
          Exit;
        end;
 
        @fCheckLicense := GetProcAddress(dllHandle, mnCheckLicense);
        if not Assigned(fCheckLicense) then
        begin
          Errors.Add(Format(LNG_METHOD_NOT_FOUND, [mnCheckLicense, dllFile]));
          Exit;
        end;
 
        @fIdentificationMethodNameW := GetProcAddress(dllHandle, mnIdentificationMethodNameW);
        if not Assigned(fIdentificationMethodNameW) then
        begin
          Errors.Add(Format(LNG_METHOD_NOT_FOUND, [mnIdentificationMethodNameW, dllFile]));
          Exit;
        end;
 
        @fDescribeOwnStatusCodeW := GetProcAddress(dllHandle, mnDescribeOwnStatusCodeW);
        if not Assigned(fDescribeOwnStatusCodeW) then
        begin
          Errors.Add(Format(LNG_METHOD_NOT_FOUND, [mnDescribeOwnStatusCodeW, dllFile]));
          Exit;
        end;
 
        pl := TUD2Plugin.Create;
        pl.PluginDLL := dllFile;
 
        if not _ApplyCompatibilityGUID then
        begin
          @fPluginIdentifier := GetProcAddress(dllHandle, mnPluginIdentifier);
          if not Assigned(fPluginIdentifier) then
          begin
            Errors.Add(Format(LNG_METHOD_NOT_FOUND, [mnPluginIdentifier, dllFile]));
            Exit;
          end;
          pl.PluginGUID := fPluginIdentifier();
        end;
 
        statusCode := fCheckLicense(nil);
        if statusCode.wCategory = UD2_STATUSCAT_FAILED then
        begin
          Errors.Add(Format(LNG_METHOD_FAILURE, [_ErrorLookup(statusCode), mnCheckLicense, dllFile]));
          Exit;
        end;
 
        ZeroMemory(@buf, cchBufferSize);
        statusCode := fPluginNameW(@buf, cchBufferSize, lngID);
             if statusCode.wCategory = UD2_STATUSCAT_SUCCESS   then pl.PluginName := PWideChar(@buf)
        else if statusCode.wCategory = UD2_STATUSCAT_NOT_AVAIL then pl.PluginName := ''
        else
        begin
          Errors.Add(Format(LNG_METHOD_FAILURE, [_ErrorLookup(statusCode), mnPluginNameW, dllFile]));
          Exit;
        end;
 
        ZeroMemory(@buf, cchBufferSize);
        statusCode := fPluginVendorW(@buf, cchBufferSize, lngID);
             if statusCode.wCategory = UD2_STATUSCAT_SUCCESS   then pl.PluginVendor := PWideChar(@buf)
        else if statusCode.wCategory = UD2_STATUSCAT_NOT_AVAIL then pl.PluginVendor := ''
        else
        begin
          Errors.Add(Format(LNG_METHOD_FAILURE, [_ErrorLookup(statusCode), mnPluginVendorW, dllFile]));
          Exit;
        end;
 
        ZeroMemory(@buf, cchBufferSize);
        statusCode := fPluginVersionW(@buf, cchBufferSize, lngID);
             if statusCode.wCategory = UD2_STATUSCAT_SUCCESS   then pl.PluginVersion := PWideChar(@buf)
        else if statusCode.wCategory = UD2_STATUSCAT_NOT_AVAIL then pl.PluginVersion := ''
        else
        begin
          Errors.Add(Format(LNG_METHOD_FAILURE, [_ErrorLookup(statusCode), mnPluginVersionW, dllFile]));
          Exit;
        end;
 
        ZeroMemory(@buf, cchBufferSize);
        statusCode := fIdentificationMethodNameW(@buf, cchBufferSize);
             if statusCode.wCategory = UD2_STATUSCAT_SUCCESS   then pl.IdentificationMethodName := PWideChar(@buf)
        else if statusCode.wCategory = UD2_STATUSCAT_NOT_AVAIL then pl.IdentificationMethodName := ''
        else
        begin
          Errors.Add(Format(LNG_METHOD_FAILURE, [_ErrorLookup(statusCode), mnIdentificationMethodNameW, dllFile]));
          Exit;
        end;
 
        ZeroMemory(@buf, cchBufferSize);
        statusCode := UD2_STATUS_FAILURE_NO_RETURNED_VALUE; // This status will be used when the DLL does not return anything (which is an error by the developer)
        if useDynamicData then
        begin
          statusCode := fDynamicIdentificationStringW(@buf, cchBufferSize, PWideChar(dynamicData));
        end
        else
        begin
          statusCode := fIdentificationStringW(@buf, cchBufferSize);
        end;
        pl.IdentificationProcedureStatusCode := statusCode;
        pl.IdentificationProcedureStatusCodeDescribed := _ErrorLookup(statusCode);
        if statusCode.wCategory = UD2_STATUSCAT_SUCCESS then
        begin
          sIdentifier := PWideChar(@buf);
          if UD2_STATUS_Equal(statusCode, UD2_STATUS_OK_MULTILINE, false) then
          begin
            // Multiple identifiers (e.g. multiple MAC addresses are delimited via UD2_MULTIPLE_ITEMS_DELIMITER)
            SetLength(ResultIdentifiers, 0);
            ResultIdentifiers := SplitString(UD2_MULTIPLE_ITEMS_DELIMITER, sIdentifier);
            for i := Low(ResultIdentifiers) to High(ResultIdentifiers) do
            begin
              pl.AddIdentification(ResultIdentifiers[i]);
            end;
          end
          else
          begin
            pl.AddIdentification(sIdentifier);
 
            SetLength(ResultIdentifiers, 1);
            ResultIdentifiers[0] := sIdentifier;
          end;
        end
        else if statusCode.wCategory <> UD2_STATUSCAT_NOT_AVAIL then
        begin
          if _AutoOSNotSupportedMode >= 3 then
          begin
            _OverwriteStatusToOSNotSupported;
            Exit;
          end;
 
          // Errors.Add(Format(LNG_METHOD_FAILURE, [_ErrorLookup(statusCode), mnIdentificationStringW, dllFile]));
          Errors.Add(Format(LNG_METHOD_FAILURE, [pl.IdentificationProcedureStatusCodeDescribed, mnIdentificationStringW, dllFile]));
          Exit;
        end;
 
        result := true;
      finally
        if not result and Assigned(pl) then FreeAndNil(pl);
        FreeLibrary(dllHandle);
      end;
    finally
      UD2_SetThreadErrorMode(bakErrorMode, nil);
 
      if result then
      begin
        endtime := GetTickCount;
        time := endtime - starttime;
        if endtime < starttime then time := High(Cardinal) - time;
        pl.time := time;
      end;
    end;
  except
    // TODO: when an exception happens in a cdecl DLL, then this code is somehow not
    // executed. Probably the memory is corrupted. Anyway, a cdecl DLL shall NEVER
    // raise an Exception.
    on E: Exception do
    begin
      Errors.Add(Format(LNG_EXCEPTION, [dllFile, E.ClassName, E.Message]));
      Exit;
    end;
  end;
end;
 
end.
 

Rev 84	Rev 85
1	unit UD2_Obj;	1	unit UD2_Obj;
2		2
3	interface	3	interface
4		4
5	{$IF CompilerVersion >= 25.0}	5	{$IF CompilerVersion >= 25.0}
6	{$LEGACYIFEND ON}	6	{$LEGACYIFEND ON}
7	{$IFEND}	7	{$IFEND}
8		8
9	{$INCLUDE 'UserDetect2.inc'}	9	{$INCLUDE 'UserDetect2.inc'}
10		10
11	uses	11	uses
12	Windows, SysUtils, Classes, IniFiles, Contnrs, Dialogs, UD2_PluginIntf,	12	Windows, SysUtils, Classes, IniFiles, Contnrs, Dialogs, UD2_PluginIntf,
13	UD2_PluginStatus, UD2_Utils;	13	UD2_PluginStatus, UD2_Utils, UD2_Parsing;
14		14
15	type	15	type
16	TUD2IdentificationEntry = class;	16	TUD2IdentificationEntry = class;
17		17
18	TUD2Plugin = class(TObject)	18	TUD2Plugin = class(TObject)
19	protected	19	protected
20	FDetectedIdentifications: TObjectList{<TUD2IdentificationEntry>};	20	FDetectedIdentifications: TObjectList{<TUD2IdentificationEntry>};
21	public	21	public
22	// This flag will be set if "AutoOSNotSupportedCompatibility" of the INI manifest had to be enforced/used	22	// This flag will be set if "AutoOSNotSupportedCompatibility" of the INI manifest had to be enforced/used
23	OSNotSupportedEnforced: boolean;	23	OSNotSupportedEnforced: boolean;
24		24
25	PluginDLL: string;	25	PluginDLL: string;
26	PluginGUID: TGUID;	26	PluginGUID: TGUID;
27	PluginName: WideString;	27	PluginName: WideString;
28	PluginVendor: WideString;	28	PluginVendor: WideString;
29	PluginVersion: WideString;	29	PluginVersion: WideString;
30	IdentificationMethodName: WideString;	30	IdentificationMethodName: WideString;
31		31
32	// ONLY contains the non-failure status code of IdentificationStringW	32	// ONLY contains the non-failure status code of IdentificationStringW
33	IdentificationProcedureStatusCode: UD2_STATUS;	33	IdentificationProcedureStatusCode: UD2_STATUS;
34	IdentificationProcedureStatusCodeDescribed: WideString;	34	IdentificationProcedureStatusCodeDescribed: WideString;
35		35
36	Time: Cardinal;	36	Time: Cardinal;
37	function PluginGUIDString: string;	37	function PluginGUIDString: string;
38	property DetectedIdentifications: TObjectList{<TUD2IdentificationEntry>} read FDetectedIdentifications;	38	property DetectedIdentifications: TObjectList{<TUD2IdentificationEntry>} read FDetectedIdentifications;
39	destructor Destroy; override;	39	destructor Destroy; override;
40	constructor Create;	40	constructor Create;
41	function AddIdentification(IdStr: WideString): TUD2IdentificationEntry;	41	function AddIdentification(IdStr: WideString): TUD2IdentificationEntry;
42		42
43	function InvokeDynamicCheck(dynamicData: string): boolean;	43	function InvokeDynamicCheck(dynamicData: string): boolean;
44	function GetDynamicRequestResult(dynamicData: string): TArrayOfString;	44	function GetDynamicRequestResult(dynamicData: string): TArrayOfString;
45		45
46	function EqualsMethodNameOrGuid(idMethodNameOrGUID: string): boolean;	46	function EqualsMethodNameOrGuid(idMethodNameOrGUID: string): boolean;
47	end;	47	end;
48		48
49	TUD2IdentificationEntry = class(TObject)	49	TUD2IdentificationEntry = class(TObject)
50	private	50	private
51	FIdentificationString: WideString;	51	FIdentificationString: WideString;
52	FPlugin: TUD2Plugin;	52	FPlugin: TUD2Plugin;
53	FDynamicDataUsed: boolean;	53	FDynamicDataUsed: boolean;
54	FDynamicData: string;	54	FDynamicData: string;
55	public	55	public
56	property DynamicDataUsed: boolean read FDynamicDataUsed write FDynamicDataUsed;	56	property DynamicDataUsed: boolean read FDynamicDataUsed write FDynamicDataUsed;
57	property DynamicData: string read FDynamicData write FDynamicData;	57	property DynamicData: string read FDynamicData write FDynamicData;
58	property IdentificationString: WideString read FIdentificationString;	58	property IdentificationString: WideString read FIdentificationString;
59	property Plugin: TUD2Plugin read FPlugin;	59	property Plugin: TUD2Plugin read FPlugin;
60	procedure GetIdNames(sl: TStrings);	60	procedure GetIdNames(sl: TStrings);
61	constructor Create(AIdentificationString: WideString; APlugin: TUD2Plugin);	61	constructor Create(AIdentificationString: WideString; APlugin: TUD2Plugin);
62	end;	62	end;
63		63
64	TUD2 = class(TObject)	64	TUD2 = class(TObject)
65	private	65	private
66	{$IFDEF CHECK_FOR_SAME_PLUGIN_GUID}	66	{$IFDEF CHECK_FOR_SAME_PLUGIN_GUID}
67	FGUIDLookup: TStrings;	67	FGUIDLookup: TStrings;
68	{$ENDIF}	68	{$ENDIF}
69	protected	69	protected
70	FLoadedPlugins: TObjectList{<TUD2Plugin>};	70	FLoadedPlugins: TObjectList{<TUD2Plugin>};
71	FIniFile: TMemIniFile;	71	FIniFile: TMemIniFile;
72	FErrors: TStrings;	72	FErrors: TStrings;
73	FIniFileName: string;	73	FIniFileName: string;
74	public	74	public
75	property IniFileName: string read FIniFileName;	75	property IniFileName: string read FIniFileName;
76	property Errors: TStrings read FErrors;	76	property Errors: TStrings read FErrors;
77	property LoadedPlugins: TObjectList{<TUD2Plugin>} read FLoadedPlugins;	77	property LoadedPlugins: TObjectList{<TUD2Plugin>} read FLoadedPlugins;
78	property IniFile: TMemIniFile read FIniFile;	78	property IniFile: TMemIniFile read FIniFile;
79	procedure GetAllDetectedIDs(outSL: TStrings);	79	procedure GetAllDetectedIDs(outSL: TStrings);
-		80	function FulfilsEverySubterm(conds: TUD2TDFConditionArray; slIdNames: TStrings=nil): boolean; overload;
80	function FulfilsEverySubterm(idTerm: WideString; slIdNames: TStrings=nil): boolean;	81	function FulfilsEverySubterm(idTerm: WideString; slIdNames: TStrings=nil): boolean; overload;
81	procedure CheckTerm(idTermAndCmd: string; commandSLout: TStrings; slIdNames: TStrings=nil);	82	function CheckTerm(idTermAndCmd: string; slIdNames: TStrings=nil): TUD2CommandArray;
82	function FindPluginByMethodNameOrGuid(idMethodName: string): TUD2Plugin;	83	function FindPluginByMethodNameOrGuid(idMethodName: string): TUD2Plugin;
83	procedure GetCommandList(ShortTaskName: string; outSL: TStrings);	84	function GetCommandList(ShortTaskName: string): TUD2CommandArray;
84	procedure HandlePluginDir(APluginDir, AFileMask: string);	85	procedure HandlePluginDir(APluginDir, AFileMask: string);
85	procedure GetTaskListing(outSL: TStrings);	86	procedure GetTaskListing(outSL: TStrings);
86	constructor Create(AIniFileName: string);	87	constructor Create(AIniFileName: string);
87	destructor Destroy; override;	88	destructor Destroy; override;
88	function TaskExists(ShortTaskName: string): boolean;	89	function TaskExists(ShortTaskName: string): boolean;
89	function ReadMetatagString(ShortTaskName, MetatagName: string; DefaultVal: string): string;	90	function ReadMetatagString(ShortTaskName, MetatagName: string; DefaultVal: string): string;
90	function ReadMetatagBool(ShortTaskName, MetatagName: string; DefaultVal: string): boolean;	91	function ReadMetatagBool(ShortTaskName, MetatagName: string; DefaultVal: string): boolean;
91	function GetTaskName(AShortTaskName: string): string;	92	function GetTaskName(AShortTaskName: string): string;
92	class function GenericErrorLookup(grStatus: UD2_STATUS): string;	93	class function GenericErrorLookup(grStatus: UD2_STATUS): string;
93	end;	94	end;
94		95
95	implementation	96	implementation
96		97
97	uses	98	uses
98	Math;	99	Math;
99		100
100	const	101	const
101	cchBufferSize = 32768;	102	cchBufferSize = 32768;
102		103
103	type	104	type
104	TUD2PluginLoader = class(TThread)	105	TUD2PluginLoader = class(TThread)
105	protected	106	protected
106	dllFile: string;	107	dllFile: string;
107	lngID: LANGID;	108	lngID: LANGID;
108	useDynamicData: boolean;	109	useDynamicData: boolean;
109	dynamicData: WideString;	110	dynamicData: WideString;
110	procedure Execute; override;	111	procedure Execute; override;
111	function HandleDLL: boolean;	112	function HandleDLL: boolean;
112	public	113	public
113	pl: TUD2Plugin; // TODO: why do we need it?! can it be leaked if we use it for dynamic requests?	114	pl: TUD2Plugin; // TODO: why do we need it?! can it be leaked if we use it for dynamic requests?
114	Errors: TStringList;	115	Errors: TStringList;
115	ResultIdentifiers: TArrayOfString;	116	ResultIdentifiers: TArrayOfString;
116	constructor Create(Suspended: boolean; DLL: string; alngid: LANGID; useDynamicData: boolean; dynamicData: WideString);	117	constructor Create(Suspended: boolean; DLL: string; alngid: LANGID; useDynamicData: boolean; dynamicData: WideString);
117	destructor Destroy; override;	118	destructor Destroy; override;
118	end;	119	end;
119		120
120	class function TUD2.GenericErrorLookup(grStatus: UD2_STATUS): string;	121	class function TUD2.GenericErrorLookup(grStatus: UD2_STATUS): string;
121	resourcestring	122	resourcestring
122	LNG_STATUS_OK_UNSPECIFIED = 'Success (Unspecified)';	123	LNG_STATUS_OK_UNSPECIFIED = 'Success (Unspecified)';
123	LNG_STATUS_OK_SINGLELINE = 'Success (One identifier returned)';	124	LNG_STATUS_OK_SINGLELINE = 'Success (One identifier returned)';
124	LNG_STATUS_OK_MULTILINE = 'Success (Multiple identifiers returned)';	125	LNG_STATUS_OK_MULTILINE = 'Success (Multiple identifiers returned)';
125	LNG_UNKNOWN_SUCCESS = 'Success (Unknown status code %s)';	126	LNG_UNKNOWN_SUCCESS = 'Success (Unknown status code %s)';
126		127
127	LNG_STATUS_NOTAVAIL_UNSPECIFIED = 'Not available (Unspecified)';	128	LNG_STATUS_NOTAVAIL_UNSPECIFIED = 'Not available (Unspecified)';
128	LNG_STATUS_NOTAVAIL_OS_NOT_SUPPORTED = 'Not available (Operating system not supported)';	129	LNG_STATUS_NOTAVAIL_OS_NOT_SUPPORTED = 'Not available (Operating system not supported)';
129	LNG_STATUS_NOTAVAIL_HW_NOT_SUPPORTED = 'Not available (Hardware not supported)';	130	LNG_STATUS_NOTAVAIL_HW_NOT_SUPPORTED = 'Not available (Hardware not supported)';
130	LNG_STATUS_NOTAVAIL_NO_ENTITIES = 'Not available (No entities to identify)';	131	LNG_STATUS_NOTAVAIL_NO_ENTITIES = 'Not available (No entities to identify)';
131	LNG_STATUS_NOTAVAIL_WINAPI_CALL_FAILURE = 'Not available (A Windows API call failed. Message: %s)';	132	LNG_STATUS_NOTAVAIL_WINAPI_CALL_FAILURE = 'Not available (A Windows API call failed. Message: %s)';
132	LNG_STATUS_NOTAVAIL_ONLY_ACCEPT_DYNAMIC = 'Not available (Arguments required)';	133	LNG_STATUS_NOTAVAIL_ONLY_ACCEPT_DYNAMIC = 'Not available (Arguments required)';
133	LNG_UNKNOWN_NOTAVAIL = 'Not available (Unknown status code %s)';	134	LNG_UNKNOWN_NOTAVAIL = 'Not available (Unknown status code %s)';
134		135
135	LNG_STATUS_FAILURE_UNSPECIFIED = 'Error (Unspecified)';	136	LNG_STATUS_FAILURE_UNSPECIFIED = 'Error (Unspecified)';
136	LNG_STATUS_FAILURE_BUFFER_TOO_SMALL = 'Error (The provided buffer is too small!)';	137	LNG_STATUS_FAILURE_BUFFER_TOO_SMALL = 'Error (The provided buffer is too small!)';
137	LNG_STATUS_FAILURE_INVALID_ARGS = 'Error (The function received invalid arguments!)';	138	LNG_STATUS_FAILURE_INVALID_ARGS = 'Error (The function received invalid arguments!)';
138	LNG_STATUS_FAILURE_PLUGIN_NOT_LICENSED = 'Error (The plugin is not licensed)';	139	LNG_STATUS_FAILURE_PLUGIN_NOT_LICENSED = 'Error (The plugin is not licensed)';
139	LNG_STATUS_FAILURE_NO_RETURNED_VALUE = 'Error (Plugin did not return a status)';	140	LNG_STATUS_FAILURE_NO_RETURNED_VALUE = 'Error (Plugin did not return a status)';
140	LNG_STATUS_FAILURE_CATCHED_EXCEPTION = 'Error (Catched unexpected Exception)';	141	LNG_STATUS_FAILURE_CATCHED_EXCEPTION = 'Error (Catched unexpected Exception)';
141	LNG_UNKNOWN_FAILED = 'Error (Unknown status code %s)';	142	LNG_UNKNOWN_FAILED = 'Error (Unknown status code %s)';
142		143
143	LNG_UNKNOWN_STATUS = 'Unknown status code with unexpected category: %s';	144	LNG_UNKNOWN_STATUS = 'Unknown status code with unexpected category: %s';
144	begin	145	begin
145	if UD2_STATUS_Equal(grStatus, UD2_STATUS_OK_UNSPECIFIED, false) then result := LNG_STATUS_OK_UNSPECIFIED	146	if UD2_STATUS_Equal(grStatus, UD2_STATUS_OK_UNSPECIFIED, false) then result := LNG_STATUS_OK_UNSPECIFIED
146	else if UD2_STATUS_Equal(grStatus, UD2_STATUS_OK_SINGLELINE, false) then result := LNG_STATUS_OK_SINGLELINE	147	else if UD2_STATUS_Equal(grStatus, UD2_STATUS_OK_SINGLELINE, false) then result := LNG_STATUS_OK_SINGLELINE
147	else if UD2_STATUS_Equal(grStatus, UD2_STATUS_OK_MULTILINE, false) then result := LNG_STATUS_OK_MULTILINE	148	else if UD2_STATUS_Equal(grStatus, UD2_STATUS_OK_MULTILINE, false) then result := LNG_STATUS_OK_MULTILINE
148		149
149	else if UD2_STATUS_Equal(grStatus, UD2_STATUS_NOTAVAIL_UNSPECIFIED, false) then result := LNG_STATUS_NOTAVAIL_UNSPECIFIED	150	else if UD2_STATUS_Equal(grStatus, UD2_STATUS_NOTAVAIL_UNSPECIFIED, false) then result := LNG_STATUS_NOTAVAIL_UNSPECIFIED
150	else if UD2_STATUS_Equal(grStatus, UD2_STATUS_NOTAVAIL_OS_NOT_SUPPORTED, false) then result := LNG_STATUS_NOTAVAIL_OS_NOT_SUPPORTED	151	else if UD2_STATUS_Equal(grStatus, UD2_STATUS_NOTAVAIL_OS_NOT_SUPPORTED, false) then result := LNG_STATUS_NOTAVAIL_OS_NOT_SUPPORTED
151	else if UD2_STATUS_Equal(grStatus, UD2_STATUS_NOTAVAIL_HW_NOT_SUPPORTED, false) then result := LNG_STATUS_NOTAVAIL_HW_NOT_SUPPORTED	152	else if UD2_STATUS_Equal(grStatus, UD2_STATUS_NOTAVAIL_HW_NOT_SUPPORTED, false) then result := LNG_STATUS_NOTAVAIL_HW_NOT_SUPPORTED
152	else if UD2_STATUS_Equal(grStatus, UD2_STATUS_NOTAVAIL_NO_ENTITIES, false) then result := LNG_STATUS_NOTAVAIL_NO_ENTITIES	153	else if UD2_STATUS_Equal(grStatus, UD2_STATUS_NOTAVAIL_NO_ENTITIES, false) then result := LNG_STATUS_NOTAVAIL_NO_ENTITIES
153	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)])	154	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)])
154	else if UD2_STATUS_Equal(grStatus, UD2_STATUS_NOTAVAIL_ONLY_ACCEPT_DYNAMIC, false) then result := LNG_STATUS_NOTAVAIL_ONLY_ACCEPT_DYNAMIC	155	else if UD2_STATUS_Equal(grStatus, UD2_STATUS_NOTAVAIL_ONLY_ACCEPT_DYNAMIC, false) then result := LNG_STATUS_NOTAVAIL_ONLY_ACCEPT_DYNAMIC
155		156
156	else if UD2_STATUS_Equal(grStatus, UD2_STATUS_FAILURE_UNSPECIFIED, false) then result := LNG_STATUS_FAILURE_UNSPECIFIED	157	else if UD2_STATUS_Equal(grStatus, UD2_STATUS_FAILURE_UNSPECIFIED, false) then result := LNG_STATUS_FAILURE_UNSPECIFIED
157	else if UD2_STATUS_Equal(grStatus, UD2_STATUS_FAILURE_BUFFER_TOO_SMALL, false) then result := LNG_STATUS_FAILURE_BUFFER_TOO_SMALL	158	else if UD2_STATUS_Equal(grStatus, UD2_STATUS_FAILURE_BUFFER_TOO_SMALL, false) then result := LNG_STATUS_FAILURE_BUFFER_TOO_SMALL
158	else if UD2_STATUS_Equal(grStatus, UD2_STATUS_FAILURE_INVALID_ARGS, false) then result := LNG_STATUS_FAILURE_INVALID_ARGS	159	else if UD2_STATUS_Equal(grStatus, UD2_STATUS_FAILURE_INVALID_ARGS, false) then result := LNG_STATUS_FAILURE_INVALID_ARGS
159	else if UD2_STATUS_Equal(grStatus, UD2_STATUS_FAILURE_PLUGIN_NOT_LICENSED, false) then result := LNG_STATUS_FAILURE_PLUGIN_NOT_LICENSED	160	else if UD2_STATUS_Equal(grStatus, UD2_STATUS_FAILURE_PLUGIN_NOT_LICENSED, false) then result := LNG_STATUS_FAILURE_PLUGIN_NOT_LICENSED
160	else if UD2_STATUS_Equal(grStatus, UD2_STATUS_FAILURE_NO_RETURNED_VALUE, false) then result := LNG_STATUS_FAILURE_NO_RETURNED_VALUE	161	else if UD2_STATUS_Equal(grStatus, UD2_STATUS_FAILURE_NO_RETURNED_VALUE, false) then result := LNG_STATUS_FAILURE_NO_RETURNED_VALUE
161	else if UD2_STATUS_Equal(grStatus, UD2_STATUS_FAILURE_CATCHED_EXCEPTION, false) then result := LNG_STATUS_FAILURE_CATCHED_EXCEPTION	162	else if UD2_STATUS_Equal(grStatus, UD2_STATUS_FAILURE_CATCHED_EXCEPTION, false) then result := LNG_STATUS_FAILURE_CATCHED_EXCEPTION
162		163
163	else if grStatus.wCategory = UD2_STATUSCAT_SUCCESS then result := Format(LNG_UNKNOWN_SUCCESS, [UD2_STATUS_FormatStatusCode(grStatus)])	164	else if grStatus.wCategory = UD2_STATUSCAT_SUCCESS then result := Format(LNG_UNKNOWN_SUCCESS, [UD2_STATUS_FormatStatusCode(grStatus)])
164	else if grStatus.wCategory = UD2_STATUSCAT_NOT_AVAIL then result := Format(LNG_UNKNOWN_NOTAVAIL, [UD2_STATUS_FormatStatusCode(grStatus)])	165	else if grStatus.wCategory = UD2_STATUSCAT_NOT_AVAIL then result := Format(LNG_UNKNOWN_NOTAVAIL, [UD2_STATUS_FormatStatusCode(grStatus)])
165	else if grStatus.wCategory = UD2_STATUSCAT_FAILED then result := Format(LNG_UNKNOWN_FAILED, [UD2_STATUS_FormatStatusCode(grStatus)])	166	else if grStatus.wCategory = UD2_STATUSCAT_FAILED then result := Format(LNG_UNKNOWN_FAILED, [UD2_STATUS_FormatStatusCode(grStatus)])
166	else result := Format(LNG_UNKNOWN_STATUS, [UD2_STATUS_FormatStatusCode(grStatus)]);	167	else result := Format(LNG_UNKNOWN_STATUS, [UD2_STATUS_FormatStatusCode(grStatus)]);
167	end;	168	end;
168		169
169	{ TUD2Plugin }	170	{ TUD2Plugin }
170		171
171	function TUD2Plugin.PluginGUIDString: string;	172	function TUD2Plugin.PluginGUIDString: string;
172	begin	173	begin
173	result := UpperCase(GUIDToString(PluginGUID));	174	result := UpperCase(GUIDToString(PluginGUID));
174	end;	175	end;
175		176
176	function TUD2Plugin.AddIdentification(IdStr: WideString): TUD2IdentificationEntry;	177	function TUD2Plugin.AddIdentification(IdStr: WideString): TUD2IdentificationEntry;
177	begin	178	begin
178	result := TUD2IdentificationEntry.Create(IdStr, Self);	179	result := TUD2IdentificationEntry.Create(IdStr, Self);
179	DetectedIdentifications.Add(result);	180	DetectedIdentifications.Add(result);
180	end;	181	end;
181		182
182	destructor TUD2Plugin.Destroy;	183	destructor TUD2Plugin.Destroy;
183	begin	184	begin
184	DetectedIdentifications.Free;	185	DetectedIdentifications.Free;
185	inherited;	186	inherited;
186	end;	187	end;
187		188
188	constructor TUD2Plugin.Create;	189	constructor TUD2Plugin.Create;
189	begin	190	begin
190	inherited Create;	191	inherited Create;
191	FDetectedIdentifications := TObjectList{<TUD2IdentificationEntry>}.Create(true);	192	FDetectedIdentifications := TObjectList{<TUD2IdentificationEntry>}.Create(true);
192	end;	193	end;
193		194
194	function TUD2Plugin.InvokeDynamicCheck(dynamicData: string): boolean;	195	function TUD2Plugin.InvokeDynamicCheck(dynamicData: string): boolean;
195	var	196	var
196	ude: TUD2IdentificationEntry;	197	ude: TUD2IdentificationEntry;
197	i: integer;	198	i: integer;
198	ids: TArrayOfString;	199	ids: TArrayOfString;
199	id: string;	200	id: string;
200	begin	201	begin
201	result := false;	202	result := false;
202		203
203	for i := 0 to FDetectedIdentifications.Count-1 do	204	for i := 0 to FDetectedIdentifications.Count-1 do
204	begin	205	begin
205	ude := FDetectedIdentifications.Items[i] as TUD2IdentificationEntry;	206	ude := FDetectedIdentifications.Items[i] as TUD2IdentificationEntry;
206	if ude.dynamicDataUsed and (ude.dynamicData = dynamicData) then	207	if ude.dynamicDataUsed and (ude.dynamicData = dynamicData) then
207	begin	208	begin
208	// The dynamic content was already evaluated (and therefore is already added in FDetectedIdentifications).	209	// The dynamic content was already evaluated (and therefore is already added in FDetectedIdentifications).
209	Exit;	210	Exit;
210	end;	211	end;
211	end;	212	end;
212		213
213	SetLength(ids, 0);	214	SetLength(ids, 0);
214	ids := GetDynamicRequestResult(dynamicData);	215	ids := GetDynamicRequestResult(dynamicData);
215		216
216	for i := 0 to Length(ids)-1 do	217	for i := 0 to Length(ids)-1 do
217	begin	218	begin
218	id := ids[i];	219	id := ids[i];
219		220
220	ude := AddIdentification(id);	221	ude := AddIdentification(id);
221	ude.dynamicDataUsed := true;	222	ude.dynamicDataUsed := true;
222	ude.dynamicData := dynamicData;	223	ude.dynamicData := dynamicData;
223		224
224	result := true;	225	result := true;
225	end;	226	end;
226	end;	227	end;
227		228
228	function TUD2Plugin.GetDynamicRequestResult(dynamicData: string): TArrayOfString;	229	function TUD2Plugin.GetDynamicRequestResult(dynamicData: string): TArrayOfString;
229	var	230	var
230	lngID: LANGID;	231	lngID: LANGID;
231	pll: TUD2PluginLoader;	232	pll: TUD2PluginLoader;
232	begin	233	begin
233	lngID := GetSystemDefaultLangID;	234	lngID := GetSystemDefaultLangID;
234		235
235	pll := TUD2PluginLoader.Create(false, PluginDLL, lngid, true, dynamicData);	236	pll := TUD2PluginLoader.Create(false, PluginDLL, lngid, true, dynamicData);
236	try	237	try
237	pll.WaitFor;	238	pll.WaitFor;
238	result := pll.ResultIdentifiers;	239	result := pll.ResultIdentifiers;
239	finally	240	finally
240	pll.Free;	241	pll.Free;
241	end;	242	end;
242	end;	243	end;
243		244
244	function TUD2Plugin.EqualsMethodNameOrGuid(idMethodNameOrGUID: string): boolean;	245	function TUD2Plugin.EqualsMethodNameOrGuid(idMethodNameOrGUID: string): boolean;
245	begin	246	begin
246	result := SameText(IdentificationMethodName, idMethodNameOrGUID) or	247	result := SameText(IdentificationMethodName, idMethodNameOrGUID) or
247	SameText(GUIDToString(PluginGUID), idMethodNameOrGUID)	248	SameText(GUIDToString(PluginGUID), idMethodNameOrGUID)
248	end;	249	end;
249		250
250	{ TUD2IdentificationEntry }	251	{ TUD2IdentificationEntry }
251		252
252	procedure TUD2IdentificationEntry.GetIdNames(sl: TStrings);	253	procedure TUD2IdentificationEntry.GetIdNames(sl: TStrings);
-		254	var
-		255	cond: TUD2TDFCondition;
253	begin	256	begin
254	if DynamicDataUsed then	257	cond.idMethodName := Plugin.IdentificationMethodName;
255	begin	258	cond.idStr := IdentificationString;
256	sl.Add(Plugin.IdentificationMethodName+'('+DynamicData+'):'+IdentificationString);	259	cond.dynamicDataUsed := DynamicDataUsed;
257	sl.Add(Plugin.PluginGUIDString+'('+DynamicData+'):'+IdentificationString);	260	cond.dynamicData := DynamicData;
258	end	261	sl.Add(UD2_CondToStr(cond));
259	else	262
260	begin	-
261	sl.Add(Plugin.IdentificationMethodName+':'+IdentificationString);	263	cond.idMethodName := Plugin.PluginGUIDString;
262	sl.Add(Plugin.PluginGUIDString+':'+IdentificationString);	264	sl.Add(UD2_CondToStr(cond));
263	end;	-
264	end;	265	end;
265		266
266	constructor TUD2IdentificationEntry.Create(AIdentificationString: WideString;	267	constructor TUD2IdentificationEntry.Create(AIdentificationString: WideString;
267	APlugin: TUD2Plugin);	268	APlugin: TUD2Plugin);
268	begin	269	begin
269	inherited Create;	270	inherited Create;
270	FIdentificationString := AIdentificationString;	271	FIdentificationString := AIdentificationString;
271	FPlugin := APlugin;	272	FPlugin := APlugin;
272	end;	273	end;
273		274
274	{ TUD2 }	275	{ TUD2 }
275		276
276	procedure TUD2.HandlePluginDir(APluginDir, AFileMask: string);	277	procedure TUD2.HandlePluginDir(APluginDir, AFileMask: string);
277	Var	278	Var
278	SR: TSearchRec;	279	SR: TSearchRec;
279	path: string;	280	path: string;
280	pluginLoader: TUD2PluginLoader;	281	pluginLoader: TUD2PluginLoader;
281	tob: TObjectList;	282	tob: TObjectList;
282	i: integer;	283	i: integer;
283	{$IFDEF CHECK_FOR_SAME_PLUGIN_GUID}	284	{$IFDEF CHECK_FOR_SAME_PLUGIN_GUID}
284	sPluginID, prevDLL: string;	285	sPluginID, prevDLL: string;
285	{$ENDIF}	286	{$ENDIF}
286	lngid: LANGID;	287	lngid: LANGID;
287	resourcestring	288	resourcestring
288	LNG_PLUGINS_SAME_GUID = 'Attention: The plugin "%s" and the plugin "%s" have the same identification GUID. The latter will not be loaded.';	289	LNG_PLUGINS_SAME_GUID = 'Attention: The plugin "%s" and the plugin "%s" have the same identification GUID. The latter will not be loaded.';
289	begin	290	begin
290	tob := TObjectList.Create;	291	tob := TObjectList.Create;
291	try	292	try
292	tob.OwnsObjects := false;	293	tob.OwnsObjects := false;
293		294
294	lngID := GetSystemDefaultLangID;	295	lngID := GetSystemDefaultLangID;
295		296
296	path := APluginDir;	297	path := APluginDir;
297	if path <> '' then path := IncludeTrailingPathDelimiter(path);	298	if path <> '' then path := IncludeTrailingPathDelimiter(path);
298		299
299	if FindFirst(path + AFileMask, 0, SR) = 0 then	300	if FindFirst(path + AFileMask, 0, SR) = 0 then
300	begin	301	begin
301	try	302	try
302	repeat	303	repeat
303	try	304	try
304	tob.Add(TUD2PluginLoader.Create(false, path + sr.Name, lngid, false, ''));	305	tob.Add(TUD2PluginLoader.Create(false, path + sr.Name, lngid, false, ''));
305	except	306	except
306	on E: Exception do	307	on E: Exception do
307	begin	308	begin
308	MessageDlg(E.Message, mtError, [mbOK], 0);	309	MessageDlg(E.Message, mtError, [mbOK], 0);
309	end;	310	end;
310	end;	311	end;
311	until FindNext(SR) <> 0;	312	until FindNext(SR) <> 0;
312	finally	313	finally
313	FindClose(SR);	314	FindClose(SR);
314	end;	315	end;
315	end;	316	end;
316		317
317	for i := 0 to tob.count-1 do	318	for i := 0 to tob.count-1 do
318	begin	319	begin
319	pluginLoader := tob.items[i] as TUD2PluginLoader;	320	pluginLoader := tob.items[i] as TUD2PluginLoader;
320	pluginLoader.WaitFor;	321	pluginLoader.WaitFor;
321	Errors.AddStrings(pluginLoader.Errors);	322	Errors.AddStrings(pluginLoader.Errors);
322	{$IFDEF CHECK_FOR_SAME_PLUGIN_GUID}	323	{$IFDEF CHECK_FOR_SAME_PLUGIN_GUID}
323	if Assigned(pluginLoader.pl) then	324	if Assigned(pluginLoader.pl) then
324	begin	325	begin
325	if not pluginLoader.pl.OSNotSupportedEnforced then	326	if not pluginLoader.pl.OSNotSupportedEnforced then
326	begin	327	begin
327	sPluginID := GUIDToString(pluginLoader.pl.PluginGUID);	328	sPluginID := GUIDToString(pluginLoader.pl.PluginGUID);
328	prevDLL := FGUIDLookup.Values[sPluginID];	329	prevDLL := FGUIDLookup.Values[sPluginID];
329	if (prevDLL <> '') and (prevDLL <> pluginLoader.pl.PluginDLL) then	330	if (prevDLL <> '') and (prevDLL <> pluginLoader.pl.PluginDLL) then
330	begin	331	begin
331	Errors.Add(Format(LNG_PLUGINS_SAME_GUID, [prevDLL, pluginLoader.pl.PluginDLL]));	332	Errors.Add(Format(LNG_PLUGINS_SAME_GUID, [prevDLL, pluginLoader.pl.PluginDLL]));
332	pluginLoader.pl.Free;	333	pluginLoader.pl.Free;
333	end	334	end
334	else	335	else
335	begin	336	begin
336	FGUIDLookup.Values[sPluginID] := pluginLoader.pl.PluginDLL;	337	FGUIDLookup.Values[sPluginID] := pluginLoader.pl.PluginDLL;
337	LoadedPlugins.Add(pluginLoader.pl);	338	LoadedPlugins.Add(pluginLoader.pl);
338	end;	339	end;
339	end;	340	end;
340	end;	341	end;
341	{$ENDIF}	342	{$ENDIF}
342	pluginLoader.Free;	343	pluginLoader.Free;
343	end;	344	end;
344	finally	345	finally
345	tob.free;	346	tob.free;
346	end;	347	end;
347	end;	348	end;
348		349
349	destructor TUD2.Destroy;	350	destructor TUD2.Destroy;
350	begin	351	begin
351	FIniFile.Free;	352	FIniFile.Free;
352	FLoadedPlugins.Free;	353	FLoadedPlugins.Free;
353	{$IFDEF CHECK_FOR_SAME_PLUGIN_GUID}	354	{$IFDEF CHECK_FOR_SAME_PLUGIN_GUID}
354	FGUIDLookup.Free;	355	FGUIDLookup.Free;
355	{$ENDIF}	356	{$ENDIF}
356	FErrors.Free;	357	FErrors.Free;
357	end;	358	end;
358		359
359	constructor TUD2.Create(AIniFileName: string);	360	constructor TUD2.Create(AIniFileName: string);
360	begin	361	begin
361	FIniFileName := AIniFileName;	362	FIniFileName := AIniFileName;
362	FLoadedPlugins := TObjectList{<TUD2Plugin>}.Create(true);	363	FLoadedPlugins := TObjectList{<TUD2Plugin>}.Create(true);
363	FIniFile := TMemIniFile.Create(IniFileName);	364	FIniFile := TMemIniFile.Create(IniFileName);
364	{$IFDEF CHECK_FOR_SAME_PLUGIN_GUID}	365	{$IFDEF CHECK_FOR_SAME_PLUGIN_GUID}
365	FGUIDLookup := TStringList.Create;	366	FGUIDLookup := TStringList.Create;
366	{$ENDIF}	367	{$ENDIF}
367	FErrors := TStringList.Create;	368	FErrors := TStringList.Create;
368	end;	369	end;
369		370
370	function TUD2.GetTaskName(AShortTaskName: string): string;	371	function TUD2.GetTaskName(AShortTaskName: string): string;
371	resourcestring	372	resourcestring
372	LNG_NO_DESCRIPTION = '(%s)';	373	LNG_NO_DESCRIPTION = '(%s)';
373	begin	374	begin
374	result := FIniFile.ReadString(AShortTaskName, 'Description', Format(LNG_NO_DESCRIPTION, [AShortTaskName]));	375	result := FIniFile.ReadString(AShortTaskName, 'Description', Format(LNG_NO_DESCRIPTION, [AShortTaskName]));
375	end;	376	end;
376		377
377	procedure TUD2.GetTaskListing(outSL: TStrings);	378	procedure TUD2.GetTaskListing(outSL: TStrings);
378	var	379	var
379	sl: TStringList;	380	sl: TStringList;
380	i: integer;	381	i: integer;
381	desc: string;	382	desc: string;
382	begin	383	begin
383	sl := TStringList.Create;	384	sl := TStringList.Create;
384	try	385	try
385	FIniFile.ReadSections(sl);	386	FIniFile.ReadSections(sl);
386	for i := 0 to sl.Count-1 do	387	for i := 0 to sl.Count-1 do
387	begin	388	begin
388	desc := GetTaskName(sl.Strings[i]);	389	desc := GetTaskName(sl.Strings[i]);
389	outSL.Values[sl.Strings[i]] := desc;	390	outSL.Values[sl.Strings[i]] := desc;
390	end;	391	end;
391	finally	392	finally
392	sl.Free;	393	sl.Free;
393	end;	394	end;
394	end;	395	end;
395		396
396	function TUD2.TaskExists(ShortTaskName: string): boolean;	397	function TUD2.TaskExists(ShortTaskName: string): boolean;
397	begin	398	begin
398	result := FIniFile.SectionExists(ShortTaskName);	399	result := FIniFile.SectionExists(ShortTaskName);
399	end;	400	end;
400		401
401	function TUD2.ReadMetatagString(ShortTaskName, MetatagName: string;	402	function TUD2.ReadMetatagString(ShortTaskName, MetatagName: string;
402	DefaultVal: string): string;	403	DefaultVal: string): string;
403	begin	404	begin
404	result := IniFile.ReadString(ShortTaskName, MetatagName, DefaultVal);	405	result := IniFile.ReadString(ShortTaskName, MetatagName, DefaultVal);
405	end;	406	end;
406		407
407	function TUD2.ReadMetatagBool(ShortTaskName, MetatagName: string;	408	function TUD2.ReadMetatagBool(ShortTaskName, MetatagName: string;
408	DefaultVal: string): boolean;	409	DefaultVal: string): boolean;
409	begin	410	begin
410	// DefaultVal is a string, because we want to allow an empty string, in case the	411	// DefaultVal is a string, because we want to allow an empty string, in case the
411	// user wishes an Exception in case the string is not a valid boolean string	412	// user wishes an Exception in case the string is not a valid boolean string
412	result := BetterInterpreteBool(IniFile.ReadString(ShortTaskName, MetatagName, DefaultVal));	413	result := BetterInterpreteBool(IniFile.ReadString(ShortTaskName, MetatagName, DefaultVal));
413	end;	414	end;
414		415
415	(*	416	(*
416		417
417	NAMING EXAMPLE: $CASESENSITIVE$ComputerName(dynXYZ):ABC&&User:John=calc.exe$RIOD$	418	NAMING EXAMPLE: $CASESENSITIVE$ComputerName(dynXYZ):ABC&&User:John=calc.exe$RIOD$
418		419
419	idTerm: ComputerName(dynXYZ):ABC&&User:John	420	idTerm: ComputerName(dynXYZ):ABC&&User:John
420	idName: ComputerName:ABC	421	idName: ComputerName:ABC
421	IdMethodName: ComputerName	422	IdMethodName: ComputerName
422	IdStr ABC	423	IdStr ABC
423	cmd: calc.exe	424	cmd: calc.exe
424	dynamicData: dynXYZ	425	dynamicData: dynXYZ
425		426
426	*)	427	*)
427		428
428	procedure TUD2.GetAllDetectedIDs(outSL: TStrings);	429	procedure TUD2.GetAllDetectedIDs(outSL: TStrings);
429	var	430	var
430	i, j: integer;	431	i, j: integer;
431	pl: TUD2Plugin;	432	pl: TUD2Plugin;
432	ude: TUD2IdentificationEntry;	433	ude: TUD2IdentificationEntry;
433	begin	434	begin
434	for i := 0 to LoadedPlugins.Count-1 do	435	for i := 0 to LoadedPlugins.Count-1 do
435	begin	436	begin
436	pl := LoadedPlugins.Items[i] as TUD2Plugin;	437	pl := LoadedPlugins.Items[i] as TUD2Plugin;
437	for j := 0 to pl.DetectedIdentifications.Count-1 do	438	for j := 0 to pl.DetectedIdentifications.Count-1 do
438	begin	439	begin
439	ude := pl.DetectedIdentifications.Items[j] as TUD2IdentificationEntry;	440	ude := pl.DetectedIdentifications.Items[j] as TUD2IdentificationEntry;
440	ude.GetIdNames(outSL);	441	ude.GetIdNames(outSL);
441	end;	442	end;
442	end;	443	end;
443	end;	444	end;
444		445
-		446	function TUD2.FulfilsEverySubterm(conds: TUD2TDFConditionArray; slIdNames: TStrings=nil): boolean;
-		447	begin
-		448	result := FulfilsEverySubterm(UD2_CondsToStr(conds), slIdNames);
-		449	end;
-		450
445	function TUD2.FulfilsEverySubterm(idTerm: WideString; slIdNames: TStrings=nil): boolean;	451	function TUD2.FulfilsEverySubterm(idTerm: WideString; slIdNames: TStrings=nil): boolean;
446	const	-
447	CASE_SENSITIVE_FLAG = '$CASESENSITIVE$';	-
448	var	452	var
449	x, a, b: TArrayOfString;	-
450	i: integer;	453	i: integer;
451	p: TUD2Plugin;	454	p: TUD2Plugin;
452	idName: WideString;	-
453	cleanUpStringList: boolean;	455	cleanUpStringList: boolean;
454	caseSensitive: boolean;	456	conds: TUD2TDFConditionArray;
455	dynamicData: string;	457	cond: TUD2TDFCondition;
456	idMethodName: string;	458	idName: string;
457	begin	459	begin
458	cleanUpStringList := slIdNames = nil;	460	cleanUpStringList := slIdNames = nil;
459	try	461	try
460	if cleanUpStringList then	462	if cleanUpStringList then
461	begin	463	begin
462	slIdNames := TStringList.Create;	464	slIdNames := TStringList.Create;
463	GetAllDetectedIDs(slIdNames);	465	GetAllDetectedIDs(slIdNames);
464	end;	466	end;
465		467
466	SetLength(x, 0);	-
467	if Pos(':', idTerm) = 0 then	-
468	begin	-
469	// Exclude stuff like "Description"	468	conds := UD2P_ParseConditions(idTerm);
470	result := false;	-
471	Exit;	-
472	end;	469
473	x := SplitString('&&', idTerm);	-
474	result := true;	470	result := true;
475	for i := Low(x) to High(x) do	471	for i := Low(conds) to High(conds) do
476	begin	472	begin
477	idName := x[i];	473	cond := conds[i];
478		-
479	/// --- Start Dynamic Extension	-
480		-
481	// xxxxxx ( xxxxx ): xxxxxxxxxxxx	-
482	// xxxxx ( xx:xx ): xxxxx:xxx(x)	-
483	// xxxxxxxxxxxx : xxxxx(xxx)xx	-
484		474
485	SetLength(a, 0);	-
486	a := SplitString('(', idName);	475	if cond.dynamicDataUsed then
487	if (Length(a) >= 2) and (Pos(':', a[0]) = 0) then	-
488	begin	476	begin
489	SetLength(b, 0);	-
490	b := SplitString('):', a[1]);	-
491	if Length(b) >= 2 then	-
492	begin	-

Subversion Repositories userdetect2

userdetect2/trunk/UserDetect2/UD2_Obj.pas – Rev 84 → 85