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_