?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
tevent: use better names for the subtests
[Samba/gebeck_regimport.git] / source4 / smb_server / smb2 / fileio.c
blobf6460e0ee72de0e6e1829c75293419c0c61c3463
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 }
reg import