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