?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
testprogs/blackbox: use subunit_ helper functions in test_smbclient_*
[Samba.git] / source4 / ntvfs / ntvfs_generic.c
blobfe68b4132bca50a3e28abe3df24a0d0e83e5030d
1 /*
2 Unix SMB/CIFS implementation.
3
4 NTVFS generic level mapping code
5
6 Copyright (C) Andrew Tridgell 2003-2004
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
20 */
21 /*
22 this implements mappings between info levels for NTVFS backend calls
23
24 the idea is that each of these functions implements one of the NTVFS
25 backend calls in terms of the 'generic' call. All backends that use
26 these functions must supply the generic call, but can if it wants to
27 also implement other levels if the need arises
28
29 this allows backend writers to only implement one variant of each
30 call unless they need fine grained control of the calls.
31 */
32
33 #include "includes.h"
34 #include "ntvfs/ntvfs.h"
35 #include "libcli/smb2/smb2.h"
36 #include "libcli/smb2/smb2_calls.h"
37
38 /* a second stage function converts from the out parameters of the generic
39 call onto the out parameters of the specific call made */
40 typedef NTSTATUS (*second_stage_t)(struct ntvfs_module_context *,
41 struct ntvfs_request *,
42 void *, void *, NTSTATUS);
43
44 /*
45 this structure holds the async state for pending mapped async calls
46 */
47 struct ntvfs_map_async {
48 struct ntvfs_module_context *ntvfs;
49 void *io, *io2;
50 second_stage_t fn;
51 };
52
53 /*
54 this is a async wrapper, called from the backend when it has completed
55 a function that it has decided to reply to in an async fashion
56 */
57 static void ntvfs_map_async_send(struct ntvfs_request *req)
58 {
59 struct ntvfs_map_async *m = talloc_get_type(req->async_states->private_data,
60 struct ntvfs_map_async);
61
62 ntvfs_async_state_pop(req);
63
64 /* call the _finish function setup in ntvfs_map_async_setup() */
65 req->async_states->status = m->fn(m->ntvfs, req, m->io, m->io2, req->async_states->status);
66
67 /* call the send function from the next module up */
68 req->async_states->send_fn(req);
69 }
70
71 /*
72 prepare for calling a ntvfs backend with async support
73 io is the original call structure
74 io2 is the new call structure for the mapped call
75 fn is a second stage function for processing the out arguments
76 */
77 static NTSTATUS ntvfs_map_async_setup(struct ntvfs_module_context *ntvfs,
78 struct ntvfs_request *req,
79 void *io, void *io2,
80 second_stage_t fn)
81 {
82 struct ntvfs_map_async *m;
83 m = talloc(req, struct ntvfs_map_async);
84 if (m == NULL) {
85 return NT_STATUS_NO_MEMORY;
86 }
87 m->ntvfs = ntvfs;
88 m->io = io;
89 m->io2 = io2;
90 m->fn = fn;
91 return ntvfs_async_state_push(ntvfs, req, m, ntvfs_map_async_send);
92 }
93
94 /*
95 called when first stage processing is complete.
96 */
97 static NTSTATUS ntvfs_map_async_finish(struct ntvfs_request *req, NTSTATUS status)
98 {
99 struct ntvfs_map_async *m;
100
101 /* if the backend has decided to reply in an async fashion then
102 we don't need to do any work here */
103 if (req->async_states->state & NTVFS_ASYNC_STATE_ASYNC) {
104 return status;
105 }
106
107 /* the backend is replying immediately. call the 2nd stage function after popping our local
108 async state */
109 m = talloc_get_type(req->async_states->private_data,
110 struct ntvfs_map_async);
111
112 ntvfs_async_state_pop(req);
113
114 return m->fn(m->ntvfs, req, m->io, m->io2, status);
115 }
116
117 /*
118 see if a filename ends in EXE COM DLL or SYM. This is needed for the
119 DENY_DOS mapping for OpenX
120 */
121 bool is_exe_filename(const char *fname)
122 {
123 char *p;
124 p = strrchr(fname, '.');
125 if (!p) {
126 return false;
127 }
128 p++;
129 if (strcasecmp(p, "EXE") == 0 ||
130 strcasecmp(p, "COM") == 0 ||
131 strcasecmp(p, "DLL") == 0 ||
132 strcasecmp(p, "SYM") == 0) {
133 return true;
134 }
135 return false;
136 }
137
138
139 /*
140 NTVFS openx to ntcreatex mapper
141 */
142 static NTSTATUS ntvfs_map_open_finish(struct ntvfs_module_context *ntvfs,
143 struct ntvfs_request *req,
144 union smb_open *io,
145 union smb_open *io2,
146 NTSTATUS status)
147 {
148 time_t write_time = 0;
149 uint32_t set_size = 0;
150 union smb_setfileinfo *sf;
151 unsigned int state;
152
153 if (!NT_STATUS_IS_OK(status)) {
154 return status;
155 }
156
157 switch (io->generic.level) {
158 case RAW_OPEN_OPEN:
159 io->openold.out.file.ntvfs = io2->generic.out.file.ntvfs;
160 io->openold.out.attrib = io2->generic.out.attrib;
161 io->openold.out.write_time = nt_time_to_unix(io2->generic.out.write_time);
162 io->openold.out.size = io2->generic.out.size;
163 io->openold.out.rmode = io->openold.in.open_mode;
164 break;
165
166 case RAW_OPEN_OPENX:
167 io->openx.out.file.ntvfs = io2->generic.out.file.ntvfs;
168 io->openx.out.attrib = io2->generic.out.attrib;
169 io->openx.out.write_time = nt_time_to_unix(io2->generic.out.write_time);
170 io->openx.out.size = io2->generic.out.size;
171 io->openx.out.access = (io->openx.in.open_mode & OPENX_MODE_ACCESS_MASK);
172 io->openx.out.ftype = 0;
173 io->openx.out.devstate = 0;
174 io->openx.out.action = io2->generic.out.create_action;
175 io->openx.out.unique_fid = 0;
176 io->openx.out.access_mask = SEC_STD_ALL;
177 io->openx.out.unknown = 0;
178
179 /* we need to extend the file to the requested size if
180 it was newly created */
181 if (io2->generic.out.create_action == NTCREATEX_ACTION_CREATED) {
182 set_size = io->openx.in.size;
183 }
184 break;
185
186 case RAW_OPEN_T2OPEN:
187 io->t2open.out.file.ntvfs = io2->generic.out.file.ntvfs;
188 io->t2open.out.attrib = io2->generic.out.attrib;
189 io->t2open.out.write_time = nt_time_to_unix(io2->generic.out.write_time);
190 io->t2open.out.size = io2->generic.out.size;
191 io->t2open.out.access = io->t2open.in.open_mode;
192 io->t2open.out.ftype = 0;
193 io->t2open.out.devstate = 0;
194 io->t2open.out.action = io2->generic.out.create_action;
195 io->t2open.out.file_id = 0;
196 break;
197
198 case RAW_OPEN_MKNEW:
199 case RAW_OPEN_CREATE:
200 io->mknew.out.file.ntvfs= io2->generic.out.file.ntvfs;
201 write_time = io->mknew.in.write_time;
202 break;
203
204 case RAW_OPEN_CTEMP:
205 io->ctemp.out.file.ntvfs= io2->generic.out.file.ntvfs;
206 io->ctemp.out.name = talloc_strdup(req, io2->generic.in.fname +
207 strlen(io->ctemp.in.directory) + 1);
208 NT_STATUS_HAVE_NO_MEMORY(io->ctemp.out.name);
209 break;
210
211 case RAW_OPEN_SMB2:
212 ZERO_STRUCT(io->smb2.out);
213 io->smb2.out.file.ntvfs = io2->generic.out.file.ntvfs;
214 switch (io2->generic.out.oplock_level) {
215 case BATCH_OPLOCK_RETURN:
216 io->smb2.out.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
217 break;
218 case EXCLUSIVE_OPLOCK_RETURN:
219 io->smb2.out.oplock_level = SMB2_OPLOCK_LEVEL_EXCLUSIVE;
220 break;
221 case LEVEL_II_OPLOCK_RETURN:
222 io->smb2.out.oplock_level = SMB2_OPLOCK_LEVEL_II;
223 break;
224 default:
225 io->smb2.out.oplock_level = SMB2_OPLOCK_LEVEL_NONE;
226 break;
227 }
228 io->smb2.out.reserved = 0;
229 io->smb2.out.create_action = io2->generic.out.create_action;
230 io->smb2.out.create_time = io2->generic.out.create_time;
231 io->smb2.out.access_time = io2->generic.out.access_time;
232 io->smb2.out.write_time = io2->generic.out.write_time;
233 io->smb2.out.change_time = io2->generic.out.change_time;
234 io->smb2.out.alloc_size = io2->generic.out.alloc_size;
235 io->smb2.out.size = io2->generic.out.size;
236 io->smb2.out.file_attr = io2->generic.out.attrib;
237 io->smb2.out.reserved2 = 0;
238 io->smb2.out.maximal_access = io2->generic.out.maximal_access;
239 memcpy(io->smb2.out.on_disk_id, io2->generic.out.on_disk_id,
240 sizeof(io2->generic.out.on_disk_id));
241 break;
242
243 default:
244 return NT_STATUS_INVALID_LEVEL;
245 }
246
247 /* doing a secondary request async is more trouble than its
248 worth */
249 state = req->async_states->state;
250 req->async_states->state &= ~NTVFS_ASYNC_STATE_MAY_ASYNC;
251
252 if (write_time != 0) {
253 sf = talloc(req, union smb_setfileinfo);
254 NT_STATUS_HAVE_NO_MEMORY(sf);
255 sf->generic.level = RAW_SFILEINFO_STANDARD;
256 sf->generic.in.file.ntvfs = io2->generic.out.file.ntvfs;
257 sf->standard.in.create_time = 0;
258 sf->standard.in.write_time = write_time;
259 sf->standard.in.access_time = 0;
260 status = ntvfs->ops->setfileinfo_fn(ntvfs, req, sf);
261 }
262
263 if (set_size != 0) {
264 sf = talloc(req, union smb_setfileinfo);
265 NT_STATUS_HAVE_NO_MEMORY(sf);
266 sf->generic.level = RAW_SFILEINFO_END_OF_FILE_INFORMATION;
267 sf->generic.in.file.ntvfs = io2->generic.out.file.ntvfs;
268 sf->end_of_file_info.in.size = set_size;
269 status = ntvfs->ops->setfileinfo_fn(ntvfs, req, sf);
270 if (NT_STATUS_IS_OK(status)) {
271 io->openx.out.size = io->openx.in.size;
272 }
273 }
274
275 req->async_states->state = state;
276
277 return NT_STATUS_OK;
278 }
279
280 /*
281 the core of the mapping between openx style parameters and ntcreatex
282 parameters
283 */
284 static NTSTATUS map_openx_open(uint16_t flags, uint16_t open_mode,
285 uint16_t open_func, const char *fname,
286 union smb_open *io2)
287 {
288 io2->generic.in.create_options = NTCREATEX_OPTIONS_NON_DIRECTORY_FILE;
289 io2->generic.in.private_flags = 0;
290
291 if (flags & OPENX_FLAGS_REQUEST_OPLOCK) {
292 io2->generic.in.flags |= NTCREATEX_FLAGS_REQUEST_OPLOCK;
293 }
294 if (flags & OPENX_FLAGS_REQUEST_BATCH_OPLOCK) {
295 io2->generic.in.flags |= NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
296 }
297
298 switch (open_mode & OPENX_MODE_ACCESS_MASK) {
299 case OPENX_MODE_ACCESS_READ:
300 case OPENX_MODE_ACCESS_EXEC:
301 io2->generic.in.access_mask = SEC_RIGHTS_FILE_READ;
302 break;
303 case OPENX_MODE_ACCESS_WRITE:
304 io2->generic.in.access_mask = SEC_RIGHTS_FILE_WRITE;
305 break;
306 case OPENX_MODE_ACCESS_RDWR:
307 case OPENX_MODE_ACCESS_FCB:
308 io2->generic.in.access_mask =
309 SEC_RIGHTS_FILE_READ |
310 SEC_RIGHTS_FILE_WRITE;
311 break;
312 default:
313 return NT_STATUS_DOS(ERRDOS, ERRbadaccess);
314 }
315
316 switch (open_mode & OPENX_MODE_DENY_MASK) {
317 case OPENX_MODE_DENY_READ:
318 io2->generic.in.share_access = NTCREATEX_SHARE_ACCESS_WRITE;
319 break;
320 case OPENX_MODE_DENY_WRITE:
321 io2->generic.in.share_access = NTCREATEX_SHARE_ACCESS_READ;
322 break;
323 case OPENX_MODE_DENY_ALL:
324 io2->generic.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
325 break;
326 case OPENX_MODE_DENY_NONE:
327 io2->generic.in.share_access =
328 NTCREATEX_SHARE_ACCESS_READ |
329 NTCREATEX_SHARE_ACCESS_WRITE;
330 break;
331 case OPENX_MODE_DENY_DOS:
332 /* DENY_DOS is quite strange - it depends on the filename! */
333 io2->generic.in.private_flags |=
334 NTCREATEX_OPTIONS_PRIVATE_DENY_DOS;
335 if (is_exe_filename(fname)) {
336 io2->generic.in.share_access =
337 NTCREATEX_SHARE_ACCESS_READ |
338 NTCREATEX_SHARE_ACCESS_WRITE;
339 } else {
340 if ((open_mode & OPENX_MODE_ACCESS_MASK) == OPENX_MODE_ACCESS_READ) {
341 io2->generic.in.share_access = NTCREATEX_SHARE_ACCESS_READ;
342 } else {
343 io2->generic.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
344 }
345 }
346 break;
347 case OPENX_MODE_DENY_FCB:
348 io2->generic.in.private_flags |= NTCREATEX_OPTIONS_PRIVATE_DENY_FCB;
349 io2->generic.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
350 break;
351 default:
352 return NT_STATUS_DOS(ERRDOS, ERRbadaccess);
353 }
354
355 switch (open_func) {
356 case (OPENX_OPEN_FUNC_OPEN):
357 io2->generic.in.open_disposition = NTCREATEX_DISP_OPEN;
358 break;
359 case (OPENX_OPEN_FUNC_TRUNC):
360 io2->generic.in.open_disposition = NTCREATEX_DISP_OVERWRITE;
361 break;
362 case (OPENX_OPEN_FUNC_FAIL | OPENX_OPEN_FUNC_CREATE):
363 io2->generic.in.open_disposition = NTCREATEX_DISP_CREATE;
364 break;
365 case (OPENX_OPEN_FUNC_OPEN | OPENX_OPEN_FUNC_CREATE):
366 io2->generic.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
367 break;
368 case (OPENX_OPEN_FUNC_TRUNC | OPENX_OPEN_FUNC_CREATE):
369 io2->generic.in.open_disposition = NTCREATEX_DISP_OVERWRITE_IF;
370 break;
371 default:
372 /* this one is very strange */
373 if ((open_mode & OPENX_MODE_ACCESS_MASK) == OPENX_MODE_ACCESS_EXEC) {
374 io2->generic.in.open_disposition = NTCREATEX_DISP_CREATE;
375 break;
376 }
377 return NT_STATUS_DOS(ERRDOS, ERRbadaccess);
378 }
379
380 return NT_STATUS_OK;
381 }
382
383 /*
384 NTVFS open generic to any mapper
385 */
386 NTSTATUS ntvfs_map_open(struct ntvfs_module_context *ntvfs,
387 struct ntvfs_request *req,
388 union smb_open *io)
389 {
390 NTSTATUS status;
391 union smb_open *io2;
392
393 io2 = talloc_zero(req, union smb_open);
394 if (io2 == NULL) {
395 return NT_STATUS_NO_MEMORY;
396 }
397
398 status = ntvfs_map_async_setup(ntvfs, req,
399 io, io2,
400 (second_stage_t)ntvfs_map_open_finish);
401 if (!NT_STATUS_IS_OK(status)) {
402 return status;
403 }
404
405 io2->generic.level = RAW_OPEN_GENERIC;
406
407 switch (io->generic.level) {
408 case RAW_OPEN_OPENX:
409 status = map_openx_open(io->openx.in.flags,
410 io->openx.in.open_mode,
411 io->openx.in.open_func,
412 io->openx.in.fname,
413 io2);
414 if (!NT_STATUS_IS_OK(status)) {
415 goto done;
416 }
417
418 io2->generic.in.file_attr = io->openx.in.file_attrs;
419 io2->generic.in.fname = io->openx.in.fname;
420
421 status = ntvfs->ops->open_fn(ntvfs, req, io2);
422 break;
423
424
425 case RAW_OPEN_OPEN:
426 status = map_openx_open(0,
427 io->openold.in.open_mode,
428 OPENX_OPEN_FUNC_OPEN,
429 io->openold.in.fname,
430 io2);
431 if (!NT_STATUS_IS_OK(status)) {
432 goto done;
433 }
434
435 io2->generic.in.file_attr = io->openold.in.search_attrs;
436 io2->generic.in.fname = io->openold.in.fname;
437
438 status = ntvfs->ops->open_fn(ntvfs, req, io2);
439 break;
440
441 case RAW_OPEN_T2OPEN:
442 io2->generic.level = RAW_OPEN_NTTRANS_CREATE;
443
444 if (io->t2open.in.open_func == 0) {
445 status = NT_STATUS_OBJECT_NAME_COLLISION;
446 goto done;
447 }
448
449 status = map_openx_open(io->t2open.in.flags,
450 io->t2open.in.open_mode,
451 io->t2open.in.open_func,
452 io->t2open.in.fname,
453 io2);
454 if (!NT_STATUS_IS_OK(status)) {
455 goto done;
456 }
457
458 io2->generic.in.file_attr = io->t2open.in.file_attrs;
459 io2->generic.in.fname = io->t2open.in.fname;
460 io2->generic.in.ea_list = talloc(io2, struct smb_ea_list);
461 io2->generic.in.ea_list->num_eas = io->t2open.in.num_eas;
462 io2->generic.in.ea_list->eas = io->t2open.in.eas;
463
464 status = ntvfs->ops->open_fn(ntvfs, req, io2);
465 break;
466
467 case RAW_OPEN_MKNEW:
468 io2->generic.in.file_attr = io->mknew.in.attrib;
469 io2->generic.in.fname = io->mknew.in.fname;
470 io2->generic.in.open_disposition = NTCREATEX_DISP_CREATE;
471 io2->generic.in.access_mask =
472 SEC_RIGHTS_FILE_READ |
473 SEC_RIGHTS_FILE_WRITE;
474 io2->generic.in.share_access =
475 NTCREATEX_SHARE_ACCESS_READ |
476 NTCREATEX_SHARE_ACCESS_WRITE;
477 status = ntvfs->ops->open_fn(ntvfs, req, io2);
478 break;
479
480 case RAW_OPEN_CREATE:
481 io2->generic.in.file_attr = io->mknew.in.attrib;
482 io2->generic.in.fname = io->mknew.in.fname;
483 io2->generic.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
484 io2->generic.in.access_mask =
485 SEC_RIGHTS_FILE_READ |
486 SEC_RIGHTS_FILE_WRITE;
487 io2->generic.in.share_access =
488 NTCREATEX_SHARE_ACCESS_READ |
489 NTCREATEX_SHARE_ACCESS_WRITE;
490 status = ntvfs->ops->open_fn(ntvfs, req, io2);
491 break;
492
493 case RAW_OPEN_CTEMP:
494 io2->generic.in.file_attr = io->ctemp.in.attrib;
495 io2->generic.in.fname =
496 talloc_asprintf(io2, "%s\\SRV%s",
497 io->ctemp.in.directory,
498 generate_random_str_list(io2, 5, "0123456789"));
499 io2->generic.in.open_disposition = NTCREATEX_DISP_CREATE;
500 io2->generic.in.access_mask =
501 SEC_RIGHTS_FILE_READ |
502 SEC_RIGHTS_FILE_WRITE;
503 io2->generic.in.share_access =
504 NTCREATEX_SHARE_ACCESS_READ |
505 NTCREATEX_SHARE_ACCESS_WRITE;
506 status = ntvfs->ops->open_fn(ntvfs, req, io2);
507 break;
508 case RAW_OPEN_SMB2:
509 switch (io->smb2.in.oplock_level) {
510 case SMB2_OPLOCK_LEVEL_BATCH:
511 io2->generic.in.flags = NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK |
512 NTCREATEX_FLAGS_REQUEST_OPLOCK;
513 break;
514 case SMB2_OPLOCK_LEVEL_EXCLUSIVE:
515 io2->generic.in.flags = NTCREATEX_FLAGS_REQUEST_OPLOCK;
516 break;
517 default:
518 io2->generic.in.flags = 0;
519 break;
520 }
521 io2->generic.in.root_fid.fnum = 0;
522 io2->generic.in.access_mask = io->smb2.in.desired_access;
523 io2->generic.in.alloc_size = io->smb2.in.alloc_size;
524 io2->generic.in.file_attr = io->smb2.in.file_attributes;
525 io2->generic.in.share_access = io->smb2.in.share_access;
526 io2->generic.in.open_disposition= io->smb2.in.create_disposition;
527 io2->generic.in.create_options = io->smb2.in.create_options;
528 io2->generic.in.impersonation = io->smb2.in.impersonation_level;
529 io2->generic.in.security_flags = 0;
530 io2->generic.in.fname = io->smb2.in.fname;
531 io2->generic.in.sec_desc = io->smb2.in.sec_desc;
532 io2->generic.in.ea_list = &io->smb2.in.eas;
533 io2->generic.in.query_maximal_access = io->smb2.in.query_maximal_access;
534 io2->generic.in.query_on_disk_id = io->smb2.in.query_on_disk_id;
535 io2->generic.in.private_flags = 0;
536
537 /* we don't support timewarp yet */
538 if (io->smb2.in.timewarp != 0) {
539 status = NT_STATUS_OBJECT_NAME_NOT_FOUND;
540 break;
541 }
542
543 /* we need to check these bits before we check the private mask */
544 if (io2->generic.in.create_options & SMB2_CREATE_OPTIONS_NOT_SUPPORTED_MASK) {
545 DEBUG(2,(__location__ " create_options 0x%x not supported\n",
546 io2->generic.in.create_options));
547 status = NT_STATUS_NOT_SUPPORTED;
548 break;
549 }
550
551 /* TODO: find out why only SMB2 ignores these */
552 io2->generic.in.create_options &= ~NTCREATEX_OPTIONS_SYNC_ALERT;
553 io2->generic.in.create_options &= ~NTCREATEX_OPTIONS_ASYNC_ALERT;
554
555 status = ntvfs->ops->open_fn(ntvfs, req, io2);
556 break;
557
558 default:
559 status = NT_STATUS_INVALID_LEVEL;
560 break;
561 }
562 done:
563 return ntvfs_map_async_finish(req, status);
564 }
565
566
567 /*
568 NTVFS any to fsinfo mapper
569 */
570 static NTSTATUS ntvfs_map_fsinfo_finish(struct ntvfs_module_context *ntvfs,
571 struct ntvfs_request *req,
572 union smb_fsinfo *fs,
573 union smb_fsinfo *fs2,
574 NTSTATUS status)
575 {
576 if (!NT_STATUS_IS_OK(status)) {
577 return status;
578 }
579
580 /* and convert it to the required level */
581 switch (fs->generic.level) {
582 case RAW_QFS_DSKATTR: {
583 /* map from generic to DSKATTR */
584 unsigned int bpunit = 64;
585
586 /* we need to scale the sizes to fit */
587 for (bpunit=64; bpunit<0x10000; bpunit *= 2) {
588 if (fs2->generic.out.blocks_total * (double)fs2->generic.out.block_size < bpunit * 512 * 65535.0) {
589 break;
590 }
591 }
592
593 fs->dskattr.out.blocks_per_unit = bpunit;
594 fs->dskattr.out.block_size = 512;
595 fs->dskattr.out.units_total =
596 (fs2->generic.out.blocks_total * (double)fs2->generic.out.block_size) / (bpunit * 512);
597 fs->dskattr.out.units_free =
598 (fs2->generic.out.blocks_free * (double)fs2->generic.out.block_size) / (bpunit * 512);
599
600 /* we must return a maximum of 2G to old DOS systems, or they get very confused */
601 if (bpunit > 64 && req->ctx->protocol <= PROTOCOL_LANMAN2) {
602 fs->dskattr.out.blocks_per_unit = 64;
603 fs->dskattr.out.units_total = 0xFFFF;
604 fs->dskattr.out.units_free = 0xFFFF;
605 }
606 return NT_STATUS_OK;
607 }
608
609 case RAW_QFS_ALLOCATION:
610 fs->allocation.out.fs_id = fs2->generic.out.fs_id;
611 fs->allocation.out.total_alloc_units = fs2->generic.out.blocks_total;
612 fs->allocation.out.avail_alloc_units = fs2->generic.out.blocks_free;
613 fs->allocation.out.sectors_per_unit = 1;
614 fs->allocation.out.bytes_per_sector = fs2->generic.out.block_size;
615 return NT_STATUS_OK;
616
617 case RAW_QFS_VOLUME:
618 fs->volume.out.serial_number = fs2->generic.out.serial_number;
619 fs->volume.out.volume_name.s = fs2->generic.out.volume_name;
620 return NT_STATUS_OK;
621
622 case RAW_QFS_VOLUME_INFO:
623 case RAW_QFS_VOLUME_INFORMATION:
624 fs->volume_info.out.create_time = fs2->generic.out.create_time;
625 fs->volume_info.out.serial_number = fs2->generic.out.serial_number;
626 fs->volume_info.out.volume_name.s = fs2->generic.out.volume_name;
627 return NT_STATUS_OK;
628
629 case RAW_QFS_SIZE_INFO:
630 case RAW_QFS_SIZE_INFORMATION:
631 fs->size_info.out.total_alloc_units = fs2->generic.out.blocks_total;
632 fs->size_info.out.avail_alloc_units = fs2->generic.out.blocks_free;
633 fs->size_info.out.sectors_per_unit = 1;
634 fs->size_info.out.bytes_per_sector = fs2->generic.out.block_size;
635 return NT_STATUS_OK;
636
637 case RAW_QFS_DEVICE_INFO:
638 case RAW_QFS_DEVICE_INFORMATION:
639 fs->device_info.out.device_type = fs2->generic.out.device_type;
640 fs->device_info.out.characteristics = fs2->generic.out.device_characteristics;
641 return NT_STATUS_OK;
642
643 case RAW_QFS_ATTRIBUTE_INFO:
644 case RAW_QFS_ATTRIBUTE_INFORMATION:
645 fs->attribute_info.out.fs_attr = fs2->generic.out.fs_attr;
646 fs->attribute_info.out.max_file_component_length = fs2->generic.out.max_file_component_length;
647 fs->attribute_info.out.fs_type.s = fs2->generic.out.fs_type;
648 return NT_STATUS_OK;
649
650 case RAW_QFS_QUOTA_INFORMATION:
651 ZERO_STRUCT(fs->quota_information.out.unknown);
652 fs->quota_information.out.quota_soft = fs2->generic.out.quota_soft;
653 fs->quota_information.out.quota_hard = fs2->generic.out.quota_hard;
654 fs->quota_information.out.quota_flags = fs2->generic.out.quota_flags;
655 return NT_STATUS_OK;
656
657 case RAW_QFS_FULL_SIZE_INFORMATION:
658 fs->full_size_information.out.total_alloc_units = fs2->generic.out.blocks_total;
659 fs->full_size_information.out.call_avail_alloc_units = fs2->generic.out.blocks_free;
660 fs->full_size_information.out.actual_avail_alloc_units = fs2->generic.out.blocks_free;
661 fs->full_size_information.out.sectors_per_unit = 1;
662 fs->full_size_information.out.bytes_per_sector = fs2->generic.out.block_size;
663 return NT_STATUS_OK;
664
665 case RAW_QFS_OBJECTID_INFORMATION:
666 fs->objectid_information.out.guid = fs2->generic.out.guid;
667 ZERO_STRUCT(fs->objectid_information.out.unknown);
668 return NT_STATUS_OK;
669
670 case RAW_QFS_SECTOR_SIZE_INFORMATION:
671 fs->sector_size_info.out.logical_bytes_per_sector
672 = fs2->generic.out.block_size;
673 fs->sector_size_info.out.phys_bytes_per_sector_atomic
674 = fs2->generic.out.block_size;
675 fs->sector_size_info.out.phys_bytes_per_sector_perf
676 = fs2->generic.out.block_size;
677 fs->sector_size_info.out.fs_effective_phys_bytes_per_sector_atomic
678 = fs2->generic.out.block_size;
679 fs->sector_size_info.out.flags
680 = QFS_SSINFO_FLAGS_ALIGNED_DEVICE
681 | QFS_SSINFO_FLAGS_PARTITION_ALIGNED_ON_DEVICE;
682 fs->sector_size_info.out.byte_off_sector_align = 0;
683 fs->sector_size_info.out.byte_off_partition_align = 0;
684 return NT_STATUS_OK;
685
686 case RAW_QFS_GENERIC:
687 case RAW_QFS_UNIX_INFO:
688 return NT_STATUS_INVALID_LEVEL;
689 }
690
691 return NT_STATUS_INVALID_LEVEL;
692 }
693
694 /*
695 NTVFS fsinfo any to generic mapper
696 */
697 NTSTATUS ntvfs_map_fsinfo(struct ntvfs_module_context *ntvfs,
698 struct ntvfs_request *req,
699 union smb_fsinfo *fs)
700 {
701 NTSTATUS status;
702 union smb_fsinfo *fs2;
703
704 fs2 = talloc(req, union smb_fsinfo);
705 if (fs2 == NULL) {
706 return NT_STATUS_NO_MEMORY;
707 }
708
709 if (fs->generic.level == RAW_QFS_GENERIC) {
710 return NT_STATUS_INVALID_LEVEL;
711 }
712
713 status = ntvfs_map_async_setup(ntvfs, req, fs, fs2,
714 (second_stage_t)ntvfs_map_fsinfo_finish);
715 if (!NT_STATUS_IS_OK(status)) {
716 return status;
717 }
718
719 /* ask the backend for the generic info */
720 fs2->generic.level = RAW_QFS_GENERIC;
721
722 status = ntvfs->ops->fsinfo_fn(ntvfs, req, fs2);
723 return ntvfs_map_async_finish(req, status);
724 }
725
726
727 /*
728 NTVFS fileinfo generic to any mapper
729 */
730 NTSTATUS ntvfs_map_fileinfo(TALLOC_CTX *mem_ctx,
731 union smb_fileinfo *info,
732 union smb_fileinfo *info2)
733 {
734 int i;
735 /* and convert it to the required level using results in info2 */
736 switch (info->generic.level) {
737 case RAW_FILEINFO_GETATTR:
738 info->getattr.out.attrib = info2->generic.out.attrib & 0xff;
739 info->getattr.out.size = info2->generic.out.size;
740 info->getattr.out.write_time = nt_time_to_unix(info2->generic.out.write_time);
741 return NT_STATUS_OK;
742
743 case RAW_FILEINFO_GETATTRE:
744 info->getattre.out.attrib = info2->generic.out.attrib;
745 info->getattre.out.size = info2->generic.out.size;
746 info->getattre.out.write_time = nt_time_to_unix(info2->generic.out.write_time);
747 info->getattre.out.create_time = nt_time_to_unix(info2->generic.out.create_time);
748 info->getattre.out.access_time = nt_time_to_unix(info2->generic.out.access_time);
749 info->getattre.out.alloc_size = info2->generic.out.alloc_size;
750 return NT_STATUS_OK;
751
752 case RAW_FILEINFO_NETWORK_OPEN_INFORMATION:
753 info->network_open_information.out.create_time = info2->generic.out.create_time;
754 info->network_open_information.out.access_time = info2->generic.out.access_time;
755 info->network_open_information.out.write_time = info2->generic.out.write_time;
756 info->network_open_information.out.change_time = info2->generic.out.change_time;
757 info->network_open_information.out.alloc_size = info2->generic.out.alloc_size;
758 info->network_open_information.out.size = info2->generic.out.size;
759 info->network_open_information.out.attrib = info2->generic.out.attrib;
760 return NT_STATUS_OK;
761
762 case RAW_FILEINFO_ALL_INFO:
763 case RAW_FILEINFO_ALL_INFORMATION:
764 info->all_info.out.create_time = info2->generic.out.create_time;
765 info->all_info.out.access_time = info2->generic.out.access_time;
766 info->all_info.out.write_time = info2->generic.out.write_time;
767 info->all_info.out.change_time = info2->generic.out.change_time;
768 info->all_info.out.attrib = info2->generic.out.attrib;
769 info->all_info.out.alloc_size = info2->generic.out.alloc_size;
770 info->all_info.out.size = info2->generic.out.size;
771 info->all_info.out.nlink = info2->generic.out.nlink;
772 info->all_info.out.delete_pending = info2->generic.out.delete_pending;
773 info->all_info.out.directory = info2->generic.out.directory;
774 info->all_info.out.ea_size = info2->generic.out.ea_size;
775 info->all_info.out.fname.s = info2->generic.out.fname.s;
776 info->all_info.out.fname.private_length = info2->generic.out.fname.private_length;
777 return NT_STATUS_OK;
778
779 case RAW_FILEINFO_BASIC_INFO:
780 case RAW_FILEINFO_BASIC_INFORMATION:
781 info->basic_info.out.create_time = info2->generic.out.create_time;
782 info->basic_info.out.access_time = info2->generic.out.access_time;
783 info->basic_info.out.write_time = info2->generic.out.write_time;
784 info->basic_info.out.change_time = info2->generic.out.change_time;
785 info->basic_info.out.attrib = info2->generic.out.attrib;
786 return NT_STATUS_OK;
787
788 case RAW_FILEINFO_STANDARD:
789 info->standard.out.create_time = nt_time_to_unix(info2->generic.out.create_time);
790 info->standard.out.access_time = nt_time_to_unix(info2->generic.out.access_time);
791 info->standard.out.write_time = nt_time_to_unix(info2->generic.out.write_time);
792 info->standard.out.size = info2->generic.out.size;
793 info->standard.out.alloc_size = info2->generic.out.alloc_size;
794 info->standard.out.attrib = info2->generic.out.attrib;
795 return NT_STATUS_OK;
796
797 case RAW_FILEINFO_EA_SIZE:
798 info->ea_size.out.create_time = nt_time_to_unix(info2->generic.out.create_time);
799 info->ea_size.out.access_time = nt_time_to_unix(info2->generic.out.access_time);
800 info->ea_size.out.write_time = nt_time_to_unix(info2->generic.out.write_time);
801 info->ea_size.out.size = info2->generic.out.size;
802 info->ea_size.out.alloc_size = info2->generic.out.alloc_size;
803 info->ea_size.out.attrib = info2->generic.out.attrib;
804 info->ea_size.out.ea_size = info2->generic.out.ea_size;
805 return NT_STATUS_OK;
806
807 case RAW_FILEINFO_STANDARD_INFO:
808 case RAW_FILEINFO_STANDARD_INFORMATION:
809 info->standard_info.out.alloc_size = info2->generic.out.alloc_size;
810 info->standard_info.out.size = info2->generic.out.size;
811 info->standard_info.out.nlink = info2->generic.out.nlink;
812 info->standard_info.out.delete_pending = info2->generic.out.delete_pending;
813 info->standard_info.out.directory = info2->generic.out.directory;
814 return NT_STATUS_OK;
815
816 case RAW_FILEINFO_INTERNAL_INFORMATION:
817 info->internal_information.out.file_id = info2->generic.out.file_id;
818 return NT_STATUS_OK;
819
820 case RAW_FILEINFO_EA_INFO:
821 case RAW_FILEINFO_EA_INFORMATION:
822 info->ea_info.out.ea_size = info2->generic.out.ea_size;
823 return NT_STATUS_OK;
824
825 case RAW_FILEINFO_ATTRIBUTE_TAG_INFORMATION:
826 info->attribute_tag_information.out.attrib = info2->generic.out.attrib;
827 info->attribute_tag_information.out.reparse_tag = info2->generic.out.reparse_tag;
828 return NT_STATUS_OK;
829
830 case RAW_FILEINFO_STREAM_INFO:
831 case RAW_FILEINFO_STREAM_INFORMATION:
832 info->stream_info.out.num_streams = info2->generic.out.num_streams;
833 if (info->stream_info.out.num_streams > 0) {
834 info->stream_info.out.streams =
835 talloc_array(mem_ctx,
836 struct stream_struct,
837 info->stream_info.out.num_streams);
838 if (!info->stream_info.out.streams) {
839 DEBUG(2,("ntvfs_map_fileinfo: no memory for %d streams\n",
840 info->stream_info.out.num_streams));
841 return NT_STATUS_NO_MEMORY;
842 }
843 for (i=0; i < info->stream_info.out.num_streams; i++) {
844 info->stream_info.out.streams[i] = info2->generic.out.streams[i];
845 info->stream_info.out.streams[i].stream_name.s =
846 talloc_strdup(info->stream_info.out.streams,
847 info2->generic.out.streams[i].stream_name.s);
848 if (!info->stream_info.out.streams[i].stream_name.s) {
849 DEBUG(2,("ntvfs_map_fileinfo: no memory for stream_name\n"));
850 return NT_STATUS_NO_MEMORY;
851 }
852 }
853 }
854 return NT_STATUS_OK;
855
856 case RAW_FILEINFO_NAME_INFO:
857 case RAW_FILEINFO_NAME_INFORMATION:
858 info->name_info.out.fname.s = talloc_strdup(mem_ctx, info2->generic.out.fname.s);
859 NT_STATUS_HAVE_NO_MEMORY(info->name_info.out.fname.s);
860 info->name_info.out.fname.private_length = info2->generic.out.fname.private_length;
861 return NT_STATUS_OK;
862
863 case RAW_FILEINFO_ALT_NAME_INFO:
864 case RAW_FILEINFO_ALT_NAME_INFORMATION:
865 info->alt_name_info.out.fname.s = talloc_strdup(mem_ctx, info2->generic.out.alt_fname.s);
866 NT_STATUS_HAVE_NO_MEMORY(info->alt_name_info.out.fname.s);
867 info->alt_name_info.out.fname.private_length = info2->generic.out.alt_fname.private_length;
868 return NT_STATUS_OK;
869
870 case RAW_FILEINFO_POSITION_INFORMATION:
871 info->position_information.out.position = info2->generic.out.position;
872 return NT_STATUS_OK;
873
874 case RAW_FILEINFO_ALL_EAS:
875 info->all_eas.out.num_eas = info2->generic.out.num_eas;
876 if (info->all_eas.out.num_eas > 0) {
877 info->all_eas.out.eas = talloc_array(mem_ctx,
878 struct ea_struct,
879 info->all_eas.out.num_eas);
880 if (!info->all_eas.out.eas) {
881 DEBUG(2,("ntvfs_map_fileinfo: no memory for %d eas\n",
882 info->all_eas.out.num_eas));
883 return NT_STATUS_NO_MEMORY;
884 }
885 for (i = 0; i < info->all_eas.out.num_eas; i++) {
886 info->all_eas.out.eas[i] = info2->generic.out.eas[i];
887 info->all_eas.out.eas[i].name.s =
888 talloc_strdup(info->all_eas.out.eas,
889 info2->generic.out.eas[i].name.s);
890 if (!info->all_eas.out.eas[i].name.s) {
891 DEBUG(2,("ntvfs_map_fileinfo: no memory for stream_name\n"));
892 return NT_STATUS_NO_MEMORY;
893 }
894 info->all_eas.out.eas[i].value.data =
895 (uint8_t *)talloc_memdup(info->all_eas.out.eas,
896 info2->generic.out.eas[i].value.data,
897 info2->generic.out.eas[i].value.length);
898 if (!info->all_eas.out.eas[i].value.data) {
899 DEBUG(2,("ntvfs_map_fileinfo: no memory for stream_name\n"));
900 return NT_STATUS_NO_MEMORY;
901 }
902 }
903 }
904 return NT_STATUS_OK;
905
906 case RAW_FILEINFO_IS_NAME_VALID:
907 return NT_STATUS_OK;
908
909 case RAW_FILEINFO_COMPRESSION_INFO:
910 case RAW_FILEINFO_COMPRESSION_INFORMATION:
911 info->compression_info.out.compressed_size = info2->generic.out.compressed_size;
912 info->compression_info.out.format = info2->generic.out.format;
913 info->compression_info.out.unit_shift = info2->generic.out.unit_shift;
914 info->compression_info.out.chunk_shift = info2->generic.out.chunk_shift;
915 info->compression_info.out.cluster_shift = info2->generic.out.cluster_shift;
916 return NT_STATUS_OK;
917
918 case RAW_FILEINFO_ACCESS_INFORMATION:
919 info->access_information.out.access_flags = info2->generic.out.access_flags;
920 return NT_STATUS_OK;
921
922 case RAW_FILEINFO_MODE_INFORMATION:
923 info->mode_information.out.mode = info2->generic.out.mode;
924 return NT_STATUS_OK;
925
926 case RAW_FILEINFO_ALIGNMENT_INFORMATION:
927 info->alignment_information.out.alignment_requirement =
928 info2->generic.out.alignment_requirement;
929 return NT_STATUS_OK;
930 case RAW_FILEINFO_UNIX_BASIC:
931 #if 1
932 return NT_STATUS_INVALID_LEVEL;
933 #else
934 info->unix_basic_info.out.end_of_file = info2->generic.out.end_of_file;
935 info->unix_basic_info.out.num_bytes = info2->generic.out.size;
936 info->unix_basic_info.out.status_change_time = info2->generic.out.change_time;
937 info->unix_basic_info.out.access_time = info2->generic.out.access_time;
938 info->unix_basic_info.out.change_time = info2->generic.out.change_time;
939 info->unix_basic_info.out.uid = info2->generic.out.uid;
940 info->unix_basic_info.out.gid = info2->generic.out.gid;
941 info->unix_basic_info.out.file_type = info2->generic.out.file_type;
942 info->unix_basic_info.out.dev_major = info2->generic.out.device;
943 info->unix_basic_info.out.dev_minor = info2->generic.out.device;
944 info->unix_basic_info.out.unique_id = info2->generic.out.inode;
945 info->unix_basic_info.out.permissions = info2->generic.out.permissions;
946 info->unix_basic_info.out.nlink = info2->generic.out.nlink;
947 return NT_STATUS_OK;
948 #endif
949 case RAW_FILEINFO_UNIX_LINK:
950 #if 1
951 return NT_STATUS_INVALID_LEVEL;
952 #else
953 info->unix_link_info.out.link_dest = info2->generic.out.link_dest;
954 return NT_STATUS_OK;
955 #endif
956 case RAW_FILEINFO_GENERIC:
957 case RAW_FILEINFO_SEC_DESC:
958 case RAW_FILEINFO_EA_LIST:
959 case RAW_FILEINFO_UNIX_INFO2:
960 case RAW_FILEINFO_SMB2_ALL_EAS:
961 case RAW_FILEINFO_SMB2_ALL_INFORMATION:
962 return NT_STATUS_INVALID_LEVEL;
963 }
964
965 return NT_STATUS_INVALID_LEVEL;
966 }
967
968 /*
969 NTVFS any to fileinfo mapper
970 */
971 static NTSTATUS ntvfs_map_qfileinfo_finish(struct ntvfs_module_context *ntvfs,
972 struct ntvfs_request *req,
973 union smb_fileinfo *info,
974 union smb_fileinfo *info2,
975 NTSTATUS status)
976 {
977 if (!NT_STATUS_IS_OK(status)) {
978 return status;
979 }
980
981 return ntvfs_map_fileinfo(req, info, info2);
982 }
983
984 /*
985 NTVFS fileinfo generic to any mapper
986 */
987 NTSTATUS ntvfs_map_qfileinfo(struct ntvfs_module_context *ntvfs,
988 struct ntvfs_request *req,
989 union smb_fileinfo *info)
990 {
991 NTSTATUS status;
992 union smb_fileinfo *info2;
993
994 info2 = talloc(req, union smb_fileinfo);
995 if (info2 == NULL) {
996 return NT_STATUS_NO_MEMORY;
997 }
998
999 if (info->generic.level == RAW_FILEINFO_GENERIC) {
1000 return NT_STATUS_INVALID_LEVEL;
1001 }
1002
1003 status = ntvfs_map_async_setup(ntvfs, req, info, info2,
1004 (second_stage_t)ntvfs_map_qfileinfo_finish);
1005 if (!NT_STATUS_IS_OK(status)) {
1006 return status;
1007 }
1008
1009 /* ask the backend for the generic info */
1010 info2->generic.level = RAW_FILEINFO_GENERIC;
1011 info2->generic.in.file.ntvfs= info->generic.in.file.ntvfs;
1012
1013 status = ntvfs->ops->qfileinfo_fn(ntvfs, req, info2);
1014 return ntvfs_map_async_finish(req, status);
1015 }
1016
1017 /*
1018 NTVFS any to fileinfo mapper
1019 */
1020 static NTSTATUS ntvfs_map_qpathinfo_finish(struct ntvfs_module_context *ntvfs,
1021 struct ntvfs_request *req,
1022 union smb_fileinfo *info,
1023 union smb_fileinfo *info2,
1024 NTSTATUS status)
1025 {
1026 if (!NT_STATUS_IS_OK(status)) {
1027 return status;
1028 }
1029
1030 return ntvfs_map_fileinfo(req, info, info2);
1031 }
1032
1033 /*
1034 NTVFS pathinfo generic to any mapper
1035 */
1036 NTSTATUS ntvfs_map_qpathinfo(struct ntvfs_module_context *ntvfs,
1037 struct ntvfs_request *req,
1038 union smb_fileinfo *info)
1039 {
1040 NTSTATUS status;
1041 union smb_fileinfo *info2;
1042
1043 info2 = talloc(req, union smb_fileinfo);
1044 if (info2 == NULL) {
1045 return NT_STATUS_NO_MEMORY;
1046 }
1047
1048 if (info->generic.level == RAW_FILEINFO_GENERIC) {
1049 return NT_STATUS_INVALID_LEVEL;
1050 }
1051
1052 status = ntvfs_map_async_setup(ntvfs, req, info, info2,
1053 (second_stage_t)ntvfs_map_qpathinfo_finish);
1054 if (!NT_STATUS_IS_OK(status)) {
1055 return status;
1056 }
1057
1058 /* ask the backend for the generic info */
1059 info2->generic.level = RAW_FILEINFO_GENERIC;
1060 info2->generic.in.file.path = info->generic.in.file.path;
1061
1062 status = ntvfs->ops->qpathinfo_fn(ntvfs, req, info2);
1063 return ntvfs_map_async_finish(req, status);
1064 }
1065
1066
1067 /*
1068 NTVFS lock generic to any mapper
1069 */
1070 NTSTATUS ntvfs_map_lock(struct ntvfs_module_context *ntvfs,
1071 struct ntvfs_request *req,
1072 union smb_lock *lck)
1073 {
1074 union smb_lock *lck2;
1075 struct smb_lock_entry *locks;
1076
1077 lck2 = talloc(req, union smb_lock);
1078 if (lck2 == NULL) {
1079 return NT_STATUS_NO_MEMORY;
1080 }
1081
1082 locks = talloc_array(lck2, struct smb_lock_entry, 1);
1083 if (locks == NULL) {
1084 return NT_STATUS_NO_MEMORY;
1085 }
1086
1087 switch (lck->generic.level) {
1088 case RAW_LOCK_LOCKX:
1089 return NT_STATUS_INVALID_LEVEL;
1090
1091 case RAW_LOCK_LOCK:
1092 lck2->generic.level = RAW_LOCK_GENERIC;
1093 lck2->generic.in.file.ntvfs= lck->lock.in.file.ntvfs;
1094 lck2->generic.in.mode = 0;
1095 lck2->generic.in.timeout = 0;
1096 lck2->generic.in.ulock_cnt = 0;
1097 lck2->generic.in.lock_cnt = 1;
1098 lck2->generic.in.locks = locks;
1099 locks->pid = req->smbpid;
1100 locks->offset = lck->lock.in.offset;
1101 locks->count = lck->lock.in.count;
1102 break;
1103
1104 case RAW_LOCK_UNLOCK:
1105 lck2->generic.level = RAW_LOCK_GENERIC;
1106 lck2->generic.in.file.ntvfs= lck->unlock.in.file.ntvfs;
1107 lck2->generic.in.mode = 0;
1108 lck2->generic.in.timeout = 0;
1109 lck2->generic.in.ulock_cnt = 1;
1110 lck2->generic.in.lock_cnt = 0;
1111 lck2->generic.in.locks = locks;
1112 locks->pid = req->smbpid;
1113 locks->offset = lck->unlock.in.offset;
1114 locks->count = lck->unlock.in.count;
1115 break;
1116
1117 case RAW_LOCK_SMB2: {
1118 /* this is only approximate! We need to change the
1119 generic structure to fix this properly */
1120 int i;
1121 bool isunlock;
1122 if (lck->smb2.in.lock_count < 1) {
1123 return NT_STATUS_INVALID_PARAMETER;
1124 }
1125
1126 lck2->generic.level = RAW_LOCK_GENERIC;
1127 lck2->generic.in.file.ntvfs= lck->smb2.in.file.ntvfs;
1128 lck2->generic.in.timeout = UINT32_MAX;
1129 lck2->generic.in.mode = 0;
1130 lck2->generic.in.lock_cnt = 0;
1131 lck2->generic.in.ulock_cnt = 0;
1132 lck2->generic.in.locks = talloc_zero_array(lck2, struct smb_lock_entry,
1133 lck->smb2.in.lock_count);
1134 if (lck2->generic.in.locks == NULL) {
1135 return NT_STATUS_NO_MEMORY;
1136 }
1137 /* only the first lock gives the UNLOCK bit - see
1138 MS-SMB2 3.3.5.14 */
1139 if (lck->smb2.in.locks[0].flags & SMB2_LOCK_FLAG_UNLOCK) {
1140 if (lck->smb2.in.locks[0].flags & SMB2_LOCK_FLAG_FAIL_IMMEDIATELY) {
1141 return NT_STATUS_INVALID_PARAMETER;
1142 }
1143 lck2->generic.in.ulock_cnt = lck->smb2.in.lock_count;
1144 isunlock = true;
1145 } else {
1146 lck2->generic.in.lock_cnt = lck->smb2.in.lock_count;
1147 isunlock = false;
1148 }
1149 for (i=0;i<lck->smb2.in.lock_count;i++) {
1150 if (!isunlock &&
1151 lck->smb2.in.locks[i].flags == SMB2_LOCK_FLAG_NONE) {
1152 return NT_STATUS_INVALID_PARAMETER;
1153 }
1154
1155 if (lck->smb2.in.locks[i].flags & ~SMB2_LOCK_FLAG_ALL_MASK) {
1156 return NT_STATUS_INVALID_PARAMETER;
1157 }
1158
1159 if (isunlock &&
1160 (lck->smb2.in.locks[i].flags &
1161 (SMB2_LOCK_FLAG_SHARED|SMB2_LOCK_FLAG_EXCLUSIVE))) {
1162 return NT_STATUS_INVALID_PARAMETER;
1163 }
1164 if (!isunlock &&
1165 (lck->smb2.in.locks[i].flags & SMB2_LOCK_FLAG_UNLOCK)) {
1166 return NT_STATUS_INVALID_PARAMETER;
1167 }
1168 lck2->generic.in.locks[i].pid = req->smbpid;
1169 lck2->generic.in.locks[i].offset = lck->smb2.in.locks[i].offset;
1170 lck2->generic.in.locks[i].count = lck->smb2.in.locks[i].length;
1171 if (!(lck->smb2.in.locks[i].flags & SMB2_LOCK_FLAG_EXCLUSIVE)) {
1172 lck2->generic.in.mode = LOCKING_ANDX_SHARED_LOCK;
1173 }
1174 if (lck->smb2.in.locks[i].flags & SMB2_LOCK_FLAG_FAIL_IMMEDIATELY) {
1175 lck2->generic.in.timeout = 0;
1176 }
1177 }
1178 /* initialize output value */
1179 lck->smb2.out.reserved = 0;
1180 break;
1181 }
1182
1183 case RAW_LOCK_SMB2_BREAK:
1184 lck2->generic.level = RAW_LOCK_GENERIC;
1185 lck2->generic.in.file.ntvfs = lck->smb2_break.in.file.ntvfs;
1186 lck2->generic.in.mode = LOCKING_ANDX_OPLOCK_RELEASE |
1187 ((lck->smb2_break.in.oplock_level << 8) & 0xFF00);
1188 lck2->generic.in.timeout = 0;
1189 lck2->generic.in.ulock_cnt = 0;
1190 lck2->generic.in.lock_cnt = 0;
1191 lck2->generic.in.locks = NULL;
1192
1193 /* initialize output value */
1194 lck->smb2_break.out.oplock_level= lck->smb2_break.in.oplock_level;
1195 lck->smb2_break.out.reserved = lck->smb2_break.in.reserved;
1196 lck->smb2_break.out.reserved2 = lck->smb2_break.in.reserved2;
1197 lck->smb2_break.out.file = lck->smb2_break.in.file;
1198 break;
1199 }
1200
1201 /*
1202 * we don't need to call ntvfs_map_async_setup() here,
1203 * as lock() doesn't have any output fields
1204 */
1205
1206 return ntvfs->ops->lock_fn(ntvfs, req, lck2);
1207 }
1208
1209
1210 /*
1211 NTVFS write generic to any mapper
1212 */
1213 static NTSTATUS ntvfs_map_write_finish(struct ntvfs_module_context *ntvfs,
1214 struct ntvfs_request *req,
1215 union smb_write *wr,
1216 union smb_write *wr2,
1217 NTSTATUS status)
1218 {
1219 union smb_lock *lck;
1220 union smb_close *cl;
1221 unsigned int state;
1222
1223 if (NT_STATUS_IS_ERR(status)) {
1224 return status;
1225 }
1226
1227 switch (wr->generic.level) {
1228 case RAW_WRITE_WRITE:
1229 wr->write.out.nwritten = wr2->generic.out.nwritten;
1230 break;
1231
1232 case RAW_WRITE_WRITEUNLOCK:
1233 wr->writeunlock.out.nwritten = wr2->generic.out.nwritten;
1234
1235 lck = talloc(wr2, union smb_lock);
1236 if (lck == NULL) {
1237 return NT_STATUS_NO_MEMORY;
1238 }
1239
1240 lck->unlock.level = RAW_LOCK_UNLOCK;
1241 lck->unlock.in.file.ntvfs = wr->writeunlock.in.file.ntvfs;
1242 lck->unlock.in.count = wr->writeunlock.in.count;
1243 lck->unlock.in.offset = wr->writeunlock.in.offset;
1244
1245 if (lck->unlock.in.count != 0) {
1246 /* do the lock sync for now */
1247 state = req->async_states->state;
1248 req->async_states->state &= ~NTVFS_ASYNC_STATE_MAY_ASYNC;
1249 status = ntvfs->ops->lock_fn(ntvfs, req, lck);
1250 req->async_states->state = state;
1251 }
1252 break;
1253
1254 case RAW_WRITE_WRITECLOSE:
1255 wr->writeclose.out.nwritten = wr2->generic.out.nwritten;
1256
1257 cl = talloc(wr2, union smb_close);
1258 if (cl == NULL) {
1259 return NT_STATUS_NO_MEMORY;
1260 }
1261
1262 cl->close.level = RAW_CLOSE_CLOSE;
1263 cl->close.in.file.ntvfs = wr->writeclose.in.file.ntvfs;
1264 cl->close.in.write_time = wr->writeclose.in.mtime;
1265
1266 if (wr2->generic.in.count != 0) {
1267 /* do the close sync for now */
1268 state = req->async_states->state;
1269 req->async_states->state &= ~NTVFS_ASYNC_STATE_MAY_ASYNC;
1270 status = ntvfs->ops->close_fn(ntvfs, req, cl);
1271 req->async_states->state = state;
1272 }
1273 break;
1274
1275 case RAW_WRITE_SPLWRITE:
1276 break;
1277
1278 case RAW_WRITE_SMB2:
1279 wr->smb2.out._pad = 0;
1280 wr->smb2.out.nwritten = wr2->generic.out.nwritten;
1281 wr->smb2.out.unknown1 = 0;
1282 break;
1283
1284 default:
1285 return NT_STATUS_INVALID_LEVEL;
1286 }
1287
1288 return status;
1289 }
1290
1291
1292 /*
1293 NTVFS write generic to any mapper
1294 */
1295 NTSTATUS ntvfs_map_write(struct ntvfs_module_context *ntvfs,
1296 struct ntvfs_request *req,
1297 union smb_write *wr)
1298 {
1299 union smb_write *wr2;
1300 NTSTATUS status;
1301
1302 wr2 = talloc(req, union smb_write);
1303 if (wr2 == NULL) {
1304 return NT_STATUS_NO_MEMORY;
1305 }
1306
1307 status = ntvfs_map_async_setup(ntvfs, req, wr, wr2,
1308 (second_stage_t)ntvfs_map_write_finish);
1309 if (!NT_STATUS_IS_OK(status)) {
1310 return status;
1311 }
1312
1313 wr2->writex.level = RAW_WRITE_GENERIC;
1314
1315 switch (wr->generic.level) {
1316 case RAW_WRITE_WRITEX:
1317 status = NT_STATUS_INVALID_LEVEL;
1318 break;
1319
1320 case RAW_WRITE_WRITE:
1321 wr2->writex.in.file.ntvfs= wr->write.in.file.ntvfs;
1322 wr2->writex.in.offset = wr->write.in.offset;
1323 wr2->writex.in.wmode = 0;
1324 wr2->writex.in.remaining = wr->write.in.remaining;
1325 wr2->writex.in.count = wr->write.in.count;
1326 wr2->writex.in.data = wr->write.in.data;
1327 status = ntvfs->ops->write_fn(ntvfs, req, wr2);
1328 break;
1329
1330 case RAW_WRITE_WRITEUNLOCK:
1331 wr2->writex.in.file.ntvfs= wr->writeunlock.in.file.ntvfs;
1332 wr2->writex.in.offset = wr->writeunlock.in.offset;
1333 wr2->writex.in.wmode = 0;
1334 wr2->writex.in.remaining = wr->writeunlock.in.remaining;
1335 wr2->writex.in.count = wr->writeunlock.in.count;
1336 wr2->writex.in.data = wr->writeunlock.in.data;
1337 status = ntvfs->ops->write_fn(ntvfs, req, wr2);
1338 break;
1339
1340 case RAW_WRITE_WRITECLOSE:
1341 wr2->writex.in.file.ntvfs= wr->writeclose.in.file.ntvfs;
1342 wr2->writex.in.offset = wr->writeclose.in.offset;
1343 wr2->writex.in.wmode = 0;
1344 wr2->writex.in.remaining = 0;
1345 wr2->writex.in.count = wr->writeclose.in.count;
1346 wr2->writex.in.data = wr->writeclose.in.data;
1347 status = ntvfs->ops->write_fn(ntvfs, req, wr2);
1348 break;
1349
1350 case RAW_WRITE_SPLWRITE:
1351 wr2->writex.in.file.ntvfs= wr->splwrite.in.file.ntvfs;
1352 wr2->writex.in.offset = 0;
1353 wr2->writex.in.wmode = 0;
1354 wr2->writex.in.remaining = 0;
1355 wr2->writex.in.count = wr->splwrite.in.count;
1356 wr2->writex.in.data = wr->splwrite.in.data;
1357 status = ntvfs->ops->write_fn(ntvfs, req, wr2);
1358 break;
1359
1360 case RAW_WRITE_SMB2:
1361 wr2->writex.in.file.ntvfs= wr->smb2.in.file.ntvfs;
1362 wr2->writex.in.offset = wr->smb2.in.offset;
1363 wr2->writex.in.wmode = 0;
1364 wr2->writex.in.remaining = 0;
1365 wr2->writex.in.count = wr->smb2.in.data.length;
1366 wr2->writex.in.data = wr->smb2.in.data.data;
1367 status = ntvfs->ops->write_fn(ntvfs, req, wr2);
1368 }
1369
1370 return ntvfs_map_async_finish(req, status);
1371 }
1372
1373
1374 /*
1375 NTVFS read generic to any mapper - finish the out mapping
1376 */
1377 static NTSTATUS ntvfs_map_read_finish(struct ntvfs_module_context *ntvfs,
1378 struct ntvfs_request *req,
1379 union smb_read *rd,
1380 union smb_read *rd2,
1381 NTSTATUS status)
1382 {
1383 switch (rd->generic.level) {
1384 case RAW_READ_READ:
1385 rd->read.out.nread = rd2->generic.out.nread;
1386 break;
1387 case RAW_READ_READBRAW:
1388 rd->readbraw.out.nread = rd2->generic.out.nread;
1389 break;
1390 case RAW_READ_LOCKREAD:
1391 rd->lockread.out.nread = rd2->generic.out.nread;
1392 break;
1393 case RAW_READ_SMB2:
1394 rd->smb2.out.data.length= rd2->generic.out.nread;
1395 rd->smb2.out.remaining = 0;
1396 rd->smb2.out.reserved = 0;
1397 break;
1398 default:
1399 return NT_STATUS_INVALID_LEVEL;
1400 }
1401
1402 return status;
1403 }
1404
1405 /*
1406 NTVFS read* to readx mapper
1407 */
1408 NTSTATUS ntvfs_map_read(struct ntvfs_module_context *ntvfs,
1409 struct ntvfs_request *req,
1410 union smb_read *rd)
1411 {
1412 union smb_read *rd2;
1413 union smb_lock *lck;
1414 NTSTATUS status;
1415 unsigned int state;
1416
1417 rd2 = talloc(req, union smb_read);
1418 if (rd2 == NULL) {
1419 return NT_STATUS_NO_MEMORY;
1420 }
1421
1422 status = ntvfs_map_async_setup(ntvfs, req, rd, rd2,
1423 (second_stage_t)ntvfs_map_read_finish);
1424 if (!NT_STATUS_IS_OK(status)) {
1425 return status;
1426 }
1427
1428 rd2->readx.level = RAW_READ_READX;
1429 rd2->readx.in.read_for_execute = false;
1430
1431 switch (rd->generic.level) {
1432 case RAW_READ_READX:
1433 status = NT_STATUS_INVALID_LEVEL;
1434 break;
1435
1436 case RAW_READ_READ:
1437 rd2->readx.in.file.ntvfs= rd->read.in.file.ntvfs;
1438 rd2->readx.in.offset = rd->read.in.offset;
1439 rd2->readx.in.mincnt = rd->read.in.count;
1440 rd2->readx.in.maxcnt = rd->read.in.count;
1441 rd2->readx.in.remaining = rd->read.in.remaining;
1442 rd2->readx.out.data = rd->read.out.data;
1443 status = ntvfs->ops->read_fn(ntvfs, req, rd2);
1444 break;
1445
1446 case RAW_READ_READBRAW:
1447 rd2->readx.in.file.ntvfs= rd->readbraw.in.file.ntvfs;
1448 rd2->readx.in.offset = rd->readbraw.in.offset;
1449 rd2->readx.in.mincnt = rd->readbraw.in.mincnt;
1450 rd2->readx.in.maxcnt = rd->readbraw.in.maxcnt;
1451 rd2->readx.in.remaining = 0;
1452 rd2->readx.out.data = rd->readbraw.out.data;
1453 status = ntvfs->ops->read_fn(ntvfs, req, rd2);
1454 break;
1455
1456 case RAW_READ_LOCKREAD:
1457 /* do the initial lock sync for now */
1458 state = req->async_states->state;
1459 req->async_states->state &= ~NTVFS_ASYNC_STATE_MAY_ASYNC;
1460
1461 lck = talloc(rd2, union smb_lock);
1462 if (lck == NULL) {
1463 status = NT_STATUS_NO_MEMORY;
1464 goto done;
1465 }
1466 lck->lock.level = RAW_LOCK_LOCK;
1467 lck->lock.in.file.ntvfs = rd->lockread.in.file.ntvfs;
1468 lck->lock.in.count = rd->lockread.in.count;
1469 lck->lock.in.offset = rd->lockread.in.offset;
1470 status = ntvfs->ops->lock_fn(ntvfs, req, lck);
1471 req->async_states->state = state;
1472
1473 rd2->readx.in.file.ntvfs= rd->lockread.in.file.ntvfs;
1474 rd2->readx.in.offset = rd->lockread.in.offset;
1475 rd2->readx.in.mincnt = rd->lockread.in.count;
1476 rd2->readx.in.maxcnt = rd->lockread.in.count;
1477 rd2->readx.in.remaining = rd->lockread.in.remaining;
1478 rd2->readx.out.data = rd->lockread.out.data;
1479
1480 if (NT_STATUS_IS_OK(status)) {
1481 status = ntvfs->ops->read_fn(ntvfs, req, rd2);
1482 }
1483 break;
1484
1485 case RAW_READ_SMB2:
1486 rd2->readx.in.file.ntvfs= rd->smb2.in.file.ntvfs;
1487 rd2->readx.in.offset = rd->smb2.in.offset;
1488 rd2->readx.in.mincnt = rd->smb2.in.min_count;
1489 rd2->readx.in.maxcnt = rd->smb2.in.length;
1490 rd2->readx.in.remaining = 0;
1491 rd2->readx.out.data = rd->smb2.out.data.data;
1492 status = ntvfs->ops->read_fn(ntvfs, req, rd2);
1493 break;
1494 }
1495
1496 done:
1497 return ntvfs_map_async_finish(req, status);
1498 }
1499
1500
1501 /*
1502 NTVFS close generic to any mapper
1503 */
1504 static NTSTATUS ntvfs_map_close_finish(struct ntvfs_module_context *ntvfs,
1505 struct ntvfs_request *req,
1506 union smb_close *cl,
1507 union smb_close *cl2,
1508 NTSTATUS status)
1509 {
1510 NT_STATUS_NOT_OK_RETURN(status);
1511
1512 switch (cl->generic.level) {
1513 case RAW_CLOSE_SMB2:
1514 cl->smb2.out.flags = cl2->generic.out.flags;
1515 cl->smb2.out._pad = 0;
1516 cl->smb2.out.create_time = cl2->generic.out.create_time;
1517 cl->smb2.out.access_time = cl2->generic.out.access_time;
1518 cl->smb2.out.write_time = cl2->generic.out.write_time;
1519 cl->smb2.out.change_time = cl2->generic.out.change_time;
1520 cl->smb2.out.alloc_size = cl2->generic.out.alloc_size;
1521 cl->smb2.out.size = cl2->generic.out.size;
1522 cl->smb2.out.file_attr = cl2->generic.out.file_attr;
1523 break;
1524 default:
1525 break;
1526 }
1527
1528 return status;
1529 }
1530
1531 /*
1532 NTVFS close generic to any mapper
1533 */
1534 NTSTATUS ntvfs_map_close(struct ntvfs_module_context *ntvfs,
1535 struct ntvfs_request *req,
1536 union smb_close *cl)
1537 {
1538 union smb_close *cl2;
1539 NTSTATUS status;
1540
1541 cl2 = talloc(req, union smb_close);
1542 if (cl2 == NULL) {
1543 return NT_STATUS_NO_MEMORY;
1544 }
1545
1546 switch (cl->generic.level) {
1547 case RAW_CLOSE_GENERIC:
1548 return NT_STATUS_INVALID_LEVEL;
1549
1550 case RAW_CLOSE_CLOSE:
1551 cl2->generic.level = RAW_CLOSE_GENERIC;
1552 cl2->generic.in.file = cl->close.in.file;
1553 cl2->generic.in.write_time = cl->close.in.write_time;
1554 cl2->generic.in.flags = 0;
1555 break;
1556
1557 case RAW_CLOSE_SPLCLOSE:
1558 cl2->generic.level = RAW_CLOSE_GENERIC;
1559 cl2->generic.in.file = cl->splclose.in.file;
1560 cl2->generic.in.write_time = 0;
1561 cl2->generic.in.flags = 0;
1562 break;
1563
1564 case RAW_CLOSE_SMB2:
1565 cl2->generic.level = RAW_CLOSE_GENERIC;
1566 cl2->generic.in.file = cl->smb2.in.file;
1567 cl2->generic.in.write_time = 0;
1568 cl2->generic.in.flags = cl->smb2.in.flags;
1569 break;
1570 }
1571
1572 status = ntvfs_map_async_setup(ntvfs, req, cl, cl2,
1573 (second_stage_t)ntvfs_map_close_finish);
1574 NT_STATUS_NOT_OK_RETURN(status);
1575
1576 status = ntvfs->ops->close_fn(ntvfs, req, cl2);
1577
1578 return ntvfs_map_async_finish(req, status);
1579 }
1580
1581 /*
1582 NTVFS notify generic to any mapper
1583 */
1584 static NTSTATUS ntvfs_map_notify_finish(struct ntvfs_module_context *ntvfs,
1585 struct ntvfs_request *req,
1586 union smb_notify *nt,
1587 union smb_notify *nt2,
1588 NTSTATUS status)
1589 {
1590 NT_STATUS_NOT_OK_RETURN(status);
1591
1592 switch (nt->nttrans.level) {
1593 case RAW_NOTIFY_SMB2:
1594 if (nt2->nttrans.out.num_changes == 0) {
1595 return STATUS_NOTIFY_ENUM_DIR;
1596 }
1597 nt->smb2.out.num_changes = nt2->nttrans.out.num_changes;
1598 nt->smb2.out.changes = talloc_steal(req, nt2->nttrans.out.changes);
1599 break;
1600
1601 default:
1602 return NT_STATUS_INVALID_LEVEL;
1603 }
1604
1605 return status;
1606 }
1607
1608
1609 /*
1610 NTVFS notify generic to any mapper
1611 */
1612 NTSTATUS ntvfs_map_notify(struct ntvfs_module_context *ntvfs,
1613 struct ntvfs_request *req,
1614 union smb_notify *nt)
1615 {
1616 union smb_notify *nt2;
1617 NTSTATUS status;
1618
1619 nt2 = talloc(req, union smb_notify);
1620 NT_STATUS_HAVE_NO_MEMORY(nt2);
1621
1622 status = ntvfs_map_async_setup(ntvfs, req, nt, nt2,
1623 (second_stage_t)ntvfs_map_notify_finish);
1624 NT_STATUS_NOT_OK_RETURN(status);
1625
1626 nt2->nttrans.level = RAW_NOTIFY_NTTRANS;
1627
1628 switch (nt->nttrans.level) {
1629 case RAW_NOTIFY_NTTRANS:
1630 status = NT_STATUS_INVALID_LEVEL;
1631 break;
1632
1633 case RAW_NOTIFY_SMB2:
1634 nt2->nttrans.in.file.ntvfs = nt->smb2.in.file.ntvfs;
1635 nt2->nttrans.in.buffer_size = nt->smb2.in.buffer_size;
1636 nt2->nttrans.in.completion_filter = nt->smb2.in.completion_filter;
1637 nt2->nttrans.in.recursive = nt->smb2.in.recursive;
1638 status = ntvfs->ops->notify_fn(ntvfs, req, nt2);
1639 break;
1640 }
1641
1642 return ntvfs_map_async_finish(req, status);
1643 }
Samba GIT mirror