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
  30 /* this is stored in ntvfs_private */
  31 struct cvfs_private {
  32         struct cli_tree *tree;
  33         struct cli_transport *transport;
  34         struct tcon_context *conn;
  35         const char *map_calls;
  36 };
  37
  38
  39 /* a structure used to pass information to an async handler */
  40 struct async_info {
  41         struct request_context *req;
  42         void *parms;
  43 };
  44
  45 /*
  46   an idle function to cope with messages from the smbd client while
  47   waiting for a reply from the server
  48   this function won't be needed once all of the cifs backend
  49   and the core of smbd is converted to use async calls
  50 */
  51 static void idle_func(struct cli_transport *transport, void *p_private)
  52 {
  53         struct cvfs_private *private = p_private;
  54         if (socket_pending(private->conn->smb->socket.fd)) {
  55                 smbd_process_async(private->conn->smb);
  56         }
  57 }
  58
  59 /*
  60   a handler for oplock break events from the server - these need to be passed
  61   along to the client
  62  */
  63 static BOOL oplock_handler(struct cli_transport *transport, uint16 tid, uint16 fnum, uint8 level, void *p_private)
  64 {
  65         struct cvfs_private *private = p_private;
  66
  67         DEBUG(5,("vfs_cifs: sending oplock break level %d for fnum %d\n", level, fnum));
  68         return req_send_oplock_break(private->conn, fnum, level);
  69 }
  70
  71 /*
  72   a handler for read events on a connection to a backend server
  73 */
  74 static void cifs_socket_handler(struct event_context *ev, struct fd_event *fde, time_t t, uint16 flags)
  75 {
  76         struct tcon_context *conn = fde->private;
  77         struct cvfs_private *private = conn->ntvfs_private;
  78
  79         DEBUG(5,("cifs_socket_handler event on fd %d\n", fde->fd));
  80
  81         if (!cli_request_receive_next(private->transport)) {
  82                 /* the connection to our server is dead */
  83                 close_cnum(conn);
  84         }
  85 }
  86
  87 /*
  88   connect to a share - used when a tree_connect operation comes in.
  89 */
  90 static NTSTATUS cvfs_connect(struct request_context *req, const char *sharename)
  91 {
  92         struct tcon_context *conn = req->conn;
  93         NTSTATUS status;
  94         struct cvfs_private *private;
  95         char *map_calls;
  96         struct fd_event fde;
  97         const char *host, *user, *pass, *domain, *remote_share;
  98
  99         /* Here we need to determine which server to connect to.
 100          * For now we use parametric options, type cifs.
 101          * Later we will use security=server and auth_server.c.
 102          */
 103         host = lp_parm_string(req->conn->service, "cifs", "server");
 104         user = lp_parm_string(req->conn->service, "cifs", "user");
 105         pass = lp_parm_string(req->conn->service, "cifs", "password");
 106         domain = lp_parm_string(req->conn->service, "cifs", "domain");
 107         remote_share = lp_parm_string(req->conn->service, "cifs", "share");
 108         if (!remote_share) {
 109                 remote_share = sharename;
 110         }
 111
 112         if (!host || !user || !pass || !domain) {
 113                 DEBUG(1,("CIFS backend: You must supply server, user, password and domain\n"));
 114                 return NT_STATUS_INVALID_PARAMETER;
 115         }
 116
 117         private = talloc(req->conn->mem_ctx, sizeof(struct cvfs_private));
 118         if (!private) {
 119                 return NT_STATUS_NO_MEMORY;
 120         }
 121         ZERO_STRUCTP(private);
 122
 123         req->conn->ntvfs_private = (void *)private;
 124
 125         status = cli_tree_full_connection(&private->tree,
 126                                           "vfs_cifs",
 127                                           host,
 128                                           0,
 129                                           remote_share, "?????",
 130                                           user, domain,
 131                                           pass);
 132         if (!NT_STATUS_IS_OK(status)) {
 133                 return status;
 134         }
 135
 136         private->transport = private->tree->session->transport;
 137         private->tree->session->pid = SVAL(req->in.hdr, HDR_PID);
 138         private->conn = req->conn;
 139
 140         conn->fs_type = talloc_strdup(conn->mem_ctx, "NTFS");
 141         conn->dev_type = talloc_strdup(conn->mem_ctx, "A:");
 142
 143         map_calls = lp_parm_string(req->conn->service, "cifs", "map calls");
 144         if (map_calls) {
 145                 private->map_calls = talloc_strdup(conn->mem_ctx, map_calls);
 146         }
 147
 148         /* if we are mapping trans2, then we need to not give a trans2
 149            pointer in the operations structure */
 150         if (private->map_calls && in_list("trans2", private->map_calls, True)) {
 151                 conn->ntvfs_ops->trans2 = NULL;
 152         }
 153
 154         /* we need to tell the event loop that we wish to receive read events
 155            on our SMB connection to the server */
 156         fde.fd = private->transport->socket->fd;
 157         fde.flags = EVENT_FD_READ;
 158         fde.private = req->conn;
 159         fde.handler = cifs_socket_handler;
 160
 161         event_add_fd(conn->smb->events, &fde);
 162
 163         /* we need to receive oplock break requests from the server */
 164         cli_oplock_handler(private->transport, oplock_handler, private);
 165         cli_transport_idle_handler(private->transport, idle_func, 100, private);
 166
 167         return NT_STATUS_OK;
 168 }
 169
 170 /*
 171   disconnect from a share
 172 */
 173 static NTSTATUS cvfs_disconnect(struct tcon_context *conn)
 174 {
 175         struct cvfs_private *private = conn->ntvfs_private;
 176
 177         event_remove_fd_all(conn->smb->events, private->transport->socket->fd);
 178         smb_tree_disconnect(private->tree);
 179         cli_tree_close(private->tree);
 180
 181         return NT_STATUS_OK;
 182 }
 183
 184 /*
 185   a handler for simple async replies
 186   this handler can only be used for functions that don't return any
 187   parameters (those that just return a status code)
 188  */
 189 static void async_simple(struct cli_request *c_req)
 190 {
 191         struct async_info *async = c_req->async.private;
 192         struct request_context *req = async->req;
 193         req->async.status = cli_request_simple_recv(c_req);
 194         req->async.send_fn(req);
 195 }
 196
 197
 198 /* save some typing for the simple functions */
 199 #define ASYNC_RECV_TAIL(io, async_fn) do { \
 200         if (!c_req) return NT_STATUS_UNSUCCESSFUL; \
 201         { \
 202                 struct async_info *async = c_req->async.private; \
 203                 async = talloc(req->mem_ctx, sizeof(*async)); \
 204                 if (!async) return NT_STATUS_NO_MEMORY; \
 205                 async->parms = io; \
 206                 async->req = req; \
 207                 c_req->async.private = async; \
 208         } \
 209         c_req->async.fn = async_fn; \
 210         req->control_flags |= REQ_CONTROL_ASYNC; \
 211         return NT_STATUS_OK; \
 212 } while (0)
 213
 214 #define SIMPLE_ASYNC_TAIL ASYNC_RECV_TAIL(NULL, async_simple)
 215
 216 /*
 217   delete a file - the dirtype specifies the file types to include in the search.
 218   The name can contain CIFS wildcards, but rarely does (except with OS/2 clients)
 219 */
 220 static NTSTATUS cvfs_unlink(struct request_context *req, struct smb_unlink *unl)
 221 {
 222         struct cvfs_private *private = req->conn->ntvfs_private;
 223         struct cli_request *c_req;
 224
 225         /* see if the front end will allow us to perform this
 226            function asynchronously.  */
 227         if (!req->async.send_fn) {
 228                 return smb_raw_unlink(private->tree, unl);
 229         }
 230
 231         c_req = smb_raw_unlink_send(private->tree, unl);
 232
 233         SIMPLE_ASYNC_TAIL;
 234 }
 235
 236 /*
 237   a handler for async ioctl replies
 238  */
 239 static void async_ioctl(struct cli_request *c_req)
 240 {
 241         struct async_info *async = c_req->async.private;
 242         struct request_context *req = async->req;
 243         req->async.status = smb_raw_ioctl_recv(c_req, req->mem_ctx, async->parms);
 244         req->async.send_fn(req);
 245 }
 246
 247 /*
 248   ioctl interface
 249 */
 250 static NTSTATUS cvfs_ioctl(struct request_context *req, struct smb_ioctl *io)
 251 {
 252         struct cvfs_private *private = req->conn->ntvfs_private;
 253         struct cli_request *c_req;
 254
 255         /* see if the front end will allow us to perform this
 256            function asynchronously.  */
 257         if (!req->async.send_fn) {
 258                 return smb_raw_ioctl(private->tree, req->mem_ctx, io);
 259         }
 260
 261         c_req = smb_raw_ioctl_send(private->tree, io);
 262
 263         ASYNC_RECV_TAIL(io, async_ioctl);
 264 }
 265
 266 /*
 267   check if a directory exists
 268 */
 269 static NTSTATUS cvfs_chkpath(struct request_context *req, struct smb_chkpath *cp)
 270 {
 271         struct cvfs_private *private = req->conn->ntvfs_private;
 272         struct cli_request *c_req;
 273
 274         if (!req->async.send_fn) {
 275                 return smb_raw_chkpath(private->tree, cp);
 276         }
 277
 278         c_req = smb_raw_chkpath_send(private->tree, cp);
 279
 280         SIMPLE_ASYNC_TAIL;
 281 }
 282
 283 /*
 284   a handler for async qpathinfo replies
 285  */
 286 static void async_qpathinfo(struct cli_request *c_req)
 287 {
 288         struct async_info *async = c_req->async.private;
 289         struct request_context *req = async->req;
 290         req->async.status = smb_raw_pathinfo_recv(c_req, req->mem_ctx, async->parms);
 291         req->async.send_fn(req);
 292 }
 293
 294 /*
 295   return info on a pathname
 296 */
 297 static NTSTATUS cvfs_qpathinfo(struct request_context *req, union smb_fileinfo *info)
 298 {
 299         struct cvfs_private *private = req->conn->ntvfs_private;
 300         struct cli_request *c_req;
 301
 302         if (!req->async.send_fn) {
 303                 return smb_raw_pathinfo(private->tree, req->mem_ctx, info);
 304         }
 305
 306         c_req = smb_raw_pathinfo_send(private->tree, info);
 307
 308         ASYNC_RECV_TAIL(info, async_qpathinfo);
 309 }
 310
 311 /*
 312   a handler for async qfileinfo replies
 313  */
 314 static void async_qfileinfo(struct cli_request *c_req)
 315 {
 316         struct async_info *async = c_req->async.private;
 317         struct request_context *req = async->req;
 318         req->async.status = smb_raw_fileinfo_recv(c_req, req->mem_ctx, async->parms);
 319         req->async.send_fn(req);
 320 }
 321
 322 /*
 323   query info on a open file
 324 */
 325 static NTSTATUS cvfs_qfileinfo(struct request_context *req, union smb_fileinfo *info)
 326 {
 327         struct cvfs_private *private = req->conn->ntvfs_private;
 328         struct cli_request *c_req;
 329
 330         if (!req->async.send_fn) {
 331                 return smb_raw_fileinfo(private->tree, req->mem_ctx, info);
 332         }
 333
 334         c_req = smb_raw_fileinfo_send(private->tree, info);
 335
 336         ASYNC_RECV_TAIL(info, async_qfileinfo);
 337 }
 338
 339
 340 /*
 341   set info on a pathname
 342 */
 343 static NTSTATUS cvfs_setpathinfo(struct request_context *req, union smb_setfileinfo *st)
 344 {
 345         struct cvfs_private *private = req->conn->ntvfs_private;
 346         struct cli_request *c_req;
 347
 348         if (!req->async.send_fn) {
 349                 return smb_raw_setpathinfo(private->tree, st);
 350         }
 351
 352         c_req = smb_raw_setpathinfo_send(private->tree, st);
 353
 354         SIMPLE_ASYNC_TAIL;
 355 }
 356
 357
 358 /*
 359   a handler for async open replies
 360  */
 361 static void async_open(struct cli_request *c_req)
 362 {
 363         struct async_info *async = c_req->async.private;
 364         struct request_context *req = async->req;
 365         req->async.status = smb_raw_open_recv(c_req, req->mem_ctx, async->parms);
 366         req->async.send_fn(req);
 367 }
 368
 369 /*
 370   open a file
 371 */
 372 static NTSTATUS cvfs_open(struct request_context *req, union smb_open *io)
 373 {
 374         struct cvfs_private *private = req->conn->ntvfs_private;
 375         struct cli_request *c_req;
 376
 377         if (private->map_calls && in_list("open", private->map_calls, True) &&
 378             io->generic.level != RAW_OPEN_GENERIC) {
 379                 return ntvfs_map_open(req, io);
 380         }
 381
 382         if (!req->async.send_fn) {
 383                 return smb_raw_open(private->tree, req->mem_ctx, io);
 384         }
 385
 386         c_req = smb_raw_open_send(private->tree, io);
 387
 388         ASYNC_RECV_TAIL(io, async_open);
 389 }
 390
 391 /*
 392   create a directory
 393 */
 394 static NTSTATUS cvfs_mkdir(struct request_context *req, union smb_mkdir *md)
 395 {
 396         struct cvfs_private *private = req->conn->ntvfs_private;
 397         struct cli_request *c_req;
 398
 399         if (!req->async.send_fn) {
 400                 return smb_raw_mkdir(private->tree, md);
 401         }
 402
 403         c_req = smb_raw_mkdir_send(private->tree, md);
 404
 405         SIMPLE_ASYNC_TAIL;
 406 }
 407
 408 /*
 409   remove a directory
 410 */
 411 static NTSTATUS cvfs_rmdir(struct request_context *req, struct smb_rmdir *rd)
 412 {
 413         struct cvfs_private *private = req->conn->ntvfs_private;
 414         struct cli_request *c_req;
 415
 416         if (!req->async.send_fn) {
 417                 return smb_raw_rmdir(private->tree, rd);
 418         }
 419         c_req = smb_raw_rmdir_send(private->tree, rd);
 420
 421         SIMPLE_ASYNC_TAIL;
 422 }
 423
 424 /*
 425   rename a set of files
 426 */
 427 static NTSTATUS cvfs_rename(struct request_context *req, struct smb_rename *ren)
 428 {
 429         struct cvfs_private *private = req->conn->ntvfs_private;
 430         struct cli_request *c_req;
 431
 432         if (!req->async.send_fn) {
 433                 return smb_raw_rename(private->tree, ren);
 434         }
 435
 436         c_req = smb_raw_rename_send(private->tree, ren);
 437
 438         SIMPLE_ASYNC_TAIL;
 439 }
 440
 441 /*
 442   copy a set of files
 443 */
 444 static NTSTATUS cvfs_copy(struct request_context *req, struct smb_copy *cp)
 445 {
 446         return NT_STATUS_NOT_SUPPORTED;
 447 }
 448
 449 /*
 450   a handler for async read replies
 451  */
 452 static void async_read(struct cli_request *c_req)
 453 {
 454         struct async_info *async = c_req->async.private;
 455         struct request_context *req = async->req;
 456         req->async.status = smb_raw_read_recv(c_req, async->parms);
 457         req->async.send_fn(req);
 458 }
 459
 460 /*
 461   read from a file
 462 */
 463 static NTSTATUS cvfs_read(struct request_context *req, union smb_read *rd)
 464 {
 465         struct cvfs_private *private = req->conn->ntvfs_private;
 466         struct cli_request *c_req;
 467
 468         if (!req->async.send_fn) {
 469                 return smb_raw_read(private->tree, rd);
 470         }
 471
 472         c_req = smb_raw_read_send(private->tree, rd);
 473
 474         ASYNC_RECV_TAIL(rd, async_read);
 475 }
 476
 477 /*
 478   a handler for async write replies
 479  */
 480 static void async_write(struct cli_request *c_req)
 481 {
 482         struct async_info *async = c_req->async.private;
 483         struct request_context *req = async->req;
 484         req->async.status = smb_raw_write_recv(c_req, async->parms);
 485         req->async.send_fn(req);
 486 }
 487
 488 /*
 489   write to a file
 490 */
 491 static NTSTATUS cvfs_write(struct request_context *req, union smb_write *wr)
 492 {
 493         struct cvfs_private *private = req->conn->ntvfs_private;
 494         struct cli_request *c_req;
 495
 496         if (!req->async.send_fn) {
 497                 return smb_raw_write(private->tree, wr);
 498         }
 499
 500         c_req = smb_raw_write_send(private->tree, wr);
 501
 502         ASYNC_RECV_TAIL(wr, async_write);
 503 }
 504
 505 /*
 506   seek in a file
 507 */
 508 static NTSTATUS cvfs_seek(struct request_context *req, struct smb_seek *io)
 509 {
 510         return NT_STATUS_NOT_SUPPORTED;
 511 }
 512
 513 /*
 514   flush a file
 515 */
 516 static NTSTATUS cvfs_flush(struct request_context *req, struct smb_flush *io)
 517 {
 518         return NT_STATUS_OK;
 519 }
 520
 521 /*
 522   close a file
 523 */
 524 static NTSTATUS cvfs_close(struct request_context *req, union smb_close *io)
 525 {
 526         struct cvfs_private *private = req->conn->ntvfs_private;
 527         struct cli_request *c_req;
 528
 529         if (!req->async.send_fn) {
 530                 return smb_raw_close(private->tree, io);
 531         }
 532
 533         c_req = smb_raw_close_send(private->tree, io);
 534
 535         SIMPLE_ASYNC_TAIL;
 536 }
 537
 538 /*
 539   exit - closing files?
 540 */
 541 static NTSTATUS cvfs_exit(struct request_context *req)
 542 {
 543         return NT_STATUS_NOT_SUPPORTED;
 544 }
 545
 546 /*
 547   lock a byte range
 548 */
 549 static NTSTATUS cvfs_lock(struct request_context *req, union smb_lock *lck)
 550 {
 551         struct cvfs_private *private = req->conn->ntvfs_private;
 552         struct cli_request *c_req;
 553
 554         if (!req->async.send_fn) {
 555                 return smb_raw_lock(private->tree, lck);
 556         }
 557
 558         c_req = smb_raw_lock_send(private->tree, lck);
 559         SIMPLE_ASYNC_TAIL;
 560 }
 561
 562 /*
 563   set info on a open file
 564 */
 565 static NTSTATUS cvfs_setfileinfo(struct request_context *req,
 566                                  union smb_setfileinfo *info)
 567 {
 568         struct cvfs_private *private = req->conn->ntvfs_private;
 569         struct cli_request *c_req;
 570
 571         if (!req->async.send_fn) {
 572                 return smb_raw_setfileinfo(private->tree, info);
 573         }
 574         c_req = smb_raw_setfileinfo_send(private->tree, info);
 575
 576         SIMPLE_ASYNC_TAIL;
 577 }
 578
 579
 580 /*
 581   a handler for async fsinfo replies
 582  */
 583 static void async_fsinfo(struct cli_request *c_req)
 584 {
 585         struct async_info *async = c_req->async.private;
 586         struct request_context *req = async->req;
 587         req->async.status = smb_raw_fsinfo_recv(c_req, req->mem_ctx, async->parms);
 588         req->async.send_fn(req);
 589 }
 590
 591 /*
 592   return filesystem space info
 593 */
 594 static NTSTATUS cvfs_fsinfo(struct request_context *req, union smb_fsinfo *fs)
 595 {
 596         struct cvfs_private *private = req->conn->ntvfs_private;
 597         struct cli_request *c_req;
 598
 599         if (!req->async.send_fn) {
 600                 return smb_raw_fsinfo(private->tree, req->mem_ctx, fs);
 601         }
 602
 603         c_req = smb_raw_fsinfo_send(private->tree, req->mem_ctx, fs);
 604
 605         ASYNC_RECV_TAIL(fs, async_fsinfo);
 606 }
 607
 608 /*
 609   return print queue info
 610 */
 611 static NTSTATUS cvfs_lpq(struct request_context *req, union smb_lpq *lpq)
 612 {
 613         return NT_STATUS_NOT_SUPPORTED;
 614 }
 615
 616 /*
 617    list files in a directory matching a wildcard pattern
 618 */
 619 static NTSTATUS cvfs_search_first(struct request_context *req, union smb_search_first *io,
 620                                   void *search_private,
 621                                   BOOL (*callback)(void *, union smb_search_data *))
 622 {
 623         struct cvfs_private *private = req->conn->ntvfs_private;
 624
 625         return smb_raw_search_first(private->tree, req->mem_ctx, io, search_private, callback);
 626 }
 627
 628 /* continue a search */
 629 static NTSTATUS cvfs_search_next(struct request_context *req, union smb_search_next *io,
 630                                  void *search_private,
 631                                  BOOL (*callback)(void *, union smb_search_data *))
 632 {
 633         struct cvfs_private *private = req->conn->ntvfs_private;
 634
 635         return smb_raw_search_next(private->tree, req->mem_ctx, io, search_private, callback);
 636 }
 637
 638 /* close a search */
 639 static NTSTATUS cvfs_search_close(struct request_context *req, union smb_search_close *io)
 640 {
 641         struct cvfs_private *private = req->conn->ntvfs_private;
 642
 643         return smb_raw_search_close(private->tree, io);
 644 }
 645
 646 /*
 647   a handler for async trans2 replies
 648  */
 649 static void async_trans2(struct cli_request *c_req)
 650 {
 651         struct async_info *async = c_req->async.private;
 652         struct request_context *req = async->req;
 653         req->async.status = smb_raw_trans2_recv(c_req, req->mem_ctx, async->parms);
 654         req->async.send_fn(req);
 655 }
 656
 657 /* raw trans2 */
 658 static NTSTATUS cvfs_trans2(struct request_context *req, struct smb_trans2 *trans2)
 659 {
 660         struct cvfs_private *private = req->conn->ntvfs_private;
 661         struct cli_request *c_req;
 662
 663         if (!req->async.send_fn) {
 664                 return smb_raw_trans2(private->tree, req->mem_ctx, trans2);
 665         }
 666
 667         c_req = smb_raw_trans2_send(private->tree, trans2);
 668
 669         ASYNC_RECV_TAIL(trans2, async_trans2);
 670 }
 671
 672 /*
 673   initialise the CIFS->CIFS backend, registering ourselves with the ntvfs subsystem
 674  */
 675 BOOL cifs_vfs_init(void)
 676 {
 677         BOOL ret;
 678         struct ntvfs_ops ops;
 679
 680         ZERO_STRUCT(ops);
 681
 682         /* fill in all the operations */
 683         ops.connect = cvfs_connect;
 684         ops.disconnect = cvfs_disconnect;
 685         ops.unlink = cvfs_unlink;
 686         ops.chkpath = cvfs_chkpath;
 687         ops.qpathinfo = cvfs_qpathinfo;
 688         ops.setpathinfo = cvfs_setpathinfo;
 689         ops.open = cvfs_open;
 690         ops.mkdir = cvfs_mkdir;
 691         ops.rmdir = cvfs_rmdir;
 692         ops.rename = cvfs_rename;
 693         ops.copy = cvfs_copy;
 694         ops.ioctl = cvfs_ioctl;
 695         ops.read = cvfs_read;
 696         ops.write = cvfs_write;
 697         ops.seek = cvfs_seek;
 698         ops.flush = cvfs_flush;
 699         ops.close = cvfs_close;
 700         ops.exit = cvfs_exit;
 701         ops.lock = cvfs_lock;
 702         ops.setfileinfo = cvfs_setfileinfo;
 703         ops.qfileinfo = cvfs_qfileinfo;
 704         ops.fsinfo = cvfs_fsinfo;
 705         ops.lpq = cvfs_lpq;
 706         ops.search_first = cvfs_search_first;
 707         ops.search_next = cvfs_search_next;
 708         ops.search_close = cvfs_search_close;
 709
 710         /* only define this one for trans2 testing */
 711         ops.trans2 = cvfs_trans2;
 712
 713         /* register ourselves with the NTVFS subsystem. We register under the name 'cifs'. */
 714
 715         ret = ntvfs_register("cifs", NTVFS_DISK, &ops);
 716
 717         if (!ret) {
 718                 DEBUG(0,("Failed to register CIFS backend!\n"));
 719                 return False;
 720         }
 721
 722         return True;
 723 }