82480924c5a802199850d49ffb04e8f3e62c6f75
[samba.git] / 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
92 interface compression
93 {
94         const uint16 COMPRESSION_FORMAT_NONE = 0x0000;
95         const uint16 COMPRESSION_FORMAT_DEFAULT = 0x0001;
96         const uint16 COMPRESSION_FORMAT_LZNT1 = 0x0002;
97
98         typedef [public] struct {
99                 uint16 format;
100         } compression_state;
101 }
102
103 interface netinterface
104 {
105         typedef [bitmap32bit] bitmap {
106                 FSCTL_NET_IFACE_RSS_CAPABLE = 0x00000001,
107                 FSCTL_NET_IFACE_RDMA_CAPABLE = 0x00000002
108         } fsctl_net_iface_capability;
109
110         typedef [enum16bit] enum {
111                 FSCTL_NET_IFACE_AF_INET = 0x0002,
112                 FSCTL_NET_IFACE_AF_INET6 = 0x0017
113         } fsctl_sockaddr_af;
114
115         typedef [flag(NDR_NOALIGN)] struct {
116                 [value(0)] uint16 port;
117                 [flag(NDR_BIG_ENDIAN)] ipv4address ipv4;
118                 [value(0)] hyper reserved;
119         } fsctl_sockaddr_in;
120
121         typedef [flag(NDR_NOALIGN)] struct {
122                 [value(0)] uint16 port;
123                 [value(0)] uint32 flowinfo;
124                 [flag(NDR_BIG_ENDIAN)] ipv6address ipv6;
125                 [value(0)] uint32 scopeid;
126         } fsctl_sockaddr_in6;
127
128         typedef [nodiscriminant,flag(NDR_NOALIGN)] union {
129                 [case (FSCTL_NET_IFACE_AF_INET)] fsctl_sockaddr_in saddr_in;
130                 [case (FSCTL_NET_IFACE_AF_INET6)] fsctl_sockaddr_in6 saddr_in6;
131         } fsctl_sockaddr_union;
132
133         typedef [flag(NDR_NOALIGN)] struct {
134                 fsctl_sockaddr_af family;
135                 [subcontext(0),subcontext_size(126),switch_is(family)] fsctl_sockaddr_union saddr;
136         } fsctl_sockaddr_storage;
137
138         typedef [public,relative_base,noprint] struct {
139                 [relative] fsctl_net_iface_info *next;
140                 uint32 ifindex;
141                 fsctl_net_iface_capability capability;
142                 [value(0)] uint32 reserved;
143                 hyper linkspeed;
144                 fsctl_sockaddr_storage sockaddr;
145         } fsctl_net_iface_info;
146 }
147
148 interface sparse
149 {
150         /* MS-FSCC 2.3.33 FSCTL_QUERY_ALLOCATED_RANGES Request */
151         typedef [public] struct {
152                 hyper file_off;
153                 hyper len;
154         } file_alloced_range_buf;
155
156         typedef [public] struct {
157                 file_alloced_range_buf buf;
158         } fsctl_query_alloced_ranges_req;
159
160         /*
161          * 2.3.34 FSCTL_QUERY_ALLOCATED_RANGES Reply
162          * ...
163          * The number of FILE_ALLOCATED_RANGE_BUFFER elements returned is
164          * computed by dividing the size of the returned output buffer (from
165          * either SMB or SMB2, the lower-layer protocol that carries the FSCTL)
166          * by the size of the FILE_ALLOCATED_RANGE_BUFFER element.
167          */
168         typedef [public] struct {
169                 file_alloced_range_buf *array;
170         } fsctl_query_alloced_ranges_rsp;
171
172         /* 2.3.65 FSCTL_SET_ZERO_DATA Request */
173         typedef [public] struct {
174                 hyper file_off;
175                 hyper beyond_final_zero;
176         } file_zero_data_info;
177
178         typedef [public] struct {
179                 file_zero_data_info info;
180         } fsctl_set_zero_data_req;
181 }