Finish removal of iconv_convenience in public API's.
[bbaumbach/samba-autobuild/.git] / source4 / smb_server / smb2 / fileio.c
1 /* 
2    Unix SMB2 implementation.
3    
4    Copyright (C) Stefan Metzmacher      2005
5    
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 3 of the License, or
9    (at your option) any later version.
10    
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15    
16    You should have received a copy of the GNU General Public License
17    along with this program.  If not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include "includes.h"
21 #include "libcli/smb2/smb2.h"
22 #include "libcli/smb2/smb2_calls.h"
23 #include "smb_server/smb_server.h"
24 #include "smb_server/smb2/smb2_server.h"
25 #include "ntvfs/ntvfs.h"
26 #include "libcli/raw/raw_proto.h"
27 #include "librpc/gen_ndr/ndr_security.h"
28
29 static void smb2srv_create_send(struct ntvfs_request *ntvfs)
30 {
31         struct smb2srv_request *req;
32         union smb_open *io;
33         DATA_BLOB blob;
34
35         SMB2SRV_CHECK_ASYNC_STATUS(io, union smb_open);
36
37         /* setup the blobs we should give in the reply */
38         if (io->smb2.out.maximal_access != 0) {
39                 uint32_t data[2];
40                 SIVAL(data, 0, 0);
41                 SIVAL(data, 4, io->smb2.out.maximal_access);
42                 SMB2SRV_CHECK(smb2_create_blob_add(req, &io->smb2.out.blobs,
43                                                    SMB2_CREATE_TAG_MXAC, 
44                                                    data_blob_const(data, 8)));
45         }
46         
47
48         SMB2SRV_CHECK(smb2_create_blob_push(req, &blob, io->smb2.out.blobs));
49         SMB2SRV_CHECK(smb2srv_setup_reply(req, 0x58, true, blob.length));
50
51         SCVAL(req->out.body,    0x02,   io->smb2.out.oplock_level);
52         SCVAL(req->out.body,    0x03,   io->smb2.out.reserved);
53         SIVAL(req->out.body,    0x04,   io->smb2.out.create_action);
54         SBVAL(req->out.body,    0x08,   io->smb2.out.create_time);
55         SBVAL(req->out.body,    0x10,   io->smb2.out.access_time);
56         SBVAL(req->out.body,    0x18,   io->smb2.out.write_time);
57         SBVAL(req->out.body,    0x20,   io->smb2.out.change_time);
58         SBVAL(req->out.body,    0x28,   io->smb2.out.alloc_size);
59         SBVAL(req->out.body,    0x30,   io->smb2.out.size);
60         SIVAL(req->out.body,    0x38,   io->smb2.out.file_attr);
61         SIVAL(req->out.body,    0x3C,   io->smb2.out.reserved2);
62         smb2srv_push_handle(req->out.body, 0x40, io->smb2.out.file.ntvfs);
63         SMB2SRV_CHECK(smb2_push_o32s32_blob(&req->out, 0x50, blob));
64
65         /* also setup the chained file handle */
66         req->chained_file_handle = req->_chained_file_handle;
67         smb2srv_push_handle(req->chained_file_handle, 0, io->smb2.out.file.ntvfs);
68
69         smb2srv_send_reply(req);
70 }
71
72 void smb2srv_create_recv(struct smb2srv_request *req)
73 {
74         union smb_open *io;
75         DATA_BLOB blob;
76         int i;
77
78         SMB2SRV_CHECK_BODY_SIZE(req, 0x38, true);
79         SMB2SRV_TALLOC_IO_PTR(io, union smb_open);
80         SMB2SRV_SETUP_NTVFS_REQUEST(smb2srv_create_send, NTVFS_ASYNC_STATE_MAY_ASYNC);
81
82         ZERO_STRUCT(io->smb2.in);
83         io->smb2.level                  = RAW_OPEN_SMB2;
84         io->smb2.in.security_flags      = CVAL(req->in.body, 0x02);
85         io->smb2.in.oplock_level        = CVAL(req->in.body, 0x03);
86         io->smb2.in.impersonation_level = IVAL(req->in.body, 0x04);
87         io->smb2.in.create_flags        = BVAL(req->in.body, 0x08);
88         io->smb2.in.reserved            = BVAL(req->in.body, 0x10);
89         io->smb2.in.desired_access      = IVAL(req->in.body, 0x18);
90         io->smb2.in.file_attributes     = IVAL(req->in.body, 0x1C);
91         io->smb2.in.share_access        = IVAL(req->in.body, 0x20);
92         io->smb2.in.create_disposition  = IVAL(req->in.body, 0x24);
93         io->smb2.in.create_options      = IVAL(req->in.body, 0x28);
94         SMB2SRV_CHECK(smb2_pull_o16s16_string(&req->in, io, req->in.body+0x2C, &io->smb2.in.fname));
95         SMB2SRV_CHECK(smb2_pull_o32s32_blob(&req->in, io, req->in.body+0x30, &blob));
96         SMB2SRV_CHECK(smb2_create_blob_parse(io, blob, &io->smb2.in.blobs));
97
98         /* interpret the parsed tags that a server needs to respond to */
99         for (i=0;i<io->smb2.in.blobs.num_blobs;i++) {
100                 if (strcmp(io->smb2.in.blobs.blobs[i].tag, SMB2_CREATE_TAG_EXTA) == 0) {
101                         SMB2SRV_CHECK(ea_pull_list_chained(&io->smb2.in.blobs.blobs[i].data, io, 
102                                                            &io->smb2.in.eas.num_eas,
103                                                            &io->smb2.in.eas.eas));
104                 }
105                 if (strcmp(io->smb2.in.blobs.blobs[i].tag, SMB2_CREATE_TAG_SECD) == 0) {
106                         enum ndr_err_code ndr_err;
107                         io->smb2.in.sec_desc = talloc(io, struct security_descriptor);
108                         if (io->smb2.in.sec_desc == NULL) {
109                                 smb2srv_send_error(req,  NT_STATUS_NO_MEMORY);
110                                 return;
111                         }
112                         ndr_err = ndr_pull_struct_blob(&io->smb2.in.blobs.blobs[i].data, io, 
113                                                        io->smb2.in.sec_desc,
114                                                        (ndr_pull_flags_fn_t)ndr_pull_security_descriptor);
115                         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
116                                 smb2srv_send_error(req,  ndr_map_error2ntstatus(ndr_err));
117                                 return;
118                         }
119                 }
120                 if (strcmp(io->smb2.in.blobs.blobs[i].tag, SMB2_CREATE_TAG_DHNQ) == 0) {
121                         io->smb2.in.durable_open = true;
122                 }
123                 if (strcmp(io->smb2.in.blobs.blobs[i].tag, SMB2_CREATE_TAG_DHNC) == 0) {
124                         if (io->smb2.in.blobs.blobs[i].data.length != 16) {
125                                 smb2srv_send_error(req,  NT_STATUS_INVALID_PARAMETER);
126                                 return;                         
127                         }
128                         io->smb2.in.durable_handle = talloc(io, struct smb2_handle);
129                         if (io->smb2.in.durable_handle == NULL) {
130                                 smb2srv_send_error(req,  NT_STATUS_NO_MEMORY);
131                                 return;
132                         }
133                         smb2_pull_handle(io->smb2.in.blobs.blobs[i].data.data, io->smb2.in.durable_handle);
134                 }
135                 if (strcmp(io->smb2.in.blobs.blobs[i].tag, SMB2_CREATE_TAG_ALSI) == 0) {
136                         if (io->smb2.in.blobs.blobs[i].data.length != 8) {
137                                 smb2srv_send_error(req,  NT_STATUS_INVALID_PARAMETER);
138                                 return;                         
139                         }
140                         io->smb2.in.alloc_size = BVAL(io->smb2.in.blobs.blobs[i].data.data, 0);
141                 }
142                 if (strcmp(io->smb2.in.blobs.blobs[i].tag, SMB2_CREATE_TAG_MXAC) == 0) {
143                         io->smb2.in.query_maximal_access = true;
144                 }
145                 if (strcmp(io->smb2.in.blobs.blobs[i].tag, SMB2_CREATE_TAG_TWRP) == 0) {
146                         if (io->smb2.in.blobs.blobs[i].data.length != 8) {
147                                 smb2srv_send_error(req,  NT_STATUS_INVALID_PARAMETER);
148                                 return;                         
149                         }
150                         io->smb2.in.timewarp = BVAL(io->smb2.in.blobs.blobs[i].data.data, 0);                   
151                 }
152                 if (strcmp(io->smb2.in.blobs.blobs[i].tag, SMB2_CREATE_TAG_QFID) == 0) {
153                         io->smb2.in.query_on_disk_id = true;
154                 }
155         }
156                 
157         /* the VFS backend does not yet handle NULL filenames */
158         if (io->smb2.in.fname == NULL) {
159                 io->smb2.in.fname = "";
160         }
161
162         SMB2SRV_CALL_NTVFS_BACKEND(ntvfs_open(req->ntvfs, io));
163 }
164
165 static void smb2srv_close_send(struct ntvfs_request *ntvfs)
166 {
167         struct smb2srv_request *req;
168         union smb_close *io;
169
170         SMB2SRV_CHECK_ASYNC_STATUS(io, union smb_close);
171         SMB2SRV_CHECK(smb2srv_setup_reply(req, 0x3C, false, 0));
172
173         SSVAL(req->out.body,    0x02,   io->smb2.out.flags);
174         SIVAL(req->out.body,    0x04,   io->smb2.out._pad);
175         SBVAL(req->out.body,    0x08,   io->smb2.out.create_time);
176         SBVAL(req->out.body,    0x10,   io->smb2.out.access_time);
177         SBVAL(req->out.body,    0x18,   io->smb2.out.write_time);
178         SBVAL(req->out.body,    0x20,   io->smb2.out.change_time);
179         SBVAL(req->out.body,    0x28,   io->smb2.out.alloc_size);
180         SBVAL(req->out.body,    0x30,   io->smb2.out.size);
181         SIVAL(req->out.body,    0x38,   io->smb2.out.file_attr);
182
183         /* also destroy the chained file handle */
184         req->chained_file_handle = NULL;
185         memset(req->_chained_file_handle, 0, sizeof(req->_chained_file_handle));
186
187         smb2srv_send_reply(req);
188 }
189
190 void smb2srv_close_recv(struct smb2srv_request *req)
191 {
192         union smb_close *io;
193
194         SMB2SRV_CHECK_BODY_SIZE(req, 0x18, false);
195         SMB2SRV_TALLOC_IO_PTR(io, union smb_close);
196         SMB2SRV_SETUP_NTVFS_REQUEST(smb2srv_close_send, NTVFS_ASYNC_STATE_MAY_ASYNC);
197
198         io->smb2.level                  = RAW_CLOSE_SMB2;
199         io->smb2.in.flags               = SVAL(req->in.body, 0x02);
200         io->smb2.in._pad                = IVAL(req->in.body, 0x04);
201         io->smb2.in.file.ntvfs          = smb2srv_pull_handle(req, req->in.body, 0x08);
202
203         SMB2SRV_CHECK_FILE_HANDLE(io->smb2.in.file.ntvfs);
204         SMB2SRV_CALL_NTVFS_BACKEND(ntvfs_close(req->ntvfs, io));
205 }
206
207 static void smb2srv_flush_send(struct ntvfs_request *ntvfs)
208 {
209         struct smb2srv_request *req;
210         union smb_flush *io;
211
212         SMB2SRV_CHECK_ASYNC_STATUS(io, union smb_flush);
213         SMB2SRV_CHECK(smb2srv_setup_reply(req, 0x04, false, 0));
214
215         SSVAL(req->out.body,    0x02,   io->smb2.out.reserved);
216
217         smb2srv_send_reply(req);
218 }
219
220 void smb2srv_flush_recv(struct smb2srv_request *req)
221 {
222         union smb_flush *io;
223
224         SMB2SRV_CHECK_BODY_SIZE(req, 0x18, false);
225         SMB2SRV_TALLOC_IO_PTR(io, union smb_flush);
226         SMB2SRV_SETUP_NTVFS_REQUEST(smb2srv_flush_send, NTVFS_ASYNC_STATE_MAY_ASYNC);
227
228         io->smb2.level                  = RAW_FLUSH_SMB2;
229         io->smb2.in.reserved1           = SVAL(req->in.body, 0x02);
230         io->smb2.in.reserved2           = IVAL(req->in.body, 0x04);
231         io->smb2.in.file.ntvfs          = smb2srv_pull_handle(req, req->in.body, 0x08);
232
233         SMB2SRV_CHECK_FILE_HANDLE(io->smb2.in.file.ntvfs);
234         SMB2SRV_CALL_NTVFS_BACKEND(ntvfs_flush(req->ntvfs, io));
235 }
236
237 static void smb2srv_read_send(struct ntvfs_request *ntvfs)
238 {
239         struct smb2srv_request *req;
240         union smb_read *io;
241
242         SMB2SRV_CHECK_ASYNC_STATUS(io, union smb_read);
243         SMB2SRV_CHECK(smb2srv_setup_reply(req, 0x10, true, io->smb2.out.data.length));
244
245         /* TODO: avoid the memcpy */
246         SMB2SRV_CHECK(smb2_push_o16s32_blob(&req->out, 0x02, io->smb2.out.data));
247         SIVAL(req->out.body,    0x08,   io->smb2.out.remaining);
248         SIVAL(req->out.body,    0x0C,   io->smb2.out.reserved);
249
250         smb2srv_send_reply(req);
251 }
252
253 void smb2srv_read_recv(struct smb2srv_request *req)
254 {
255         union smb_read *io;
256
257         SMB2SRV_CHECK_BODY_SIZE(req, 0x30, true);
258
259         /* MS-SMB2 2.2.19 read must have a single byte of zero */
260         if (req->in.body_size - req->in.body_fixed < 1) {
261                 smb2srv_send_error(req,  NT_STATUS_INVALID_PARAMETER);
262                 return;
263         }
264         SMB2SRV_TALLOC_IO_PTR(io, union smb_read);
265         SMB2SRV_SETUP_NTVFS_REQUEST(smb2srv_read_send, NTVFS_ASYNC_STATE_MAY_ASYNC);
266
267         io->smb2.level                  = RAW_READ_SMB2;
268         io->smb2.in._pad                = SVAL(req->in.body, 0x02);
269         io->smb2.in.length              = IVAL(req->in.body, 0x04);
270         io->smb2.in.offset              = BVAL(req->in.body, 0x08);
271         io->smb2.in.file.ntvfs          = smb2srv_pull_handle(req, req->in.body, 0x10);
272         io->smb2.in.min_count           = IVAL(req->in.body, 0x20);
273         io->smb2.in.channel             = IVAL(req->in.body, 0x24);
274         io->smb2.in.remaining           = IVAL(req->in.body, 0x28);
275         io->smb2.in.channel_offset      = SVAL(req->in.body, 0x2C);
276         io->smb2.in.channel_length      = SVAL(req->in.body, 0x2E);
277
278         SMB2SRV_CHECK_FILE_HANDLE(io->smb2.in.file.ntvfs);
279
280         /* preallocate the buffer for the backends */
281         io->smb2.out.data = data_blob_talloc(io, NULL, io->smb2.in.length);
282         if (io->smb2.out.data.length != io->smb2.in.length) {
283                 SMB2SRV_CHECK(NT_STATUS_NO_MEMORY);
284         }
285
286         SMB2SRV_CALL_NTVFS_BACKEND(ntvfs_read(req->ntvfs, io));
287 }
288
289 static void smb2srv_write_send(struct ntvfs_request *ntvfs)
290 {
291         struct smb2srv_request *req;
292         union smb_write *io;
293
294         SMB2SRV_CHECK_ASYNC_STATUS(io, union smb_write);
295         SMB2SRV_CHECK(smb2srv_setup_reply(req, 0x10, true, 0));
296
297         SSVAL(req->out.body,    0x02,   io->smb2.out._pad);
298         SIVAL(req->out.body,    0x04,   io->smb2.out.nwritten);
299         SBVAL(req->out.body,    0x08,   io->smb2.out.unknown1);
300
301         smb2srv_send_reply(req);
302 }
303
304 void smb2srv_write_recv(struct smb2srv_request *req)
305 {
306         union smb_write *io;
307
308         SMB2SRV_CHECK_BODY_SIZE(req, 0x30, true);
309         SMB2SRV_TALLOC_IO_PTR(io, union smb_write);
310         SMB2SRV_SETUP_NTVFS_REQUEST(smb2srv_write_send, NTVFS_ASYNC_STATE_MAY_ASYNC);
311
312         /* TODO: avoid the memcpy */
313         io->smb2.level                  = RAW_WRITE_SMB2;
314         SMB2SRV_CHECK(smb2_pull_o16s32_blob(&req->in, io, req->in.body+0x02, &io->smb2.in.data));
315         io->smb2.in.offset              = BVAL(req->in.body, 0x08);
316         io->smb2.in.file.ntvfs          = smb2srv_pull_handle(req, req->in.body, 0x10);
317         io->smb2.in.unknown1            = BVAL(req->in.body, 0x20);
318         io->smb2.in.unknown2            = BVAL(req->in.body, 0x28);
319
320         SMB2SRV_CHECK_FILE_HANDLE(io->smb2.in.file.ntvfs);
321         SMB2SRV_CALL_NTVFS_BACKEND(ntvfs_write(req->ntvfs, io));
322 }
323
324 static void smb2srv_lock_send(struct ntvfs_request *ntvfs)
325 {
326         struct smb2srv_request *req;
327         union smb_lock *io;
328
329         SMB2SRV_CHECK_ASYNC_STATUS_ERR(io, union smb_lock);
330         SMB2SRV_CHECK(smb2srv_setup_reply(req, 0x04, false, 0));
331
332         SSVAL(req->out.body,    0x02,   io->smb2.out.reserved);
333
334         smb2srv_send_reply(req);
335 }
336
337 void smb2srv_lock_recv(struct smb2srv_request *req)
338 {
339         union smb_lock *io;
340         int i;
341
342         SMB2SRV_CHECK_BODY_SIZE(req, 0x30, false);
343         SMB2SRV_TALLOC_IO_PTR(io, union smb_lock);
344         SMB2SRV_SETUP_NTVFS_REQUEST(smb2srv_lock_send, NTVFS_ASYNC_STATE_MAY_ASYNC);
345
346         io->smb2.level                  = RAW_LOCK_SMB2;
347         io->smb2.in.lock_count          = SVAL(req->in.body, 0x02);
348         io->smb2.in.lock_sequence       = IVAL(req->in.body, 0x04);
349         io->smb2.in.file.ntvfs          = smb2srv_pull_handle(req, req->in.body, 0x08);
350         if (req->in.body_size < 24 + 24*(uint64_t)io->smb2.in.lock_count) {
351                 DEBUG(0,("%s: lock buffer too small\n", __location__));
352                 smb2srv_send_error(req,  NT_STATUS_FOOBAR);
353                 return;
354         }
355         io->smb2.in.locks = talloc_array(io, struct smb2_lock_element, 
356                                          io->smb2.in.lock_count);
357         if (io->smb2.in.locks == NULL) {
358                 smb2srv_send_error(req, NT_STATUS_NO_MEMORY);
359                 return;
360         }
361
362         for (i=0;i<io->smb2.in.lock_count;i++) {
363                 io->smb2.in.locks[i].offset     = BVAL(req->in.body, 24 + i*24);
364                 io->smb2.in.locks[i].length     = BVAL(req->in.body, 32 + i*24);
365                 io->smb2.in.locks[i].flags      = IVAL(req->in.body, 40 + i*24);
366                 io->smb2.in.locks[i].reserved   = IVAL(req->in.body, 44 + i*24);
367         }
368
369         SMB2SRV_CHECK_FILE_HANDLE(io->smb2.in.file.ntvfs);
370         SMB2SRV_CALL_NTVFS_BACKEND(ntvfs_lock(req->ntvfs, io));
371 }
372
373 static void smb2srv_ioctl_send(struct ntvfs_request *ntvfs)
374 {
375         struct smb2srv_request *req;
376         union smb_ioctl *io;
377
378         SMB2SRV_CHECK_ASYNC_STATUS_ERR(io, union smb_ioctl);
379         SMB2SRV_CHECK(smb2srv_setup_reply(req, 0x30, true, 0));
380
381         SSVAL(req->out.body,    0x02,   io->smb2.out._pad);
382         SIVAL(req->out.body,    0x04,   io->smb2.out.function);
383         if (io->smb2.level == RAW_IOCTL_SMB2_NO_HANDLE) {
384                 struct smb2_handle h;
385                 h.data[0] = UINT64_MAX;
386                 h.data[1] = UINT64_MAX;
387                 smb2_push_handle(req->out.body + 0x08, &h);
388         } else {
389                 smb2srv_push_handle(req->out.body, 0x08,io->smb2.in.file.ntvfs);
390         }
391         SMB2SRV_CHECK(smb2_push_o32s32_blob(&req->out, 0x18, io->smb2.out.in));
392         SMB2SRV_CHECK(smb2_push_o32s32_blob(&req->out, 0x20, io->smb2.out.out));
393         SIVAL(req->out.body,    0x28,   io->smb2.out.unknown2);
394         SIVAL(req->out.body,    0x2C,   io->smb2.out.unknown3);
395
396         smb2srv_send_reply(req);
397 }
398
399 void smb2srv_ioctl_recv(struct smb2srv_request *req)
400 {
401         union smb_ioctl *io;
402         struct smb2_handle h;
403
404         SMB2SRV_CHECK_BODY_SIZE(req, 0x38, true);
405         SMB2SRV_TALLOC_IO_PTR(io, union smb_ioctl);
406         SMB2SRV_SETUP_NTVFS_REQUEST(smb2srv_ioctl_send, NTVFS_ASYNC_STATE_MAY_ASYNC);
407
408         /* TODO: avoid the memcpy */
409         io->smb2.in._pad                = SVAL(req->in.body, 0x02);
410         io->smb2.in.function            = IVAL(req->in.body, 0x04);
411         /* file handle ... */
412         SMB2SRV_CHECK(smb2_pull_o32s32_blob(&req->in, io, req->in.body+0x18, &io->smb2.in.out));
413         io->smb2.in.unknown2            = IVAL(req->in.body, 0x20);
414         SMB2SRV_CHECK(smb2_pull_o32s32_blob(&req->in, io, req->in.body+0x24, &io->smb2.in.in));
415         io->smb2.in.max_response_size   = IVAL(req->in.body, 0x2C);
416         io->smb2.in.flags               = BVAL(req->in.body, 0x30);
417
418         smb2_pull_handle(req->in.body + 0x08, &h);
419         if (h.data[0] == UINT64_MAX && h.data[1] == UINT64_MAX) {
420                 io->smb2.level          = RAW_IOCTL_SMB2_NO_HANDLE;
421         } else {
422                 io->smb2.level          = RAW_IOCTL_SMB2;
423                 io->smb2.in.file.ntvfs  = smb2srv_pull_handle(req, req->in.body, 0x08);
424                 SMB2SRV_CHECK_FILE_HANDLE(io->smb2.in.file.ntvfs);
425         }
426
427         SMB2SRV_CALL_NTVFS_BACKEND(ntvfs_ioctl(req->ntvfs, io));
428 }
429
430 static void smb2srv_notify_send(struct ntvfs_request *ntvfs)
431 {
432         struct smb2srv_request *req;
433         union smb_notify *io;
434         size_t size = 0;
435         int i;
436         uint8_t *p;
437         DATA_BLOB blob = data_blob(NULL, 0);
438
439         SMB2SRV_CHECK_ASYNC_STATUS(io, union smb_notify);
440         SMB2SRV_CHECK(smb2srv_setup_reply(req, 0x08, true, 0));
441
442 #define MAX_BYTES_PER_CHAR 3
443         
444         /* work out how big the reply buffer could be */
445         for (i=0;i<io->smb2.out.num_changes;i++) {
446                 size += 12 + 3 + (1+strlen(io->smb2.out.changes[i].name.s)) * MAX_BYTES_PER_CHAR;
447         }
448
449         blob = data_blob_talloc(req, NULL, size);
450         if (size > 0 && !blob.data) {
451                 SMB2SRV_CHECK(NT_STATUS_NO_MEMORY);
452         }
453
454         p = blob.data;
455
456         /* construct the changes buffer */
457         for (i=0;i<io->smb2.out.num_changes;i++) {
458                 uint32_t ofs;
459                 ssize_t len;
460
461                 SIVAL(p, 4, io->smb2.out.changes[i].action);
462                 len = push_string(p + 12, io->smb2.out.changes[i].name.s, 
463                                   blob.length - (p+12 - blob.data), STR_UNICODE);
464                 SIVAL(p, 8, len);
465
466                 ofs = len + 12;
467
468                 if (ofs & 3) {
469                         int pad = 4 - (ofs & 3);
470                         memset(p+ofs, 0, pad);
471                         ofs += pad;
472                 }
473
474                 if (i == io->smb2.out.num_changes-1) {
475                         SIVAL(p, 0, 0);
476                 } else {
477                         SIVAL(p, 0, ofs);
478                 }
479
480                 p += ofs;
481         }
482
483         blob.length = p - blob.data;
484
485         SMB2SRV_CHECK(smb2_push_o16s32_blob(&req->out, 0x02, blob));
486
487         smb2srv_send_reply(req);
488 }
489
490 void smb2srv_notify_recv(struct smb2srv_request *req)
491 {
492         union smb_notify *io;
493
494         SMB2SRV_CHECK_BODY_SIZE(req, 0x20, false);
495         SMB2SRV_TALLOC_IO_PTR(io, union smb_notify);
496         SMB2SRV_SETUP_NTVFS_REQUEST(smb2srv_notify_send, NTVFS_ASYNC_STATE_MAY_ASYNC);
497
498         io->smb2.level                  = RAW_NOTIFY_SMB2;
499         io->smb2.in.recursive           = SVAL(req->in.body, 0x02);
500         io->smb2.in.buffer_size         = IVAL(req->in.body, 0x04);
501         io->smb2.in.file.ntvfs          = smb2srv_pull_handle(req, req->in.body, 0x08);
502         io->smb2.in.completion_filter   = IVAL(req->in.body, 0x18);
503         io->smb2.in.unknown             = BVAL(req->in.body, 0x1C);
504
505         SMB2SRV_CHECK_FILE_HANDLE(io->smb2.in.file.ntvfs);
506         SMB2SRV_CALL_NTVFS_BACKEND(ntvfs_notify(req->ntvfs, io));
507 }
508
509 static void smb2srv_break_send(struct ntvfs_request *ntvfs)
510 {
511         struct smb2srv_request *req;
512         union smb_lock *io;
513
514         SMB2SRV_CHECK_ASYNC_STATUS_ERR(io, union smb_lock);
515         SMB2SRV_CHECK(smb2srv_setup_reply(req, 0x18, false, 0));
516
517         SCVAL(req->out.body,    0x02,   io->smb2_break.out.oplock_level);
518         SCVAL(req->out.body,    0x03,   io->smb2_break.out.reserved);
519         SIVAL(req->out.body,    0x04,   io->smb2_break.out.reserved2);
520         smb2srv_push_handle(req->out.body, 0x08,io->smb2_break.out.file.ntvfs);
521
522         smb2srv_send_reply(req);
523 }
524
525 void smb2srv_break_recv(struct smb2srv_request *req)
526 {
527         union smb_lock *io;
528
529         SMB2SRV_CHECK_BODY_SIZE(req, 0x18, false);
530         SMB2SRV_TALLOC_IO_PTR(io, union smb_lock);
531         SMB2SRV_SETUP_NTVFS_REQUEST(smb2srv_break_send, NTVFS_ASYNC_STATE_MAY_ASYNC);
532
533         io->smb2_break.level            = RAW_LOCK_SMB2_BREAK;
534         io->smb2_break.in.oplock_level  = CVAL(req->in.body, 0x02);
535         io->smb2_break.in.reserved      = CVAL(req->in.body, 0x03);
536         io->smb2_break.in.reserved2     = IVAL(req->in.body, 0x04);
537         io->smb2_break.in.file.ntvfs    = smb2srv_pull_handle(req, req->in.body, 0x08);
538
539         SMB2SRV_CHECK_FILE_HANDLE(io->smb2_break.in.file.ntvfs);
540         SMB2SRV_CALL_NTVFS_BACKEND(ntvfs_lock(req->ntvfs, io));
541 }