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