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