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