?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r9152: fix a crash bug
[Samba/aatanasov.git] / source / ntvfs / ntvfs_generic.c
blob024a48bf7a7a1298606729980f0823fb692538f0
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 2 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, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 */
22 /*
23 this implements mappings between info levels for NTVFS backend calls
24
25 the idea is that each of these functions implements one of the NTVFS
26 backend calls in terms of the 'generic' call. All backends that use
27 these functions must supply the generic call, but can if it wants to
28 also implement other levels if the need arises
29
30 this allows backend writers to only implement one variant of each
31 call unless they need fine grained control of the calls.
32 */
33
34 #include "includes.h"
35 #include "smb_server/smb_server.h"
36 #include "librpc/gen_ndr/ndr_security.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 smbsrv_request *,
41 struct ntvfs_module_context *,
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 smbsrv_request *req)
58 {
59 struct ntvfs_map_async *m = req->async_states->private_data;
60
61 ntvfs_async_state_pop(req);
62
63 /* call the _finish function setup in ntvfs_map_async_setup() */
64 req->async_states->status = m->fn(req, m->ntvfs, m->io, m->io2, req->async_states->status);
65
66 /* call the send function from the next module up */
67 req->async_states->send_fn(req);
68 }
69
70 /*
71 prepare for calling a ntvfs backend with async support
72 io is the original call structure
73 io2 is the new call structure for the mapped call
74 fn is a second stage function for processing the out arguments
75 */
76 static NTSTATUS ntvfs_map_async_setup(struct smbsrv_request *req,
77 struct ntvfs_module_context *ntvfs,
78 void *io, void *io2,
79 second_stage_t fn)
80 {
81 struct ntvfs_map_async *m;
82 m = talloc(req, struct ntvfs_map_async);
83 if (m == NULL) {
84 return NT_STATUS_NO_MEMORY;
85 }
86 m->ntvfs = ntvfs;
87 m->io = io;
88 m->io2 = io2;
89 m->fn = fn;
90 return ntvfs_async_state_push(req, m, ntvfs_map_async_send, ntvfs);
91 }
92
93
94 /*
95 called when first stage processing is complete.
96 */
97 static NTSTATUS ntvfs_map_async_finish(struct smbsrv_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 = req->async_states->private_data;
110
111 ntvfs_async_state_pop(req);
112
113 return m->fn(req, m->ntvfs, m->io, m->io2, status);
114 }
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 smbsrv_request *req,
143 struct ntvfs_module_context *ntvfs,
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.fnum = io2->generic.out.fnum;
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.fnum = io2->generic.out.fnum;
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.fnum = io2->generic.out.fnum;
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.fnum = io2->generic.out.fnum;
201 write_time = io->mknew.in.write_time;
202 break;
203
204 case RAW_OPEN_CTEMP:
205 io->ctemp.out.fnum = io2->generic.out.fnum;
206 io->ctemp.out.name = talloc_strdup(req, io2->generic.in.fname +
207 strlen(io->ctemp.in.directory) + 1);
208 break;
209
210 default:
211 return NT_STATUS_INVALID_LEVEL;
212 }
213
214 /* doing a secondary request async is more trouble than its
215 worth */
216 state = req->async_states->state;
217 req->async_states->state &= ~NTVFS_ASYNC_STATE_MAY_ASYNC;
218
219 if (write_time != 0) {
220 sf = talloc(req, union smb_setfileinfo);
221 sf->generic.level = RAW_SFILEINFO_STANDARD;
222 sf->generic.file.fnum = io2->generic.out.fnum;
223 sf->standard.in.create_time = 0;
224 sf->standard.in.write_time = write_time;
225 sf->standard.in.access_time = 0;
226 status = ntvfs->ops->setfileinfo(ntvfs, req, sf);
227 }
228
229 if (set_size != 0) {
230 sf = talloc(req, union smb_setfileinfo);
231 sf->generic.level = RAW_SFILEINFO_END_OF_FILE_INFORMATION;
232 sf->generic.file.fnum = io2->generic.out.fnum;
233 sf->end_of_file_info.in.size = set_size;
234 status = ntvfs->ops->setfileinfo(ntvfs, req, sf);
235 if (NT_STATUS_IS_OK(status)) {
236 io->openx.out.size = io->openx.in.size;
237 }
238 }
239
240 req->async_states->state = state;
241
242 return NT_STATUS_OK;
243 }
244
245 /*
246 the core of the mapping between openx style parameters and ntcreatex
247 parameters
248 */
249 static NTSTATUS map_openx_open(uint16_t flags, uint16_t open_mode,
250 uint16_t open_func, const char *fname,
251 union smb_open *io2)
252 {
253 if (flags & OPENX_FLAGS_REQUEST_OPLOCK) {
254 io2->generic.in.flags |= NTCREATEX_FLAGS_REQUEST_OPLOCK;
255 }
256 if (flags & OPENX_FLAGS_REQUEST_BATCH_OPLOCK) {
257 io2->generic.in.flags |= NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
258 }
259
260 switch (open_mode & OPENX_MODE_ACCESS_MASK) {
261 case OPENX_MODE_ACCESS_READ:
262 io2->generic.in.access_mask = SEC_RIGHTS_FILE_READ;
263 break;
264 case OPENX_MODE_ACCESS_WRITE:
265 io2->generic.in.access_mask = SEC_RIGHTS_FILE_WRITE;
266 break;
267 case OPENX_MODE_ACCESS_RDWR:
268 case OPENX_MODE_ACCESS_FCB:
269 case OPENX_MODE_ACCESS_EXEC:
270 io2->generic.in.access_mask =
271 SEC_RIGHTS_FILE_READ |
272 SEC_RIGHTS_FILE_WRITE;
273 break;
274 default:
275 return NT_STATUS_DOS(ERRDOS, ERRbadaccess);
276 }
277
278 switch (open_mode & OPENX_MODE_DENY_MASK) {
279 case OPENX_MODE_DENY_READ:
280 io2->generic.in.share_access = NTCREATEX_SHARE_ACCESS_WRITE;
281 break;
282 case OPENX_MODE_DENY_WRITE:
283 io2->generic.in.share_access = NTCREATEX_SHARE_ACCESS_READ;
284 break;
285 case OPENX_MODE_DENY_ALL:
286 io2->generic.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
287 break;
288 case OPENX_MODE_DENY_NONE:
289 io2->generic.in.share_access =
290 NTCREATEX_SHARE_ACCESS_READ |
291 NTCREATEX_SHARE_ACCESS_WRITE;
292 break;
293 case OPENX_MODE_DENY_DOS:
294 /* DENY_DOS is quite strange - it depends on the filename! */
295 io2->generic.in.create_options |=
296 NTCREATEX_OPTIONS_PRIVATE_DENY_DOS;
297 if (is_exe_filename(fname)) {
298 io2->generic.in.share_access =
299 NTCREATEX_SHARE_ACCESS_READ |
300 NTCREATEX_SHARE_ACCESS_WRITE;
301 } else {
302 if ((open_mode & OPENX_MODE_ACCESS_MASK) == OPENX_MODE_ACCESS_READ) {
303 io2->generic.in.share_access = NTCREATEX_SHARE_ACCESS_READ;
304 } else {
305 io2->generic.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
306 }
307 }
308 break;
309 case OPENX_MODE_DENY_FCB:
310 io2->generic.in.create_options |= NTCREATEX_OPTIONS_PRIVATE_DENY_FCB;
311 io2->generic.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
312 break;
313 default:
314 return NT_STATUS_DOS(ERRDOS, ERRbadaccess);
315 }
316
317 switch (open_func) {
318 case (OPENX_OPEN_FUNC_OPEN):
319 io2->generic.in.open_disposition = NTCREATEX_DISP_OPEN;
320 break;
321 case (OPENX_OPEN_FUNC_TRUNC):
322 io2->generic.in.open_disposition = NTCREATEX_DISP_OVERWRITE;
323 break;
324 case (OPENX_OPEN_FUNC_FAIL | OPENX_OPEN_FUNC_CREATE):
325 io2->generic.in.open_disposition = NTCREATEX_DISP_CREATE;
326 break;
327 case (OPENX_OPEN_FUNC_OPEN | OPENX_OPEN_FUNC_CREATE):
328 io2->generic.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
329 break;
330 case (OPENX_OPEN_FUNC_TRUNC | OPENX_OPEN_FUNC_CREATE):
331 io2->generic.in.open_disposition = NTCREATEX_DISP_OVERWRITE_IF;
332 break;
333 default:
334 /* this one is very strange */
335 if ((open_mode & OPENX_MODE_ACCESS_MASK) == OPENX_MODE_ACCESS_EXEC) {
336 io2->generic.in.open_disposition = NTCREATEX_DISP_CREATE;
337 break;
338 }
339 return NT_STATUS_DOS(ERRDOS, ERRbadaccess);
340 }
341
342 return NT_STATUS_OK;
343 }
344
345 /*
346 NTVFS open generic to any mapper
347 */
348 NTSTATUS ntvfs_map_open(struct smbsrv_request *req, union smb_open *io,
349 struct ntvfs_module_context *ntvfs)
350 {
351 NTSTATUS status;
352 union smb_open *io2;
353
354 io2 = talloc_zero(req, union smb_open);
355 if (io2 == NULL) {
356 return NT_STATUS_NO_MEMORY;
357 }
358
359 status = ntvfs_map_async_setup(req, ntvfs, io, io2,
360 (second_stage_t)ntvfs_map_open_finish);
361 if (!NT_STATUS_IS_OK(status)) {
362 return status;
363 }
364
365 io2->generic.level = RAW_OPEN_GENERIC;
366
367 switch (io->generic.level) {
368 case RAW_OPEN_OPENX:
369 status = map_openx_open(io->openx.in.flags,
370 io->openx.in.open_mode,
371 io->openx.in.open_func,
372 io->openx.in.fname,
373 io2);
374 if (!NT_STATUS_IS_OK(status)) {
375 goto done;
376 }
377
378 io2->generic.in.file_attr = io->openx.in.file_attrs;
379 io2->generic.in.fname = io->openx.in.fname;
380
381 status = ntvfs->ops->openfile(ntvfs, req, io2);
382 break;
383
384
385 case RAW_OPEN_OPEN:
386 status = map_openx_open(0,
387 io->openold.in.open_mode,
388 OPENX_OPEN_FUNC_OPEN,
389 io->openold.in.fname,
390 io2);
391 if (!NT_STATUS_IS_OK(status)) {
392 goto done;
393 }
394
395 io2->generic.in.file_attr = io->openold.in.search_attrs;
396 io2->generic.in.fname = io->openold.in.fname;
397
398 status = ntvfs->ops->openfile(ntvfs, req, io2);
399 break;
400
401 case RAW_OPEN_T2OPEN:
402 io2->generic.level = RAW_OPEN_NTTRANS_CREATE;
403
404 if (io->t2open.in.open_func == 0) {
405 status = NT_STATUS_OBJECT_NAME_COLLISION;
406 goto done;
407 }
408
409 status = map_openx_open(io->t2open.in.flags,
410 io->t2open.in.open_mode,
411 io->t2open.in.open_func,
412 io->t2open.in.fname,
413 io2);
414 if (!NT_STATUS_IS_OK(status)) {
415 goto done;
416 }
417
418 io2->generic.in.file_attr = io->t2open.in.file_attrs;
419 io2->generic.in.fname = io->t2open.in.fname;
420 io2->generic.in.ea_list = talloc(io2, struct smb_ea_list);
421 io2->generic.in.ea_list->num_eas = io->t2open.in.num_eas;
422 io2->generic.in.ea_list->eas = io->t2open.in.eas;
423
424 status = ntvfs->ops->openfile(ntvfs, req, io2);
425 break;
426
427 case RAW_OPEN_MKNEW:
428 io2->generic.in.file_attr = io->mknew.in.attrib;
429 io2->generic.in.fname = io->mknew.in.fname;
430 io2->generic.in.open_disposition = NTCREATEX_DISP_CREATE;
431 io2->generic.in.access_mask =
432 SEC_RIGHTS_FILE_READ |
433 SEC_RIGHTS_FILE_WRITE;
434 io2->generic.in.share_access =
435 NTCREATEX_SHARE_ACCESS_READ |
436 NTCREATEX_SHARE_ACCESS_WRITE;
437 status = ntvfs->ops->openfile(ntvfs, req, io2);
438 break;
439
440 case RAW_OPEN_CREATE:
441 io2->generic.in.file_attr = io->mknew.in.attrib;
442 io2->generic.in.fname = io->mknew.in.fname;
443 io2->generic.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
444 io2->generic.in.access_mask =
445 SEC_RIGHTS_FILE_READ |
446 SEC_RIGHTS_FILE_WRITE;
447 io2->generic.in.share_access =
448 NTCREATEX_SHARE_ACCESS_READ |
449 NTCREATEX_SHARE_ACCESS_WRITE;
450 status = ntvfs->ops->openfile(ntvfs, req, io2);
451 break;
452
453 case RAW_OPEN_CTEMP:
454 io2->generic.in.file_attr = io->ctemp.in.attrib;
455 io2->generic.in.file_attr = 0;
456 io2->generic.in.fname =
457 talloc_asprintf(io2, "%s\\SRV%s",
458 io->ctemp.in.directory,
459 generate_random_str_list(io2, 5, "0123456789"));
460 io2->generic.in.open_disposition = NTCREATEX_DISP_CREATE;
461 io2->generic.in.access_mask =
462 SEC_RIGHTS_FILE_READ |
463 SEC_RIGHTS_FILE_WRITE;
464 io2->generic.in.share_access =
465 NTCREATEX_SHARE_ACCESS_READ |
466 NTCREATEX_SHARE_ACCESS_WRITE;
467 status = ntvfs->ops->openfile(ntvfs, req, io2);
468 break;
469
470 default:
471 status = NT_STATUS_INVALID_LEVEL;
472 break;
473 }
474 done:
475 return ntvfs_map_async_finish(req, status);
476 }
477
478
479 /*
480 NTVFS fsinfo generic to any mapper
481 */
482 NTSTATUS ntvfs_map_fsinfo(struct smbsrv_request *req, union smb_fsinfo *fs,
483 struct ntvfs_module_context *ntvfs)
484 {
485 NTSTATUS status;
486 union smb_fsinfo *fs2;
487
488 fs2 = talloc(req, union smb_fsinfo);
489 if (fs2 == NULL) {
490 return NT_STATUS_NO_MEMORY;
491 }
492
493 if (fs->generic.level == RAW_QFS_GENERIC) {
494 return NT_STATUS_INVALID_LEVEL;
495 }
496
497 /* this map function is only used by the simple backend, which
498 doesn't do async */
499 req->async_states->state &= ~NTVFS_ASYNC_STATE_MAY_ASYNC;
500
501 /* ask the backend for the generic info */
502 fs2->generic.level = RAW_QFS_GENERIC;
503
504 status = ntvfs->ops->fsinfo(ntvfs, req, fs2);
505 if (!NT_STATUS_IS_OK(status)) {
506 return status;
507 }
508
509 /* and convert it to the required level */
510 switch (fs->generic.level) {
511 case RAW_QFS_GENERIC:
512 return NT_STATUS_INVALID_LEVEL;
513
514 case RAW_QFS_DSKATTR: {
515 /* map from generic to DSKATTR */
516 uint_t bpunit = 64;
517
518 /* we need to scale the sizes to fit */
519 for (bpunit=64; bpunit<0x10000; bpunit *= 2) {
520 if (fs2->generic.out.blocks_total * (double)fs2->generic.out.block_size < bpunit * 512 * 65535.0) {
521 break;
522 }
523 }
524
525 fs->dskattr.out.blocks_per_unit = bpunit;
526 fs->dskattr.out.block_size = 512;
527 fs->dskattr.out.units_total =
528 (fs2->generic.out.blocks_total * (double)fs2->generic.out.block_size) / (bpunit * 512);
529 fs->dskattr.out.units_free =
530 (fs2->generic.out.blocks_free * (double)fs2->generic.out.block_size) / (bpunit * 512);
531
532 /* we must return a maximum of 2G to old DOS systems, or they get very confused */
533 if (bpunit > 64 && req->smb_conn->negotiate.protocol <= PROTOCOL_LANMAN2) {
534 fs->dskattr.out.blocks_per_unit = 64;
535 fs->dskattr.out.units_total = 0xFFFF;
536 fs->dskattr.out.units_free = 0xFFFF;
537 }
538 return NT_STATUS_OK;
539 }
540
541 case RAW_QFS_ALLOCATION:
542 fs->allocation.out.fs_id = fs2->generic.out.fs_id;
543 fs->allocation.out.total_alloc_units = fs2->generic.out.blocks_total;
544 fs->allocation.out.avail_alloc_units = fs2->generic.out.blocks_free;
545 fs->allocation.out.sectors_per_unit = 1;
546 fs->allocation.out.bytes_per_sector = fs2->generic.out.block_size;
547 return NT_STATUS_OK;
548
549 case RAW_QFS_VOLUME:
550 fs->volume.out.serial_number = fs2->generic.out.serial_number;
551 fs->volume.out.volume_name.s = fs2->generic.out.volume_name;
552 return NT_STATUS_OK;
553
554 case RAW_QFS_VOLUME_INFO:
555 case RAW_QFS_VOLUME_INFORMATION:
556 fs->volume_info.out.create_time = fs2->generic.out.create_time;
557 fs->volume_info.out.serial_number = fs2->generic.out.serial_number;
558 fs->volume_info.out.volume_name.s = fs2->generic.out.volume_name;
559 return NT_STATUS_OK;
560
561 case RAW_QFS_SIZE_INFO:
562 case RAW_QFS_SIZE_INFORMATION:
563 fs->size_info.out.total_alloc_units = fs2->generic.out.blocks_total;
564 fs->size_info.out.avail_alloc_units = fs2->generic.out.blocks_free;
565 fs->size_info.out.sectors_per_unit = 1;
566 fs->size_info.out.bytes_per_sector = fs2->generic.out.block_size;
567 return NT_STATUS_OK;
568
569 case RAW_QFS_DEVICE_INFO:
570 case RAW_QFS_DEVICE_INFORMATION:
571 fs->device_info.out.device_type = fs2->generic.out.device_type;
572 fs->device_info.out.characteristics = fs2->generic.out.device_characteristics;
573 return NT_STATUS_OK;
574
575 case RAW_QFS_ATTRIBUTE_INFO:
576 case RAW_QFS_ATTRIBUTE_INFORMATION:
577 fs->attribute_info.out.fs_attr = fs2->generic.out.fs_attr;
578 fs->attribute_info.out.max_file_component_length = fs2->generic.out.max_file_component_length;
579 fs->attribute_info.out.fs_type.s = fs2->generic.out.fs_type;
580 return NT_STATUS_OK;
581
582 case RAW_QFS_QUOTA_INFORMATION:
583 ZERO_STRUCT(fs->quota_information.out.unknown);
584 fs->quota_information.out.quota_soft = fs2->generic.out.quota_soft;
585 fs->quota_information.out.quota_hard = fs2->generic.out.quota_hard;
586 fs->quota_information.out.quota_flags = fs2->generic.out.quota_flags;
587 return NT_STATUS_OK;
588
589 case RAW_QFS_FULL_SIZE_INFORMATION:
590 fs->full_size_information.out.total_alloc_units = fs2->generic.out.blocks_total;
591 fs->full_size_information.out.call_avail_alloc_units = fs2->generic.out.blocks_free;
592 fs->full_size_information.out.actual_avail_alloc_units = fs2->generic.out.blocks_free;
593 fs->full_size_information.out.sectors_per_unit = 1;
594 fs->full_size_information.out.bytes_per_sector = fs2->generic.out.block_size;
595 return NT_STATUS_OK;
596
597 case RAW_QFS_OBJECTID_INFORMATION:
598 fs->objectid_information.out.guid = fs2->generic.out.guid;
599 ZERO_STRUCT(fs->objectid_information.out.unknown);
600 return NT_STATUS_OK;
601 }
602
603
604 return NT_STATUS_INVALID_LEVEL;
605 }
606
607
608 /*
609 NTVFS fileinfo generic to any mapper
610 */
611 NTSTATUS ntvfs_map_fileinfo(struct smbsrv_request *req, union smb_fileinfo *info,
612 union smb_fileinfo *info2)
613 {
614 int i;
615 /* and convert it to the required level using results in info2 */
616 switch (info->generic.level) {
617 case RAW_FILEINFO_GENERIC:
618 return NT_STATUS_INVALID_LEVEL;
619 case RAW_FILEINFO_GETATTR:
620 info->getattr.out.attrib = info2->generic.out.attrib & 0xff;
621 info->getattr.out.size = info2->generic.out.size;
622 info->getattr.out.write_time = nt_time_to_unix(info2->generic.out.write_time);
623 return NT_STATUS_OK;
624
625 case RAW_FILEINFO_GETATTRE:
626 info->getattre.out.attrib = info2->generic.out.attrib;
627 info->getattre.out.size = info2->generic.out.size;
628 info->getattre.out.write_time = nt_time_to_unix(info2->generic.out.write_time);
629 info->getattre.out.create_time = nt_time_to_unix(info2->generic.out.create_time);
630 info->getattre.out.access_time = nt_time_to_unix(info2->generic.out.access_time);
631 info->getattre.out.alloc_size = info2->generic.out.alloc_size;
632 return NT_STATUS_OK;
633
634 case RAW_FILEINFO_NETWORK_OPEN_INFORMATION:
635 info->network_open_information.out.create_time = info2->generic.out.create_time;
636 info->network_open_information.out.access_time = info2->generic.out.access_time;
637 info->network_open_information.out.write_time = info2->generic.out.write_time;
638 info->network_open_information.out.change_time = info2->generic.out.change_time;
639 info->network_open_information.out.alloc_size = info2->generic.out.alloc_size;
640 info->network_open_information.out.size = info2->generic.out.size;
641 info->network_open_information.out.attrib = info2->generic.out.attrib;
642 return NT_STATUS_OK;
643
644 case RAW_FILEINFO_ALL_INFO:
645 case RAW_FILEINFO_ALL_INFORMATION:
646 info->all_info.out.create_time = info2->generic.out.create_time;
647 info->all_info.out.access_time = info2->generic.out.access_time;
648 info->all_info.out.write_time = info2->generic.out.write_time;
649 info->all_info.out.change_time = info2->generic.out.change_time;
650 info->all_info.out.attrib = info2->generic.out.attrib;
651 info->all_info.out.alloc_size = info2->generic.out.alloc_size;
652 info->all_info.out.size = info2->generic.out.size;
653 info->all_info.out.nlink = info2->generic.out.nlink;
654 info->all_info.out.delete_pending = info2->generic.out.delete_pending;
655 info->all_info.out.directory = info2->generic.out.directory;
656 info->all_info.out.ea_size = info2->generic.out.ea_size;
657 info->all_info.out.fname.s = info2->generic.out.fname.s;
658 info->all_info.out.fname.private_length = info2->generic.out.fname.private_length;
659 return NT_STATUS_OK;
660
661 case RAW_FILEINFO_BASIC_INFO:
662 case RAW_FILEINFO_BASIC_INFORMATION:
663 info->basic_info.out.create_time = info2->generic.out.create_time;
664 info->basic_info.out.access_time = info2->generic.out.access_time;
665 info->basic_info.out.write_time = info2->generic.out.write_time;
666 info->basic_info.out.change_time = info2->generic.out.change_time;
667 info->basic_info.out.attrib = info2->generic.out.attrib;
668 return NT_STATUS_OK;
669
670 case RAW_FILEINFO_STANDARD:
671 info->standard.out.create_time = nt_time_to_unix(info2->generic.out.create_time);
672 info->standard.out.access_time = nt_time_to_unix(info2->generic.out.access_time);
673 info->standard.out.write_time = nt_time_to_unix(info2->generic.out.write_time);
674 info->standard.out.size = info2->generic.out.size;
675 info->standard.out.alloc_size = info2->generic.out.alloc_size;
676 info->standard.out.attrib = info2->generic.out.attrib;
677 return NT_STATUS_OK;
678
679 case RAW_FILEINFO_EA_SIZE:
680 info->ea_size.out.create_time = nt_time_to_unix(info2->generic.out.create_time);
681 info->ea_size.out.access_time = nt_time_to_unix(info2->generic.out.access_time);
682 info->ea_size.out.write_time = nt_time_to_unix(info2->generic.out.write_time);
683 info->ea_size.out.size = info2->generic.out.size;
684 info->ea_size.out.alloc_size = info2->generic.out.alloc_size;
685 info->ea_size.out.attrib = info2->generic.out.attrib;
686 info->ea_size.out.ea_size = info2->generic.out.ea_size;
687 return NT_STATUS_OK;
688
689 case RAW_FILEINFO_STANDARD_INFO:
690 case RAW_FILEINFO_STANDARD_INFORMATION:
691 info->standard_info.out.alloc_size = info2->generic.out.alloc_size;
692 info->standard_info.out.size = info2->generic.out.size;
693 info->standard_info.out.nlink = info2->generic.out.nlink;
694 info->standard_info.out.delete_pending = info2->generic.out.delete_pending;
695 info->standard_info.out.directory = info2->generic.out.directory;
696 return NT_STATUS_OK;
697
698 case RAW_FILEINFO_INTERNAL_INFORMATION:
699 info->internal_information.out.file_id = info2->generic.out.file_id;
700 return NT_STATUS_OK;
701
702 case RAW_FILEINFO_EA_INFO:
703 case RAW_FILEINFO_EA_INFORMATION:
704 info->ea_info.out.ea_size = info2->generic.out.ea_size;
705 return NT_STATUS_OK;
706
707 case RAW_FILEINFO_ATTRIBUTE_TAG_INFORMATION:
708 info->attribute_tag_information.out.attrib = info2->generic.out.attrib;
709 info->attribute_tag_information.out.reparse_tag = info2->generic.out.reparse_tag;
710 return NT_STATUS_OK;
711
712 case RAW_FILEINFO_STREAM_INFO:
713 case RAW_FILEINFO_STREAM_INFORMATION:
714 info->stream_info.out.num_streams = info2->generic.out.num_streams;
715 if (info->stream_info.out.num_streams > 0) {
716 info->stream_info.out.streams =
717 talloc_array(req,
718 struct stream_struct,
719 info->stream_info.out.num_streams);
720 if (!info->stream_info.out.streams) {
721 DEBUG(2,("ntvfs_map_fileinfo: no memory for %d streams\n",
722 info->stream_info.out.num_streams));
723 return NT_STATUS_NO_MEMORY;
724 }
725 for (i=0; i < info->stream_info.out.num_streams; i++) {
726 info->stream_info.out.streams[i] = info2->generic.out.streams[i];
727 info->stream_info.out.streams[i].stream_name.s =
728 talloc_strdup(req, info2->generic.out.streams[i].stream_name.s);
729 if (!info->stream_info.out.streams[i].stream_name.s) {
730 DEBUG(2,("ntvfs_map_fileinfo: no memory for stream_name\n"));
731 return NT_STATUS_NO_MEMORY;
732 }
733 }
734 }
735 return NT_STATUS_OK;
736
737 case RAW_FILEINFO_NAME_INFO:
738 case RAW_FILEINFO_NAME_INFORMATION:
739 info->name_info.out.fname.s = talloc_strdup(req, info2->generic.out.fname.s);
740 info->name_info.out.fname.private_length = info2->generic.out.fname.private_length;
741 return NT_STATUS_OK;
742
743 case RAW_FILEINFO_ALT_NAME_INFO:
744 case RAW_FILEINFO_ALT_NAME_INFORMATION:
745 info->alt_name_info.out.fname.s = talloc_strdup(req, info2->generic.out.alt_fname.s);
746 info->alt_name_info.out.fname.private_length = info2->generic.out.alt_fname.private_length;
747 return NT_STATUS_OK;
748
749 case RAW_FILEINFO_POSITION_INFORMATION:
750 info->position_information.out.position = info2->generic.out.position;
751 return NT_STATUS_OK;
752
753 case RAW_FILEINFO_ALL_EAS:
754 info->all_eas.out.num_eas = info2->generic.out.num_eas;
755 if (info->all_eas.out.num_eas > 0) {
756 info->all_eas.out.eas = talloc_array(req,
757 struct ea_struct,
758 info->all_eas.out.num_eas);
759 if (!info->all_eas.out.eas) {
760 DEBUG(2,("ntvfs_map_fileinfo: no memory for %d eas\n",
761 info->all_eas.out.num_eas));
762 return NT_STATUS_NO_MEMORY;
763 }
764 for (i = 0; i < info->all_eas.out.num_eas; i++) {
765 info->all_eas.out.eas[i] = info2->generic.out.eas[i];
766 info->all_eas.out.eas[i].name.s =
767 talloc_strdup(req, info2->generic.out.eas[i].name.s);
768 if (!info->all_eas.out.eas[i].name.s) {
769 DEBUG(2,("ntvfs_map_fileinfo: no memory for stream_name\n"));
770 return NT_STATUS_NO_MEMORY;
771 }
772 info->all_eas.out.eas[i].value.data =
773 talloc_memdup(req,
774 info2->generic.out.eas[i].value.data,
775 info2->generic.out.eas[i].value.length);
776 if (!info->all_eas.out.eas[i].value.data) {
777 DEBUG(2,("ntvfs_map_fileinfo: no memory for stream_name\n"));
778 return NT_STATUS_NO_MEMORY;
779 }
780 }
781 }
782 return NT_STATUS_OK;
783
784 case RAW_FILEINFO_IS_NAME_VALID:
785 return NT_STATUS_OK;
786
787 case RAW_FILEINFO_COMPRESSION_INFO:
788 case RAW_FILEINFO_COMPRESSION_INFORMATION:
789 info->compression_info.out.compressed_size = info2->generic.out.compressed_size;
790 info->compression_info.out.format = info2->generic.out.format;
791 info->compression_info.out.unit_shift = info2->generic.out.unit_shift;
792 info->compression_info.out.chunk_shift = info2->generic.out.chunk_shift;
793 info->compression_info.out.cluster_shift = info2->generic.out.cluster_shift;
794 return NT_STATUS_OK;
795
796 case RAW_FILEINFO_ACCESS_INFORMATION:
797 info->access_information.out.access_flags = info2->generic.out.access_flags;
798 return NT_STATUS_OK;
799
800 case RAW_FILEINFO_MODE_INFORMATION:
801 info->mode_information.out.mode = info2->generic.out.mode;
802 return NT_STATUS_OK;
803
804 case RAW_FILEINFO_ALIGNMENT_INFORMATION:
805 info->alignment_information.out.alignment_requirement =
806 info2->generic.out.alignment_requirement;
807 return NT_STATUS_OK;
808 #if 0
809 case RAW_FILEINFO_UNIX_BASIC:
810 info->unix_basic_info.out.end_of_file = info2->generic.out.end_of_file;
811 info->unix_basic_info.out.num_bytes = info2->generic.out.size;
812 info->unix_basic_info.out.status_change_time = info2->generic.out.change_time;
813 info->unix_basic_info.out.access_time = info2->generic.out.access_time;
814 info->unix_basic_info.out.change_time = info2->generic.out.change_time;
815 info->unix_basic_info.out.uid = info2->generic.out.uid;
816 info->unix_basic_info.out.gid = info2->generic.out.gid;
817 info->unix_basic_info.out.file_type = info2->generic.out.file_type;
818 info->unix_basic_info.out.dev_major = info2->generic.out.device;
819 info->unix_basic_info.out.dev_minor = info2->generic.out.device;
820 info->unix_basic_info.out.unique_id = info2->generic.out.inode;
821 info->unix_basic_info.out.permissions = info2->generic.out.permissions;
822 info->unix_basic_info.out.nlink = info2->generic.out.nlink;
823 return NT_STATUS_OK;
824
825 case RAW_FILEINFO_UNIX_LINK:
826 info->unix_link_info.out.link_dest = info2->generic.out.link_dest;
827 return NT_STATUS_OK;
828 #endif
829 }
830
831 return NT_STATUS_INVALID_LEVEL;
832 }
833
834 /*
835 NTVFS fileinfo generic to any mapper
836 */
837 NTSTATUS ntvfs_map_qfileinfo(struct smbsrv_request *req, union smb_fileinfo *info,
838 struct ntvfs_module_context *ntvfs)
839 {
840 NTSTATUS status;
841 union smb_fileinfo *info2;
842
843 info2 = talloc(req, union smb_fileinfo);
844 if (info2 == NULL) {
845 return NT_STATUS_NO_MEMORY;
846 }
847
848 if (info->generic.level == RAW_FILEINFO_GENERIC) {
849 return NT_STATUS_INVALID_LEVEL;
850 }
851
852 /* ask the backend for the generic info */
853 info2->generic.level = RAW_FILEINFO_GENERIC;
854 info2->generic.in.fnum = info->generic.in.fnum;
855
856 status = ntvfs->ops->qfileinfo(ntvfs, req, info2);
857 if (!NT_STATUS_IS_OK(status)) {
858 return status;
859 }
860 return ntvfs_map_fileinfo(req, info, info2);
861 }
862
863 /*
864 NTVFS pathinfo generic to any mapper
865 */
866 NTSTATUS ntvfs_map_qpathinfo(struct smbsrv_request *req, union smb_fileinfo *info,
867 struct ntvfs_module_context *ntvfs)
868 {
869 NTSTATUS status;
870 union smb_fileinfo *info2;
871
872 info2 = talloc(req, union smb_fileinfo);
873 if (info2 == NULL) {
874 return NT_STATUS_NO_MEMORY;
875 }
876
877 if (info->generic.level == RAW_FILEINFO_GENERIC) {
878 return NT_STATUS_INVALID_LEVEL;
879 }
880
881 /* ask the backend for the generic info */
882 info2->generic.level = RAW_FILEINFO_GENERIC;
883 info2->generic.in.fname = info->generic.in.fname;
884
885 /* only used by the simple backend, which doesn't do async */
886 req->async_states->state &= ~NTVFS_ASYNC_STATE_MAY_ASYNC;
887
888 status = ntvfs->ops->qpathinfo(ntvfs, req, info2);
889 if (!NT_STATUS_IS_OK(status)) {
890 return status;
891 }
892 return ntvfs_map_fileinfo(req, info, info2);
893 }
894
895
896 /*
897 NTVFS lock generic to any mapper
898 */
899 NTSTATUS ntvfs_map_lock(struct smbsrv_request *req, union smb_lock *lck,
900 struct ntvfs_module_context *ntvfs)
901 {
902 union smb_lock *lck2;
903 struct smb_lock_entry *locks;
904
905 lck2 = talloc(req, union smb_lock);
906 if (lck2 == NULL) {
907 return NT_STATUS_NO_MEMORY;
908 }
909
910 locks = talloc_array(lck2, struct smb_lock_entry, 1);
911 if (locks == NULL) {
912 return NT_STATUS_NO_MEMORY;
913 }
914
915 switch (lck->generic.level) {
916 case RAW_LOCK_LOCKX:
917 return NT_STATUS_INVALID_LEVEL;
918
919 case RAW_LOCK_LOCK:
920 lck2->generic.in.ulock_cnt = 0;
921 lck2->generic.in.lock_cnt = 1;
922 break;
923
924 case RAW_LOCK_UNLOCK:
925 lck2->generic.in.ulock_cnt = 1;
926 lck2->generic.in.lock_cnt = 0;
927 break;
928 }
929
930 lck2->generic.level = RAW_LOCK_GENERIC;
931 lck2->generic.in.fnum = lck->lock.in.fnum;
932 lck2->generic.in.mode = 0;
933 lck2->generic.in.timeout = 0;
934 lck2->generic.in.locks = locks;
935 locks->pid = req->smbpid;
936 locks->offset = lck->lock.in.offset;
937 locks->count = lck->lock.in.count;
938
939 return ntvfs->ops->lock(ntvfs, req, lck2);
940 }
941
942
943 /*
944 NTVFS write generic to any mapper
945 */
946 static NTSTATUS ntvfs_map_write_finish(struct smbsrv_request *req,
947 struct ntvfs_module_context *ntvfs,
948 union smb_write *wr,
949 union smb_write *wr2,
950 NTSTATUS status)
951
952 {
953 union smb_lock *lck;
954 union smb_close *cl;
955 uint_t state;
956
957 if (NT_STATUS_IS_ERR(status)) {
958 return status;
959 }
960
961 switch (wr->generic.level) {
962 case RAW_WRITE_WRITE:
963 wr->write.out.nwritten = wr2->generic.out.nwritten;
964 break;
965
966 case RAW_WRITE_WRITEUNLOCK:
967 wr->writeunlock.out.nwritten = wr2->generic.out.nwritten;
968
969 lck = talloc(wr2, union smb_lock);
970 if (lck == NULL) {
971 return NT_STATUS_NO_MEMORY;
972 }
973
974 lck->unlock.level = RAW_LOCK_UNLOCK;
975 lck->unlock.in.fnum = wr->writeunlock.in.fnum;
976 lck->unlock.in.count = wr->writeunlock.in.count;
977 lck->unlock.in.offset = wr->writeunlock.in.offset;
978
979 if (lck->unlock.in.count != 0) {
980 /* do the lock sync for now */
981 state = req->async_states->state;
982 req->async_states->state &= ~NTVFS_ASYNC_STATE_MAY_ASYNC;
983 status = ntvfs->ops->lock(ntvfs, req, lck);
984 req->async_states->state = state;
985 }
986 break;
987
988 case RAW_WRITE_WRITECLOSE:
989 wr->writeclose.out.nwritten = wr2->generic.out.nwritten;
990
991 cl = talloc(wr2, union smb_close);
992 if (cl == NULL) {
993 return NT_STATUS_NO_MEMORY;
994 }
995
996 cl->close.level = RAW_CLOSE_CLOSE;
997 cl->close.in.fnum = wr->writeclose.in.fnum;
998 cl->close.in.write_time = wr->writeclose.in.mtime;
999
1000 if (wr2->generic.in.count != 0) {
1001 /* do the close sync for now */
1002 state = req->async_states->state;
1003 req->async_states->state &= ~NTVFS_ASYNC_STATE_MAY_ASYNC;
1004 status = ntvfs->ops->close(ntvfs, req, cl);
1005 req->async_states->state = state;
1006 }
1007 break;
1008
1009 case RAW_WRITE_SPLWRITE:
1010 break;
1011 default:
1012 return NT_STATUS_INVALID_LEVEL;
1013 }
1014
1015 return status;
1016 }
1017
1018
1019 /*
1020 NTVFS write generic to any mapper
1021 */
1022 NTSTATUS ntvfs_map_write(struct smbsrv_request *req, union smb_write *wr,
1023 struct ntvfs_module_context *ntvfs)
1024 {
1025 union smb_write *wr2;
1026 NTSTATUS status;
1027
1028 wr2 = talloc(req, union smb_write);
1029 if (wr2 == NULL) {
1030 return NT_STATUS_NO_MEMORY;
1031 }
1032
1033 status = ntvfs_map_async_setup(req, ntvfs, wr, wr2,
1034 (second_stage_t)ntvfs_map_write_finish);
1035 if (!NT_STATUS_IS_OK(status)) {
1036 return status;
1037 }
1038
1039 wr2->writex.level = RAW_WRITE_GENERIC;
1040
1041 switch (wr->generic.level) {
1042 case RAW_WRITE_WRITEX:
1043 status = NT_STATUS_INVALID_LEVEL;
1044 break;
1045
1046 case RAW_WRITE_WRITE:
1047 wr2->writex.in.fnum = wr->write.in.fnum;
1048 wr2->writex.in.offset = wr->write.in.offset;
1049 wr2->writex.in.wmode = 0;
1050 wr2->writex.in.remaining = wr->write.in.remaining;
1051 wr2->writex.in.count = wr->write.in.count;
1052 wr2->writex.in.data = wr->write.in.data;
1053 status = ntvfs->ops->write(ntvfs, req, wr2);
1054 break;
1055
1056 case RAW_WRITE_WRITEUNLOCK:
1057 wr2->writex.in.fnum = wr->writeunlock.in.fnum;
1058 wr2->writex.in.offset = wr->writeunlock.in.offset;
1059 wr2->writex.in.wmode = 0;
1060 wr2->writex.in.remaining = wr->writeunlock.in.remaining;
1061 wr2->writex.in.count = wr->writeunlock.in.count;
1062 wr2->writex.in.data = wr->writeunlock.in.data;
1063 status = ntvfs->ops->write(ntvfs, req, wr2);
1064 break;
1065
1066 case RAW_WRITE_WRITECLOSE:
1067 wr2->writex.in.fnum = wr->writeclose.in.fnum;
1068 wr2->writex.in.offset = wr->writeclose.in.offset;
1069 wr2->writex.in.wmode = 0;
1070 wr2->writex.in.remaining = 0;
1071 wr2->writex.in.count = wr->writeclose.in.count;
1072 wr2->writex.in.data = wr->writeclose.in.data;
1073 status = ntvfs->ops->write(ntvfs, req, wr2);
1074 break;
1075
1076 case RAW_WRITE_SPLWRITE:
1077 wr2->writex.in.fnum = wr->splwrite.in.fnum;
1078 wr2->writex.in.offset = 0;
1079 wr2->writex.in.wmode = 0;
1080 wr2->writex.in.remaining = 0;
1081 wr2->writex.in.count = wr->splwrite.in.count;
1082 wr2->writex.in.data = wr->splwrite.in.data;
1083 status = ntvfs->ops->write(ntvfs, req, wr2);
1084 break;
1085 }
1086
1087 return ntvfs_map_async_finish(req, status);
1088 }
1089
1090
1091 /*
1092 NTVFS read generic to any mapper - finish the out mapping
1093 */
1094 static NTSTATUS ntvfs_map_read_finish(struct smbsrv_request *req,
1095 struct ntvfs_module_context *ntvfs,
1096 union smb_read *rd,
1097 union smb_read *rd2,
1098 NTSTATUS status)
1099 {
1100 switch (rd->generic.level) {
1101 case RAW_READ_READ:
1102 rd->read.out.nread = rd2->generic.out.nread;
1103 break;
1104 case RAW_READ_READBRAW:
1105 rd->readbraw.out.nread = rd2->generic.out.nread;
1106 break;
1107 case RAW_READ_LOCKREAD:
1108 rd->lockread.out.nread = rd2->generic.out.nread;
1109 break;
1110 default:
1111 return NT_STATUS_INVALID_LEVEL;
1112 }
1113
1114 return status;
1115 }
1116
1117 /*
1118 NTVFS read* to readx mapper
1119 */
1120 NTSTATUS ntvfs_map_read(struct smbsrv_request *req, union smb_read *rd,
1121 struct ntvfs_module_context *ntvfs)
1122 {
1123 union smb_read *rd2;
1124 union smb_lock *lck;
1125 NTSTATUS status;
1126 uint_t state;
1127
1128 rd2 = talloc(req, union smb_read);
1129 if (rd2 == NULL) {
1130 return NT_STATUS_NO_MEMORY;
1131 }
1132
1133 status = ntvfs_map_async_setup(req, ntvfs, rd, rd2,
1134 (second_stage_t)ntvfs_map_read_finish);
1135 if (!NT_STATUS_IS_OK(status)) {
1136 return status;
1137 }
1138
1139 rd2->readx.level = RAW_READ_READX;
1140
1141 switch (rd->generic.level) {
1142 case RAW_READ_READX:
1143 status = NT_STATUS_INVALID_LEVEL;
1144 break;
1145
1146 case RAW_READ_READ:
1147 rd2->readx.in.fnum = rd->read.in.fnum;
1148 rd2->readx.in.offset = rd->read.in.offset;
1149 rd2->readx.in.mincnt = rd->read.in.count;
1150 rd2->readx.in.maxcnt = rd->read.in.count;
1151 rd2->readx.in.remaining = rd->read.in.remaining;
1152 rd2->readx.out.data = rd->read.out.data;
1153 status = ntvfs->ops->read(ntvfs, req, rd2);
1154 break;
1155
1156 case RAW_READ_READBRAW:
1157 rd2->readx.in.fnum = rd->readbraw.in.fnum;
1158 rd2->readx.in.offset = rd->readbraw.in.offset;
1159 rd2->readx.in.mincnt = rd->readbraw.in.mincnt;
1160 rd2->readx.in.maxcnt = rd->readbraw.in.maxcnt;
1161 rd2->readx.in.remaining = 0;
1162 rd2->readx.out.data = rd->readbraw.out.data;
1163 status = ntvfs->ops->read(ntvfs, req, rd2);
1164 break;
1165
1166 case RAW_READ_LOCKREAD:
1167 /* do the initial lock sync for now */
1168 state = req->async_states->state;
1169 req->async_states->state &= ~NTVFS_ASYNC_STATE_MAY_ASYNC;
1170
1171 lck = talloc(rd2, union smb_lock);
1172 if (lck == NULL) {
1173 status = NT_STATUS_NO_MEMORY;
1174 goto done;
1175 }
1176 lck->lock.level = RAW_LOCK_LOCK;
1177 lck->lock.in.fnum = rd->lockread.in.fnum;
1178 lck->lock.in.count = rd->lockread.in.count;
1179 lck->lock.in.offset = rd->lockread.in.offset;
1180 status = ntvfs->ops->lock(ntvfs, req, lck);
1181 req->async_states->state = state;
1182
1183 rd2->readx.in.fnum = rd->lockread.in.fnum;
1184 rd2->readx.in.offset = rd->lockread.in.offset;
1185 rd2->readx.in.mincnt = rd->lockread.in.count;
1186 rd2->readx.in.maxcnt = rd->lockread.in.count;
1187 rd2->readx.in.remaining = rd->lockread.in.remaining;
1188 rd2->readx.out.data = rd->lockread.out.data;
1189
1190 if (NT_STATUS_IS_OK(status)) {
1191 status = ntvfs->ops->read(ntvfs, req, rd2);
1192 }
1193 break;
1194 }
1195
1196 done:
1197 return ntvfs_map_async_finish(req, status);
1198 }
1199
1200
1201 /*
1202 NTVFS close generic to any mapper
1203 */
1204 NTSTATUS ntvfs_map_close(struct smbsrv_request *req, union smb_close *cl,
1205 struct ntvfs_module_context *ntvfs)
1206 {
1207 union smb_close *cl2;
1208
1209 cl2 = talloc(req, union smb_close);
1210 if (cl2 == NULL) {
1211 return NT_STATUS_NO_MEMORY;
1212 }
1213
1214 switch (cl->generic.level) {
1215 case RAW_CLOSE_CLOSE:
1216 return NT_STATUS_INVALID_LEVEL;
1217
1218 case RAW_CLOSE_SPLCLOSE:
1219 cl2->close.level = RAW_CLOSE_CLOSE;
1220 cl2->close.in.fnum = cl->splclose.in.fnum;
1221 break;
1222 }
1223
1224 return ntvfs->ops->close(ntvfs, req, cl2);
1225 }
aatanasov's samba4 branch