Win32::API - Perl Win32 API Import Facility |
Win32::API - Perl Win32 API Import Facility
use Win32::API; $function = new Win32::API( $library, $functionname, \@argumenttypes, $returntype, ); $return = $function->Call(@arguments);
With this module you can import and call arbitrary functions from Win32's Dynamic Link Libraries (DLL), without having to write an XS extension. Note, however, that this module can't do anything (parameters input and output is limited to simpler cases), and anyway a regular XS extension is always safer and faster.
The current version of Win32::API is available at my website:
http://dada.perl.it/
It's also available on your nearest CPAN mirror (but allow a few days for worldwide spreading of the latest version) reachable at:
http://www.perl.com/CPAN/authors/Aldo_Calpini/
A short example of how you can use this module (it just gets the
PID of
the current process, eg. same as Perl's internal $$
):
use Win32::API; $GetPID = new Win32::API("kernel32", "GetCurrentProcessId", '', 'N'); $PID = $GetPID->Call();
The possibilities are nearly infinite (but not all are good :-). Enjoy it.
All the credits go to Andrea Frosini for the neat assembler trick that makes this thing work. A big thank you also to Gurusamy Sarathy for his unvaluable help in XS development, and to all the Perl community for being what it is.
To use this module put the following line at the beginning of your script:
use Win32::API;
You can now use the new()
function of the Win32::API module to create a
new
API object (see
IMPORTING
A
FUNCTION) and then invoke the
Call()
method on this object to perform a call to the imported
API
(see
CALLING
AN
IMPORTED
FUNCTION).
You can import a function from a 32 bit Dynamic Link Library
(DLL) file
with the new()
function. This will create a Perl object that contains the
reference to that function, which you can later Call()
.
You need to pass 4 parameters:
To better explain their meaning, let's suppose that we
want to import and call the Win32
API GetTempPath()
.
This function is defined in
C as:
DWORD WINAPI GetTempPathA( DWORD nBufferLength, LPSTR lpBuffer );
This is documented in the Win32 SDK Reference; you can look for it on the Microsoft's WWW site, or in your C compiler's documentation, if you own one.
So, you don't have to write C:\windows\system\kernel32.dll; only kernel32 is enough:
$GetTempPath = new Win32::API('kernel32', ...
Also note that many Win32 APIs are exported twice, with the addition of a final A or W to their name, for - respectively - the ASCII and the Unicode version. When a function name is not found, Win32::API will actually append an A to the name and try again; if the extension is built on a Unicode system, then it will try with the W instead. So our function name will be:
$GetTempPath = new Win32::API('kernel32', 'GetTempPath', ...
In our case GetTempPath
is really loaded as GetTempPathA
.
"abcd" [a, b, c, d] \@LIST
But those are not:
(a, b, c, d) @LIST
The number of characters, or elements in the list, specifies the number of parameters, and each character or element specifies the type of an argument; allowed types are:
I
:
value is an integerN
:
value is a number (long)F
:
value is a floating point number (float)D
:
value is a double precision number (double)P
:
value is a pointer (to a string, structure, etc...)Our function needs two parameters: a number (DWORD
) and a pointer to a
string (LPSTR
):
$GetTempPath = new Win32::API('kernel32', 'GetTempPath', 'NP', ...
void
), used for functions that do not return a value.
In our example the value returned by GetTempPath()
is a DWORD
, so
our return type will be
N:
$GetTempPath = new Win32::API('kernel32', 'GetTempPath', 'NP', 'N');
Now the line is complete, and the GetTempPath()
API is ready to be used
in Perl. Before calling it, you should test that $GetTempPath is
defined
, otherwise either the function or the library could not be
loaded; in this case, $!
will be set to the error message reported
by Windows.
Our definition, with error checking added, should then look like this:
$GetTempPath = new Win32::API('kernel32', 'GetTempPath', 'NP', 'N'); if(not defined $GetTempPath) { die "Can't import API GetTempPath: $!\n"; }
To effectively make a call to an imported function you must use the
Call()
method on the Win32::API object you created.
Continuing with the example from the previous paragraph,
the GetTempPath()
API can be called using the method:
$GetTempPath->Call(...
Of course, parameters have to be passed as defined in the import phase.
In particular, if the number of parameters does not match (in the example,
if GetTempPath()
is called with more or less than two parameters),
Perl will croak
an error message and die
.
The two parameters needed here are the length of the buffer that will hold the returned temporary path, and a pointer to the buffer itself. For numerical parameters, you can use either a constant expression or a variable, while for pointers you must use a variable name (no Perl references, just a plain variable name). Also note that memory must be allocated before calling the function, just like in C. For example, to pass a buffer of 80 characters to GetTempPath(), it must be initialized before with:
$lpBuffer = " " x 80;
This allocates a string of 80 characters. If you don't do so, you'll
probably get Runtime exception
errors, and generally nothing will
work. The call should therefore include:
$lpBuffer = " " x 80; $GetTempPath->Call(80, $lpBuffer);
And the result will be stored in the $lpBuffer variable.
Note that you don't need to pass a reference to the variable
(eg. you don't need \$lpBuffer
), even if its value will be set
by the function.
A little problem here is that Perl does not trim the variable,
so $lpBuffer will still contain 80 characters in return; the exceeding
characters will be spaces, because we said " " x 80
.
In this case we're lucky enough, because the value returned by
the GetTempPath()
function is the length of the string, so to get
the actual temporary path we can write:
$lpBuffer = " " x 80; $return = $GetTempPath->Call(80, $lpBuffer); $TempPath = substr($lpBuffer, 0, $return);
If you don't know the length of the string, you can usually
cut it at the \0
(ASCII zero) character, which is the string
delimiter in
C:
$TempPath = ((split(/\0/, $lpBuffer))[0];
# or
$lpBuffer =~ s/\0.*$//;
Another note: to pass a pointer to a structure in
C, you have
to pack()
the required elements in a variable. And of course, to
access the values stored in a structure, unpack()
it as required.
A short example of how it works: the POINT
structure is defined
in
C as:
typedef struct { LONG x; LONG y; } POINT;
Thus, to call a function that uses a POINT
structure you
need the following lines:
$GetCursorPos = new Win32::API('user32', 'GetCursorPos', 'P', 'V');
$lpPoint = pack('LL', 0, 0); # store two LONGs $GetCursorPos->Call($lpPoint); ($x, $y) = unpack('LL', $lpPoint); # get the actual values
The rest is left as an exercise to the reader...
Aldo Calpini ( dada@perl.it ).
Win32::API - Perl Win32 API Import Facility |