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

Subversion Repositories userdetect2

userdetect2/trunk/UserDetect2/UD2_Obj.pas – Rev 92 → 94