source4/ntvfs/ipc/vfs_ipc.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    default IPC$ NTVFS backend
   4
   5    Copyright (C) Andrew Tridgell 2003
   6    Copyright (C) Stefan (metze) Metzmacher 2004-2005
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22 /*
  23   this implements the IPC$ backend, called by the NTVFS subsystem to
  24   handle requests on IPC$ shares
  25 */
  26
  27
  28 #include "includes.h"
  29 #include "system/filesys.h"
  30 #include "dlinklist.h"
  31 #include "smb_server/smb_server.h"
  32
  33 #define IPC_BASE_FNUM 0x400
  34
  35 /* this is the private structure used to keep the state of an open
  36    ipc$ connection. It needs to keep information about all open
  37    pipes */
  38 struct ipc_private {
  39         struct idr_context *idtree_fnum;
  40
  41         struct dcesrv_context *dcesrv;
  42
  43         /* a list of open pipes */
  44         struct pipe_state {
  45                 struct pipe_state *next, *prev;
  46                 struct ipc_private *private;
  47                 const char *pipe_name;
  48                 uint16_t fnum;
  49                 struct dcesrv_connection *dce_conn;
  50                 uint16_t ipc_state;
  51                 /* we need to remember the session it was opened on,
  52                    as it is illegal to operate on someone elses fnum */
  53                 struct smbsrv_session *session;
  54
  55                 /* we need to remember the client pid that
  56                    opened the file so SMBexit works */
  57                 uint16_t smbpid;
  58         } *pipe_list;
  59
  60 };
  61
  62
  63 /*
  64   find a open pipe give a file descriptor
  65 */
  66 static struct pipe_state *pipe_state_find(struct ipc_private *private, uint16_t fnum)
  67 {
  68         return idr_find(private->idtree_fnum, fnum);
  69 }
  70
  71
  72 /*
  73   connect to a share - always works
  74 */
  75 static NTSTATUS ipc_connect(struct ntvfs_module_context *ntvfs,
  76                             struct smbsrv_request *req, const char *sharename)
  77 {
  78         NTSTATUS status;
  79         struct smbsrv_tcon *tcon = req->tcon;
  80         struct ipc_private *private;
  81
  82         tcon->fs_type = talloc_strdup(tcon, "IPC");
  83         NT_STATUS_HAVE_NO_MEMORY(tcon->fs_type);
  84
  85         tcon->dev_type = talloc_strdup(tcon, "IPC");
  86         NT_STATUS_HAVE_NO_MEMORY(tcon->dev_type);
  87
  88         /* prepare the private state for this connection */
  89         private = talloc(tcon, struct ipc_private);
  90         NT_STATUS_HAVE_NO_MEMORY(private);
  91
  92         ntvfs->private_data = private;
  93
  94         private->pipe_list = NULL;
  95
  96         private->idtree_fnum = idr_init(private);
  97         NT_STATUS_HAVE_NO_MEMORY(private->idtree_fnum);
  98
  99         /* setup the DCERPC server subsystem */
 100         status = dcesrv_init_ipc_context(private, &private->dcesrv);
 101         NT_STATUS_NOT_OK_RETURN(status);
 102
 103         return NT_STATUS_OK;
 104 }
 105
 106 /*
 107   disconnect from a share
 108 */
 109 static NTSTATUS ipc_disconnect(struct ntvfs_module_context *ntvfs,
 110                                struct smbsrv_tcon *tcon)
 111 {
 112         return NT_STATUS_OK;
 113 }
 114
 115 /*
 116   delete a file
 117 */
 118 static NTSTATUS ipc_unlink(struct ntvfs_module_context *ntvfs,
 119                            struct smbsrv_request *req, struct smb_unlink *unl)
 120 {
 121         return NT_STATUS_ACCESS_DENIED;
 122 }
 123
 124
 125 /*
 126   ioctl interface - we don't do any
 127 */
 128 static NTSTATUS ipc_ioctl(struct ntvfs_module_context *ntvfs,
 129                           struct smbsrv_request *req, union smb_ioctl *io)
 130 {
 131         return NT_STATUS_ACCESS_DENIED;
 132 }
 133
 134 /*
 135   check if a directory exists
 136 */
 137 static NTSTATUS ipc_chkpath(struct ntvfs_module_context *ntvfs,
 138                             struct smbsrv_request *req, struct smb_chkpath *cp)
 139 {
 140         return NT_STATUS_ACCESS_DENIED;
 141 }
 142
 143 /*
 144   return info on a pathname
 145 */
 146 static NTSTATUS ipc_qpathinfo(struct ntvfs_module_context *ntvfs,
 147                               struct smbsrv_request *req, union smb_fileinfo *info)
 148 {
 149         return NT_STATUS_ACCESS_DENIED;
 150 }
 151
 152 /*
 153   set info on a pathname
 154 */
 155 static NTSTATUS ipc_setpathinfo(struct ntvfs_module_context *ntvfs,
 156                                 struct smbsrv_request *req, union smb_setfileinfo *st)
 157 {
 158         return NT_STATUS_ACCESS_DENIED;
 159 }
 160
 161
 162 /*
 163   destroy a open pipe structure
 164 */
 165 static int ipc_fd_destructor(void *ptr)
 166 {
 167         struct pipe_state *p = ptr;
 168         idr_remove(p->private->idtree_fnum, p->fnum);
 169         DLIST_REMOVE(p->private->pipe_list, p);
 170         return 0;
 171 }
 172
 173
 174 /*
 175   open a file backend - used for MSRPC pipes
 176 */
 177 static NTSTATUS ipc_open_generic(struct ntvfs_module_context *ntvfs,
 178                                  struct smbsrv_request *req, const char *fname,
 179                                  struct pipe_state **ps)
 180 {
 181         struct pipe_state *p;
 182         NTSTATUS status;
 183         struct dcerpc_binding ep_description;
 184         struct ipc_private *private = ntvfs->private_data;
 185         int fnum;
 186         struct stream_connection *srv_conn = req->smb_conn->connection;
 187
 188         if (!req->session || !req->session->session_info) {
 189                 return NT_STATUS_ACCESS_DENIED;
 190         }
 191
 192         p = talloc(req, struct pipe_state);
 193         NT_STATUS_HAVE_NO_MEMORY(p);
 194
 195         while (fname[0] == '\\') fname++;
 196
 197         p->pipe_name = talloc_asprintf(p, "\\pipe\\%s", fname);
 198         NT_STATUS_HAVE_NO_MEMORY(p->pipe_name);
 199
 200         fnum = idr_get_new_above(private->idtree_fnum, p, IPC_BASE_FNUM, UINT16_MAX);
 201         if (fnum == -1) {
 202                 return NT_STATUS_TOO_MANY_OPENED_FILES;
 203         }
 204
 205         p->fnum = fnum;
 206         p->ipc_state = 0x5ff;
 207
 208         /*
 209           we're all set, now ask the dcerpc server subsystem to open the
 210           endpoint. At this stage the pipe isn't bound, so we don't
 211           know what interface the user actually wants, just that they want
 212           one of the interfaces attached to this pipe endpoint.
 213         */
 214         ep_description.transport = NCACN_NP;
 215         ep_description.endpoint = p->pipe_name;
 216
 217         /* The session info is refcount-increased in the
 218          * dcesrv_endpoint_search_connect() function
 219          */
 220         status = dcesrv_endpoint_search_connect(private->dcesrv,
 221                                                 p,
 222                                                 &ep_description,
 223                                                 req->session->session_info,
 224                                                 srv_conn,
 225                                                 &p->dce_conn);
 226         if (!NT_STATUS_IS_OK(status)) {
 227                 idr_remove(private->idtree_fnum, p->fnum);
 228                 return status;
 229         }
 230
 231         DLIST_ADD(private->pipe_list, p);
 232
 233         p->smbpid = req->smbpid;
 234         p->session = req->session;
 235         p->private = private;
 236
 237         *ps = p;
 238
 239         talloc_steal(private, p);
 240
 241         talloc_set_destructor(p, ipc_fd_destructor);
 242
 243         return NT_STATUS_OK;
 244 }
 245
 246 /*
 247   open a file with ntcreatex - used for MSRPC pipes
 248 */
 249 static NTSTATUS ipc_open_ntcreatex(struct ntvfs_module_context *ntvfs,
 250                                    struct smbsrv_request *req, union smb_open *oi)
 251 {
 252         struct pipe_state *p;
 253         NTSTATUS status;
 254
 255         status = ipc_open_generic(ntvfs, req, oi->ntcreatex.in.fname, &p);
 256         if (!NT_STATUS_IS_OK(status)) {
 257                 return status;
 258         }
 259
 260         ZERO_STRUCT(oi->ntcreatex.out);
 261         oi->ntcreatex.out.fnum = p->fnum;
 262         oi->ntcreatex.out.ipc_state = p->ipc_state;
 263         oi->ntcreatex.out.file_type = FILE_TYPE_MESSAGE_MODE_PIPE;
 264
 265         return status;
 266 }
 267
 268 /*
 269   open a file with openx - used for MSRPC pipes
 270 */
 271 static NTSTATUS ipc_open_openx(struct ntvfs_module_context *ntvfs,
 272                                struct smbsrv_request *req, union smb_open *oi)
 273 {
 274         struct pipe_state *p;
 275         NTSTATUS status;
 276         const char *fname = oi->openx.in.fname;
 277
 278         status = ipc_open_generic(ntvfs, req, fname, &p);
 279         if (!NT_STATUS_IS_OK(status)) {
 280                 return status;
 281         }
 282
 283         ZERO_STRUCT(oi->openx.out);
 284         oi->openx.out.fnum = p->fnum;
 285         oi->openx.out.ftype = 2;
 286         oi->openx.out.devstate = p->ipc_state;
 287
 288         return status;
 289 }
 290
 291 /*
 292   open a file - used for MSRPC pipes
 293 */
 294 static NTSTATUS ipc_open(struct ntvfs_module_context *ntvfs,
 295                                 struct smbsrv_request *req, union smb_open *oi)
 296 {
 297         NTSTATUS status;
 298
 299         switch (oi->generic.level) {
 300         case RAW_OPEN_NTCREATEX:
 301                 status = ipc_open_ntcreatex(ntvfs, req, oi);
 302                 break;
 303         case RAW_OPEN_OPENX:
 304                 status = ipc_open_openx(ntvfs, req, oi);
 305                 break;
 306         default:
 307                 status = NT_STATUS_NOT_SUPPORTED;
 308                 break;
 309         }
 310
 311         return status;
 312 }
 313
 314 /*
 315   create a directory
 316 */
 317 static NTSTATUS ipc_mkdir(struct ntvfs_module_context *ntvfs,
 318                           struct smbsrv_request *req, union smb_mkdir *md)
 319 {
 320         return NT_STATUS_ACCESS_DENIED;
 321 }
 322
 323 /*
 324   remove a directory
 325 */
 326 static NTSTATUS ipc_rmdir(struct ntvfs_module_context *ntvfs,
 327                           struct smbsrv_request *req, struct smb_rmdir *rd)
 328 {
 329         return NT_STATUS_ACCESS_DENIED;
 330 }
 331
 332 /*
 333   rename a set of files
 334 */
 335 static NTSTATUS ipc_rename(struct ntvfs_module_context *ntvfs,
 336                            struct smbsrv_request *req, union smb_rename *ren)
 337 {
 338         return NT_STATUS_ACCESS_DENIED;
 339 }
 340
 341 /*
 342   copy a set of files
 343 */
 344 static NTSTATUS ipc_copy(struct ntvfs_module_context *ntvfs,
 345                          struct smbsrv_request *req, struct smb_copy *cp)
 346 {
 347         return NT_STATUS_ACCESS_DENIED;
 348 }
 349
 350 /*
 351   read from a file
 352 */
 353 static NTSTATUS ipc_read(struct ntvfs_module_context *ntvfs,
 354                          struct smbsrv_request *req, union smb_read *rd)
 355 {
 356         struct ipc_private *private = ntvfs->private_data;
 357         DATA_BLOB data;
 358         uint16_t fnum;
 359         struct pipe_state *p;
 360         NTSTATUS status;
 361
 362         if (rd->generic.level != RAW_READ_GENERIC) {
 363                 return ntvfs_map_read(req, rd, ntvfs);
 364         }
 365
 366         fnum = rd->readx.in.fnum;
 367
 368         p = pipe_state_find(private, fnum);
 369         if (!p) {
 370                 return NT_STATUS_INVALID_HANDLE;
 371         }
 372
 373         data.length = rd->readx.in.maxcnt;
 374         data.data = rd->readx.out.data;
 375         if (data.length > UINT16_MAX) {
 376                 data.length = 0;
 377         }
 378
 379         if (data.length != 0) {
 380                 status = dcesrv_output_blob(p->dce_conn, &data);
 381                 if (NT_STATUS_IS_ERR(status)) {
 382                         return status;
 383                 }
 384         }
 385
 386         rd->readx.out.remaining = 0;
 387         rd->readx.out.compaction_mode = 0;
 388         rd->readx.out.nread = data.length;
 389
 390         return status;
 391 }
 392
 393 /*
 394   write to a file
 395 */
 396 static NTSTATUS ipc_write(struct ntvfs_module_context *ntvfs,
 397                           struct smbsrv_request *req, union smb_write *wr)
 398 {
 399         struct ipc_private *private = ntvfs->private_data;
 400         DATA_BLOB data;
 401         uint16_t fnum;
 402         struct pipe_state *p;
 403         NTSTATUS status;
 404
 405         if (wr->generic.level != RAW_WRITE_GENERIC) {
 406                 return ntvfs_map_write(req, wr, ntvfs);
 407         }
 408
 409         fnum = wr->writex.in.fnum;
 410         data.data = discard_const_p(void, wr->writex.in.data);
 411         data.length = wr->writex.in.count;
 412
 413         p = pipe_state_find(private, fnum);
 414         if (!p) {
 415                 return NT_STATUS_INVALID_HANDLE;
 416         }
 417
 418         status = dcesrv_input(p->dce_conn, &data);
 419         if (!NT_STATUS_IS_OK(status)) {
 420                 return status;
 421         }
 422
 423         wr->writex.out.nwritten = data.length;
 424         wr->writex.out.remaining = 0;
 425
 426         return NT_STATUS_OK;
 427 }
 428
 429 /*
 430   seek in a file
 431 */
 432 static NTSTATUS ipc_seek(struct ntvfs_module_context *ntvfs,
 433                          struct smbsrv_request *req, struct smb_seek *io)
 434 {
 435         return NT_STATUS_ACCESS_DENIED;
 436 }
 437
 438 /*
 439   flush a file
 440 */
 441 static NTSTATUS ipc_flush(struct ntvfs_module_context *ntvfs,
 442                           struct smbsrv_request *req, struct smb_flush *io)
 443 {
 444         return NT_STATUS_ACCESS_DENIED;
 445 }
 446
 447 /*
 448   close a file
 449 */
 450 static NTSTATUS ipc_close(struct ntvfs_module_context *ntvfs,
 451                           struct smbsrv_request *req, union smb_close *io)
 452 {
 453         struct ipc_private *private = ntvfs->private_data;
 454         struct pipe_state *p;
 455
 456         if (io->generic.level != RAW_CLOSE_CLOSE) {
 457                 return ntvfs_map_close(req, io, ntvfs);
 458         }
 459
 460         p = pipe_state_find(private, io->close.in.fnum);
 461         if (!p) {
 462                 return NT_STATUS_INVALID_HANDLE;
 463         }
 464
 465         talloc_free(p);
 466
 467         return NT_STATUS_OK;
 468 }
 469
 470 /*
 471   exit - closing files
 472 */
 473 static NTSTATUS ipc_exit(struct ntvfs_module_context *ntvfs,
 474                          struct smbsrv_request *req)
 475 {
 476         struct ipc_private *private = ntvfs->private_data;
 477         struct pipe_state *p, *next;
 478
 479         for (p=private->pipe_list; p; p=next) {
 480                 next = p->next;
 481                 if (p->smbpid == req->smbpid) {
 482                         talloc_free(p);
 483                 }
 484         }
 485
 486         return NT_STATUS_OK;
 487 }
 488
 489 /*
 490   logoff - closing files open by the user
 491 */
 492 static NTSTATUS ipc_logoff(struct ntvfs_module_context *ntvfs,
 493                            struct smbsrv_request *req)
 494 {
 495         struct ipc_private *private = ntvfs->private_data;
 496         struct pipe_state *p, *next;
 497
 498         for (p=private->pipe_list; p; p=next) {
 499                 next = p->next;
 500                 if (p->session == req->session) {
 501                         talloc_free(p);
 502                 }
 503         }
 504
 505         return NT_STATUS_OK;
 506 }
 507
 508 /*
 509   setup for an async call
 510 */
 511 static NTSTATUS ipc_async_setup(struct ntvfs_module_context *ntvfs,
 512                                 struct smbsrv_request *req,
 513                                 void *private)
 514 {
 515         return NT_STATUS_OK;
 516 }
 517
 518 /*
 519   cancel an async call
 520 */
 521 static NTSTATUS ipc_cancel(struct ntvfs_module_context *ntvfs,
 522                            struct smbsrv_request *req)
 523 {
 524         return NT_STATUS_UNSUCCESSFUL;
 525 }
 526
 527 /*
 528   lock a byte range
 529 */
 530 static NTSTATUS ipc_lock(struct ntvfs_module_context *ntvfs,
 531                          struct smbsrv_request *req, union smb_lock *lck)
 532 {
 533         return NT_STATUS_ACCESS_DENIED;
 534 }
 535
 536 /*
 537   set info on a open file
 538 */
 539 static NTSTATUS ipc_setfileinfo(struct ntvfs_module_context *ntvfs,
 540                                 struct smbsrv_request *req, union smb_setfileinfo *info)
 541 {
 542         return NT_STATUS_ACCESS_DENIED;
 543 }
 544
 545 /*
 546   query info on a open file
 547 */
 548 static NTSTATUS ipc_qfileinfo(struct ntvfs_module_context *ntvfs,
 549                               struct smbsrv_request *req, union smb_fileinfo *info)
 550 {
 551         return NT_STATUS_ACCESS_DENIED;
 552 }
 553
 554
 555 /*
 556   return filesystem info
 557 */
 558 static NTSTATUS ipc_fsinfo(struct ntvfs_module_context *ntvfs,
 559                            struct smbsrv_request *req, union smb_fsinfo *fs)
 560 {
 561         return NT_STATUS_ACCESS_DENIED;
 562 }
 563
 564 /*
 565   return print queue info
 566 */
 567 static NTSTATUS ipc_lpq(struct ntvfs_module_context *ntvfs,
 568                         struct smbsrv_request *req, union smb_lpq *lpq)
 569 {
 570         return NT_STATUS_ACCESS_DENIED;
 571 }
 572
 573 /*
 574    list files in a directory matching a wildcard pattern
 575 */
 576 static NTSTATUS ipc_search_first(struct ntvfs_module_context *ntvfs,
 577                           struct smbsrv_request *req, union smb_search_first *io,
 578                           void *search_private,
 579                           BOOL (*callback)(void *, union smb_search_data *))
 580 {
 581         return NT_STATUS_ACCESS_DENIED;
 582 }
 583
 584 /*
 585    continue listing files in a directory
 586 */
 587 static NTSTATUS ipc_search_next(struct ntvfs_module_context *ntvfs,
 588                          struct smbsrv_request *req, union smb_search_next *io,
 589                          void *search_private,
 590                          BOOL (*callback)(void *, union smb_search_data *))
 591 {
 592         return NT_STATUS_ACCESS_DENIED;
 593 }
 594
 595 /*
 596    end listing files in a directory
 597 */
 598 static NTSTATUS ipc_search_close(struct ntvfs_module_context *ntvfs,
 599                           struct smbsrv_request *req, union smb_search_close *io)
 600 {
 601         return NT_STATUS_ACCESS_DENIED;
 602 }
 603
 604
 605 /* SMBtrans - handle a DCERPC command */
 606 static NTSTATUS ipc_dcerpc_cmd(struct ntvfs_module_context *ntvfs,
 607                                struct smbsrv_request *req, struct smb_trans2 *trans)
 608 {
 609         struct pipe_state *p;
 610         struct ipc_private *private = ntvfs->private_data;
 611         NTSTATUS status;
 612
 613         /* the fnum is in setup[1] */
 614         p = pipe_state_find(private, trans->in.setup[1]);
 615         if (!p) {
 616                 return NT_STATUS_INVALID_HANDLE;
 617         }
 618
 619         trans->out.data = data_blob_talloc(req, NULL, trans->in.max_data);
 620         if (!trans->out.data.data) {
 621                 return NT_STATUS_NO_MEMORY;
 622         }
 623
 624         /* pass the data to the dcerpc server. Note that we don't
 625            expect this to fail, and things like NDR faults are not
 626            reported at this stage. Those sorts of errors happen in the
 627            dcesrv_output stage */
 628         status = dcesrv_input(p->dce_conn, &trans->in.data);
 629         if (!NT_STATUS_IS_OK(status)) {
 630                 return status;
 631         }
 632
 633         /*
 634           now ask the dcerpc system for some output. This doesn't yet handle
 635           async calls. Again, we only expect NT_STATUS_OK. If the call fails then
 636           the error is encoded at the dcerpc level
 637         */
 638         status = dcesrv_output_blob(p->dce_conn, &trans->out.data);
 639         if (NT_STATUS_IS_ERR(status)) {
 640                 return status;
 641         }
 642
 643         trans->out.setup_count = 0;
 644         trans->out.setup = NULL;
 645         trans->out.params = data_blob(NULL, 0);
 646
 647         return status;
 648 }
 649
 650
 651 /* SMBtrans - set named pipe state */
 652 static NTSTATUS ipc_set_nm_pipe_state(struct ntvfs_module_context *ntvfs,
 653                                 struct smbsrv_request *req, struct smb_trans2 *trans)
 654 {
 655         struct ipc_private *private = ntvfs->private_data;
 656         struct pipe_state *p;
 657
 658         /* the fnum is in setup[1] */
 659         p = pipe_state_find(private, trans->in.setup[1]);
 660         if (!p) {
 661                 return NT_STATUS_INVALID_HANDLE;
 662         }
 663
 664         if (trans->in.params.length != 2) {
 665                 return NT_STATUS_INVALID_PARAMETER;
 666         }
 667         p->ipc_state = SVAL(trans->in.params.data, 0);
 668
 669         trans->out.setup_count = 0;
 670         trans->out.setup = NULL;
 671         trans->out.params = data_blob(NULL, 0);
 672         trans->out.data = data_blob(NULL, 0);
 673
 674         return NT_STATUS_OK;
 675 }
 676
 677
 678 /* SMBtrans - used to provide access to SMB pipes */
 679 static NTSTATUS ipc_trans(struct ntvfs_module_context *ntvfs,
 680                                 struct smbsrv_request *req, struct smb_trans2 *trans)
 681 {
 682         NTSTATUS status;
 683
 684         if (strequal(trans->in.trans_name, "\\PIPE\\LANMAN"))
 685                 return ipc_rap_call(req, trans);
 686
 687         if (trans->in.setup_count != 2) {
 688                 return NT_STATUS_INVALID_PARAMETER;
 689         }
 690
 691         switch (trans->in.setup[0]) {
 692         case TRANSACT_SETNAMEDPIPEHANDLESTATE:
 693                 status = ipc_set_nm_pipe_state(ntvfs, req, trans);
 694                 break;
 695         case TRANSACT_DCERPCCMD:
 696                 status = ipc_dcerpc_cmd(ntvfs, req, trans);
 697                 break;
 698         default:
 699                 status = NT_STATUS_INVALID_PARAMETER;
 700                 break;
 701         }
 702
 703         return status;
 704 }
 705
 706
 707
 708 /*
 709   initialialise the IPC backend, registering ourselves with the ntvfs subsystem
 710  */
 711 NTSTATUS ntvfs_ipc_init(void)
 712 {
 713         NTSTATUS ret;
 714         struct ntvfs_ops ops;
 715
 716         ZERO_STRUCT(ops);
 717
 718         /* fill in the name and type */
 719         ops.name = "default";
 720         ops.type = NTVFS_IPC;
 721
 722         /* fill in all the operations */
 723         ops.connect = ipc_connect;
 724         ops.disconnect = ipc_disconnect;
 725         ops.unlink = ipc_unlink;
 726         ops.chkpath = ipc_chkpath;
 727         ops.qpathinfo = ipc_qpathinfo;
 728         ops.setpathinfo = ipc_setpathinfo;
 729         ops.openfile = ipc_open;
 730         ops.mkdir = ipc_mkdir;
 731         ops.rmdir = ipc_rmdir;
 732         ops.rename = ipc_rename;
 733         ops.copy = ipc_copy;
 734         ops.ioctl = ipc_ioctl;
 735         ops.read = ipc_read;
 736         ops.write = ipc_write;
 737         ops.seek = ipc_seek;
 738         ops.flush = ipc_flush;
 739         ops.close = ipc_close;
 740         ops.exit = ipc_exit;
 741         ops.lock = ipc_lock;
 742         ops.setfileinfo = ipc_setfileinfo;
 743         ops.qfileinfo = ipc_qfileinfo;
 744         ops.fsinfo = ipc_fsinfo;
 745         ops.lpq = ipc_lpq;
 746         ops.search_first = ipc_search_first;
 747         ops.search_next = ipc_search_next;
 748         ops.search_close = ipc_search_close;
 749         ops.trans = ipc_trans;
 750         ops.logoff = ipc_logoff;
 751         ops.async_setup = ipc_async_setup;
 752         ops.cancel = ipc_cancel;
 753
 754         /* register ourselves with the NTVFS subsystem. */
 755         ret = ntvfs_register(&ops);
 756
 757         if (!NT_STATUS_IS_OK(ret)) {
 758                 DEBUG(0,("Failed to register IPC backend!\n"));
 759                 return ret;
 760         }
 761
 762         return ret;
 763 }