diff options
Diffstat (limited to 'public/sdk/inc/ntfsprop.h')
-rw-r--r-- | public/sdk/inc/ntfsprop.h | 264 |
1 files changed, 264 insertions, 0 deletions
diff --git a/public/sdk/inc/ntfsprop.h b/public/sdk/inc/ntfsprop.h new file mode 100644 index 000000000..a6669e614 --- /dev/null +++ b/public/sdk/inc/ntfsprop.h @@ -0,0 +1,264 @@ +/*++ + +Copyright (c) 1989-1996 Microsoft Corporation + +Module Name: + + ntfsprop.h + +Abstract: + + This module contains the structure definitions for nt property Fsctl calls. + +Author: + + Mark Zbikowski (MarkZ) 23-April-1996 + + +--*/ + + +#ifndef _NTFSPROP_ +#define _NTFSPROP_ + +// +// WARNING! This file requires OBJIDL.H. +// + + +// +// VARIABLE_STRUCTURE_SIZE returns the size of a structure S that contains +// an array of C structures V +// + +#define VARIABLE_STRUCTURE_SIZE(S,V,C) ((int)sizeof( S ) + ((C) - 1) * (int)sizeof( V )) + +// +// COUNTED_STRING is length-preceded unicode string. This does NOT include +// a trailing L'\0' +// + +typedef struct _COUNTED_STRING +{ + USHORT Length; + WCHAR Text[1]; +} COUNTED_STRING, *PCOUNTED_STRING; + +#define COUNTED_STRING_SIZE(l) \ + (sizeof( COUNTED_STRING ) - sizeof ( WCHAR ) + (l)) +#define COUNTED_STRING_LENGTH(c) \ + ((c)->Length) +#define COUNTED_STRING_TEXT(c) \ + (&(c)->Text[0]) + +// +// PROPERTY_SPECIFIER is a serialized form of a PROPSPEC. Instead of +// a LPWSTR, there is an offset from the beginning of the +// PROPERTY_SPECIFICATIONS to a COUNTED_STRING +// +// #define PRSPEC_LPWSTR ( 0 ) +// #define PRSPEC_PROPID ( 1 ) + +typedef struct _PROPERTY_SPECIFIER +{ + ULONG Variant; // Distinguish the type + union { // Switch on Variant + PROPID Id; // Property ID + ULONG NameOffset; // Offset to COUNTED_STRING + }; +} PROPERTY_SPECIFIER, *PPROPERTY_SPECIFIER; + + +// +// PROPERTY_SPECIFICATIONS is a serialized form of an array PROPERTY_SPECIFIERs. +// Immediately following PROPERTY_SPECIFICATIONS on a USHORT boundary are +// of the name strings. Each name string is a COUNTED_STRING +// + +typedef struct _PROPERTY_SPECIFICATIONS { + ULONG Length; // Length in bytes of structure and name strings + ULONG Count; // Count of PROPERTY_SPECIFIERS + PROPERTY_SPECIFIER Specifiers[1]; // Array of actual specifiers, length Count +} PROPERTY_SPECIFICATIONS, *PPROPERTY_SPECIFICATIONS; + +#define PROPERTY_SPECIFICATIONS_SIZE(c) \ + (VARIABLE_STRUCTURE_SIZE( PROPERTY_SPECIFICATIONS, PROPERTY_SPECIFIER, (c) )) +#define PROPERTY_SPECIFIER_ID(PS,I) \ + ((PS)->Specifiers[(I)].Id) +#define PROPERTY_SPECIFIER_COUNTED_STRING(PS,I) \ + ((PCOUNTED_STRING)Add2Ptr( (PS), (PS)->Specifiers[(I)].NameOffset)) +#define PROPERTY_SPECIFIER_NAME(PS,I) \ + (&PROPERTY_SPECIFIER_COUNTED_STRING( PS, I )->Text[0]) +#define PROPERTY_SPECIFIER_NAME_LENGTH(PS,I) \ + (PROPERTY_SPECIFIER_COUNTED_STRING( PS, I )->Length) + + +// +// PROPERTY_VALUES is a serialized form of an array of SERIALIZEDPROPERTYVALUES. +// Immediately following the structure are the values, each of which is on a DWORD +// boundary. The last PropertyValue (count+1) is used only to help determine the +// size of the last property value. The offsets to the values are relative +// to the address of the PROPERTY_VALUES structure itself. +// + +typedef struct _PROPERTY_VALUES { + ULONG Length; // Length in bytes of structure and values + ULONG Count; // Count of SERIALIZEDPROPERTYVALUES + ULONG PropertyValueOffset[1]; // Array of offsets to actual values, length count + 1 +} PROPERTY_VALUES, *PPROPERTY_VALUES; + +#define PROPERTY_VALUES_SIZE(c) \ + (VARIABLE_STRUCTURE_SIZE( PROPERTY_VALUES, ULONG, (c) + 1 )) +#define PROPERTY_VALUE_LENGTH(v,i) \ + ((v)->PropertyValueOffset[(i) + 1] - (v)->PropertyValueOffset[(i)]) +#define PROPERTY_VALUE(v,i) \ + ((SERIALIZEDPROPERTYVALUE *) Add2Ptr( (v), (v)->PropertyValueOffset[(i)])) + + +// +// PROPERTY_IDS is a serialized form of an array of PROPIDs +// + +typedef struct _PROPERTY_IDS { + ULONG Count; // Count of the number of propids + PROPID PropertyIds[1]; // Array of propids, length Count +} PROPERTY_IDS, *PPROPERTY_IDS; + +#define PROPERTY_IDS_SIZE(c) \ + (VARIABLE_STRUCTURE_SIZE( PROPERTY_IDS, PROPID, (c) )) +#define PROPERTY_ID(p,i) \ + ((p)->PropertyIds[i]) + + +// +// INDIRECT_PROPERTIES is a serialized form of an array of PROPID/string-value +// pairs. Immediately following the structure are the INDIRECT_ENTRIES, each of +// which is on a WCHAR boundary. +// + +typedef struct _INDIRECT_ENTRY { + PROPID PropertyId; // Propid of indirect property + ULONG IndirectValueOffset; // Offset to the string text, L'\0' terminated +} INDIRECT_ENTRY; + +typedef struct _INDIRECT_PROPERTIES { + ULONG Length; // Length in bytes of structure and values + ULONG Count; // Count of indirect properties being replaced + INDIRECT_ENTRY Entrys[1]; // First indirect entry +} INDIRECT_PROPERTIES, *PINDIRECT_PROPERTIES; + +#define INDIRECT_PROPERTIES_SIZE(c) \ + (VARIABLE_STRUCTURE_SIZE( INDIRECT_PROPERTIES, INDIRECT_ENTRY, (c) + 1 )) +#define INDIRECT_VALUE_ID(v,i) \ + ((v)->Entrys[i].PropertyId) +#define INDIRECT_VALUE_LENGTH(v,i) \ + ((v)->IndirectValueOffset[(i) + 1] - (v)->IndirectValueOffset[(i)]) +#define INDIRECT_VALUE(v,i) \ + ((SERIALIZED_PROPERTY_VALUE *) Add2Ptr( (v), (v)->Entrys[i].IndirectValueOffset)) + + +// +// PROPERTY_STAT_DATA is a serialized array of STATPROPSTG. Following the +// structure are the individual STATPROPSTG instances each of which is on a DWORD +// boundary. +// + +typedef struct _PROPERTY_STAT_DATA { + ULONG Length; // Length in bytes of structure and values + ULONG Count; // Count of STATPROPSTG entries that follow + STATPROPSTG PropertyStat[1]; // First statpropstg +} PROPERTY_STAT_DATA, *PPROPERTY_STAT_DATA; + + +// +// PROPERTY_NAMES is a serialized array of strings's. Following the structure +// are the individual strings, each of which is on a WCHAR boundary. The +// offsets to the property names are relative to the beginning of the +// PROPERTY_NAMES structure. There are count+1 offsets allowing the length +// of each to be calculated. +// + +typedef struct _PROPERTY_NAMES { + ULONG Length; // Length in bytes of structure and values + ULONG Count; // Count of strings + ULONG PropertyNameOffset[1]; // Array of offsets to property names. +} PROPERTY_NAMES, *PPROPERTY_NAMES; + +#define PROPERTY_NAMES_SIZE(c) \ + (VARIABLE_STRUCTURE_SIZE( PROPERTY_NAMES, ULONG, (c) + 1 )) +#define PROPERTY_NAME_LENGTH(v,i) \ + ((v)->PropertyNameOffset[(i) + 1] - (v)->PropertyNameOffset[(i)]) +#define PROPERTY_NAME(v,i) \ + ((PWCHAR) Add2Ptr( (v), (v)->PropertyNameOffset[(i)])) + + +// +// PROPERTY_READ_CONTROL is the structure used to control all property read +// operations. Following the structure on a DWORD boundary is either +// an instance of PROPERTY_IDS or PROPERTY_SPECIFICATIONS, depending on +// the operation code. +// +// On successful output, the data buffer will contain, on DWORD boundaries, +// in order PROPERTY_VALUES, PROPERTY_IDS, and PROPERTY_NAMES. Each structure +// may be absent depending on the setting of the operation code: +// +// PRC_READ_PROP: PROPERTY_SPECIFICATIONS => PROPERTY_VALUES +// +// PRC_READ_NAME: PROPERTY_IDS => PROPERTY_NAMES +// +// / PROPERTY_IDS +// PRC_READ_ALL: <empty> => PROPERTY_NAMES +// \ PROPERTY_VALUES +// +// + +typedef enum _READ_CONTROL_OPERATION { + PRC_READ_PROP = 0, + PRC_READ_NAME = 1, + PRC_READ_ALL = 2, +} READ_CONTROL_OPERATION; + +typedef struct _PROPERTY_READ_CONTROL { + READ_CONTROL_OPERATION Op; +} PROPERTY_READ_CONTROL, *PPROPERTY_READ_CONTROL; + + +// +// PROPERTY_WRITE_CONTROL is the structure used to control all property write +// operations. Following the structure on a DWORD boundary is either an instance +// of PROPERTY_IDS or PROPERTY_SPECIFICATIONS (used to control which properties are +// being changed) and followed by PROPERTY_VALUES and PROPERTY_NAMES. The +// presence of these are dependent on the operation code. +// +// On successful outputs, the data buffer will contain, on DWORD boundaries, +// in order PROPERTY_IDS and INDIRECT_PROPERTIES. Each structure may be absent +// depending on the setting of the operation code: +// +// PWC_WRITE_PROP: PROPERTY_SPECIFICATIONS \__/ PROPERTY_IDS +// PROPERTY_VALUES / \ INDIRECT_PROPERTIES +// +// PWC_DELETE_PROP: PROPERTY_SPECIFICATIONS => <empty> +// +// PWC_WRITE_NAME: PROPERTY_IDS \__ <empty> +// PROPERTY_NAMES / +// +// PWC_DELETE_NAME: PROPERTY_IDS => <empty> +// +// PROPERTY_IDS \ +// PWC_WRITE_ALL: PROPERTY_NAMES => <empty> +// PROPERTY_VALUES / + +typedef enum _WRITE_CONTROL_OPERATION { + PWC_WRITE_PROP = 0, + PWC_DELETE_PROP = 1, + PWC_WRITE_NAME = 2, + PWC_DELETE_NAME = 3, + PWC_WRITE_ALL = 4, +} WRITE_CONTROL_OPERATION; + +typedef struct _PROPERTY_WRITE_CONTROL { + WRITE_CONTROL_OPERATION Op; + PROPID NextPropertyId; +} PROPERTY_WRITE_CONTROL, *PPROPERTY_WRITE_CONTROL; + +#endif // _NTFSPROP_ |