Free desktop tools and utilities for Windows. Download our software now.Free desktop tools and utilities for Windows. Download our software now.
HomeContact
molecular biology software
scf trace assembly

Hardware ID Extractor
Hardware serial number extractor library - Tutorials

Delphi programming C/C++  programming VB (Visual Basic)  programming

free software

 

Hardware ID Extractor source code

 

The DLL works in Visual C, C Builder, Delphi, Visual Basic, etc. Details here.

 

Delphi programming C/C++  programming VB (Visual Basic)  programming

 

Awards

 

 

 

Related programs

 

Windows memory memory statistics

Word Extractor

Word Extractor is a universal hacking tool that extracts (human) text from binary (machine) files.

 

 

More tutorials

 

Import DLL's dynamic or static

Dynamic loading and binding of DLLs

Retrieve list of exported functions

Dynamically load DLL's?

What is a DLL?

 

 

 

 

 

DLLs: Import dynamic or static

 

Both techniques have their advantages. Static importing means you define functions like this:

 

  function f : integer;
  external 'mydll.dll';

 

The advantage of static imports are:

    * It is easy - it does not require ugly code.
    * The application will only start up if all DLLs are present and can be loaded (this could also be considered a negative)
    * All functions across all modules are bound during startup time.

 

Dynamic importing has its advantages as well.

  • It basically gives you full control over the usage of the DLL. If your DLL is only needed rarely, you may not want to load it at startup of your application. Your application will start faster then.
  • If the application will work without that DLL to a usable extent, you may allow the user to do so.
  • If you have different DLLs for different environments, for example one for Windows NT, another one for Windows 95 etc, then you MUST bind dynamic - you determine the operating system and load the DLL that you want.
  • Dynamic binding allows you to release the DLL if you do not need it anymore

The following code shows you how to do it:

 

 

Dynamic loading and binding of DLLs

 

Sometimes you may need to load a DLL at runtime, for example

  • if you have a couple of different DLLs to choose between
  • to have a concept for optional functionality.

This small source code shows how to load the DLL with LoadLibrary and use the returned handle to access (bind) the functions that are contained:

 

type
  TfncCnx = function (s : string) : THandle;{ function declaration }

var
  cnx : TfncCnx;
begin
  { load the DLL and get the function's address }
  h := LoadLibrary('myDll');
  if h = 0 then
  begin
    ShowMessage ('DLL not available');
  end
  else
  begin
    @cnx := GetProcAddress(h, 'myProc');
    if @cnx = nil then
    begin
      { function not found.. misspelled? }
      ShowMessage ('blub');
    end
            else
    begin
      { call the function as usually }
      x := cnx('alpha');
    end;
    { unload the DLL }
    FreeLibrary(h);
  end;
end;

 

 

Retrieve list of exported functions from a DLL

 

To retrieve the list of exported functions from a DLL, pass the DLL name and a TStrings object to the function ListDLLFunctions() shown below.

This does not show the parameters for each export, which you can only get from the author of the DLL.

 

program Project1;

uses
  Forms,
  Classes,
  SysUtils,
  Dialogs,
  ImageHlp, // routines to access debug information
  Windows;

// by Dmitry Streblechenko
procedure ListDLLFunctions(DLLName: String; List: TStrings);
type
  chararr = array [0..$FFFFFF] of Char;
  var
  H: THandle;
  I,
  fc: integer;
  st: string;
  arr: Pointer;
  ImageDebugInformation: PImageDebugInformation;
begin
  List.Clear;
  DLLName := ExpandFileName(DLLName);
  if FileExists(DLLName) then
  begin
    H := CreateFile(PChar(DLLName), GENERIC_READ, FILE_SHARE_READ or
      FILE_SHARE_WRITE, nil, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
    if H<>INVALID_HANDLE_VALUE then
      try
        ImageDebugInformation := MapDebugInformation(H, PChar(DLLName), nil, 0);
        if ImageDebugInformation<>nil then
          try
            arr := ImageDebugInformation^.ExportedNames;
            fc := 0;
            for I := 0 to ImageDebugInformation^.ExportedNamesSize - 1 do
              if chararr(arr^)[I]=#0 then
              begin
                st := PChar(@chararr(arr^)[fc]);
                if Length(st)>0 then
                  List.Add(st);
                if (I>0) and (chararr(arr^)[I-1]=#0) then
                  Break;
                fc := I + 1
              end
          finally
            UnmapDebugInformation(ImageDebugInformation)
          end
      finally
        CloseHandle(H)
      end
  end
end;

// the following is an example how to use the procedure
var
  List: TStrings;
  I: integer;
  S: String;

begin
  List := TStringList.Create;

  ListDLLFunctions('c:\winnt\system32\mfc42.dll', List);

  S := 'List of functions';
  for I := 0 to List.Count - 1 do
    S := S + #13#10 + List[I];
  ShowMessage(S);
  List.Free
end.

 

 

Dynamically load DLLs?

 


  There are two possibilities to load a dll:

  1. Static loading of a DLL means that the DLL is loaded when the application is executed.
     This is the easier option to dynamic loading, as you'll see, however it means that if the DLL
     is missing, your program will not run.


  {Examples:}

 

  {a. Import a function called MYImportFunction from MYLIBRARY.dll}
  procedure MYImportFunction; external 'MYLIBRARY.dll';

  {b. Import a routine under a different name from the one it has in the library. }
  procedure MYImportFunction; external 'MYLIBRARY.dll' name 'MyNewImportFunctionName';

  {c. By ordinal value: Has to be the same value as when using the exports
      keyword when making the DLL}
  procedure MYImportFunction; external 'MYLIBRARY.dll' index 10;

 


  2. Dynamic loading

 

  By dynamically loading a DLL you decide at runtime which DLL to use. This means you can give your program different functionality depending on which DLL's are present (freeware or shareware versions of a program).
  Or also if you want to load a library whose name or path must be computed at run time or generated from user input.

  Dynamic loading of a DLL loads the DLL in your application when it is needed and unload it once you its work is done. It requires more code to use, however it more resource friendly than static loading.}

 

 

{**********************************************************}

// Example for dynamically loading a DLL
// Beispiel um eine Dll dynamisch zu laden:

 

type
  TDLLFunction = function(someParam: TSomeType): TSomeOtherType;

{
  To execute such a function by name from a named DLL one could use a
  "caller" function like
}

function CallDLLFunction(const dllname, functionname: string;
  theParameter: TSomeType): TSomeOtherType;
var
  hDLL: THandle;
  theFunction: TDLLFunction;
  buf: array [0..144] of Char;
begin
  // Get a handle to the DLL module.
  // das Handle zum DLL Modul ermitteln.
  hDLL := LoadLibrary(StrPCopy(buf, dllname));
  // If the handle is valid, try to get the function address.
  // Wenn das Handle gültig ist, versuche die Adresse der Funktion zu ermitteln
  if hDLL <> 0 then
  begin
    // Return the address of the specified exported (DLL) function.
    // Adresse der Dll-Funktion ermitteln
    try
      @theFunction := GetProcAddress(hDll, StrPCopy(buf, functionname));
      // If the function address is valid, call the function.
      // Wenn die Funktion gefunden wurde...
      if @theFunction <> nil then
        Result := theFunction(theParameter)
      else
        raise EDLLException.CreateFmt('Unable to link to function %s in DLL %s!',
          [functionname, dllname]);
    finally
      // Free the DLL module.
      // Dll wieder freigeben.
      FreeLibrary(hDLL);
    end;
  end
  else
    raise EDLLException.CreateFmt('Unable to load DLL %s!'#13#10 +
      'Reason: %s.', [dllname, DLLErrors[hDLL]]);
end;

 

contig assembly software

 

Hardware ID Extractor