librpc/idl/ioctl.idl

   1 #include "idl_types.h"
   2 [
   3         pointer_default(unique)
   4 ]
   5 interface copychunk
   6 {
   7         typedef [public] struct {
   8                 uint8 resume_key[24];
   9                 uint32 context_len;
  10                 /* <56> Windows sends 4 bytes of zero for the context field. */
  11                 uint8 context[4];
  12         } req_resume_key_rsp;
  13
  14         typedef struct {
  15                 hyper source_off;
  16                 hyper target_off;
  17                 uint32 length;
  18                 uint32 reserved;
  19         } srv_copychunk;
  20
  21         typedef [public] struct {
  22                 uint8 source_key[24];
  23                 uint32 chunk_count;
  24                 uint32 reserved;
  25                 srv_copychunk chunks[chunk_count];
  26         } srv_copychunk_copy;
  27
  28         typedef [public] struct {
  29                 uint32 chunks_written;
  30                 uint32 chunk_bytes_written;
  31                 uint32 total_bytes_written;
  32         } srv_copychunk_rsp;
  33
  34         typedef [public] struct {
  35                 uint32 version;
  36                 uint32 size;
  37                 uint32 maximum_token_lifetime;
  38                 uint32 default_token_lifetime;
  39                 hyper maximum_xfer_size;
  40                 hyper optimal_xfer_count;
  41                 uint32 maximum_data_descriptors;
  42                 uint32 maximum_xfer_length_per_descriptor;
  43                 uint32 optimal_xfer_length_per_descriptor;
  44                 uint16 optimal_xfer_length_granularity;
  45                 uint8 reserved[2];
  46         } device_copy_offload_descriptor;
  47
  48         /* XXX: 0x00000001 is unconfirmed */
  49         const uint32 STORAGE_OFFLOAD_TOKEN_TYPE_ZERO_DATA = 0x00000001;
  50         typedef [public] struct {
  51                 uint32 token_type;
  52                 uint8 reserved[2];
  53                 uint16 token_id_len;
  54                 [size_is(token_id_len)] uint8 token[];
  55         } storage_offload_token;
  56
  57         typedef [public] struct {
  58                 uint32 size;
  59                 uint32 flags;
  60                 uint32 token_time_to_live;
  61                 uint32 reserved;
  62                 hyper file_offset;
  63                 hyper length;
  64         } fsctl_offload_read_input;
  65
  66         const uint32 OFFLOAD_READ_FLAG_FILE_TOO_SMALL = 0x00000001;
  67         const uint32 OFFLOAD_READ_FLAG_ALL_ZERO_BEYOND_RANGE = 0x00000002;
  68         const uint32 OFFLOAD_READ_FLAG_CANNOT_OFFLOAD_BEYOND_RANGE = 0x00000004;
  69         typedef [public] struct {
  70                 uint32 size;
  71                 uint32 flags;
  72                 hyper xfer_length;
  73                 uint8 token[512];
  74         } fsctl_offload_read_output;
  75
  76         typedef [public] struct {
  77                 uint32 size;
  78                 uint32 flags;
  79                 hyper file_offset;
  80                 hyper copy_length;
  81                 hyper xfer_offset;
  82                 uint8 token[512];
  83         } fsctl_offload_write_input;
  84
  85         typedef [public] struct {
  86                 uint32 size;
  87                 uint32 flags;
  88                 hyper length_written;
  89         } fsctl_offload_write_output;
  90
  91         typedef [public] struct {
  92                 /* The FileHandle field is the volatile part of the fileid */
  93                 hyper fid_volatile;
  94                 hyper source_off;
  95                 hyper target_off;
  96                 hyper byte_count;
  97         } fsctl_dup_extents_to_file;
  98 }
  99
 100 interface compression
 101 {
 102         const uint16 COMPRESSION_FORMAT_NONE = 0x0000;
 103         const uint16 COMPRESSION_FORMAT_DEFAULT = 0x0001;
 104         const uint16 COMPRESSION_FORMAT_LZNT1 = 0x0002;
 105
 106         typedef [public] struct {
 107                 uint16 format;
 108         } compression_state;
 109 }
 110
 111 interface netinterface
 112 {
 113         typedef [bitmap32bit] bitmap {
 114                 FSCTL_NET_IFACE_NONE_CAPABLE = 0x00000000,
 115                 FSCTL_NET_IFACE_RSS_CAPABLE = 0x00000001,
 116                 FSCTL_NET_IFACE_RDMA_CAPABLE = 0x00000002
 117         } fsctl_net_iface_capability;
 118
 119         typedef [enum16bit] enum {
 120                 FSCTL_NET_IFACE_AF_INET = 0x0002,
 121                 FSCTL_NET_IFACE_AF_INET6 = 0x0017
 122         } fsctl_sockaddr_af;
 123
 124         typedef [flag(NDR_NOALIGN)] struct {
 125                 [value(0)] uint16 port;
 126                 [flag(NDR_BIG_ENDIAN)] ipv4address ipv4;
 127                 [value(0)] hyper reserved;
 128         } fsctl_sockaddr_in;
 129
 130         typedef [flag(NDR_NOALIGN)] struct {
 131                 [value(0)] uint16 port;
 132                 [value(0)] uint32 flowinfo;
 133                 [flag(NDR_BIG_ENDIAN)] ipv6address ipv6;
 134                 [value(0)] uint32 scopeid;
 135         } fsctl_sockaddr_in6;
 136
 137         typedef [nodiscriminant,flag(NDR_NOALIGN)] union {
 138                 [case (FSCTL_NET_IFACE_AF_INET)] fsctl_sockaddr_in saddr_in;
 139                 [case (FSCTL_NET_IFACE_AF_INET6)] fsctl_sockaddr_in6 saddr_in6;
 140         } fsctl_sockaddr_union;
 141
 142         typedef [flag(NDR_NOALIGN)] struct {
 143                 fsctl_sockaddr_af family;
 144                 [subcontext(0),subcontext_size(126),switch_is(family)] fsctl_sockaddr_union saddr;
 145         } fsctl_sockaddr_storage;
 146
 147         typedef [public,relative_base,noprint] struct {
 148                 [relative] fsctl_net_iface_info *next;
 149                 uint32 ifindex;
 150                 fsctl_net_iface_capability capability;
 151                 [value(0)] uint32 reserved;
 152                 hyper linkspeed;
 153                 fsctl_sockaddr_storage sockaddr;
 154         } fsctl_net_iface_info;
 155 }
 156
 157 interface sparse
 158 {
 159         /* MS-FSCC 2.3.33 FSCTL_QUERY_ALLOCATED_RANGES Request */
 160         typedef [public] struct {
 161                 hyper file_off;
 162                 hyper len;
 163         } file_alloced_range_buf;
 164
 165         typedef [public] struct {
 166                 file_alloced_range_buf buf;
 167         } fsctl_query_alloced_ranges_req;
 168
 169         /*
 170          * 2.3.34 FSCTL_QUERY_ALLOCATED_RANGES Reply
 171          * ...
 172          * The number of FILE_ALLOCATED_RANGE_BUFFER elements returned is
 173          * computed by dividing the size of the returned output buffer (from
 174          * either SMB or SMB2, the lower-layer protocol that carries the FSCTL)
 175          * by the size of the FILE_ALLOCATED_RANGE_BUFFER element.
 176          *
 177          * This logic can't (currently) be represented in pidl, so just use a
 178          * blob. Perhaps in future we'll support:
 179          *      [flag(NDR_REMAINING)] file_alloced_range_buf array[];
 180          */
 181         typedef [public] struct {
 182                 [flag(NDR_REMAINING)] DATA_BLOB far_buf_array;
 183         } fsctl_query_alloced_ranges_rsp;
 184
 185         /* 2.3.65 FSCTL_SET_ZERO_DATA Request */
 186         typedef [public] struct {
 187                 hyper file_off;
 188                 hyper beyond_final_zero;
 189         } file_zero_data_info;
 190
 191         typedef [public] struct {
 192                 file_zero_data_info info;
 193         } fsctl_set_zero_data_req;
 194 }
 195
 196 interface resiliency
 197 {
 198         /* 2.2.31.3 NETWORK_RESILIENCY_REQUEST */
 199         typedef [public] struct {
 200                 uint32 timeout;
 201                 uint32 reserved;
 202         } network_resiliency_request;
 203 }
 204
 205 interface trim
 206 {
 207         /* MS-FSCC 2.3.73.1 FILE_LEVEL_TRIM_RANGE */
 208         typedef [public] struct {
 209                 hyper off;
 210                 hyper len;
 211         } file_level_trim_range;
 212
 213         /* MS-FSCC 2.3.73 FSCTL_FILE_LEVEL_TRIM Request */
 214         typedef [public] struct {
 215                 uint32 key;
 216                 uint32 num_ranges;
 217                 file_level_trim_range ranges[num_ranges];
 218         } fsctl_file_level_trim_req;
 219
 220         /* MS-FSCC 2.3.74 FSCTL_FILE_LEVEL_TRIM Reply */
 221         typedef [public] struct {
 222                 uint32 num_ranges_processed;
 223         } fsctl_file_level_trim_rsp;
 224 }