windows-xp/Source/XPSP1/NT/published/sdk/inc/ntfsprop.h

/*++

Copyright (c) 1989-1999  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_

#if _MSC_VER > 1000
#pragma once
#endif

#ifdef __cplusplus
extern "C" {
#endif

//
//  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])


//
//  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)]))

//
//  All property output buffers are preceded by PROPERTY_OUTPUT_HEADER
//  which contains the amount of data returned.  If STATUS_BUFFER_OVERFLOW
//  is returned, the Length field contains the length required to satisfy
//  the request.
//

typedef struct _PROPERTY_OUTPUT_HEADER {
    ULONG Length;                   //  Total length in bytes of output buffer
} PROPERTY_OUTPUT_HEADER, *PPROPERTY_OUTPUT_HEADER;

//
//  PROPERTY_READ_CONTROL is the structure used to control all property read
//  operations.  Following the structure on a DWORD boundary is either
//  an instaence 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_OUTPUT_HEADER
//                                              PROPERTY_VALUES
//
//  PRC_READ_NAME:   PROPERTY_IDS => PROPERTY_OUTPUT_HEADER
//                                   PROPERTY_NAMES
//
//                             / PROPERTY_OUTPUT_HEADER
//  PRC_READ_ALL:    <empty> =>  PROPERTY_IDS
//                             \ 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.  Each structure may be absent
//  depending on the setting of the operation code:
//
//  PWC_WRITE_PROP:  PROPERTY_SPECIFICATIONS \__/ PROPERTY_OUTPUT_HEADER
//                   PROPERTY_VALUES         /  \ PROPERTY_IDS
//
//  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;

#ifdef __cplusplus
}
#endif

#endif  //  _NTFSPROP_