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