8102c995369bdcdb8941ef9486faea205d1cc5a4
[ira/wip.git] / source4 / ntvfs / unixuid / vfs_unixuid.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    a pass-thru NTVFS module to setup a security context using unix
5    uid/gid
6
7    Copyright (C) Andrew Tridgell 2004
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 3 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, see <http://www.gnu.org/licenses/>.
21 */
22
23 #include "includes.h"
24 #include "system/filesys.h"
25 #include "system/passwd.h"
26 #include "auth/auth.h"
27 #include "ntvfs/ntvfs.h"
28 #include "libcli/wbclient/wbclient.h"
29 #define TEVENT_DEPRECATED
30 #include <tevent.h>
31
32 struct unixuid_private {
33         struct wbc_context *wbc_ctx;
34         struct unix_sec_ctx *last_sec_ctx;
35         struct security_token *last_token;
36 };
37
38
39
40 struct unix_sec_ctx {
41         uid_t uid;
42         gid_t gid;
43         unsigned int ngroups;
44         gid_t *groups;
45 };
46
47 /*
48   pull the current security context into a unix_sec_ctx
49 */
50 static struct unix_sec_ctx *save_unix_security(TALLOC_CTX *mem_ctx)
51 {
52         struct unix_sec_ctx *sec = talloc(mem_ctx, struct unix_sec_ctx);
53         if (sec == NULL) {
54                 return NULL;
55         }
56         sec->uid = geteuid();
57         sec->gid = getegid();
58         sec->ngroups = getgroups(0, NULL);
59         if (sec->ngroups == -1) {
60                 talloc_free(sec);
61                 return NULL;
62         }
63         sec->groups = talloc_array(sec, gid_t, sec->ngroups);
64         if (sec->groups == NULL) {
65                 talloc_free(sec);
66                 return NULL;
67         }
68
69         if (getgroups(sec->ngroups, sec->groups) != sec->ngroups) {
70                 talloc_free(sec);
71                 return NULL;
72         }
73
74         return sec;
75 }
76
77 /*
78   set the current security context from a unix_sec_ctx
79 */
80 static NTSTATUS set_unix_security(struct unix_sec_ctx *sec)
81 {
82         seteuid(0);
83
84         if (setgroups(sec->ngroups, sec->groups) != 0) {
85                 return NT_STATUS_ACCESS_DENIED;
86         }
87         if (setegid(sec->gid) != 0) {
88                 return NT_STATUS_ACCESS_DENIED;
89         }
90         if (seteuid(sec->uid) != 0) {
91                 return NT_STATUS_ACCESS_DENIED;
92         }
93         return NT_STATUS_OK;
94 }
95
96 static int unixuid_nesting_level;
97
98 /*
99   called at the start and end of a tevent nesting loop. Needs to save/restore
100   unix security context
101  */
102 static int unixuid_event_nesting_hook(struct tevent_context *ev,
103                                       void *private_data,
104                                       uint32_t level,
105                                       bool begin,
106                                       void *stack_ptr,
107                                       const char *location)
108 {
109         struct unix_sec_ctx *sec_ctx;
110
111         if (unixuid_nesting_level == 0) {
112                 /* we don't need to do anything unless we are nested
113                    inside of a call in this module */
114                 return 0;
115         }
116
117         if (begin) {
118                 sec_ctx = save_unix_security(ev);
119                 if (sec_ctx == NULL) {
120                         DEBUG(0,("%s: Failed to save security context\n", location));
121                         return -1;
122                 }
123                 *(struct unix_sec_ctx **)stack_ptr = sec_ctx;
124                 if (seteuid(0) != 0 || setegid(0) != 0) {
125                         DEBUG(0,("%s: Failed to change to root\n", location));
126                         return -1;                      
127                 }
128         } else {
129                 /* called when we come out of a nesting level */
130                 NTSTATUS status;
131
132                 sec_ctx = *(struct unix_sec_ctx **)stack_ptr;
133                 if (sec_ctx == NULL) {
134                         /* this happens the first time this function
135                            is called, as we install the hook while
136                            inside an event in unixuid_connect() */
137                         return 0;
138                 }
139
140                 sec_ctx = talloc_get_type_abort(sec_ctx, struct unix_sec_ctx);
141                 status = set_unix_security(sec_ctx);
142                 talloc_free(sec_ctx);
143                 if (!NT_STATUS_IS_OK(status)) {
144                         DEBUG(0,("%s: Failed to revert security context (%s)\n", 
145                                  location, nt_errstr(status)));
146                         return -1;
147                 }
148         }
149
150         return 0;
151 }
152
153
154 /*
155   form a unix_sec_ctx from the current security_token
156 */
157 static NTSTATUS nt_token_to_unix_security(struct ntvfs_module_context *ntvfs,
158                                           struct ntvfs_request *req,
159                                           struct security_token *token,
160                                           struct unix_sec_ctx **sec)
161 {
162         struct unixuid_private *priv = ntvfs->private_data;
163         int i;
164         NTSTATUS status;
165         struct id_mapping *ids;
166         struct composite_context *ctx;
167         *sec = talloc(req, struct unix_sec_ctx);
168
169         /* we can't do unix security without a user and group */
170         if (token->num_sids < 2) {
171                 return NT_STATUS_ACCESS_DENIED;
172         }
173
174         ids = talloc_array(req, struct id_mapping, token->num_sids);
175         NT_STATUS_HAVE_NO_MEMORY(ids);
176
177         ids[0].unixid = NULL;
178         ids[0].sid = token->user_sid;
179         ids[0].status = NT_STATUS_NONE_MAPPED;
180
181         ids[1].unixid = NULL;
182         ids[1].sid = token->group_sid;
183         ids[1].status = NT_STATUS_NONE_MAPPED;
184
185         (*sec)->ngroups = token->num_sids - 2;
186         (*sec)->groups = talloc_array(*sec, gid_t, (*sec)->ngroups);
187         NT_STATUS_HAVE_NO_MEMORY((*sec)->groups);
188
189         for (i=0;i<(*sec)->ngroups;i++) {
190                 ids[i+2].unixid = NULL;
191                 ids[i+2].sid = token->sids[i+2];
192                 ids[i+2].status = NT_STATUS_NONE_MAPPED;
193         }
194
195         ctx = wbc_sids_to_xids_send(priv->wbc_ctx, ids, token->num_sids, ids);
196         NT_STATUS_HAVE_NO_MEMORY(ctx);
197
198         status = wbc_sids_to_xids_recv(ctx, &ids);
199         NT_STATUS_NOT_OK_RETURN(status);
200
201         if (ids[0].unixid->type == ID_TYPE_BOTH ||
202             ids[0].unixid->type == ID_TYPE_UID) {
203                 (*sec)->uid = ids[0].unixid->id;
204         } else {
205                 return NT_STATUS_INVALID_SID;
206         }
207
208         if (ids[1].unixid->type == ID_TYPE_BOTH ||
209             ids[1].unixid->type == ID_TYPE_GID) {
210                 (*sec)->gid = ids[1].unixid->id;
211         } else {
212                 return NT_STATUS_INVALID_SID;
213         }
214
215         for (i=0;i<(*sec)->ngroups;i++) {
216                 if (ids[i+2].unixid->type == ID_TYPE_BOTH ||
217                     ids[i+2].unixid->type == ID_TYPE_GID) {
218                         (*sec)->groups[i] = ids[i+2].unixid->id;
219                 } else {
220                         return NT_STATUS_INVALID_SID;
221                 }
222         }
223
224         return NT_STATUS_OK;
225 }
226
227 /*
228   setup our unix security context according to the session authentication info
229 */
230 static NTSTATUS unixuid_setup_security(struct ntvfs_module_context *ntvfs,
231                                        struct ntvfs_request *req, struct unix_sec_ctx **sec)
232 {
233         struct unixuid_private *priv = ntvfs->private_data;
234         struct security_token *token;
235         struct unix_sec_ctx *newsec;
236         NTSTATUS status;
237
238         /* If we are asked to set up, but have not had a successful
239          * session setup or tree connect, then these may not be filled
240          * in.  ACCESS_DENIED is the right error code here */
241         if (req->session_info == NULL || priv == NULL) {
242                 return NT_STATUS_ACCESS_DENIED;
243         }
244
245         token = req->session_info->security_token;
246
247         *sec = save_unix_security(ntvfs);
248         if (*sec == NULL) {
249                 return NT_STATUS_NO_MEMORY;
250         }
251
252         if (token == priv->last_token) {
253                 newsec = priv->last_sec_ctx;
254         } else {
255                 status = nt_token_to_unix_security(ntvfs, req, token, &newsec);
256                 if (!NT_STATUS_IS_OK(status)) {
257                         talloc_free(*sec);
258                         return status;
259                 }
260                 if (priv->last_sec_ctx) {
261                         talloc_free(priv->last_sec_ctx);
262                 }
263                 priv->last_sec_ctx = newsec;
264                 priv->last_token = token;
265                 talloc_steal(priv, newsec);
266         }
267
268         status = set_unix_security(newsec);
269         if (!NT_STATUS_IS_OK(status)) {
270                 talloc_free(*sec);
271                 return status;
272         }
273
274         return NT_STATUS_OK;
275 }
276
277 /*
278   this pass through macro operates on request contexts
279 */
280 #define PASS_THRU_REQ(ntvfs, req, op, args) do { \
281         NTSTATUS status2; \
282         struct unix_sec_ctx *sec; \
283         status = unixuid_setup_security(ntvfs, req, &sec); \
284         NT_STATUS_NOT_OK_RETURN(status); \
285         unixuid_nesting_level++; \
286         status = ntvfs_next_##op args; \
287         unixuid_nesting_level--; \
288         status2 = set_unix_security(sec); \
289         talloc_free(sec); \
290         if (!NT_STATUS_IS_OK(status2)) smb_panic("Unable to reset security context"); \
291 } while (0)
292
293
294
295 /*
296   connect to a share - used when a tree_connect operation comes in.
297 */
298 static NTSTATUS unixuid_connect(struct ntvfs_module_context *ntvfs,
299                                 struct ntvfs_request *req, union smb_tcon *tcon)
300 {
301         struct unixuid_private *priv;
302         NTSTATUS status;
303
304         priv = talloc(ntvfs, struct unixuid_private);
305         if (!priv) {
306                 return NT_STATUS_NO_MEMORY;
307         }
308
309         priv->wbc_ctx = wbc_init(priv, ntvfs->ctx->msg_ctx,
310                                     ntvfs->ctx->event_ctx);
311         if (priv->wbc_ctx == NULL) {
312                 talloc_free(priv);
313                 return NT_STATUS_INTERNAL_ERROR;
314         }
315
316         priv->last_sec_ctx = NULL;
317         priv->last_token = NULL;
318         ntvfs->private_data = priv;
319
320         tevent_loop_set_nesting_hook(ntvfs->ctx->event_ctx, 
321                                      unixuid_event_nesting_hook,
322                                      &unixuid_nesting_level);
323
324         /* we don't use PASS_THRU_REQ here, as the connect operation runs with 
325            root privileges. This allows the backends to setup any database
326            links they might need during the connect. */
327         status = ntvfs_next_connect(ntvfs, req, tcon);
328
329         return status;
330 }
331
332 /*
333   disconnect from a share
334 */
335 static NTSTATUS unixuid_disconnect(struct ntvfs_module_context *ntvfs)
336 {
337         struct unixuid_private *priv = ntvfs->private_data;
338         NTSTATUS status;
339
340         talloc_free(priv);
341         ntvfs->private_data = NULL;
342
343         status = ntvfs_next_disconnect(ntvfs);
344  
345         return status;
346 }
347
348
349 /*
350   delete a file
351 */
352 static NTSTATUS unixuid_unlink(struct ntvfs_module_context *ntvfs,
353                               struct ntvfs_request *req,
354                               union smb_unlink *unl)
355 {
356         NTSTATUS status;
357
358         PASS_THRU_REQ(ntvfs, req, unlink, (ntvfs, req, unl));
359
360         return status;
361 }
362
363 /*
364   ioctl interface
365 */
366 static NTSTATUS unixuid_ioctl(struct ntvfs_module_context *ntvfs,
367                              struct ntvfs_request *req, union smb_ioctl *io)
368 {
369         NTSTATUS status;
370
371         PASS_THRU_REQ(ntvfs, req, ioctl, (ntvfs, req, io));
372
373         return status;
374 }
375
376 /*
377   check if a directory exists
378 */
379 static NTSTATUS unixuid_chkpath(struct ntvfs_module_context *ntvfs,
380                                 struct ntvfs_request *req,
381                                 union smb_chkpath *cp)
382 {
383         NTSTATUS status;
384
385         PASS_THRU_REQ(ntvfs, req, chkpath, (ntvfs, req, cp));
386
387         return status;
388 }
389
390 /*
391   return info on a pathname
392 */
393 static NTSTATUS unixuid_qpathinfo(struct ntvfs_module_context *ntvfs,
394                                  struct ntvfs_request *req, union smb_fileinfo *info)
395 {
396         NTSTATUS status;
397
398         PASS_THRU_REQ(ntvfs, req, qpathinfo, (ntvfs, req, info));
399
400         return status;
401 }
402
403 /*
404   query info on a open file
405 */
406 static NTSTATUS unixuid_qfileinfo(struct ntvfs_module_context *ntvfs,
407                                  struct ntvfs_request *req, union smb_fileinfo *info)
408 {
409         NTSTATUS status;
410
411         PASS_THRU_REQ(ntvfs, req, qfileinfo, (ntvfs, req, info));
412
413         return status;
414 }
415
416
417 /*
418   set info on a pathname
419 */
420 static NTSTATUS unixuid_setpathinfo(struct ntvfs_module_context *ntvfs,
421                                    struct ntvfs_request *req, union smb_setfileinfo *st)
422 {
423         NTSTATUS status;
424
425         PASS_THRU_REQ(ntvfs, req, setpathinfo, (ntvfs, req, st));
426
427         return status;
428 }
429
430 /*
431   open a file
432 */
433 static NTSTATUS unixuid_open(struct ntvfs_module_context *ntvfs,
434                              struct ntvfs_request *req, union smb_open *io)
435 {
436         NTSTATUS status;
437
438         PASS_THRU_REQ(ntvfs, req, open, (ntvfs, req, io));
439
440         return status;
441 }
442
443 /*
444   create a directory
445 */
446 static NTSTATUS unixuid_mkdir(struct ntvfs_module_context *ntvfs,
447                              struct ntvfs_request *req, union smb_mkdir *md)
448 {
449         NTSTATUS status;
450
451         PASS_THRU_REQ(ntvfs, req, mkdir, (ntvfs, req, md));
452
453         return status;
454 }
455
456 /*
457   remove a directory
458 */
459 static NTSTATUS unixuid_rmdir(struct ntvfs_module_context *ntvfs,
460                              struct ntvfs_request *req, struct smb_rmdir *rd)
461 {
462         NTSTATUS status;
463
464         PASS_THRU_REQ(ntvfs, req, rmdir, (ntvfs, req, rd));
465
466         return status;
467 }
468
469 /*
470   rename a set of files
471 */
472 static NTSTATUS unixuid_rename(struct ntvfs_module_context *ntvfs,
473                               struct ntvfs_request *req, union smb_rename *ren)
474 {
475         NTSTATUS status;
476
477         PASS_THRU_REQ(ntvfs, req, rename, (ntvfs, req, ren));
478
479         return status;
480 }
481
482 /*
483   copy a set of files
484 */
485 static NTSTATUS unixuid_copy(struct ntvfs_module_context *ntvfs,
486                             struct ntvfs_request *req, struct smb_copy *cp)
487 {
488         NTSTATUS status;
489
490         PASS_THRU_REQ(ntvfs, req, copy, (ntvfs, req, cp));
491
492         return status;
493 }
494
495 /*
496   read from a file
497 */
498 static NTSTATUS unixuid_read(struct ntvfs_module_context *ntvfs,
499                             struct ntvfs_request *req, union smb_read *rd)
500 {
501         NTSTATUS status;
502
503         PASS_THRU_REQ(ntvfs, req, read, (ntvfs, req, rd));
504
505         return status;
506 }
507
508 /*
509   write to a file
510 */
511 static NTSTATUS unixuid_write(struct ntvfs_module_context *ntvfs,
512                              struct ntvfs_request *req, union smb_write *wr)
513 {
514         NTSTATUS status;
515
516         PASS_THRU_REQ(ntvfs, req, write, (ntvfs, req, wr));
517
518         return status;
519 }
520
521 /*
522   seek in a file
523 */
524 static NTSTATUS unixuid_seek(struct ntvfs_module_context *ntvfs,
525                              struct ntvfs_request *req,
526                              union smb_seek *io)
527 {
528         NTSTATUS status;
529
530         PASS_THRU_REQ(ntvfs, req, seek, (ntvfs, req, io));
531
532         return status;
533 }
534
535 /*
536   flush a file
537 */
538 static NTSTATUS unixuid_flush(struct ntvfs_module_context *ntvfs,
539                               struct ntvfs_request *req,
540                               union smb_flush *io)
541 {
542         NTSTATUS status;
543
544         PASS_THRU_REQ(ntvfs, req, flush, (ntvfs, req, io));
545
546         return status;
547 }
548
549 /*
550   close a file
551 */
552 static NTSTATUS unixuid_close(struct ntvfs_module_context *ntvfs,
553                              struct ntvfs_request *req, union smb_close *io)
554 {
555         NTSTATUS status;
556
557         PASS_THRU_REQ(ntvfs, req, close, (ntvfs, req, io));
558
559         return status;
560 }
561
562 /*
563   exit - closing files
564 */
565 static NTSTATUS unixuid_exit(struct ntvfs_module_context *ntvfs,
566                             struct ntvfs_request *req)
567 {
568         NTSTATUS status;
569
570         PASS_THRU_REQ(ntvfs, req, exit, (ntvfs, req));
571
572         return status;
573 }
574
575 /*
576   logoff - closing files
577 */
578 static NTSTATUS unixuid_logoff(struct ntvfs_module_context *ntvfs,
579                               struct ntvfs_request *req)
580 {
581         struct unixuid_private *priv = ntvfs->private_data;
582         NTSTATUS status;
583
584         PASS_THRU_REQ(ntvfs, req, logoff, (ntvfs, req));
585
586         priv->last_token = NULL;
587
588         return status;
589 }
590
591 /*
592   async setup
593 */
594 static NTSTATUS unixuid_async_setup(struct ntvfs_module_context *ntvfs,
595                                     struct ntvfs_request *req, 
596                                     void *private_data)
597 {
598         NTSTATUS status;
599
600         PASS_THRU_REQ(ntvfs, req, async_setup, (ntvfs, req, private_data));
601
602         return status;
603 }
604
605 /*
606   cancel an async request
607 */
608 static NTSTATUS unixuid_cancel(struct ntvfs_module_context *ntvfs,
609                                struct ntvfs_request *req)
610 {
611         NTSTATUS status;
612
613         PASS_THRU_REQ(ntvfs, req, cancel, (ntvfs, req));
614
615         return status;
616 }
617
618 /*
619   change notify
620 */
621 static NTSTATUS unixuid_notify(struct ntvfs_module_context *ntvfs,
622                                struct ntvfs_request *req, union smb_notify *info)
623 {
624         NTSTATUS status;
625
626         PASS_THRU_REQ(ntvfs, req, notify, (ntvfs, req, info));
627
628         return status;
629 }
630
631 /*
632   lock a byte range
633 */
634 static NTSTATUS unixuid_lock(struct ntvfs_module_context *ntvfs,
635                             struct ntvfs_request *req, union smb_lock *lck)
636 {
637         NTSTATUS status;
638
639         PASS_THRU_REQ(ntvfs, req, lock, (ntvfs, req, lck));
640
641         return status;
642 }
643
644 /*
645   set info on a open file
646 */
647 static NTSTATUS unixuid_setfileinfo(struct ntvfs_module_context *ntvfs,
648                                    struct ntvfs_request *req, 
649                                    union smb_setfileinfo *info)
650 {
651         NTSTATUS status;
652
653         PASS_THRU_REQ(ntvfs, req, setfileinfo, (ntvfs, req, info));
654
655         return status;
656 }
657
658
659 /*
660   return filesystem space info
661 */
662 static NTSTATUS unixuid_fsinfo(struct ntvfs_module_context *ntvfs,
663                               struct ntvfs_request *req, union smb_fsinfo *fs)
664 {
665         NTSTATUS status;
666
667         PASS_THRU_REQ(ntvfs, req, fsinfo, (ntvfs, req, fs));
668
669         return status;
670 }
671
672 /*
673   return print queue info
674 */
675 static NTSTATUS unixuid_lpq(struct ntvfs_module_context *ntvfs,
676                            struct ntvfs_request *req, union smb_lpq *lpq)
677 {
678         NTSTATUS status;
679
680         PASS_THRU_REQ(ntvfs, req, lpq, (ntvfs, req, lpq));
681
682         return status;
683 }
684
685 /* 
686    list files in a directory matching a wildcard pattern
687 */
688 static NTSTATUS unixuid_search_first(struct ntvfs_module_context *ntvfs,
689                                     struct ntvfs_request *req, union smb_search_first *io, 
690                                     void *search_private, 
691                                     bool (*callback)(void *, const union smb_search_data *))
692 {
693         NTSTATUS status;
694
695         PASS_THRU_REQ(ntvfs, req, search_first, (ntvfs, req, io, search_private, callback));
696
697         return status;
698 }
699
700 /* continue a search */
701 static NTSTATUS unixuid_search_next(struct ntvfs_module_context *ntvfs,
702                                    struct ntvfs_request *req, union smb_search_next *io, 
703                                    void *search_private, 
704                                    bool (*callback)(void *, const union smb_search_data *))
705 {
706         NTSTATUS status;
707
708         PASS_THRU_REQ(ntvfs, req, search_next, (ntvfs, req, io, search_private, callback));
709
710         return status;
711 }
712
713 /* close a search */
714 static NTSTATUS unixuid_search_close(struct ntvfs_module_context *ntvfs,
715                                     struct ntvfs_request *req, union smb_search_close *io)
716 {
717         NTSTATUS status;
718
719         PASS_THRU_REQ(ntvfs, req, search_close, (ntvfs, req, io));
720
721         return status;
722 }
723
724 /* SMBtrans - not used on file shares */
725 static NTSTATUS unixuid_trans(struct ntvfs_module_context *ntvfs,
726                              struct ntvfs_request *req, struct smb_trans2 *trans2)
727 {
728         NTSTATUS status;
729
730         PASS_THRU_REQ(ntvfs, req, trans, (ntvfs, req, trans2));
731
732         return status;
733 }
734
735 /*
736   initialise the unixuid backend, registering ourselves with the ntvfs subsystem
737  */
738 NTSTATUS ntvfs_unixuid_init(void)
739 {
740         NTSTATUS ret;
741         struct ntvfs_ops ops;
742         NTVFS_CURRENT_CRITICAL_SIZES(vers);
743
744         ZERO_STRUCT(ops);
745
746         /* fill in all the operations */
747         ops.connect = unixuid_connect;
748         ops.disconnect = unixuid_disconnect;
749         ops.unlink = unixuid_unlink;
750         ops.chkpath = unixuid_chkpath;
751         ops.qpathinfo = unixuid_qpathinfo;
752         ops.setpathinfo = unixuid_setpathinfo;
753         ops.open = unixuid_open;
754         ops.mkdir = unixuid_mkdir;
755         ops.rmdir = unixuid_rmdir;
756         ops.rename = unixuid_rename;
757         ops.copy = unixuid_copy;
758         ops.ioctl = unixuid_ioctl;
759         ops.read = unixuid_read;
760         ops.write = unixuid_write;
761         ops.seek = unixuid_seek;
762         ops.flush = unixuid_flush;      
763         ops.close = unixuid_close;
764         ops.exit = unixuid_exit;
765         ops.lock = unixuid_lock;
766         ops.setfileinfo = unixuid_setfileinfo;
767         ops.qfileinfo = unixuid_qfileinfo;
768         ops.fsinfo = unixuid_fsinfo;
769         ops.lpq = unixuid_lpq;
770         ops.search_first = unixuid_search_first;
771         ops.search_next = unixuid_search_next;
772         ops.search_close = unixuid_search_close;
773         ops.trans = unixuid_trans;
774         ops.logoff = unixuid_logoff;
775         ops.async_setup = unixuid_async_setup;
776         ops.cancel = unixuid_cancel;
777         ops.notify = unixuid_notify;
778
779         ops.name = "unixuid";
780
781         /* we register under all 3 backend types, as we are not type specific */
782         ops.type = NTVFS_DISK;  
783         ret = ntvfs_register(&ops, &vers);
784         if (!NT_STATUS_IS_OK(ret)) goto failed;
785
786         ops.type = NTVFS_PRINT; 
787         ret = ntvfs_register(&ops, &vers);
788         if (!NT_STATUS_IS_OK(ret)) goto failed;
789
790         ops.type = NTVFS_IPC;   
791         ret = ntvfs_register(&ops, &vers);
792         if (!NT_STATUS_IS_OK(ret)) goto failed;
793         
794 failed:
795         return ret;
796 }