HP OpenVMS System Services Reference Manual
Specify the item codes as follows:
| Item Code |
Required |
Parameter Type |
|
REG$_FLAGSUBKEY
|
Yes
|
Input
|
|
REG$_KEYID
|
Yes
|
Input
|
|
REG$_KEYPATH
|
No
|
Input (Pointer to Unicode string. Unicode character is 4 bytes long.)
|
|
REG$_NOTIFYFILTER
|
Yes
|
Input
|
|
REG$_RETURNSTATUS
|
No
|
Output
|
REG$FC_OPEN_KEY
This request opens the specified key. If you do not specify a subkey,
the system opens the key specified in REG$_KEYID.
If REG$_KEYID specifies a key other than a predefined key, the system
opens the key again (duplicates the key).
Specify the item codes as follows:
| Item Code |
Required |
Parameter Type |
|
REG$_KEYID
|
Yes
|
Input
|
|
REG$_KEYRESULT
|
Yes
|
Output
|
|
REG$_KEYPATH
|
No
|
Input (Pointer to Unicode string. Unicode character is 4 bytes long.)
|
|
REG$_RETURNSTATUS
|
No
|
Output
|
|
REG$_SECACCESS
|
Yes
|
Input
|
|
REG$_SUBKEYNAME
|
No
|
Input (Pointer to Unicode string. Unicode character is 4 bytes long.)
|
REG$FC_QUERY_KEY
This request retrieves attributes about a specified key.
Specify the item codes as follows:
| Item Code |
Required |
Parameter Type |
|
REG$_CACHEACTION
|
No
|
Output
|
|
REG$_CLASSNAME
|
No
|
Output (Pointer to Unicode string. Unicode character is 4 bytes long.)
|
|
REG$_CLASSNAMEMAX
|
No
|
Output
|
|
REG$_KEYID
|
Yes
|
Input
|
|
REG$_KEYPATH
|
No
|
Input (Pointer to Unicode string. Unicode character is 4 bytes long.)
|
|
REG$_LASTWRITE
|
No
|
Output
|
|
REG$_LINKCOUNT
|
No
|
Output
|
|
REG$_LINKPATH
|
No
|
Output (Pointer to Unicode string. Unicode character is 4 bytes long.)
|
|
REG$_LINKTYPE
|
No
|
Output
|
|
REG$_RETURNSTATUS
|
No
|
Output
|
|
REG$_SECURITYPOLICY
|
No
|
Output
|
|
REG$_SUBKEYNAMEMAX
|
No
|
Output
|
|
REG$_SUBKEYSNUMBER
|
Yes
|
Output
|
|
REG$_VALUEDATAMAX
|
No
|
Output
|
|
REG$_VALUENAMEMAX
|
No
|
Output
|
|
REG$_VALUENUMBER
|
No
|
Output
|
|
REG$_VOLATILE
|
No
|
Output
|
REG$FC_QUERY_VALUE
This request retrieves the type, data flags, and data for the specified
value name.
Using this function code, you can group multiple requests into a single
call to the $REGISTRY service.
If you use this multiple-request feature, use the REG$_SEPARATOR item
code to indicate the end of the set of item codes for the current
request and that there is another request to process.
Specify the item codes as follows:
| Item Code |
Required |
Parameter Type |
|
REG$_DATAFLAGS
|
No
|
Output
|
|
REG$_DATATYPE
|
No
|
Output
|
|
REG$_KEYPATH
|
No
|
Input (Pointer to Unicode string. Unicode character is 4 bytes long.)
|
|
REG$_KEYID
|
Yes
|
Input
|
|
REG$_LINKCOUNT
|
No
|
Output
|
|
REG$_LINKPATH
|
No
|
Output (Pointer to Unicode string. Unicode character is 4 bytes long.)
|
|
REG$_LINKTYPE
|
No
|
Output
|
|
REG$_RETURNSTATUS
|
No
|
Output
|
|
REG$_SEPARATOR
|
No
|
n/a
|
|
REG$_VALUEDATA
|
No
|
Output
|
|
REG$_VALUEDATASIZE
|
No
|
Output
|
|
REG$_VALUENAME
|
Yes
|
Input
|
|
REG$_VOLATILE
|
No
|
Output
|
REG$FC_SEARCH_TREE_DATA
This request scans a specified key and all its descendants for a match
with a specified set of data information.
The set of data information can be either the REG$_DATAFLAGS item code,
or the pair REG$_DATATYPE and REG$_VALUEDATA item codes, or all three
item codes.
The REG$_FLAGOPCODE item code specifies how the REG$_DATAFLAGS item
code should be matched against the database. (See the item codes
description for more information about the REG$_FLAGOPCODE item code.)
Every time the system finds a match, it appends the path name relative
to the specified key to the REG$_PATHBUFFER item code. A Unicode null
character is used to separate the value path names.
If the buffer supplied by the application is not big enough to hold all
the value path names found, the system returns the SS$_BUFFEROVF error
message in the iosb argument, and the length required
to complete the operation successfully is returned in the
REG$_REQLENGTH item (if specified).
Use the ellipsis (...) wildcard to match zero or more subkeys in the
REG$_KEYPATH item code.
(For example,
Hardware\...\disks
finds all the paths that start with the
Hardware
subkey and end with the
disk
subkey, with zero or more subkeys in between.)
Use the asterisk (*) wildcard to match an entire subkey or a portion of
a subkey in the REG$_KEYPATH item code.
Use the percent (%) wildcard to match one character in a key name in
the REG$_KEYPATH item code.
Specify the item codes as follows:
| Item Code |
Required |
Parameter Type |
|
REG$_DATAFLAGS
|
No
|
Input
|
|
REG$_DATATYPE
|
No
|
Input
|
|
REG$_FLAGOPCODE
|
No
|
Input
|
|
REG$_KEYPATH
|
No
|
Input (Pointer to Unicode string. Unicode character is 4 bytes long.)
|
|
REG$_KEYID
|
Yes
|
Input
|
|
REG$_PATHBUFFER
|
Yes
|
Output
|
|
REG$_REQLENGTH
|
No
|
Output
|
|
REG$_RETURNSTATUS
|
No
|
Output
|
|
REG$_VALUEDATA
|
No
|
Input
|
REG$FC_SEARCH_TREE_KEY
This request scans a specified key and all its descendants for a
specified key path.
For this function code, a valid key path is a Unicode string that can
include the ellipsis (...), asterisk (*), or percent (%) wildcard
character, but that cannot start with the backslash character (\).
Use the ellipsis (...) wildcard to match zero or more subkeys in the
REG$_KEYPATH item code. (For example,
Hardware\...\disks
finds all the paths that start with the
Hardware
subkey and end with the
disk
subkey, with zero or more subkeys in between.)
Use the asterisk (*) wildcard to match an entire subkey or a portion of
a subkey in the REG$_KEYPATH item code.
Use the percent (%) wildcard to match one character in a key name in
the REG$_KEYPATH item code.
An example of a valid key path is as follows:
Every time the system finds a match, the system appends its path name
relative to the specified key identifier to the REG$_PATHBUFFER item
code. A Unicode null character (4 bytes) separates the subkey path
names.
If the buffer supplied by the application is not big enough to contain
all the subkey path names found, the system returns the SS$_BUFFEROVF
error message in the iosb argument, and the system
returns the required length to complete the operation successfully in
the REG$_REQLENGTH item (if specified).
Specify the item codes as follows:
| Item Code |
Required |
Parameter Type |
|
REG$_KEYID
|
Yes
|
Input
|
|
REG$_KEYPATH
|
No
|
Input (Pointer to Unicode string. Unicode character is 4 bytes long.)
|
|
REG$_PATHBUFFER
|
Yes
|
Output
|
|
REG$_REQLENGTH
|
No
|
Output
|
|
REG$_RETURNSTATUS
|
No
|
Output
|
REG$FC_SEARCH_TREE_VALUE
This request scans a specified key and all its descendants for a
specified value name.
For this function code a valid key name is a Unicode string that can
include the ellipsis (...), asterisk (*), or percent (%) wildcard
character, but cannot start with the backslash character (\).
Use the ellipsis (...) wildcard to match zero or more subkeys in the
REG$_KEYPATH item code. (For example,
Hardware\...\disks
finds all the paths that start with the
Hardware
subkey and end with the
disk
subkey, with zero or more subkeys in between.)
Use the asterisk (*) wildcard to match an entire subkey or a portion of
a subkey in the REG$_KEYPATH item code.
Use the percent (%) wildcard to match one character in a key name in
the REG$_KEYPATH item code.
An example of a valid key path is as follows:
For this function code, a valid name is a Unicode string that can
include the asterisk (*) and percent (%) wildcard characters.
Every time the system finds a match, the system appends its path name
relative to the specified key identifier to the REG$_PATHBUFFER item
code. A Unicode null character (4 bytes) separates the subkey path
names.
If the buffer supplied by the application is not big enough to contain
all the subkey path names found, the system returns the SS$_BUFFEROVF
error message in the iosb argument, and the system
returns the required length to complete the operation successfully in
the REG$_REQLENGTH item (if specified).
Specify the item codes as follows:
| Item Code |
Required |
Parameter Type |
|
REG$_KEYPATH
|
No
|
Input (Pointer to Unicode string. Unicode character is 4 bytes long.)
|
|
REG$_KEYID
|
Yes
|
Input
|
|
REG$_PATHBUFFER
|
Yes
|
Output
|
|
REG$_REQLENGTH
|
No
|
Output
|
|
REG$_RETURNSTATUS
|
No
|
Output
|
|
REG$_VALUENAME
|
Yes
|
Input
|
REG$FC_SET_VALUE
This request sets value and type information for a specified key.
Using this function code, you can group multiple requests into a single
call to the $REGISTRY service.
If you use this multiple-request feature, use the REG$_SEPARATOR item
code to indicate the end of the set of item codes for the current
request and that there is another request to process.
When a value is set to a link, the system validates the link unless you
specify the REG$M_IGNORE_LINKS function code modifier.
Specify the item codes as follows:
| Item Code |
Required |
Parameter Type |
|
REG$_DATAFLAGS
|
No
|
Input
|
|
REG$_DATATYPE
|
No
|
Input
|
|
REG$_KEYID
|
Yes
|
Input
|
|
REG$_KEYPATH
|
No
|
Input (Pointer to Unicode string. Unicode character is 4 bytes long.)
|
|
REG$_LINKPATH
|
No
|
Input (Pointer to Unicode string. Unicode character is 4 bytes long.)
|
|
REG$_LINKTYPE
|
No
|
Input
|
|
REG$_RETURNSTATUS
|
No
|
Output
|
|
REG$_SEPARATOR
|
No
|
n/a
|
|
REG$_VALUEDATA
|
No
|
Input
|
|
REG$_VALUENAME
|
No
|
Input
|
Item Codes Table SYS-50 provides a summary of item codes that are
valid as an item descriptor in the itmlst argument.
The table lists the item codes, input/output usage, and data types.
Complete descriptions of each item code are provided in the sections
that follow this table.
Table SYS-50 Item Code Summary
| Item Code |
Input/Output |
Data Type |
|
REG$_CACHEACTION
|
Input, output
|
Longword
|
|
REG$_CLASSNAME
|
Input, output
|
(Pointer to Unicode string. Unicode character is 4 bytes long.)
|
|
REG$_CLASSNAMEMAX
|
Output
|
Longword
|
|
REG$_DATAFLAGS
|
Input, output
|
Quadword
|
|
REG$_DATATYPE
|
Input, output
|
Longword
|
|
REG$_DISPOSITION
|
Output
|
Longword
|
|
REG$_FLAGOPCODE
|
Input
|
Longword
|
|
REG$_FLAGSUBKEY
|
Input
|
Longword
|
|
REG$_KEYID
|
Input, output
|
Longword
|
|
REG$_KEYPATH
|
Input
|
(Pointer to Unicode string. Unicode character is 4 bytes long.)
|
|
REG$_KEYRESULT
|
Output
|
Longword
|
|
REG$_LASTWRITE
|
Output
|
Quadword
|
|
REG$_LINKCOUNT
|
Output
|
Longword
|
|
REG$_LINKPATH
|
Input, output
|
(Pointer to Unicode string. Unicode character is 4 bytes long.)
|
|
REG$_LINKTYPE
|
Input, output
|
Longword
|
|
REG$_NEWNAME
|
Input
|
Unicode string
|
|
REG$_NOTIFYFILTER
|
Input
|
Longword
|
|
REG$_PATHBUFFER
|
Output
|
Buffer
|
|
REG$_REQLENGTH
|
Output
|
Longword
|
|
REG$_RETURNSTATUS
|
Output
|
Longword
|
|
REG$_SECACCESS
|
Input
|
Longword
|
|
REG$_SECURITYPOLICY
|
Input, output
|
Longword
|
|
REG$_SEPARATOR
|
n/a
|
None
|
|
REG$_SUBKEYINDEX
|
Input
|
Longword
|
|
REG$_SUBKEYNAME
|
Input, output
|
(Pointer to Unicode string. Unicode character is 4 bytes long.)
|
|
REG$_SUBKEYNAMEMAX
|
Output
|
Longword
|
|
REG$_SUBKEYSNUMBER
|
Output
|
Longword
|
|
REG$_VALUEDATA
|
Input, output
|
Buffer
|
|
REG$_VALUEDATAMAX
|
Output
|
Longword
|
|
REG$_VALUEDATASIZE
|
Output
|
Longword
|
|
REG$_VALUEINDEX
|
Input
|
Longword
|
|
REG$_VALUENAME
|
Input, output
|
Unicode string
|
|
REG$_VALUENAMEMAX
|
Output
|
Longword
|
|
REG$_VALUENUMBER
|
Output
|
Longword
|
|
REG$_VOLATILE
|
Input, output
|
Longword
|
REG$_CACHEACTION
The REG$_CACHEACTION item code is an input item code. It is a longword
flag that specifies whether the information on a specified object
should be written to disk immediately. It takes one of the following
values:
| Cache Value |
Description |
|
REG$K_WRITEBEHIND
|
Write information about the specified object written to disk at a later
time (default).
|
|
REG$K_WRITETHRU
|
Write information about the specified object to disk immediately.
|
Note
If you do not specify this item code, the value or key inherits its
value from the parent object. By default, the entry points
(REG$_HKEY_CLASSES_ROOT, REG$_HKEY_LOCAL_MACHINE, and REG$_HKEY_USERS)
are set with a value equal to that of REG$K_WRITEBEHIND.
|
REG$_CLASSNAME
The REG$_CLASSNAME item code is, depending on the function code, either
an input or output item code.
The class name is an information field for a key. The type of an object
is an example of a class name. It can be composed of any string of
Unicode characters. A Unicode character is 4 bytes long.
REG$_CLASSNAMEMAX
The REG$_CLASSNAMEMAX item code is an output item code. It receives the
length, in bytes, of the longest string specifying a subkey class name.
REG$_DATAFLAGS
Depending on the function code, the REG$_DATAFLAGS item code is either
an input or output item code. It is a 64-bit application-dependent
value data flag.
REG$_DATATYPE
Depending on the function code, the REG$_DATATYPE item code is either
an input or output item code.
It is a longword that either specifies the type of information to be
stored as a value data or receives the type of information of a
specified value data component.
It takes one of the following values:
| Type code |
Description |
|
REG$K_BINARY
|
Binary data
|
|
REG$K_DWORD
|
A 32-bit number
|
|
REG$K_EXPAND_SZ
|
A string of Unicode characters
|
|
REG$K_MULTI_SZ
|
A concatenated array of REG$K_SZ strings
|
|
REG$K_NONE
|
No defined value type (default)
|
|
REG$K_QWORD
|
A 64-bit number
|
|
REG$K_SZ
|
A null-terminated Unicode string
|
Note
The difference between REG$K_EXPAND_SZ and REG$K_SZ:
A string is a set of characters usually in human-readable form. Many
value entries in the OpenVMS Registry are written using a
string (REG_SZ) or an expandable
string (REG_EXPAND_SZ) format.
An expandable string is usually human-readable text, but it can also
include a variable that will be replaced when the string is called by
an application.
For example, on a Windows NT system, in the value entry
%SystemRoot%\System32\Bootok.exe
,
%SystemRoot%
is the expandable portion of the variable. This part is replaced with
the actual location of the directory that contains the Windows NT
system files.
|
REG$_DISPOSITION
The REG$_DISPOSITION item code is an output item code. It is a longword
and takes one of the following values:
| Disposition value |
Description |
|
REG$K_CREATENEWKEY
|
The key did not exist and was created.
|
|
REG$K_OPENEXISTINGKEY
|
The key existed and was opened.
|
REG$_FLAGOPCODE
The REG$_FLAGOPCODE item code is an input item code. It is a longword
flag that indicates how the REG$_DATAFLAGS input item code should be
matched against the data flags field in the OpenVMS Registry database. It
takes one of the following values:
| Operator code options |
Description |
|
REG$K_ANY
|
The data field in the OpenVMS Registry database must contain at least one
of the flags in the REG$_DATAFLAGS input item code.
|
|
REG$K_EXACTMATCH
|
The REG$_DATAFLAGS input item code must match exactly the data flags
field in the OpenVMS Registry database.
|
|
REG$K_EXCLUDE
|
The data flags field in the OpenVMS Registry database must
not contain the flags in the REG$_DATAFLAGS input item code.
|
|
REG$K_INCLUDE
|
The data flags field in the OpenVMS Registry database must contain, at a
minimum, the flags in the REG$_DATAFLAGS input item code.
|
|
REG$K_NOTANY
|
The data field in the OpenVMS Registry database must
not contain any of the flags in the REG$_DATAFLAGS input item
code.
|
REG$_FLAGSUBKEY
The REG$_FLAGSUBKEY item code is an input item code. It is a longword
Boolean field that indicates the following:
- If set to 1, report changes in a specified key and any of its
subkeys.
- If set to 0, report changes to a specified key only.
REG$_KEYID
The REG$_KEYID item code is an input item code. It is a longword that
contains the key identifier.
REG$_KEYRESULT
The REG$_KEYRESULT item code is an output item code. It is a longword
that receives a key identifier. The key identifier can be passed to
other Registry calls using the REG$_KEYID item code.
REG$_KEYPATH
The REG$_KEYPATH item code is an input item code. It is a string of
Unicode characters that specifies a key path. A Unicode character is 4
bytes long.
REG$_LASTWRITE
The REG$_LASTWRITE item code is an output item code. It is a quadword
representation of absolute time that receives the time a specified key
was last written to (including changes to its values).
REG$_LINKCOUNT
The REG$_LINKCOUNT item code is an output item code. It is longword
count of the number of symbolic links that refer to the item.
REG$_LINKPATH
The REG$_LINKPATH item code is, depending on the function code, either
an input or an output item code. It is a string of Unicode characters
that specifies the key path to which a specified key is linked. A
Unicode character is 4 bytes long.
REG$_LINKTYPE
The REG$_LINKTYPE item code is, depending on the function code, either
an input or an output item code. It is longword type that indicates the
link type.
| Link Type |
Description |
|
REG$K_NONE
|
No link (default)
|
|
REG$K_SYMBOLICLINK
|
Symbolic (logical) link
|
REG$_NEWNAME
The REG$_NEWNAME item code is a string of Unicode characters that
specifies the new name of the key.
REG$_NOTIFYFILTER
The REG$_NOTIFYFILTER item code is an input item code. It is a longword
mask that specifies which changes to the specified key and its subkeys
and values to report. It takes any combination of the following values:
| Value |
Description |
|
REG$M_CHANGEATTRIBUTES
|
An attribute change of the specified key or its subkeys.
|
|
REG$M_CHANGELASTSET
|
Changes to the last write time of the specified key or its subkeys.
|
|
REG$M_CHANGENAME
|
A key name change, including creation and deletion, of the specified
key or its subkeys.
|
| 
