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