2b4f9bb8c59a28b16fc0daf00e2079a82acea346
[bbaumbach/samba-autobuild/.git] / source4 / ntvfs / cifs / vfs_cifs.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    CIFS-on-CIFS NTVFS filesystem backend
5
6    Copyright (C) Andrew Tridgell 2003
7    Copyright (C) James J Myers 2003 <myersjj@samba.org>
8
9    This program is free software; you can redistribute it and/or modify
10    it under the terms of the GNU General Public License as published by
11    the Free Software Foundation; either version 2 of the License, or
12    (at your option) any later version.
13    
14    This program is distributed in the hope that it will be useful,
15    but WITHOUT ANY WARRANTY; without even the implied warranty of
16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17    GNU General Public License for more details.
18    
19    You should have received a copy of the GNU General Public License
20    along with this program; if not, write to the Free Software
21    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 */
23 /*
24   this implements a CIFS->CIFS NTVFS filesystem backend. 
25   
26 */
27
28 #include "includes.h"
29 #include "libcli/raw/libcliraw.h"
30 #include "libcli/smb_composite/smb_composite.h"
31 #include "auth/auth.h"
32 #include "ntvfs/ntvfs.h"
33 #include "include/dlinklist.h"
34
35 struct cvfs_file {
36         struct cvfs_file *prev, *next;
37         uint16_t fnum;
38         struct ntvfs_handle *h;
39 };
40
41 /* this is stored in ntvfs_private */
42 struct cvfs_private {
43         struct smbcli_tree *tree;
44         struct smbcli_transport *transport;
45         struct ntvfs_module_context *ntvfs;
46         struct async_info *pending;
47         struct cvfs_file *files;
48         BOOL map_generic;
49         BOOL map_trans2;
50 };
51
52
53 /* a structure used to pass information to an async handler */
54 struct async_info {
55         struct async_info *next, *prev;
56         struct cvfs_private *cvfs;
57         struct ntvfs_request *req;
58         struct smbcli_request *c_req;
59         struct cvfs_file *f;
60         void *parms;
61 };
62
63 #define SETUP_PID private->tree->session->pid = req->smbpid
64
65 #define SETUP_FILE do { \
66         struct cvfs_file *f; \
67         f = ntvfs_handle_get_backend_data(io->generic.in.file.ntvfs, ntvfs); \
68         if (!f) return NT_STATUS_INVALID_HANDLE; \
69         io->generic.in.file.fnum = f->fnum; \
70 } while (0) 
71
72 #define SETUP_PID_AND_FILE do { \
73         SETUP_PID; \
74         SETUP_FILE; \
75 } while (0)
76
77 /*
78   a handler for oplock break events from the server - these need to be passed
79   along to the client
80  */
81 static BOOL oplock_handler(struct smbcli_transport *transport, uint16_t tid, uint16_t fnum, uint8_t level, void *p_private)
82 {
83         struct cvfs_private *private = p_private;
84         NTSTATUS status;
85         struct ntvfs_handle *h = NULL;
86         struct cvfs_file *f;
87
88         for (f=private->files; f; f=f->next) {
89                 if (f->fnum != fnum) continue;
90                 h = f->h;
91                 break;
92         }
93
94         if (!h) {
95                 DEBUG(5,("vfs_cifs: ignoring oplock break level %d for fnum %d\n", level, fnum));
96                 return True;
97         }
98
99         DEBUG(5,("vfs_cifs: sending oplock break level %d for fnum %d\n", level, fnum));
100         status = ntvfs_send_oplock_break(private->ntvfs, h, level);
101         if (!NT_STATUS_IS_OK(status)) return False;
102         return True;
103 }
104
105 /*
106   connect to a share - used when a tree_connect operation comes in.
107 */
108 static NTSTATUS cvfs_connect(struct ntvfs_module_context *ntvfs, 
109                              struct ntvfs_request *req, const char *sharename)
110 {
111         NTSTATUS status;
112         struct cvfs_private *private;
113         const char *host, *user, *pass, *domain, *remote_share;
114         struct smb_composite_connect io;
115         struct composite_context *creq;
116         int snum = ntvfs->ctx->config.snum;
117
118         struct cli_credentials *credentials;
119         BOOL machine_account;
120
121         /* Here we need to determine which server to connect to.
122          * For now we use parametric options, type cifs.
123          * Later we will use security=server and auth_server.c.
124          */
125         host = lp_parm_string(snum, "cifs", "server");
126         user = lp_parm_string(snum, "cifs", "user");
127         pass = lp_parm_string(snum, "cifs", "password");
128         domain = lp_parm_string(snum, "cifs", "domain");
129         remote_share = lp_parm_string(snum, "cifs", "share");
130         if (!remote_share) {
131                 remote_share = sharename;
132         }
133
134         machine_account = lp_parm_bool(snum, "cifs", "use_machine_account", False);
135
136         private = talloc_zero(ntvfs, struct cvfs_private);
137         if (!private) {
138                 return NT_STATUS_NO_MEMORY;
139         }
140
141         ntvfs->private_data = private;
142
143         if (!host) {
144                 DEBUG(1,("CIFS backend: You must supply server\n"));
145                 return NT_STATUS_INVALID_PARAMETER;
146         } 
147         
148         if (user && pass) {
149                 DEBUG(5, ("CIFS backend: Using specified password\n"));
150                 credentials = cli_credentials_init(private);
151                 if (!credentials) {
152                         return NT_STATUS_NO_MEMORY;
153                 }
154                 cli_credentials_set_conf(credentials);
155                 cli_credentials_set_username(credentials, user, CRED_SPECIFIED);
156                 if (domain) {
157                         cli_credentials_set_domain(credentials, domain, CRED_SPECIFIED);
158                 }
159                 cli_credentials_set_password(credentials, pass, CRED_SPECIFIED);
160         } else if (machine_account) {
161                 DEBUG(5, ("CIFS backend: Using machine account\n"));
162                 credentials = cli_credentials_init(private);
163                 cli_credentials_set_conf(credentials);
164                 if (domain) {
165                         cli_credentials_set_domain(credentials, domain, CRED_SPECIFIED);
166                 }
167                 status = cli_credentials_set_machine_account(credentials);
168                 if (!NT_STATUS_IS_OK(status)) {
169                         return status;
170                 }
171         } else if (req->session_info->credentials) {
172                 DEBUG(5, ("CIFS backend: Using delegated credentials\n"));
173                 credentials = req->session_info->credentials;
174         } else {
175                 DEBUG(1,("CIFS backend: You must supply server, user and password and or have delegated credentials\n"));
176                 return NT_STATUS_INVALID_PARAMETER;
177         }
178
179         /* connect to the server, using the smbd event context */
180         io.in.dest_host = host;
181         io.in.port = 0;
182         io.in.called_name = host;
183         io.in.credentials = credentials;
184         io.in.fallback_to_anonymous = False;
185         io.in.workgroup = lp_workgroup();
186         io.in.service = remote_share;
187         io.in.service_type = "?????";
188         
189         creq = smb_composite_connect_send(&io, private, ntvfs->ctx->event_ctx);
190         status = smb_composite_connect_recv(creq, private);
191         NT_STATUS_NOT_OK_RETURN(status);
192
193         private->tree = io.out.tree;
194
195         private->transport = private->tree->session->transport;
196         SETUP_PID;
197         private->ntvfs = ntvfs;
198
199         ntvfs->ctx->fs_type = talloc_strdup(ntvfs->ctx, "NTFS");
200         NT_STATUS_HAVE_NO_MEMORY(ntvfs->ctx->fs_type);
201         ntvfs->ctx->dev_type = talloc_strdup(ntvfs->ctx, "A:");
202         NT_STATUS_HAVE_NO_MEMORY(ntvfs->ctx->dev_type);
203
204         /* we need to receive oplock break requests from the server */
205         smbcli_oplock_handler(private->transport, oplock_handler, private);
206
207         private->map_generic = lp_parm_bool(ntvfs->ctx->config.snum, 
208                                             "cifs", "mapgeneric", False);
209
210         private->map_trans2 = lp_parm_bool(ntvfs->ctx->config.snum,
211                                            "cifs", "maptrans2", True);
212
213         return NT_STATUS_OK;
214 }
215
216 /*
217   disconnect from a share
218 */
219 static NTSTATUS cvfs_disconnect(struct ntvfs_module_context *ntvfs)
220 {
221         struct cvfs_private *private = ntvfs->private_data;
222         struct async_info *a, *an;
223
224         /* first cleanup pending requests */
225         for (a=private->pending; a; a = an) {
226                 an = a->next;
227                 smbcli_request_destroy(a->c_req);
228                 talloc_free(a);
229         }
230
231         talloc_free(private);
232         ntvfs->private_data = NULL;
233
234         return NT_STATUS_OK;
235 }
236
237 /*
238   destroy an async info structure
239 */
240 static int async_info_destructor(void *p)
241 {
242         struct async_info *async = talloc_get_type(p, struct async_info);
243         DLIST_REMOVE(async->cvfs->pending, async);
244         return 0;
245 }
246
247 /*
248   a handler for simple async replies
249   this handler can only be used for functions that don't return any
250   parameters (those that just return a status code)
251  */
252 static void async_simple(struct smbcli_request *c_req)
253 {
254         struct async_info *async = c_req->async.private;
255         struct ntvfs_request *req = async->req;
256         req->async_states->status = smbcli_request_simple_recv(c_req);
257         talloc_free(async);
258         req->async_states->send_fn(req);
259 }
260
261
262 /* save some typing for the simple functions */
263 #define ASYNC_RECV_TAIL_F(io, async_fn, file) do { \
264         if (!c_req) return NT_STATUS_UNSUCCESSFUL; \
265         { \
266                 struct async_info *async; \
267                 async = talloc(req, struct async_info); \
268                 if (!async) return NT_STATUS_NO_MEMORY; \
269                 async->parms = io; \
270                 async->req = req; \
271                 async->f = file; \
272                 async->cvfs = private; \
273                 async->c_req = c_req; \
274                 DLIST_ADD(private->pending, async); \
275                 c_req->async.private = async; \
276                 talloc_set_destructor(async, async_info_destructor); \
277         } \
278         c_req->async.fn = async_fn; \
279         req->async_states->state |= NTVFS_ASYNC_STATE_ASYNC; \
280         return NT_STATUS_OK; \
281 } while (0)
282
283 #define ASYNC_RECV_TAIL(io, async_fn) ASYNC_RECV_TAIL_F(io, async_fn, NULL)
284
285 #define SIMPLE_ASYNC_TAIL ASYNC_RECV_TAIL(NULL, async_simple)
286
287 /*
288   delete a file - the dirtype specifies the file types to include in the search. 
289   The name can contain CIFS wildcards, but rarely does (except with OS/2 clients)
290 */
291 static NTSTATUS cvfs_unlink(struct ntvfs_module_context *ntvfs, 
292                             struct ntvfs_request *req, union smb_unlink *unl)
293 {
294         struct cvfs_private *private = ntvfs->private_data;
295         struct smbcli_request *c_req;
296
297         SETUP_PID;
298
299         /* see if the front end will allow us to perform this
300            function asynchronously.  */
301         if (!(req->async_states->state & NTVFS_ASYNC_STATE_MAY_ASYNC)) {
302                 return smb_raw_unlink(private->tree, unl);
303         }
304
305         c_req = smb_raw_unlink_send(private->tree, unl);
306
307         SIMPLE_ASYNC_TAIL;
308 }
309
310 /*
311   a handler for async ioctl replies
312  */
313 static void async_ioctl(struct smbcli_request *c_req)
314 {
315         struct async_info *async = c_req->async.private;
316         struct ntvfs_request *req = async->req;
317         req->async_states->status = smb_raw_ioctl_recv(c_req, req, async->parms);
318         talloc_free(async);
319         req->async_states->send_fn(req);
320 }
321
322 /*
323   ioctl interface
324 */
325 static NTSTATUS cvfs_ioctl(struct ntvfs_module_context *ntvfs, 
326                            struct ntvfs_request *req, union smb_ioctl *io)
327 {
328         struct cvfs_private *private = ntvfs->private_data;
329         struct smbcli_request *c_req;
330
331         SETUP_PID_AND_FILE;
332
333         /* see if the front end will allow us to perform this
334            function asynchronously.  */
335         if (!(req->async_states->state & NTVFS_ASYNC_STATE_MAY_ASYNC)) {
336                 return smb_raw_ioctl(private->tree, req, io);
337         }
338
339         c_req = smb_raw_ioctl_send(private->tree, io);
340
341         ASYNC_RECV_TAIL(io, async_ioctl);
342 }
343
344 /*
345   check if a directory exists
346 */
347 static NTSTATUS cvfs_chkpath(struct ntvfs_module_context *ntvfs, 
348                              struct ntvfs_request *req, union smb_chkpath *cp)
349 {
350         struct cvfs_private *private = ntvfs->private_data;
351         struct smbcli_request *c_req;
352
353         SETUP_PID;
354
355         if (!(req->async_states->state & NTVFS_ASYNC_STATE_MAY_ASYNC)) {
356                 return smb_raw_chkpath(private->tree, cp);
357         }
358
359         c_req = smb_raw_chkpath_send(private->tree, cp);
360
361         SIMPLE_ASYNC_TAIL;
362 }
363
364 /*
365   a handler for async qpathinfo replies
366  */
367 static void async_qpathinfo(struct smbcli_request *c_req)
368 {
369         struct async_info *async = c_req->async.private;
370         struct ntvfs_request *req = async->req;
371         req->async_states->status = smb_raw_pathinfo_recv(c_req, req, async->parms);
372         talloc_free(async);
373         req->async_states->send_fn(req);
374 }
375
376 /*
377   return info on a pathname
378 */
379 static NTSTATUS cvfs_qpathinfo(struct ntvfs_module_context *ntvfs, 
380                                struct ntvfs_request *req, union smb_fileinfo *info)
381 {
382         struct cvfs_private *private = ntvfs->private_data;
383         struct smbcli_request *c_req;
384
385         SETUP_PID;
386
387         if (!(req->async_states->state & NTVFS_ASYNC_STATE_MAY_ASYNC)) {
388                 return smb_raw_pathinfo(private->tree, req, info);
389         }
390
391         c_req = smb_raw_pathinfo_send(private->tree, info);
392
393         ASYNC_RECV_TAIL(info, async_qpathinfo);
394 }
395
396 /*
397   a handler for async qfileinfo replies
398  */
399 static void async_qfileinfo(struct smbcli_request *c_req)
400 {
401         struct async_info *async = c_req->async.private;
402         struct ntvfs_request *req = async->req;
403         req->async_states->status = smb_raw_fileinfo_recv(c_req, req, async->parms);
404         talloc_free(async);
405         req->async_states->send_fn(req);
406 }
407
408 /*
409   query info on a open file
410 */
411 static NTSTATUS cvfs_qfileinfo(struct ntvfs_module_context *ntvfs, 
412                                struct ntvfs_request *req, union smb_fileinfo *io)
413 {
414         struct cvfs_private *private = ntvfs->private_data;
415         struct smbcli_request *c_req;
416
417         SETUP_PID_AND_FILE;
418
419         if (!(req->async_states->state & NTVFS_ASYNC_STATE_MAY_ASYNC)) {
420                 return smb_raw_fileinfo(private->tree, req, io);
421         }
422
423         c_req = smb_raw_fileinfo_send(private->tree, io);
424
425         ASYNC_RECV_TAIL(io, async_qfileinfo);
426 }
427
428
429 /*
430   set info on a pathname
431 */
432 static NTSTATUS cvfs_setpathinfo(struct ntvfs_module_context *ntvfs, 
433                                  struct ntvfs_request *req, union smb_setfileinfo *st)
434 {
435         struct cvfs_private *private = ntvfs->private_data;
436         struct smbcli_request *c_req;
437
438         SETUP_PID;
439
440         if (!(req->async_states->state & NTVFS_ASYNC_STATE_MAY_ASYNC)) {
441                 return smb_raw_setpathinfo(private->tree, st);
442         }
443
444         c_req = smb_raw_setpathinfo_send(private->tree, st);
445
446         SIMPLE_ASYNC_TAIL;
447 }
448
449
450 /*
451   a handler for async open replies
452  */
453 static void async_open(struct smbcli_request *c_req)
454 {
455         struct async_info *async = c_req->async.private;
456         struct cvfs_private *cvfs = async->cvfs;
457         struct ntvfs_request *req = async->req;
458         struct cvfs_file *f = async->f;
459         union smb_open *io = async->parms;
460         union smb_handle *file;
461         talloc_free(async);
462         req->async_states->status = smb_raw_open_recv(c_req, req, io);
463         SMB_OPEN_OUT_FILE(io, file);
464         f->fnum = file->fnum;
465         file->ntvfs = NULL;
466         if (!NT_STATUS_IS_OK(req->async_states->status)) goto failed;
467         req->async_states->status = ntvfs_handle_set_backend_data(f->h, cvfs->ntvfs, f);
468         if (!NT_STATUS_IS_OK(req->async_states->status)) goto failed;
469         file->ntvfs = f->h;
470 failed:
471         req->async_states->send_fn(req);
472 }
473
474 /*
475   open a file
476 */
477 static NTSTATUS cvfs_open(struct ntvfs_module_context *ntvfs, 
478                           struct ntvfs_request *req, union smb_open *io)
479 {
480         struct cvfs_private *private = ntvfs->private_data;
481         struct smbcli_request *c_req;
482         struct ntvfs_handle *h;
483         struct cvfs_file *f;
484         NTSTATUS status;
485
486         SETUP_PID;
487
488         if (io->generic.level != RAW_OPEN_GENERIC &&
489             private->map_generic) {
490                 return ntvfs_map_open(ntvfs, req, io);
491         }
492
493         status = ntvfs_handle_new(ntvfs, req, &h);
494         NT_STATUS_NOT_OK_RETURN(status);
495
496         f = talloc_zero(h, struct cvfs_file);
497         NT_STATUS_HAVE_NO_MEMORY(f);
498         f->h = h;
499
500         if (!(req->async_states->state & NTVFS_ASYNC_STATE_MAY_ASYNC)) {
501                 union smb_handle *file;
502
503                 status = smb_raw_open(private->tree, req, io);
504                 NT_STATUS_NOT_OK_RETURN(status);
505
506                 SMB_OPEN_OUT_FILE(io, file);
507                 f->fnum = file->fnum;
508                 file->ntvfs = NULL;
509                 status = ntvfs_handle_set_backend_data(f->h, private->ntvfs, f);
510                 NT_STATUS_NOT_OK_RETURN(status);
511                 file->ntvfs = f->h;
512
513                 return NT_STATUS_OK;
514         }
515
516         c_req = smb_raw_open_send(private->tree, io);
517
518         ASYNC_RECV_TAIL_F(io, async_open, f);
519 }
520
521 /*
522   create a directory
523 */
524 static NTSTATUS cvfs_mkdir(struct ntvfs_module_context *ntvfs, 
525                            struct ntvfs_request *req, union smb_mkdir *md)
526 {
527         struct cvfs_private *private = ntvfs->private_data;
528         struct smbcli_request *c_req;
529
530         SETUP_PID;
531
532         if (!(req->async_states->state & NTVFS_ASYNC_STATE_MAY_ASYNC)) {
533                 return smb_raw_mkdir(private->tree, md);
534         }
535
536         c_req = smb_raw_mkdir_send(private->tree, md);
537
538         SIMPLE_ASYNC_TAIL;
539 }
540
541 /*
542   remove a directory
543 */
544 static NTSTATUS cvfs_rmdir(struct ntvfs_module_context *ntvfs, 
545                            struct ntvfs_request *req, struct smb_rmdir *rd)
546 {
547         struct cvfs_private *private = ntvfs->private_data;
548         struct smbcli_request *c_req;
549
550         SETUP_PID;
551
552         if (!(req->async_states->state & NTVFS_ASYNC_STATE_MAY_ASYNC)) {
553                 return smb_raw_rmdir(private->tree, rd);
554         }
555         c_req = smb_raw_rmdir_send(private->tree, rd);
556
557         SIMPLE_ASYNC_TAIL;
558 }
559
560 /*
561   rename a set of files
562 */
563 static NTSTATUS cvfs_rename(struct ntvfs_module_context *ntvfs, 
564                             struct ntvfs_request *req, union smb_rename *ren)
565 {
566         struct cvfs_private *private = ntvfs->private_data;
567         struct smbcli_request *c_req;
568
569         SETUP_PID;
570
571         if (!(req->async_states->state & NTVFS_ASYNC_STATE_MAY_ASYNC)) {
572                 return smb_raw_rename(private->tree, ren);
573         }
574
575         c_req = smb_raw_rename_send(private->tree, ren);
576
577         SIMPLE_ASYNC_TAIL;
578 }
579
580 /*
581   copy a set of files
582 */
583 static NTSTATUS cvfs_copy(struct ntvfs_module_context *ntvfs, 
584                           struct ntvfs_request *req, struct smb_copy *cp)
585 {
586         return NT_STATUS_NOT_SUPPORTED;
587 }
588
589 /*
590   a handler for async read replies
591  */
592 static void async_read(struct smbcli_request *c_req)
593 {
594         struct async_info *async = c_req->async.private;
595         struct ntvfs_request *req = async->req;
596         req->async_states->status = smb_raw_read_recv(c_req, async->parms);
597         talloc_free(async);
598         req->async_states->send_fn(req);
599 }
600
601 /*
602   read from a file
603 */
604 static NTSTATUS cvfs_read(struct ntvfs_module_context *ntvfs, 
605                           struct ntvfs_request *req, union smb_read *io)
606 {
607         struct cvfs_private *private = ntvfs->private_data;
608         struct smbcli_request *c_req;
609
610         SETUP_PID;
611
612         if (io->generic.level != RAW_READ_GENERIC &&
613             private->map_generic) {
614                 return ntvfs_map_read(ntvfs, req, io);
615         }
616
617         SETUP_FILE;
618
619         if (!(req->async_states->state & NTVFS_ASYNC_STATE_MAY_ASYNC)) {
620                 return smb_raw_read(private->tree, io);
621         }
622
623         c_req = smb_raw_read_send(private->tree, io);
624
625         ASYNC_RECV_TAIL(io, async_read);
626 }
627
628 /*
629   a handler for async write replies
630  */
631 static void async_write(struct smbcli_request *c_req)
632 {
633         struct async_info *async = c_req->async.private;
634         struct ntvfs_request *req = async->req;
635         req->async_states->status = smb_raw_write_recv(c_req, async->parms);
636         talloc_free(async);
637         req->async_states->send_fn(req);
638 }
639
640 /*
641   write to a file
642 */
643 static NTSTATUS cvfs_write(struct ntvfs_module_context *ntvfs, 
644                            struct ntvfs_request *req, union smb_write *io)
645 {
646         struct cvfs_private *private = ntvfs->private_data;
647         struct smbcli_request *c_req;
648
649         SETUP_PID;
650
651         if (io->generic.level != RAW_WRITE_GENERIC &&
652             private->map_generic) {
653                 return ntvfs_map_write(ntvfs, req, io);
654         }
655         SETUP_FILE;
656
657         if (!(req->async_states->state & NTVFS_ASYNC_STATE_MAY_ASYNC)) {
658                 return smb_raw_write(private->tree, io);
659         }
660
661         c_req = smb_raw_write_send(private->tree, io);
662
663         ASYNC_RECV_TAIL(io, async_write);
664 }
665
666 /*
667   a handler for async seek replies
668  */
669 static void async_seek(struct smbcli_request *c_req)
670 {
671         struct async_info *async = c_req->async.private;
672         struct ntvfs_request *req = async->req;
673         req->async_states->status = smb_raw_seek_recv(c_req, async->parms);
674         talloc_free(async);
675         req->async_states->send_fn(req);
676 }
677
678 /*
679   seek in a file
680 */
681 static NTSTATUS cvfs_seek(struct ntvfs_module_context *ntvfs, 
682                           struct ntvfs_request *req,
683                           union smb_seek *io)
684 {
685         struct cvfs_private *private = ntvfs->private_data;
686         struct smbcli_request *c_req;
687
688         SETUP_PID_AND_FILE;
689
690         if (!(req->async_states->state & NTVFS_ASYNC_STATE_MAY_ASYNC)) {
691                 return smb_raw_seek(private->tree, io);
692         }
693
694         c_req = smb_raw_seek_send(private->tree, io);
695
696         ASYNC_RECV_TAIL(io, async_seek);
697 }
698
699 /*
700   flush a file
701 */
702 static NTSTATUS cvfs_flush(struct ntvfs_module_context *ntvfs, 
703                            struct ntvfs_request *req,
704                            union smb_flush *io)
705 {
706         struct cvfs_private *private = ntvfs->private_data;
707         struct smbcli_request *c_req;
708
709         SETUP_PID;
710         switch (io->generic.level) {
711         case RAW_FLUSH_FLUSH:
712                 SETUP_FILE;
713                 break;
714         case RAW_FLUSH_ALL:
715                 io->generic.in.file.fnum = 0xFFFF;
716                 break;
717         case RAW_FLUSH_SMB2:
718                 return NT_STATUS_INVALID_LEVEL;
719         }
720
721         if (!(req->async_states->state & NTVFS_ASYNC_STATE_MAY_ASYNC)) {
722                 return smb_raw_flush(private->tree, io);
723         }
724
725         c_req = smb_raw_flush_send(private->tree, io);
726
727         SIMPLE_ASYNC_TAIL;
728 }
729
730 /*
731   close a file
732 */
733 static NTSTATUS cvfs_close(struct ntvfs_module_context *ntvfs, 
734                            struct ntvfs_request *req, union smb_close *io)
735 {
736         struct cvfs_private *private = ntvfs->private_data;
737         struct smbcli_request *c_req;
738
739         SETUP_PID;
740
741         if (io->generic.level != RAW_CLOSE_GENERIC &&
742             private->map_generic) {
743                 return ntvfs_map_close(ntvfs, req, io);
744         }
745         SETUP_FILE;
746
747         if (!(req->async_states->state & NTVFS_ASYNC_STATE_MAY_ASYNC)) {
748                 return smb_raw_close(private->tree, io);
749         }
750
751         c_req = smb_raw_close_send(private->tree, io);
752
753         SIMPLE_ASYNC_TAIL;
754 }
755
756 /*
757   exit - closing files open by the pid
758 */
759 static NTSTATUS cvfs_exit(struct ntvfs_module_context *ntvfs, 
760                           struct ntvfs_request *req)
761 {
762         struct cvfs_private *private = ntvfs->private_data;
763         struct smbcli_request *c_req;
764
765         SETUP_PID;
766
767         if (!(req->async_states->state & NTVFS_ASYNC_STATE_MAY_ASYNC)) {
768                 return smb_raw_exit(private->tree->session);
769         }
770
771         c_req = smb_raw_exit_send(private->tree->session);
772
773         SIMPLE_ASYNC_TAIL;
774 }
775
776 /*
777   logoff - closing files open by the user
778 */
779 static NTSTATUS cvfs_logoff(struct ntvfs_module_context *ntvfs, 
780                             struct ntvfs_request *req)
781 {
782         /* we can't do this right in the cifs backend .... */
783         return NT_STATUS_OK;
784 }
785
786 /*
787   setup for an async call - nothing to do yet
788 */
789 static NTSTATUS cvfs_async_setup(struct ntvfs_module_context *ntvfs, 
790                                  struct ntvfs_request *req, 
791                                  void *private)
792 {
793         return NT_STATUS_OK;
794 }
795
796 /*
797   cancel an async call
798 */
799 static NTSTATUS cvfs_cancel(struct ntvfs_module_context *ntvfs, 
800                             struct ntvfs_request *req)
801 {
802         struct cvfs_private *private = ntvfs->private_data;
803         struct async_info *a;
804
805         /* find the matching request */
806         for (a=private->pending;a;a=a->next) {
807                 if (a->req->smbmid == req->smbmid) {
808                         break;
809                 }
810         }
811
812         if (a == NULL) {
813                 return NT_STATUS_INVALID_PARAMETER;
814         }
815
816         return smb_raw_ntcancel(a->c_req);
817 }
818
819 /*
820   lock a byte range
821 */
822 static NTSTATUS cvfs_lock(struct ntvfs_module_context *ntvfs, 
823                           struct ntvfs_request *req, union smb_lock *io)
824 {
825         struct cvfs_private *private = ntvfs->private_data;
826         struct smbcli_request *c_req;
827
828         SETUP_PID;
829
830         if (io->generic.level != RAW_LOCK_GENERIC &&
831             private->map_generic) {
832                 return ntvfs_map_lock(ntvfs, req, io);
833         }
834         SETUP_FILE;
835
836         if (!(req->async_states->state & NTVFS_ASYNC_STATE_MAY_ASYNC)) {
837                 return smb_raw_lock(private->tree, io);
838         }
839
840         c_req = smb_raw_lock_send(private->tree, io);
841         SIMPLE_ASYNC_TAIL;
842 }
843
844 /*
845   set info on a open file
846 */
847 static NTSTATUS cvfs_setfileinfo(struct ntvfs_module_context *ntvfs, 
848                                  struct ntvfs_request *req, 
849                                  union smb_setfileinfo *io)
850 {
851         struct cvfs_private *private = ntvfs->private_data;
852         struct smbcli_request *c_req;
853
854         SETUP_PID_AND_FILE;
855
856         if (!(req->async_states->state & NTVFS_ASYNC_STATE_MAY_ASYNC)) {
857                 return smb_raw_setfileinfo(private->tree, io);
858         }
859         c_req = smb_raw_setfileinfo_send(private->tree, io);
860
861         SIMPLE_ASYNC_TAIL;
862 }
863
864
865 /*
866   a handler for async fsinfo replies
867  */
868 static void async_fsinfo(struct smbcli_request *c_req)
869 {
870         struct async_info *async = c_req->async.private;
871         struct ntvfs_request *req = async->req;
872         req->async_states->status = smb_raw_fsinfo_recv(c_req, req, async->parms);
873         talloc_free(async);
874         req->async_states->send_fn(req);
875 }
876
877 /*
878   return filesystem space info
879 */
880 static NTSTATUS cvfs_fsinfo(struct ntvfs_module_context *ntvfs, 
881                             struct ntvfs_request *req, union smb_fsinfo *fs)
882 {
883         struct cvfs_private *private = ntvfs->private_data;
884         struct smbcli_request *c_req;
885
886         SETUP_PID;
887
888         if (!(req->async_states->state & NTVFS_ASYNC_STATE_MAY_ASYNC)) {
889                 return smb_raw_fsinfo(private->tree, req, fs);
890         }
891
892         c_req = smb_raw_fsinfo_send(private->tree, req, fs);
893
894         ASYNC_RECV_TAIL(fs, async_fsinfo);
895 }
896
897 /*
898   return print queue info
899 */
900 static NTSTATUS cvfs_lpq(struct ntvfs_module_context *ntvfs, 
901                          struct ntvfs_request *req, union smb_lpq *lpq)
902 {
903         return NT_STATUS_NOT_SUPPORTED;
904 }
905
906 /* 
907    list files in a directory matching a wildcard pattern
908 */
909 static NTSTATUS cvfs_search_first(struct ntvfs_module_context *ntvfs, 
910                                   struct ntvfs_request *req, union smb_search_first *io, 
911                                   void *search_private, 
912                                   BOOL (*callback)(void *, union smb_search_data *))
913 {
914         struct cvfs_private *private = ntvfs->private_data;
915
916         SETUP_PID;
917
918         return smb_raw_search_first(private->tree, req, io, search_private, callback);
919 }
920
921 /* continue a search */
922 static NTSTATUS cvfs_search_next(struct ntvfs_module_context *ntvfs, 
923                                  struct ntvfs_request *req, union smb_search_next *io, 
924                                  void *search_private, 
925                                  BOOL (*callback)(void *, union smb_search_data *))
926 {
927         struct cvfs_private *private = ntvfs->private_data;
928
929         SETUP_PID;
930
931         return smb_raw_search_next(private->tree, req, io, search_private, callback);
932 }
933
934 /* close a search */
935 static NTSTATUS cvfs_search_close(struct ntvfs_module_context *ntvfs, 
936                                   struct ntvfs_request *req, union smb_search_close *io)
937 {
938         struct cvfs_private *private = ntvfs->private_data;
939
940         SETUP_PID;
941
942         return smb_raw_search_close(private->tree, io);
943 }
944
945 /*
946   a handler for async trans2 replies
947  */
948 static void async_trans2(struct smbcli_request *c_req)
949 {
950         struct async_info *async = c_req->async.private;
951         struct ntvfs_request *req = async->req;
952         req->async_states->status = smb_raw_trans2_recv(c_req, req, async->parms);
953         talloc_free(async);
954         req->async_states->send_fn(req);
955 }
956
957 /* raw trans2 */
958 static NTSTATUS cvfs_trans2(struct ntvfs_module_context *ntvfs, 
959                             struct ntvfs_request *req,
960                             struct smb_trans2 *trans2)
961 {
962         struct cvfs_private *private = ntvfs->private_data;
963         struct smbcli_request *c_req;
964
965         if (private->map_trans2) {
966                 return NT_STATUS_NOT_IMPLEMENTED;
967         }
968
969         SETUP_PID;
970
971         if (!(req->async_states->state & NTVFS_ASYNC_STATE_MAY_ASYNC)) {
972                 return smb_raw_trans2(private->tree, req, trans2);
973         }
974
975         c_req = smb_raw_trans2_send(private->tree, trans2);
976
977         ASYNC_RECV_TAIL(trans2, async_trans2);
978 }
979
980
981 /* SMBtrans - not used on file shares */
982 static NTSTATUS cvfs_trans(struct ntvfs_module_context *ntvfs, 
983                            struct ntvfs_request *req,
984                            struct smb_trans2 *trans2)
985 {
986         return NT_STATUS_ACCESS_DENIED;
987 }
988
989 /*
990   a handler for async change notify replies
991  */
992 static void async_changenotify(struct smbcli_request *c_req)
993 {
994         struct async_info *async = c_req->async.private;
995         struct ntvfs_request *req = async->req;
996         req->async_states->status = smb_raw_changenotify_recv(c_req, req, async->parms);
997         talloc_free(async);
998         req->async_states->send_fn(req);
999 }
1000
1001 /* change notify request - always async */
1002 static NTSTATUS cvfs_notify(struct ntvfs_module_context *ntvfs, 
1003                             struct ntvfs_request *req,
1004                             struct smb_notify *io)
1005 {
1006         struct cvfs_private *private = ntvfs->private_data;
1007         struct smbcli_request *c_req;
1008         int saved_timeout = private->transport->options.request_timeout;
1009         struct cvfs_file *f;
1010
1011         SETUP_PID;
1012
1013         f = ntvfs_handle_get_backend_data(io->in.file.ntvfs, ntvfs);
1014         if (!f) return NT_STATUS_INVALID_HANDLE;
1015         io->in.file.fnum = f->fnum;
1016
1017         /* this request doesn't make sense unless its async */
1018         if (!(req->async_states->state & NTVFS_ASYNC_STATE_MAY_ASYNC)) {
1019                 return NT_STATUS_INVALID_PARAMETER;
1020         }
1021
1022         /* we must not timeout on notify requests - they wait
1023            forever */
1024         private->transport->options.request_timeout = 0;
1025
1026         c_req = smb_raw_changenotify_send(private->tree, io);
1027
1028         private->transport->options.request_timeout = saved_timeout;
1029
1030         ASYNC_RECV_TAIL(io, async_changenotify);
1031 }
1032
1033 /*
1034   initialise the CIFS->CIFS backend, registering ourselves with the ntvfs subsystem
1035  */
1036 NTSTATUS ntvfs_cifs_init(void)
1037 {
1038         NTSTATUS ret;
1039         struct ntvfs_ops ops;
1040         NTVFS_CURRENT_CRITICAL_SIZES(vers);
1041
1042         ZERO_STRUCT(ops);
1043
1044         /* fill in the name and type */
1045         ops.name = "cifs";
1046         ops.type = NTVFS_DISK;
1047         
1048         /* fill in all the operations */
1049         ops.connect = cvfs_connect;
1050         ops.disconnect = cvfs_disconnect;
1051         ops.unlink = cvfs_unlink;
1052         ops.chkpath = cvfs_chkpath;
1053         ops.qpathinfo = cvfs_qpathinfo;
1054         ops.setpathinfo = cvfs_setpathinfo;
1055         ops.open = cvfs_open;
1056         ops.mkdir = cvfs_mkdir;
1057         ops.rmdir = cvfs_rmdir;
1058         ops.rename = cvfs_rename;
1059         ops.copy = cvfs_copy;
1060         ops.ioctl = cvfs_ioctl;
1061         ops.read = cvfs_read;
1062         ops.write = cvfs_write;
1063         ops.seek = cvfs_seek;
1064         ops.flush = cvfs_flush; 
1065         ops.close = cvfs_close;
1066         ops.exit = cvfs_exit;
1067         ops.lock = cvfs_lock;
1068         ops.setfileinfo = cvfs_setfileinfo;
1069         ops.qfileinfo = cvfs_qfileinfo;
1070         ops.fsinfo = cvfs_fsinfo;
1071         ops.lpq = cvfs_lpq;
1072         ops.search_first = cvfs_search_first;
1073         ops.search_next = cvfs_search_next;
1074         ops.search_close = cvfs_search_close;
1075         ops.trans = cvfs_trans;
1076         ops.logoff = cvfs_logoff;
1077         ops.async_setup = cvfs_async_setup;
1078         ops.cancel = cvfs_cancel;
1079         ops.notify = cvfs_notify;
1080         ops.trans2 = cvfs_trans2;
1081
1082         /* register ourselves with the NTVFS subsystem. We register
1083            under the name 'cifs'. */
1084         ret = ntvfs_register(&ops, &vers);
1085
1086         if (!NT_STATUS_IS_OK(ret)) {
1087                 DEBUG(0,("Failed to register CIFS backend!\n"));
1088         }
1089         
1090         return ret;
1091 }