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

Subversion Repositories userdetect2

userdetect2/trunk/UserDetect2/UD2_Obj.pas – Rev 90 → 91