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