librpc/idl/xattr.idl

   1 #include "idl_types.h"
   2
   3 /*
   4    IDL structures for xattr file attributes
   5
   6    this has nothing to do with RPC, we are just using our NDR/IDL
   7    infrastructure as a convenient way to store linearised information
   8    about a file in a architecture independent manner
   9 */
  10
  11 import "security.idl";
  12
  13 [
  14   version(0.0),
  15   helper("../librpc/ndr/ndr_xattr.h"),
  16   pyhelper("librpc/ndr/py_xattr.c"),
  17   pointer_default(unique)
  18 ]
  19 interface xattr
  20 {
  21         const char *XATTR_DOSATTRIB_NAME = "user.DosAttrib";
  22         const char *XATTR_DOSATTRIB_NAME_S3 = "user.DOSATTRIB";
  23         const int XATTR_DOSATTRIB_ESTIMATED_SIZE = 64;
  24
  25         /* we store basic dos attributes in a DosAttrib xattr. By
  26            using a union we can cope with new version of this
  27            structure more easily */
  28
  29         /*
  30          * the FFFF level is never really used,
  31          * it's used to pass the information from
  32          * the old hex string attrib information
  33          * we have a handwritten parser which converts
  34          * the hex string to the xattr_DosInfoFFFFCompat strucure
  35          */
  36
  37         typedef struct {
  38                 uint32 attrib;
  39         } xattr_DosInfoFFFFCompat;
  40
  41         typedef struct {
  42                 uint32 attrib;
  43                 uint32 ea_size;
  44                 udlong size;
  45                 udlong alloc_size;
  46                 NTTIME create_time;
  47                 NTTIME change_time;
  48         } xattr_DosInfo1;
  49
  50 /*
  51         We use xattrDosInfo1 again when we store values.
  52         Because the sticky write time is now stored in the opendb
  53         and xattr_DosInfo2Old is only present to parse existing
  54         values from disk.
  55
  56         const int XATTR_ATTRIB_FLAG_STICKY_WRITE_TIME = 0x1;
  57 */
  58         typedef struct {
  59                 uint32     flags;
  60                 uint32     attrib;
  61                 uint32     ea_size;
  62                 udlong     size;
  63                 udlong     alloc_size;
  64                 NTTIME     create_time;
  65                 NTTIME     change_time;
  66                 NTTIME     write_time; /* only used when sticky write time is set */
  67                 utf8string name;
  68         } xattr_DosInfo2Old;
  69
  70         typedef [bitmap32bit] bitmap {
  71                 XATTR_DOSINFO_ATTRIB            = 0x00000001,
  72                 XATTR_DOSINFO_EA_SIZE           = 0x00000002,
  73                 XATTR_DOSINFO_SIZE              = 0x00000004,
  74                 XATTR_DOSINFO_ALLOC_SIZE        = 0x00000008,
  75                 XATTR_DOSINFO_CREATE_TIME       = 0x00000010,
  76                 XATTR_DOSINFO_CHANGE_TIME       = 0x00000020,
  77                 XATTR_DOSINFO_ITIME             = 0x00000040
  78         } xattr_DosInfoValidFlags;
  79
  80         typedef struct {
  81                 xattr_DosInfoValidFlags valid_flags;
  82                 uint32 attrib;
  83                 uint32 ea_size;
  84                 udlong size;
  85                 udlong alloc_size;
  86                 NTTIME create_time;
  87                 NTTIME change_time;
  88         } xattr_DosInfo3;
  89
  90         typedef struct {
  91                 xattr_DosInfoValidFlags valid_flags;
  92                 uint32 attrib;
  93                 NTTIME itime;
  94                 NTTIME create_time;
  95         } xattr_DosInfo4;
  96
  97         typedef struct {
  98                 xattr_DosInfoValidFlags valid_flags;
  99                 uint32 attrib;
 100                 NTTIME create_time;
 101         } xattr_DosInfo5;
 102
 103         typedef [public,switch_type(uint16)] union {
 104                 [case(0xFFFF)] xattr_DosInfoFFFFCompat compatinfoFFFF;
 105                 [case(1)] xattr_DosInfo1 info1;
 106                 [case(2)] xattr_DosInfo2Old oldinfo2;
 107                 [case(3)] xattr_DosInfo3 info3;
 108                 [case(4)] xattr_DosInfo4 info4;
 109                 [case(5)] xattr_DosInfo5 info5;
 110         } xattr_DosInfo;
 111
 112         typedef [public] struct {
 113                 uint16 version;
 114                 [switch_is(version)] xattr_DosInfo info;
 115         } xattr_DosAttrib;
 116
 117         typedef [public,nopush,nopull,noprint] struct {
 118                 astring attrib_hex;
 119                 uint16 version;
 120                 [switch_is(version)] xattr_DosInfo info;
 121         } xattr_DOSATTRIB;
 122
 123         /* we store DOS style extended attributes in a DosEAs xattr */
 124         const char *XATTR_DOSEAS_NAME = "user.DosEAs";
 125
 126         typedef struct {
 127                 utf8string name;
 128                 DATA_BLOB value;
 129         } xattr_EA;
 130
 131         typedef [public] struct {
 132                 uint16 num_eas;
 133                 [size_is(num_eas)] xattr_EA *eas;
 134         } xattr_DosEAs;
 135
 136         /* Slightly different version, used by the vfs_xattr_tdb module */
 137         typedef [public] struct {
 138                 uint32 num_eas;
 139                 xattr_EA eas[num_eas];
 140         } tdb_xattrs;
 141
 142         /* we store stream information in this xattr structure. Then
 143            the streams themselves are stored in
 144            user.DosStream.STREAMNAME or in external files, according
 145            to the flags */
 146         const char *XATTR_DOSSTREAMS_NAME = "user.DosStreams";
 147
 148         const int XATTR_STREAM_FLAG_INTERNAL = 0x00000001;
 149
 150         /* stream data is stored in attributes with the given prefix */
 151         const char *XATTR_DOSSTREAM_PREFIX = "user.DosStream.";
 152
 153         const int XATTR_MAX_STREAM_SIZE     = 0x4000;
 154         const int XATTR_MAX_STREAM_SIZE_TDB = 0x100000;
 155
 156         typedef struct {
 157                 uint32     flags;
 158                 udlong     size;
 159                 udlong     alloc_size;
 160                 utf8string name;
 161         } xattr_DosStream;
 162
 163         typedef [public] struct {
 164                 uint32 num_streams;
 165                 [size_is(num_streams)] xattr_DosStream *streams;
 166         } xattr_DosStreams;
 167
 168
 169         /* we store the NT ACL a NTACL xattr. It is versioned so we
 170            can later add other acl attribs (such as posix acl mapping)
 171
 172            we put this xattr in the security namespace to ensure that
 173            only trusted users can write to the ACL
 174
 175            stored in "security.NTACL"
 176
 177            Version 1. raw SD stored as Samba4 does it.
 178            Version 2. raw SD + last changed hash so we
 179                       can discard if this doesn't match the underlying ACL hash.
 180         */
 181
 182         const char *XATTR_NTACL_NAME = "security.NTACL";
 183
 184         const int XATTR_SD_HASH_SIZE = 64;
 185         const int XATTR_SD_HASH_TYPE_NONE = 0x0;
 186         const int XATTR_SD_HASH_TYPE_SHA256 = 0x1;
 187
 188         typedef [public] struct {
 189                 security_descriptor *sd;
 190                 uint8 hash[16];
 191         } security_descriptor_hash_v2; /* Hash never used in this version. */
 192
 193         typedef [public] struct {
 194                 security_descriptor *sd;
 195                 uint16 hash_type;
 196                 uint8 hash[64]; /* 64 bytes hash. */
 197         } security_descriptor_hash_v3;
 198
 199         typedef [public] struct {
 200                 security_descriptor *sd;
 201                 uint16 hash_type;
 202                 uint8 hash[64]; /* 64 bytes hash. */
 203                 utf8string description; /* description of what created
 204                                          * this hash (to allow
 205                                          * forensics later, if we have
 206                                          * a bug in one codepath */
 207                 NTTIME time;
 208                 uint8 sys_acl_hash[64]; /* 64 bytes hash. */
 209         } security_descriptor_hash_v4;
 210
 211         typedef [switch_type(uint16)] union {
 212                 [case(1)] security_descriptor *sd;
 213                 [case(2)] security_descriptor_hash_v2 *sd_hs2;
 214                 [case(3)] security_descriptor_hash_v3 *sd_hs3;
 215                 [case(4)] security_descriptor_hash_v4 *sd_hs4;
 216         } xattr_NTACL_Info;
 217
 218         typedef [public] struct {
 219                 uint16 version;
 220                 [switch_is(version)] xattr_NTACL_Info info;
 221         } xattr_NTACL;
 222
 223         /*
 224          * A wrapper of the common information required to be in the
 225          * hash of the ACL, for the acl_xattr and acl_tdb modules.
 226          */
 227         [public] typedef struct {
 228                 DATA_BLOB acl_as_blob;
 229                 uid_t owner;
 230                 gid_t group;
 231                 mode_t mode;
 232         } xattr_sys_acl_hash_wrapper;
 233
 234 }