Re: how do I read registry key?

[ToddAndMargo via perl6-users]

This is how far I have gotten:

Note that is I use a "0" in
$RtnCode = RegQueryValueExW( HKEY_LOCAL_MACHINE, $lpValueName, 1, 
REG_DWORD, $lpData, $lpcbData );

The program dies with no return code.

-T



        K:\Windows\NtUtil>perl6 -I. -e "use WinMount :GetLUA; say 
GetLUA();"
        RegOpenKeyExW
        RegOpenKeyExW   RtnCode 161

        RegQueryValueExW
        1
        2
        RegQueryValueExW   RtnCode 87
        lpData pointer 0
        lpcbData data length 0

        RegCloseKey
        RegCloseKey   RtnCode 6

        True





        # unit module WinMount;
        # WinMount.pm6

        #`{

           Utilities to mount and dismound drive partitions
           Note: LUA must be unset (0x00000000) for mount to function 
prpoperly

           raku -I. -c WinMount.pm6

        }

        use NativeCall;
        use WinPopUps :WinMsg;


        # Reference to types and values: 
http://dsource.org/projects/tango/ticket/820

        constant BYTE    := uint8;
        constant WCHAR   := uint16;
        constant DWORD   := int32;
        constant REGSAM  := int32;
        constant WCHARS  := CArray[WCHAR];
        constant BYTES   := CArray[BYTE];

        constant HKEY_CURRENT_USER  = 0x80000001;
        constant HKEY_LOCAL_MACHINE = 0x80000002;
        constant KEY_QUERY_VALUE   = 1;
        constant ERROR_SUCCESS     = 0; # Yeah, I know. The Win-Api 
uses 0 for success and other values to indicate errors
        constant REG_SZ = 1;

        constant KEY_READ      = 0x20019;
        constant KEY_SET_VALUE = 0x0002;
        constant REG_DWORD     = 0x00000004;



        sub to-c-str( Str $str ) returns CArray[WCHAR]  is export( 
:to-c-str ) {
           my @str := CArray[WCHAR].new;
           for ( $str.comb ).kv -> $i, $char { @str[$i] = $char.ord; }
           @str[ $str.chars ] = 0;
           @str;
        }


        sub wstr( Str $str ) returns WCHARS  is export( :wstr ) {
            CArray[WCHAR].new( $str.comb.map: *.ord )
        }


        sub GetLUA() is export( :GetLUA ) {

        #`{

        Returns the LUA value in the registry to True (0x00000001) or 
False (0x00000000)


[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System]
                  "EnableLUA"=dword:00000000

            https://docs.perl6.org/language/nativecall

        }

           my Str $SubName = &?ROUTINE.name;
           my Str $OS      = $*KERNEL.name;
           if not $OS eq "win32" { say "Sorry, $SubName only work in 
Windows."; exit; }

           my Bool  $LUA = True;
           my       $RtnCode;

           my Str   $SubKey = 
'\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System';
           my Str   $Key = $SubKey ~ '\EnableLUA';

           my       $lpSubKey    = wstr( $SubKey );
           my       $lpValueName = wstr( $Key );
           # my $lpSubKey    = CArray[uint8].new($Key.encode.list);
           # my $lpValueName = CArray[uint8].new($SubKey.encode.list);


           my int32 $Handle;
           my int32 $ulOptions = 0;
           my int32 $lpData;
           my int32 $lpcbData;


        #`{
            Open the key:

https://docs.microsoft.com/en-us/windows/win32/api/winreg/nf-winreg-regopenkeyexw

https://docs.microsoft.com/en-us/windows/win32/sysinfo/registry-key-security-and-access-rights
            C++
            LSTATUS RegOpenKeyExW(
               HKEY    hKey,          # Hive name (HKEY_LOCAL_MACHINE)
               LPCWSTR lpSubKey,      # path to the 
key(/SOFTWARE/Microsoft/Windows/CurrentVersion/Policies/System/EnableLUA)
               DWORD   ulOptions,     # 0
               REGSAM  samDesired,    # KEY_READ (0x20019), 
KEY_SET_VALUE (0x0002)
               PHKEY   phkResult      # A pointer to a variable that 
receives a handle to the opened key
            );
        }
           say "RegOpenKeyExW";
           sub RegOpenKeyExW( DWORD, WCHARS, DWORD, DWORD, DWORD is rw) 
is native("Kernel32.dll") returns DWORD { * };
           $RtnCode = RegOpenKeyExW( HKEY_LOCAL_MACHINE, $lpSubKey, 
$ulOptions, KEY_READ, $Handle );
           say "RegOpenKeyExW   RtnCode $RtnCode\n";



        #`{
            Read the key:
            use RegQueryValueExW if you know key and value name

https://docs.microsoft.com/en-us/windows/win32/api/winreg/nf-winreg-regqueryvalueexw
            C++
            LSTATUS RegQueryValueExW(
               HKEY    hKey,          # Hive name (HKEY_LOCAL_MACHINE)
               LPCWSTR lpValueName,   # path to the 
key(\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System\EnableLUA)
               LPDWORD lpReserved,    # give it "int32" without the 
quotes to give it a NULL
               LPDWORD lpType,        # Registry Value Type (REG_DWORD 
which is 32 bit)
               LPBYTE  lpData,        # Pointer to the return value
               LPDWORD lpcbData       # number of bytes in the return value
            );
        }
           say "RegQueryValueExW";
           sub RegQueryValueExW( DWORD, WCHARS, DWORD, DWORD, DWORD is 
rw, DWORD is rw ) is native("Kernel32.dll") returns DWORD { * };
        say "1";
           $RtnCode = RegQueryValueExW( HKEY_LOCAL_MACHINE, 
$lpValueName, 1, REG_DWORD, $lpData, $lpcbData );
        say "2";
           say "RegQueryValueExW   RtnCode $RtnCode\nlpData pointer 
$lpData\nlpcbData data length $lpcbData\n";



        #`{
            Close the key

https://docs.microsoft.com/en-us/windows/win32/api/winreg/nf-winreg-regclosekey
            C++
            LSTATUS RegCloseKey(
               HKEY hKey    # handle to the open key to be closed.  See 
RegOpenKeyExW phkResult
            );
        }
           say "RegCloseKey";
           sub RegCloseKey( DWORD ) is native("Kernel32.dll") returns 
DWORD { * };
           $RtnCode = RegCloseKey( $Handle );
           say "RegCloseKey   RtnCode $RtnCode\n";


           return $LUA;
        }