e947e66134835962a57dddac38c02dd6d78145a8
[openafs.git] / src / afs / afs_nfsdisp.c
1 /*
2  * This software has been released under the terms of the IBM Public
3  * License.  For details, see the LICENSE file in the top-level source
4  * directory or online at http://www.openafs.org/dl/license10.html
5  */
6
7 /*
8  * Implements:
9  */
10 #include <afsconfig.h>
11 #include "afs/param.h"
12
13
14 /* Ugly Ugly Ugly  but precludes conflicting XDR macros; We want kernel xdr */
15 #define __XDR_INCLUDE__
16 #include "afs/stds.h"
17 #include "afs/sysincludes.h"    /* Standard vendor system headers */
18 #if defined(AFS_SUN55_ENV) && !defined(AFS_NONFSTRANS)
19 #include "rpc/types.h"
20 #include "rpc/auth.h"
21 #include "rpc/auth_unix.h"
22 #include "rpc/auth_des.h"
23 #if !defined(AFS_SUN58_ENV)
24 #include "rpc/auth_kerb.h"
25 #endif
26 #include "sys/tiuser.h"
27 #include "rpc/xdr.h"
28 #include "rpc/svc.h"
29 #include "nfs/nfs.h"
30 #include "nfs/export.h"
31 #include "nfs/nfs_clnt.h"
32 #include "nfs/nfs_acl.h"
33 #include "afs/afsincludes.h"
34 #include "afs/afs_stats.h"
35 #include "afs/exporter.h"
36
37 static int xlatorinit_v2_done = 0;
38 static int xlatorinit_v3_done = 0;
39 extern int afs_nobody;
40 extern int afs_NFSRootOnly;
41
42 struct rfs_disp_tbl {
43     void (*dis_proc) ();
44     xdrproc_t dis_xdrargs;
45     xdrproc_t dis_fastxdrargs;
46     int dis_argsz;
47     xdrproc_t dis_xdrres;
48     xdrproc_t dis_fastxdrres;
49     int dis_ressz;
50     void (*dis_resfree) ();
51     int dis_flags;
52       fhandle_t(*dis_getfh) ();
53 };
54
55 struct afs_nfs_disp_tbl {
56     void (*afs_proc) ();
57     void (*orig_proc) ();
58 };
59 struct afs_nfs2_resp {
60     enum nfsstat status;
61 };
62
63 #ifndef ACL2_NPROC
64 #if defined(AFS_SUN510_ENV)
65 #define ACL2_NPROC      6
66 #else
67 #define ACL2_NPROC      5
68 #endif
69 #endif
70 struct afs_nfs_disp_tbl afs_rfs_disp_tbl[RFS_NPROC];
71 struct afs_nfs_disp_tbl afs_acl_disp_tbl[ACL2_NPROC];
72
73 static int
74 is_afs_fh(fhandle_t * fhp)
75 {
76     if ((fhp->fh_fsid.val[0] == AFS_VFSMAGIC)
77         && (fhp->fh_fsid.val[1] == AFS_VFSFSID))
78         return 1;
79     return 0;
80 }
81
82 afs_int32
83 nfs2_to_afs_call(int which, caddr_t * args, fhandle_t ** fhpp,
84                  fhandle_t ** fh2pp)
85 {
86     struct vnode *vp;
87     fhandle_t *fhp1 = 0;
88     fhandle_t *fhp2 = 0;
89     int errorcode;
90
91     afs_Trace1(afs_iclSetp, CM_TRACE_NFSIN, ICL_TYPE_INT32, which);
92     *fh2pp = (fhandle_t *) 0;
93     switch (which) {
94     case RFS_GETATTR:
95     case RFS_READLINK:
96     case RFS_STATFS:
97         fhp1 = (fhandle_t *) args;
98         break;
99     case RFS_SETATTR:
100         {
101             struct nfssaargs *sargs = (struct nfssaargs *)args;
102             fhp1 = (fhandle_t *) & sargs->saa_fh;
103             break;
104         }
105     case RFS_LOOKUP:
106         {
107             struct nfsdiropargs *sargs = (struct nfsdiropargs *)args;
108             fhp1 = sargs->da_fhandle;
109             break;
110         }
111     case RFS_READ:
112         {
113             struct nfsreadargs *sargs = (struct nfsreadargs *)args;
114             fhp1 = (fhandle_t *) & sargs->ra_fhandle;
115             break;
116         }
117     case RFS_WRITE:
118         {
119             struct nfswriteargs *sargs = (struct nfswriteargs *)args;
120             fhp1 = (fhandle_t *) & sargs->wa_fhandle;
121             break;
122         }
123     case RFS_CREATE:
124         {
125             struct nfscreatargs *sargs = (struct nfscreatargs *)args;
126             fhp1 = sargs->ca_da.da_fhandle;
127             break;
128         }
129     case RFS_REMOVE:
130         {
131             struct nfsdiropargs *sargs = (struct nfsdiropargs *)args;
132             fhp1 = sargs->da_fhandle;
133             break;
134         }
135     case RFS_RENAME:
136         {
137             struct nfsrnmargs *sargs = (struct nfsrnmargs *)args;
138             fhp1 = sargs->rna_from.da_fhandle;
139             fhp2 = sargs->rna_to.da_fhandle;
140             break;
141         }
142     case RFS_LINK:
143         {
144             struct nfslinkargs *sargs = (struct nfslinkargs *)args;
145             fhp1 = sargs->la_from;
146             fhp2 = sargs->la_to.da_fhandle;
147             break;
148         }
149     case RFS_SYMLINK:
150         {
151             struct nfsslargs *sargs = (struct nfsslargs *)args;
152             fhp1 = sargs->sla_from.da_fhandle;
153             break;
154         }
155     case RFS_MKDIR:
156         {
157             struct nfscreatargs *sargs = (struct nfscreatargs *)args;
158             fhp1 = sargs->ca_da.da_fhandle;
159             break;
160         }
161     case RFS_RMDIR:
162         {
163             struct nfsdiropargs *sargs = (struct nfsdiropargs *)args;
164             fhp1 = sargs->da_fhandle;
165             break;
166         }
167     case RFS_READDIR:
168         {
169             struct nfsrddirargs *sargs = (struct nfsrddirargs *)args;
170             fhp1 = (fhandle_t *) & sargs->rda_fh;
171             break;
172         }
173     default:
174         return NULL;
175     }
176
177     /* Ok if arg 1 is in AFS or if 2 args and arg 2 is in AFS */
178     if (fhp1 && is_afs_fh(fhp1)) {
179         *fhpp = fhp1;
180         if (fhp2)
181             *fh2pp = fhp2;
182         return 1;
183     }
184     if (fhp2 && is_afs_fh(fhp2)) {
185         *fhpp = fhp1;
186         *fh2pp = fhp2;
187         return 1;
188     }
189     return NULL;
190 }
191
192 afs_int32
193 acl2_to_afs_call(int which, caddr_t * args, fhandle_t ** fhpp)
194 {
195     fhandle_t *fhp;
196
197     switch (which) {
198     case ACLPROC2_NULL:
199         {
200             return NULL;
201         }
202     case ACLPROC2_GETACL:
203         {
204             struct GETACL2args *sargs = (struct GETACL2args *)args;
205             fhp = &sargs->fh;
206             break;
207         }
208     case ACLPROC2_SETACL:
209         {
210             struct SETACL2args *sargs = (struct SETACL2args *)args;
211             fhp = &sargs->fh;
212             break;
213         }
214     case ACLPROC2_GETATTR:
215         {
216             struct GETATTR2args *sargs = (struct GETATTR2args *)args;
217             fhp = &sargs->fh;
218             break;
219         }
220     case ACLPROC2_ACCESS:
221         {
222             struct ACCESS2args *sargs = (struct ACCESS2args *)args;
223             fhp = &sargs->fh;
224             break;
225         }
226 #if defined(AFS_SUN510_ENV) 
227     case ACLPROC2_GETXATTRDIR:
228         {
229             struct GETXATTRDIR2args *sargs = (struct GETXATTRDIR2args *)args;
230             fhp = &sargs->fh;
231             break;
232         }
233 #endif
234     default:
235         return NULL;
236     }
237
238     if (fhp && is_afs_fh(fhp)) {
239         *fhpp = fhp;
240         return 1;
241     }
242
243     return NULL;
244 }
245
246 int
247 afs_nfs2_dispatcher(int type, afs_int32 which, char *argp,
248                     struct exportinfo **expp, struct svc_req *rp,
249                     struct AFS_UCRED *crp)
250 {
251     afs_int32 call = 0;
252     afs_int32 code = 0;
253     afs_int32 client = 0;
254     struct sockaddr *sa;
255     fhandle_t *fh = (fhandle_t *) argp;
256     fhandle_t *fh2 = (fhandle_t *) 0;
257
258     if (!xlatorinit_v2_done)
259         return 2;
260
261     sa = (struct sockaddr *)svc_getrpccaller(rp->rq_xprt)->buf;
262     if (sa->sa_family == AF_INET)
263         client = ((struct sockaddr_in *)sa)->sin_addr.s_addr;
264
265     AFS_GLOCK();
266     code = 0;
267     switch (type) {
268     case 0:
269         code = (client && nfs2_to_afs_call(which, argp, &fh, &fh2));
270         break;
271     case 1:
272         code = (client && acl2_to_afs_call(which, argp, &fh));
273         break;
274     default:
275         break;
276     }
277
278     if (code) {
279         struct afs_exporter *out = 0;
280         afs_int32 dummy;
281         static int once = 0;
282         struct SmallFid Sfid;
283
284         memcpy((char *)&Sfid, fh->fh_data, SIZEOF_SMALLFID);
285
286         afs_Trace2(afs_iclSetp, CM_TRACE_NFSIN1, ICL_TYPE_POINTER, client,
287                    ICL_TYPE_FID, &Sfid);
288
289         /* We ran */
290         call = 1;
291         if (!once && *expp) {
292             afs_nobody = (*expp)->exi_export.ex_anon;
293             once = 1;
294         }
295         code =
296             afs_nfsclient_reqhandler((struct afs_exporter *)0, &crp, client,
297                                      &dummy, &out);
298
299         if (!code && out)
300             EXP_RELE(out);
301
302         if (code == EINVAL)
303             call = 2;
304     }
305
306     AFS_GUNLOCK();
307     return call;
308 }
309
310 void
311 afs_nfs2_smallfidder(struct nfsdiropres *dr)
312 {
313     register fhandle_t *fhp = (fhandle_t *) & dr->dr_fhandle;
314     afs_int32 addr[2];
315     struct vcache *vcp;
316
317 #if defined(AFS_SUN57_64BIT_ENV)
318     /* See also afs_fid() */
319     memcpy((char *)addr, fhp->fh_data, SIZEOF_SMALLFID);
320     addr[1] = (addr[1] >> 48) & 0xffff;
321 #else
322     memcpy((char *)addr, fhp->fh_data, 2 * sizeof(long));
323 #endif
324
325     AFS_GLOCK();
326     vcp = VTOAFS((struct vnode *)addr[0]);
327
328     if (addr[1] == AFS_XLATOR_MAGIC) {
329         if (dr->dr_status == NFS_OK) {
330             struct SmallFid Sfid;
331             struct cell *tcell;
332
333             /* Make up and copy out a SmallFid */
334             tcell = afs_GetCell(vcp->f.fid.Cell, READ_LOCK);
335             Sfid.Volume = vcp->f.fid.Fid.Volume;
336             Sfid.CellAndUnique =
337                 ((tcell->cellIndex << 24) | (vcp->f.fid.Fid.Unique & 0xffffff));
338             afs_PutCell(tcell, READ_LOCK);
339             Sfid.Vnode = (u_short) (vcp->f.fid.Fid.Vnode & 0xffff);
340             fhp->fh_len = SIZEOF_SMALLFID;
341             memcpy(dr->dr_fhandle.fh_data, (char *)&Sfid, fhp->fh_len);
342
343             afs_Trace3(afs_iclSetp, CM_TRACE_NFSOUT, ICL_TYPE_INT32, 0,
344                        ICL_TYPE_POINTER, vcp, ICL_TYPE_FID, &Sfid);
345         }
346
347         /* If we have a ref, release it */
348         if (vcp->vrefCount >= 1)
349             AFS_RELE(AFSTOV(vcp));
350     }
351     AFS_GUNLOCK();
352 }
353
354 void
355 afs_nfs2_noaccess(struct afs_nfs2_resp *resp)
356 {
357     resp->status = NFSERR_ACCES;
358 }
359
360 void
361 afs_nfs2_null(char *args, char *xp, char *exp, char *rp, char *crp)
362 {
363 }
364
365 void
366 afs_nfs2_root(char *args, char *xp, char *exp, char *rp, char *crp)
367 {
368 }
369
370 void
371 afs_nfs2_writecache(char *args, char *xp, char *exp, char *rp, char *crp)
372 {
373 }
374
375 void
376 afs_nfs2_getattr(char *args, char *xp, char *exp, char *rp, char *crp)
377 {
378     u_int call;
379     struct AFS_UCRED *svcred = curthread->t_cred;
380     curthread->t_cred = (struct AFS_UCRED *)crp;
381     call = afs_nfs2_dispatcher(0, RFS_GETATTR, (char *)args, &exp, rp, crp);
382     if (call > 1)
383         afs_nfs2_noaccess((struct afs_nfs2_resp *)xp);
384     else
385         (*afs_rfs_disp_tbl[RFS_GETATTR].orig_proc) (args, xp, exp, rp, crp);
386     curthread->t_cred = svcred;
387     return;
388 }
389
390 void
391 afs_nfs2_setattr(char *args, char *xp, char *exp, char *rp, char *crp)
392 {
393     u_int call;
394     struct AFS_UCRED *svcred = curthread->t_cred;
395     curthread->t_cred = (struct AFS_UCRED *)crp;
396     call = afs_nfs2_dispatcher(0, RFS_SETATTR, (char *)args, &exp, rp, crp);
397     if (call > 1)
398         afs_nfs2_noaccess((struct afs_nfs2_resp *)xp);
399     else
400         (*afs_rfs_disp_tbl[RFS_SETATTR].orig_proc) (args, xp, exp, rp, crp);
401     curthread->t_cred = svcred;
402     return;
403 }
404
405 void
406 afs_nfs2_lookup(char *args, char *xp, char *exp, char *rp, char *crp)
407 {
408     u_int call;
409     struct AFS_UCRED *svcred = curthread->t_cred;
410     curthread->t_cred = (struct AFS_UCRED *)crp;
411     call = afs_nfs2_dispatcher(0, RFS_LOOKUP, (char *)args, &exp, rp, crp);
412     if (call > 1)
413         afs_nfs2_noaccess((struct afs_nfs2_resp *)xp);
414     else {
415         (*afs_rfs_disp_tbl[RFS_LOOKUP].orig_proc) (args, xp, exp, rp, crp);
416         if (afs_NFSRootOnly && call)
417             afs_nfs2_smallfidder(xp);
418     }
419     curthread->t_cred = svcred;
420     return;
421 }
422
423 void
424 afs_nfs2_readlink(char *args, char *xp, char *exp, char *rp, char *crp)
425 {
426     u_int call;
427     struct AFS_UCRED *svcred = curthread->t_cred;
428     curthread->t_cred = (struct AFS_UCRED *)crp;
429     call = afs_nfs2_dispatcher(0, RFS_READLINK, (char *)args, &exp, rp, crp);
430     if (call > 1)
431         afs_nfs2_noaccess((struct afs_nfs2_resp *)xp);
432     else
433         (*afs_rfs_disp_tbl[RFS_READLINK].orig_proc) (args, xp, exp, rp, crp);
434     curthread->t_cred = svcred;
435     return;
436 }
437
438 void
439 afs_nfs2_read(char *args, char *xp, char *exp, char *rp, char *crp)
440 {
441     u_int call;
442     struct AFS_UCRED *svcred = curthread->t_cred;
443     curthread->t_cred = (struct AFS_UCRED *)crp;
444     call = afs_nfs2_dispatcher(0, RFS_READ, (char *)args, &exp, rp, crp);
445     if (call > 1)
446         afs_nfs2_noaccess((struct afs_nfs2_resp *)xp);
447     else
448         (*afs_rfs_disp_tbl[RFS_READ].orig_proc) (args, xp, exp, rp, crp);
449     curthread->t_cred = svcred;
450     return;
451 }
452
453 void
454 afs_nfs2_write(char *args, char *xp, char *exp, char *rp, char *crp)
455 {
456     u_int call;
457     struct AFS_UCRED *svcred = curthread->t_cred;
458     curthread->t_cred = (struct AFS_UCRED *)crp;
459     call = afs_nfs2_dispatcher(0, RFS_WRITE, (char *)args, &exp, rp, crp);
460     if (call > 1)
461         afs_nfs2_noaccess((struct afs_nfs2_resp *)xp);
462     else
463         (*afs_rfs_disp_tbl[RFS_WRITE].orig_proc) (args, xp, exp, rp, crp);
464     curthread->t_cred = svcred;
465     return;
466 }
467
468 void
469 afs_nfs2_create(char *args, char *xp, char *exp, char *rp, char *crp)
470 {
471     u_int call;
472     struct AFS_UCRED *svcred = curthread->t_cred;
473     curthread->t_cred = (struct AFS_UCRED *)crp;
474     call = afs_nfs2_dispatcher(0, RFS_CREATE, (char *)args, &exp, rp, crp);
475     if (call > 1)
476         afs_nfs2_noaccess((struct afs_nfs2_resp *)xp);
477     else {
478         (*afs_rfs_disp_tbl[RFS_CREATE].orig_proc) (args, xp, exp, rp, crp);
479         if (afs_NFSRootOnly && call)
480             afs_nfs2_smallfidder(xp);
481     }
482     curthread->t_cred = svcred;
483     return;
484 }
485
486 void
487 afs_nfs2_remove(char *args, char *xp, char *exp, char *rp, char *crp)
488 {
489     u_int call;
490     struct AFS_UCRED *svcred = curthread->t_cred;
491     curthread->t_cred = (struct AFS_UCRED *)crp;
492     call = afs_nfs2_dispatcher(0, RFS_REMOVE, (char *)args, &exp, rp, crp);
493     if (call > 1)
494         afs_nfs2_noaccess((struct afs_nfs2_resp *)xp);
495     else
496         (*afs_rfs_disp_tbl[RFS_REMOVE].orig_proc) (args, xp, exp, rp, crp);
497     curthread->t_cred = svcred;
498     return;
499 }
500
501 void
502 afs_nfs2_rename(char *args, char *xp, char *exp, char *rp, char *crp)
503 {
504     u_int call;
505     struct AFS_UCRED *svcred = curthread->t_cred;
506     curthread->t_cred = (struct AFS_UCRED *)crp;
507     call = afs_nfs2_dispatcher(0, RFS_RENAME, (char *)args, &exp, rp, crp);
508     if (call > 1)
509         afs_nfs2_noaccess((struct afs_nfs2_resp *)xp);
510     else
511         (*afs_rfs_disp_tbl[RFS_RENAME].orig_proc) (args, xp, exp, rp, crp);
512     curthread->t_cred = svcred;
513     return;
514 }
515
516 void
517 afs_nfs2_link(char *args, char *xp, char *exp, char *rp, char *crp)
518 {
519     u_int call;
520     struct AFS_UCRED *svcred = curthread->t_cred;
521     curthread->t_cred = (struct AFS_UCRED *)crp;
522     call = afs_nfs2_dispatcher(0, RFS_LINK, (char *)args, &exp, rp, crp);
523     if (call > 1)
524         afs_nfs2_noaccess((struct afs_nfs2_resp *)xp);
525     else
526         (*afs_rfs_disp_tbl[RFS_LINK].orig_proc) (args, xp, exp, rp, crp);
527     curthread->t_cred = svcred;
528     return;
529 }
530
531 void
532 afs_nfs2_symlink(char *args, char *xp, char *exp, char *rp, char *crp)
533 {
534     u_int call;
535     struct AFS_UCRED *svcred = curthread->t_cred;
536     curthread->t_cred = (struct AFS_UCRED *)crp;
537     call = afs_nfs2_dispatcher(0, RFS_SYMLINK, (char *)args, &exp, rp, crp);
538     if (call > 1)
539         afs_nfs2_noaccess((struct afs_nfs2_resp *)xp);
540     else
541         (*afs_rfs_disp_tbl[RFS_SYMLINK].orig_proc) (args, xp, exp, rp, crp);
542     curthread->t_cred = svcred;
543     return;
544 }
545
546 void
547 afs_nfs2_mkdir(char *args, char *xp, char *exp, char *rp, char *crp)
548 {
549     u_int call;
550     struct AFS_UCRED *svcred = curthread->t_cred;
551     curthread->t_cred = (struct AFS_UCRED *)crp;
552     call = afs_nfs2_dispatcher(0, RFS_MKDIR, (char *)args, &exp, rp, crp);
553     if (call > 1)
554         afs_nfs2_noaccess((struct afs_nfs2_resp *)xp);
555     else {
556         (*afs_rfs_disp_tbl[RFS_MKDIR].orig_proc) (args, xp, exp, rp, crp);
557         if (afs_NFSRootOnly && call)
558             afs_nfs2_smallfidder(xp);
559     }
560     curthread->t_cred = svcred;
561     return;
562 }
563
564 void
565 afs_nfs2_rmdir(char *args, char *xp, char *exp, char *rp, char *crp)
566 {
567     u_int call;
568     struct AFS_UCRED *svcred = curthread->t_cred;
569     curthread->t_cred = (struct AFS_UCRED *)crp;
570     call = afs_nfs2_dispatcher(0, RFS_RMDIR, (char *)args, &exp, rp, crp);
571     if (call > 1)
572         afs_nfs2_noaccess((struct afs_nfs2_resp *)xp);
573     else
574         (*afs_rfs_disp_tbl[RFS_RMDIR].orig_proc) (args, xp, exp, rp, crp);
575     curthread->t_cred = svcred;
576     return;
577 }
578
579 void
580 afs_nfs2_readdir(char *args, char *xp, char *exp, char *rp, char *crp)
581 {
582     u_int call;
583     struct AFS_UCRED *svcred = curthread->t_cred;
584     curthread->t_cred = (struct AFS_UCRED *)crp;
585     call = afs_nfs2_dispatcher(0, RFS_READDIR, (char *)args, &exp, rp, crp);
586     if (call > 1)
587         afs_nfs2_noaccess((struct afs_nfs2_resp *)xp);
588     else
589         (*afs_rfs_disp_tbl[RFS_READDIR].orig_proc) (args, xp, exp, rp, crp);
590     curthread->t_cred = svcred;
591     return;
592 }
593
594 void
595 afs_nfs2_statfs(char *args, char *xp, char *exp, char *rp, char *crp)
596 {
597     u_int call;
598     struct AFS_UCRED *svcred = curthread->t_cred;
599     curthread->t_cred = (struct AFS_UCRED *)crp;
600     call = afs_nfs2_dispatcher(0, RFS_STATFS, (char *)args, &exp, rp, crp);
601     if (call > 1)
602         afs_nfs2_noaccess((struct afs_nfs2_resp *)xp);
603     else
604         (*afs_rfs_disp_tbl[RFS_STATFS].orig_proc) (args, xp, exp, rp, crp);
605     curthread->t_cred = svcred;
606     return;
607 }
608
609 struct afs_nfs_disp_tbl afs_rfs_disp_tbl[RFS_NPROC] = {
610     {afs_nfs2_null},
611     {afs_nfs2_getattr},
612     {afs_nfs2_setattr},
613     {afs_nfs2_root},
614     {afs_nfs2_lookup},
615     {afs_nfs2_readlink},
616     {afs_nfs2_read},
617     {afs_nfs2_writecache},
618     {afs_nfs2_write},
619     {afs_nfs2_create},
620     {afs_nfs2_remove},
621     {afs_nfs2_rename},
622     {afs_nfs2_link},
623     {afs_nfs2_symlink},
624     {afs_nfs2_mkdir},
625     {afs_nfs2_rmdir},
626     {afs_nfs2_readdir},
627     {afs_nfs2_statfs}
628 };
629
630 void
631 afs_acl2_getacl(char *args, char *xp, char *exp, char *rp, char *crp)
632 {
633     u_int call;
634     struct AFS_UCRED *svcred = curthread->t_cred;
635     curthread->t_cred = (struct AFS_UCRED *)crp;
636     call =
637         afs_nfs2_dispatcher(1, ACLPROC2_GETACL, (char *)args, &exp, rp, crp);
638     if (call > 1)
639         afs_nfs2_noaccess((struct afs_nfs2_resp *)xp);
640     else
641         (*afs_acl_disp_tbl[ACLPROC2_GETACL].orig_proc) (args, xp, exp, rp,
642                                                         crp);
643     curthread->t_cred = svcred;
644     return;
645 }
646
647 void
648 afs_acl2_setacl(char *args, char *xp, char *exp, char *rp, char *crp)
649 {
650     u_int call;
651     struct AFS_UCRED *svcred = curthread->t_cred;
652     curthread->t_cred = (struct AFS_UCRED *)crp;
653     call =
654         afs_nfs2_dispatcher(1, ACLPROC2_SETACL, (char *)args, &exp, rp, crp);
655     if (call > 1)
656         afs_nfs2_noaccess((struct afs_nfs2_resp *)xp);
657     else
658         (*afs_acl_disp_tbl[ACLPROC2_SETACL].orig_proc) (args, xp, exp, rp,
659                                                         crp);
660     curthread->t_cred = svcred;
661     return;
662 }
663
664 void
665 afs_acl2_getattr(char *args, char *xp, char *exp, char *rp, char *crp)
666 {
667     u_int call;
668     struct AFS_UCRED *svcred = curthread->t_cred;
669     curthread->t_cred = (struct AFS_UCRED *)crp;
670     call =
671         afs_nfs2_dispatcher(1, ACLPROC2_GETATTR, (char *)args, &exp, rp, crp);
672     if (call > 1)
673         afs_nfs2_noaccess((struct afs_nfs2_resp *)xp);
674     else
675         (*afs_acl_disp_tbl[ACLPROC2_GETATTR].orig_proc) (args, xp, exp, rp,
676                                                          crp);
677     curthread->t_cred = svcred;
678     return;
679 }
680
681 void
682 afs_acl2_access(char *args, char *xp, char *exp, char *rp, char *crp)
683 {
684     u_int call;
685     struct AFS_UCRED *svcred = curthread->t_cred;
686     curthread->t_cred = (struct AFS_UCRED *)crp;
687     call =
688         afs_nfs2_dispatcher(1, ACLPROC2_ACCESS, (char *)args, &exp, rp, crp);
689     if (call > 1)
690         afs_nfs2_noaccess((struct afs_nfs2_resp *)xp);
691     else
692         (*afs_acl_disp_tbl[ACLPROC2_ACCESS].orig_proc) (args, xp, exp, rp,
693                                                         crp);
694     curthread->t_cred = svcred;
695     return;
696 }
697
698 #if defined(AFS_SUN510_ENV) 
699 void
700 afs_acl2_getxattrdir(char *args, char *xp, char *exp, char *rp, char *crp)
701 {
702     u_int call;
703     struct AFS_UCRED *svcred = curthread->t_cred;
704     curthread->t_cred = (struct AFS_UCRED *)crp;
705     call =
706         afs_nfs2_dispatcher(1, ACLPROC2_GETXATTRDIR, (char *)args, &exp, rp, crp);
707     if (call > 1)
708         afs_nfs2_noaccess((struct afs_nfs2_resp *)xp);
709     else
710         (*afs_acl_disp_tbl[ACLPROC2_GETXATTRDIR].orig_proc) (args, xp, exp, rp,
711                                                         crp);
712     curthread->t_cred = svcred;
713     return;
714 }
715 #endif
716
717 struct afs_nfs_disp_tbl afs_acl_disp_tbl[ACL2_NPROC] = {
718     {afs_nfs2_null},
719     {afs_acl2_getacl},
720     {afs_acl2_setacl},
721     {afs_acl2_getattr},
722     {afs_acl2_access},
723 #if defined(AFS_SUN510_ENV) 
724     {afs_acl2_getxattrdir}
725 #endif
726 };
727
728 /* Munge the dispatch tables to link us in first */
729 void
730 afs_xlatorinit_v2(struct rfs_disp_tbl *_rfs_tbl,
731                   struct rfs_disp_tbl *_acl_tbl)
732 {
733     int i;
734
735     if (xlatorinit_v2_done++)
736         return;
737
738     for (i = 0; i < RFS_NPROC; i++) {
739         afs_rfs_disp_tbl[i].orig_proc = _rfs_tbl[i].dis_proc;
740         _rfs_tbl[i].dis_proc = afs_rfs_disp_tbl[i].afs_proc;
741     }
742
743     for (i = 0; i < 5; i++) {
744         afs_acl_disp_tbl[i].orig_proc = _acl_tbl[i].dis_proc;
745         _acl_tbl[i].dis_proc = afs_acl_disp_tbl[i].afs_proc;
746     }
747 }
748
749 #ifndef RFS3_NPROC
750 #define RFS3_NPROC      22
751 #endif
752
753 #ifndef ACL3_NPROC
754 #if defined(AFS_SUN510_ENV)
755 #define ACL3_NPROC      4
756 #else
757 #define ACL3_NPROC      3
758 #endif
759 #endif
760
761 struct afs_nfs_disp_tbl afs_rfs3_disp_tbl[RFS3_NPROC];
762 struct afs_nfs_disp_tbl afs_acl3_disp_tbl[ACL3_NPROC];
763
764 struct afs_nfs3_resp {
765     nfsstat3 status;
766     bool_t flags;
767 };
768 typedef struct afs_nfs3_resp afs_nfs3_resp;
769
770 static int
771 is_afs_fh3(nfs_fh3 * fhp)
772 {
773     if ((fhp->fh3_fsid.val[0] == AFS_VFSMAGIC)
774         && (fhp->fh3_fsid.val[1] == AFS_VFSFSID))
775         return 1;
776     return 0;
777 }
778
779 void
780 afs_nfs3_noaccess(struct afs_nfs3_resp *resp)
781 {
782     resp->status = NFS3ERR_ACCES;
783     resp->flags = FALSE;
784 }
785
786 void
787 afs_nfs3_notsupp(struct afs_nfs3_resp *resp)
788 {
789     resp->status = NFS3ERR_NOTSUPP;
790     resp->flags = FALSE;
791 }
792
793 afs_int32
794 nfs3_to_afs_call(int which, caddr_t * args, nfs_fh3 ** fhpp, nfs_fh3 ** fh2pp)
795 {
796     struct vnode *vp;
797     nfs_fh3 *fhp1 = 0;
798     nfs_fh3 *fhp2 = 0;
799     int errorcode;
800
801     afs_Trace1(afs_iclSetp, CM_TRACE_NFS3IN, ICL_TYPE_INT32, which);
802     *fh2pp = (nfs_fh3 *) 0;
803     switch (which) {
804     case NFSPROC3_GETATTR:
805         {
806             GETATTR3args *arg = (GETATTR3args *) args;
807             fhp1 = (nfs_fh3 *) & arg->object;
808             break;
809         }
810     case NFSPROC3_SETATTR:
811         {
812             SETATTR3args *arg = (SETATTR3args *) args;
813             fhp1 = (nfs_fh3 *) & arg->object;
814             break;
815         }
816     case NFSPROC3_LOOKUP:
817         {
818             LOOKUP3args *arg = (LOOKUP3args *) args;
819 #ifdef AFS_SUN58_ENV
820             fhp1 = (nfs_fh3 *) arg->what.dirp;
821 #else
822             fhp1 = (nfs_fh3 *) & arg->what.dir;
823 #endif
824             break;
825         }
826     case NFSPROC3_ACCESS:
827         {
828             ACCESS3args *arg = (ACCESS3args *) args;
829             fhp1 = (nfs_fh3 *) & arg->object;
830             break;
831         }
832     case NFSPROC3_READLINK:
833         {
834             READLINK3args *arg = (READLINK3args *) args;
835             fhp1 = (nfs_fh3 *) & arg->symlink;
836             break;
837         }
838     case NFSPROC3_READ:
839         {
840             READ3args *arg = (READ3args *) args;
841             fhp1 = (nfs_fh3 *) & arg->file;
842             break;
843         }
844     case NFSPROC3_WRITE:
845         {
846             WRITE3args *arg = (WRITE3args *) args;
847             fhp1 = (nfs_fh3 *) & arg->file;
848             break;
849         }
850     case NFSPROC3_CREATE:
851         {
852             CREATE3args *arg = (CREATE3args *) args;
853 #ifdef AFS_SUN58_ENV
854             fhp1 = (nfs_fh3 *) arg->where.dirp;
855 #else
856             fhp1 = (nfs_fh3 *) & arg->where.dir;
857 #endif
858             break;
859         }
860     case NFSPROC3_MKDIR:
861         {
862             MKDIR3args *arg = (MKDIR3args *) args;
863 #ifdef AFS_SUN58_ENV
864             fhp1 = (nfs_fh3 *) arg->where.dirp;
865 #else
866             fhp1 = (nfs_fh3 *) & arg->where.dir;
867 #endif
868             break;
869         }
870     case NFSPROC3_SYMLINK:
871         {
872             SYMLINK3args *arg = (SYMLINK3args *) args;
873 #ifdef AFS_SUN58_ENV
874             fhp1 = (nfs_fh3 *) arg->where.dirp;
875 #else
876             fhp1 = (nfs_fh3 *) & arg->where.dir;
877 #endif
878             break;
879         }
880     case NFSPROC3_MKNOD:
881         {
882             MKNOD3args *arg = (MKNOD3args *) args;
883 #ifdef AFS_SUN58_ENV
884             fhp1 = (nfs_fh3 *) arg->where.dirp;
885 #else
886             fhp1 = (nfs_fh3 *) & arg->where.dir;
887 #endif
888             break;
889         }
890     case NFSPROC3_REMOVE:
891         {
892             REMOVE3args *arg = (REMOVE3args *) args;
893 #ifdef AFS_SUN58_ENV
894             fhp1 = (nfs_fh3 *) arg->object.dirp;
895 #else
896             fhp1 = (nfs_fh3 *) & arg->object.dir;
897 #endif
898             break;
899         }
900     case NFSPROC3_RMDIR:
901         {
902             RMDIR3args *arg = (RMDIR3args *) args;
903 #ifdef AFS_SUN58_ENV
904             fhp1 = (nfs_fh3 *) arg->object.dirp;
905 #else
906             fhp1 = (nfs_fh3 *) & arg->object.dir;
907 #endif
908             break;
909         }
910     case NFSPROC3_RENAME:
911         {
912             RENAME3args *arg = (RENAME3args *) args;
913 #ifdef AFS_SUN58_ENV
914             fhp1 = (nfs_fh3 *) arg->from.dirp;
915             fhp2 = (nfs_fh3 *) arg->to.dirp;
916 #else
917             fhp1 = (nfs_fh3 *) & arg->from.dir;
918             fhp2 = (nfs_fh3 *) & arg->to.dir;
919 #endif
920             break;
921         }
922     case NFSPROC3_LINK:
923         {
924             LINK3args *arg = (LINK3args *) args;
925             fhp1 = (nfs_fh3 *) & arg->file;
926 #ifdef AFS_SUN58_ENV
927             fhp2 = (nfs_fh3 *) arg->link.dirp;
928 #else
929             fhp2 = (nfs_fh3 *) & arg->link.dir;
930 #endif
931             break;
932         }
933     case NFSPROC3_READDIR:
934         {
935             READDIR3args *arg = (READDIR3args *) args;
936             fhp1 = (nfs_fh3 *) & arg->dir;
937             break;
938         }
939     case NFSPROC3_READDIRPLUS:
940         {
941             READDIRPLUS3args *arg = (READDIRPLUS3args *) args;
942             fhp1 = (nfs_fh3 *) & arg->dir;
943             break;
944         }
945     case NFSPROC3_FSSTAT:
946         {
947             FSSTAT3args *arg = (FSSTAT3args *) args;
948             fhp1 = (nfs_fh3 *) & arg->fsroot;
949             break;
950         }
951     case NFSPROC3_FSINFO:
952         {
953             FSINFO3args *arg = (FSINFO3args *) args;
954             fhp1 = (nfs_fh3 *) & arg->fsroot;
955             break;
956         }
957     case NFSPROC3_PATHCONF:
958         {
959             PATHCONF3args *arg = (PATHCONF3args *) args;
960             fhp1 = (nfs_fh3 *) & arg->object;
961             break;
962         }
963     case NFSPROC3_COMMIT:
964         {
965             COMMIT3args *arg = (COMMIT3args *) args;
966             fhp1 = (nfs_fh3 *) & arg->file;
967             break;
968         }
969     default:
970         return NULL;
971     }
972
973     if (fhp1 && is_afs_fh3(fhp1)) {
974         *fhpp = fhp1;
975         if (fhp2)
976             *fh2pp = fhp2;
977         return 1;
978     }
979     if (fhp2 && is_afs_fh3(fhp2)) {
980         *fhpp = fhp1;
981         *fh2pp = fhp2;
982         return 1;
983     }
984     return NULL;
985 }
986
987 afs_int32
988 acl3_to_afs_call(int which, caddr_t * args, nfs_fh3 ** fhpp)
989 {
990     nfs_fh3 *fhp;
991
992     switch (which) {
993     case ACLPROC3_GETACL:
994         {
995             struct GETACL3args *sargs = (struct GETACL3args *)args;
996             fhp = &sargs->fh;
997             break;
998         }
999     case ACLPROC3_SETACL:
1000         {
1001             struct SETACL3args *sargs = (struct SETACL3args *)args;
1002             fhp = &sargs->fh;
1003             break;
1004         }
1005 #if defined(AFS_SUN510_ENV) 
1006     case ACLPROC3_GETXATTRDIR:
1007         {
1008             struct GETXATTRDIR3args *sargs = (struct GETXATTRDIR3args *)args;
1009             fhp = &sargs->fh;
1010             break;
1011         }
1012 #endif
1013     default:
1014         return NULL;
1015     }
1016
1017     if (fhp && is_afs_fh3(fhp)) {
1018         *fhpp = fhp;
1019         return 1;
1020     }
1021
1022     return NULL;
1023 }
1024
1025 int
1026 afs_nfs3_dispatcher(int type, afs_int32 which, char *argp,
1027                     struct exportinfo **expp, struct svc_req *rp,
1028                     struct AFS_UCRED *crp)
1029 {
1030     afs_int32 call = 0;
1031     afs_int32 code = 0;
1032     afs_int32 client = 0;
1033     struct sockaddr *sa;
1034     nfs_fh3 *fh = (nfs_fh3 *) argp;
1035     nfs_fh3 *fh2 = (nfs_fh3 *) 0;
1036
1037     if (!xlatorinit_v3_done)
1038         return 2;
1039
1040     sa = (struct sockaddr *)svc_getrpccaller(rp->rq_xprt)->buf;
1041     if (sa == NULL) 
1042         return;
1043
1044     if (sa->sa_family == AF_INET)
1045         client = ((struct sockaddr_in *)sa)->sin_addr.s_addr;
1046
1047     AFS_GLOCK();
1048     code = 0;
1049     switch (type) {
1050     case 0:
1051         code = (client && nfs3_to_afs_call(which, argp, &fh, &fh2));
1052         break;
1053     case 1:
1054         code = (client && acl3_to_afs_call(which, argp, &fh));
1055         break;
1056     default:
1057         break;
1058     }
1059
1060     if (code) {
1061         struct afs_exporter *out = 0;
1062         afs_int32 dummy;
1063         static int once = 0;
1064         struct SmallFid Sfid;
1065
1066         memcpy((char *)&Sfid, fh->fh3_data, SIZEOF_SMALLFID);
1067
1068         afs_Trace2(afs_iclSetp, CM_TRACE_NFS3IN1, ICL_TYPE_INT32, client,
1069                    ICL_TYPE_FID, &Sfid);
1070
1071         call = 1;
1072         if (!once && *expp) {
1073             afs_nobody = (*expp)->exi_export.ex_anon;
1074             once = 1;
1075         }
1076         code =
1077             afs_nfsclient_reqhandler((struct afs_exporter *)0, &crp, client,
1078                                      &dummy, &out);
1079
1080         if (!code && out)
1081             EXP_RELE(out);
1082
1083
1084         if (code == EINVAL)
1085             call = 2;
1086     }
1087
1088     AFS_GUNLOCK();
1089     return call;
1090 }
1091
1092 void
1093 afs_nfs3_smallfidder(struct nfs_fh3 *fhp, int status)
1094 {
1095     afs_int32 addr[2];
1096     struct vcache *vcp;
1097
1098 #if defined(AFS_SUN57_64BIT_ENV)
1099     /* See also afs_fid() */
1100     memcpy((char *)addr, fhp->fh3_data, 10);
1101     addr[1] = (addr[1] >> 48) & 0xffff;
1102 #else
1103     memcpy((char *)addr, fhp->fh3_data, 2 * sizeof(long));
1104 #endif
1105
1106     AFS_GLOCK();
1107     vcp = VTOAFS((struct vnode *)addr[0]);
1108
1109     /* See also afs_osi_vget */
1110     if (addr[1] == AFS_XLATOR_MAGIC) {
1111         if (status == NFS_OK) {
1112             struct SmallFid Sfid;
1113             struct cell *tcell;
1114
1115             /* Make up and copy out a SmallFid */
1116             tcell = afs_GetCell(vcp->f.fid.Cell, READ_LOCK);
1117             Sfid.Volume = vcp->f.fid.Fid.Volume;
1118             Sfid.CellAndUnique =
1119                 ((tcell->cellIndex << 24) | (vcp->f.fid.Fid.Unique & 0xffffff));
1120             afs_PutCell(tcell, READ_LOCK);
1121             Sfid.Vnode = (u_short) (vcp->f.fid.Fid.Vnode & 0xffff);
1122             fhp->fh3_len = SIZEOF_SMALLFID;
1123             memcpy(fhp->fh3_data, (char *)&Sfid, fhp->fh3_len);
1124
1125             afs_Trace3(afs_iclSetp, CM_TRACE_NFS3OUT, ICL_TYPE_INT32, status,
1126                        ICL_TYPE_POINTER, vcp, ICL_TYPE_FID, &Sfid);
1127         }
1128
1129         /* If we have a ref, release it */
1130         if (vcp->vrefCount >= 1)
1131             AFS_RELE(AFSTOV(vcp));
1132     }
1133     AFS_GUNLOCK();
1134 }
1135
1136 void
1137 afs_nfs3_getattr(char *args, char *xp, char *exp, char *rp, char *crp)
1138 {
1139     u_int call;
1140     afs_nfs3_resp dummy;
1141     struct AFS_UCRED *svcred = curthread->t_cred;
1142     curthread->t_cred = (struct AFS_UCRED *)crp;
1143     call =
1144         afs_nfs3_dispatcher(0, NFSPROC3_GETATTR, (char *)args, &exp, rp, crp);
1145     if (call > 1)
1146         afs_nfs3_noaccess((struct afs_nfs3_resp *)xp);
1147     else
1148         (*afs_rfs3_disp_tbl[NFSPROC3_GETATTR].orig_proc) (args, xp, exp, rp,
1149                                                           crp);
1150     curthread->t_cred = svcred;
1151     return;
1152 }
1153
1154 void
1155 afs_nfs3_setattr(char *args, char *xp, char *exp, char *rp, char *crp)
1156 {
1157     u_int call;
1158     afs_nfs3_resp dummy;
1159     struct AFS_UCRED *svcred = curthread->t_cred;
1160     curthread->t_cred = (struct AFS_UCRED *)crp;
1161     call =
1162         afs_nfs3_dispatcher(0, NFSPROC3_SETATTR, (char *)args, &exp, rp, crp);
1163     if (call > 1)
1164         afs_nfs3_noaccess((struct afs_nfs3_resp *)xp);
1165     else
1166         (*afs_rfs3_disp_tbl[NFSPROC3_SETATTR].orig_proc) (args, xp, exp, rp,
1167                                                           crp);
1168     curthread->t_cred = svcred;
1169     return;
1170 }
1171
1172 void
1173 afs_nfs3_lookup(char *args, char *xp, char *exp, char *rp, char *crp)
1174 {
1175     u_int call;
1176     afs_nfs3_resp dummy;
1177     struct AFS_UCRED *svcred = curthread->t_cred;
1178     curthread->t_cred = (struct AFS_UCRED *)crp;
1179     call =
1180         afs_nfs3_dispatcher(0, NFSPROC3_LOOKUP, (char *)args, &exp, rp, crp);
1181     if (call > 1)
1182         afs_nfs3_noaccess((struct afs_nfs3_resp *)xp);
1183     else {
1184         (*afs_rfs3_disp_tbl[NFSPROC3_LOOKUP].orig_proc) (args, xp, exp, rp,
1185                                                          crp);
1186         if (afs_NFSRootOnly && call) {
1187             LOOKUP3res *resp = (LOOKUP3res *) xp;
1188             afs_nfs3_smallfidder(&resp->resok.object, resp->status);
1189         }
1190     }
1191     curthread->t_cred = svcred;
1192     return;
1193 }
1194
1195 void
1196 afs_nfs3_access(char *args, char *xp, char *exp, char *rp, char *crp)
1197 {
1198     u_int call;
1199     afs_nfs3_resp dummy;
1200     struct AFS_UCRED *svcred = curthread->t_cred;
1201     curthread->t_cred = (struct AFS_UCRED *)crp;
1202     call =
1203         afs_nfs3_dispatcher(0, NFSPROC3_ACCESS, (char *)args, &exp, rp, crp);
1204     if (call > 1)
1205         afs_nfs3_noaccess((struct afs_nfs3_resp *)xp);
1206     else
1207         (*afs_rfs3_disp_tbl[NFSPROC3_ACCESS].orig_proc) (args, xp, exp, rp,
1208                                                          crp);
1209     curthread->t_cred = svcred;
1210     return;
1211 }
1212
1213 void
1214 afs_nfs3_readlink(char *args, char *xp, char *exp, char *rp, char *crp)
1215 {
1216     u_int call;
1217     afs_nfs3_resp dummy;
1218     struct AFS_UCRED *svcred = curthread->t_cred;
1219     curthread->t_cred = (struct AFS_UCRED *)crp;
1220     call =
1221         afs_nfs3_dispatcher(0, NFSPROC3_READLINK, (char *)args, &exp, rp,
1222                             crp);
1223     if (call > 1)
1224         afs_nfs3_noaccess((struct afs_nfs3_resp *)xp);
1225     else
1226         (*afs_rfs3_disp_tbl[NFSPROC3_READLINK].orig_proc) (args, xp, exp, rp,
1227                                                            crp);
1228     curthread->t_cred = svcred;
1229     return;
1230 }
1231
1232 void
1233 afs_nfs3_read(char *args, char *xp, char *exp, char *rp, char *crp)
1234 {
1235     u_int call;
1236     afs_nfs3_resp dummy;
1237     struct AFS_UCRED *svcred = curthread->t_cred;
1238     curthread->t_cred = (struct AFS_UCRED *)crp;
1239     call = afs_nfs3_dispatcher(0, NFSPROC3_READ, (char *)args, &exp, rp, crp);
1240     if (call > 1)
1241         afs_nfs3_noaccess((struct afs_nfs3_resp *)xp);
1242     else
1243         (*afs_rfs3_disp_tbl[NFSPROC3_READ].orig_proc) (args, xp, exp, rp,
1244                                                        crp);
1245     curthread->t_cred = svcred;
1246     return;
1247 }
1248
1249 void
1250 afs_nfs3_write(char *args, char *xp, char *exp, char *rp, char *crp)
1251 {
1252     u_int call;
1253     afs_nfs3_resp dummy;
1254     struct AFS_UCRED *svcred = curthread->t_cred;
1255     curthread->t_cred = (struct AFS_UCRED *)crp;
1256     call =
1257         afs_nfs3_dispatcher(0, NFSPROC3_WRITE, (char *)args, &exp, rp, crp);
1258     if (call > 1)
1259         afs_nfs3_noaccess((struct afs_nfs3_resp *)xp);
1260     else
1261         (*afs_rfs3_disp_tbl[NFSPROC3_WRITE].orig_proc) (args, xp, exp, rp,
1262                                                         crp);
1263     curthread->t_cred = svcred;
1264     return;
1265 }
1266
1267 void
1268 afs_nfs3_create(char *args, char *xp, char *exp, char *rp, char *crp)
1269 {
1270     u_int call;
1271     afs_nfs3_resp dummy;
1272     struct AFS_UCRED *svcred = curthread->t_cred;
1273     curthread->t_cred = (struct AFS_UCRED *)crp;
1274     call =
1275         afs_nfs3_dispatcher(0, NFSPROC3_CREATE, (char *)args, &exp, rp, crp);
1276     if (call > 1)
1277         afs_nfs3_noaccess((struct afs_nfs3_resp *)xp);
1278     else {
1279         (*afs_rfs3_disp_tbl[NFSPROC3_CREATE].orig_proc) (args, xp, exp, rp,
1280                                                          crp);
1281         if (afs_NFSRootOnly && call) {
1282             CREATE3res *resp = (CREATE3res *) xp;
1283             afs_nfs3_smallfidder(&resp->resok.obj.handle, resp->status);
1284         }
1285     }
1286     curthread->t_cred = svcred;
1287     return;
1288 }
1289
1290 void
1291 afs_nfs3_mkdir(char *args, char *xp, char *exp, char *rp, char *crp)
1292 {
1293     u_int call;
1294     afs_nfs3_resp dummy;
1295     struct AFS_UCRED *svcred = curthread->t_cred;
1296     curthread->t_cred = (struct AFS_UCRED *)crp;
1297     call =
1298         afs_nfs3_dispatcher(0, NFSPROC3_MKDIR, (char *)args, &exp, rp, crp);
1299     if (call > 1)
1300         afs_nfs3_noaccess((struct afs_nfs3_resp *)xp);
1301     else {
1302         (*afs_rfs3_disp_tbl[NFSPROC3_MKDIR].orig_proc) (args, xp, exp, rp,
1303                                                         crp);
1304         if (afs_NFSRootOnly && call) {
1305             MKDIR3res *resp = (MKDIR3res *) xp;
1306             afs_nfs3_smallfidder(&resp->resok.obj.handle, resp->status);
1307         }
1308     }
1309     curthread->t_cred = svcred;
1310     return;
1311 }
1312
1313 void
1314 afs_nfs3_symlink(char *args, char *xp, char *exp, char *rp, char *crp)
1315 {
1316     u_int call;
1317     afs_nfs3_resp dummy;
1318     struct AFS_UCRED *svcred = curthread->t_cred;
1319     curthread->t_cred = (struct AFS_UCRED *)crp;
1320     call =
1321         afs_nfs3_dispatcher(0, NFSPROC3_SYMLINK, (char *)args, &exp, rp, crp);
1322     if (call > 1)
1323         afs_nfs3_noaccess((struct afs_nfs3_resp *)xp);
1324     else {
1325         (*afs_rfs3_disp_tbl[NFSPROC3_SYMLINK].orig_proc) (args, xp, exp, rp,
1326                                                           crp);
1327         if (afs_NFSRootOnly && call) {
1328             SYMLINK3res *resp = (SYMLINK3res *) xp;
1329             afs_nfs3_smallfidder(&resp->resok.obj.handle, resp->status);
1330         }
1331     }
1332     curthread->t_cred = svcred;
1333     return;
1334 }
1335
1336 void
1337 afs_nfs3_mknod(char *args, char *xp, char *exp, char *rp, char *crp)
1338 {
1339     u_int call;
1340     afs_nfs3_resp dummy;
1341     struct AFS_UCRED *svcred = curthread->t_cred;
1342     curthread->t_cred = (struct AFS_UCRED *)crp;
1343     call =
1344         afs_nfs3_dispatcher(0, NFSPROC3_MKNOD, (char *)args, &exp, rp, crp);
1345     if (call > 1)
1346         afs_nfs3_noaccess((struct afs_nfs3_resp *)xp);
1347     else {
1348         (*afs_rfs3_disp_tbl[NFSPROC3_MKNOD].orig_proc) (args, xp, exp, rp,
1349                                                         crp);
1350         if (afs_NFSRootOnly && call) {
1351             MKNOD3res *resp = (MKNOD3res *) xp;
1352             afs_nfs3_smallfidder(&resp->resok.obj.handle, resp->status);
1353         }
1354     }
1355     curthread->t_cred = svcred;
1356     return;
1357 }
1358
1359 void
1360 afs_nfs3_remove(char *args, char *xp, char *exp, char *rp, char *crp)
1361 {
1362     u_int call;
1363     afs_nfs3_resp dummy;
1364     struct AFS_UCRED *svcred = curthread->t_cred;
1365     curthread->t_cred = (struct AFS_UCRED *)crp;
1366     call =
1367         afs_nfs3_dispatcher(0, NFSPROC3_REMOVE, (char *)args, &exp, rp, crp);
1368     if (call > 1)
1369         afs_nfs3_noaccess((struct afs_nfs3_resp *)xp);
1370     else
1371         (*afs_rfs3_disp_tbl[NFSPROC3_REMOVE].orig_proc) (args, xp, exp, rp,
1372                                                          crp);
1373     curthread->t_cred = svcred;
1374     return;
1375 }
1376
1377 void
1378 afs_nfs3_rmdir(char *args, char *xp, char *exp, char *rp, char *crp)
1379 {
1380     u_int call;
1381     afs_nfs3_resp dummy;
1382     struct AFS_UCRED *svcred = curthread->t_cred;
1383     curthread->t_cred = (struct AFS_UCRED *)crp;
1384     call =
1385         afs_nfs3_dispatcher(0, NFSPROC3_RMDIR, (char *)args, &exp, rp, crp);
1386     if (call > 1)
1387         afs_nfs3_noaccess((struct afs_nfs3_resp *)xp);
1388     else
1389         (*afs_rfs3_disp_tbl[NFSPROC3_RMDIR].orig_proc) (args, xp, exp, rp,
1390                                                         crp);
1391     curthread->t_cred = svcred;
1392     return;
1393 }
1394
1395 void
1396 afs_nfs3_rename(char *args, char *xp, char *exp, char *rp, char *crp)
1397 {
1398     u_int call;
1399     afs_nfs3_resp dummy;
1400     struct AFS_UCRED *svcred = curthread->t_cred;
1401     curthread->t_cred = (struct AFS_UCRED *)crp;
1402     call =
1403         afs_nfs3_dispatcher(0, NFSPROC3_RENAME, (char *)args, &exp, rp, crp);
1404     if (call > 1)
1405         afs_nfs3_noaccess((struct afs_nfs3_resp *)xp);
1406     else
1407         (*afs_rfs3_disp_tbl[NFSPROC3_RENAME].orig_proc) (args, xp, exp, rp,
1408                                                          crp);
1409     curthread->t_cred = svcred;
1410     return;
1411 }
1412
1413 void
1414 afs_nfs3_link(char *args, char *xp, char *exp, char *rp, char *crp)
1415 {
1416     u_int call;
1417     afs_nfs3_resp dummy;
1418     struct AFS_UCRED *svcred = curthread->t_cred;
1419     curthread->t_cred = (struct AFS_UCRED *)crp;
1420     call = afs_nfs3_dispatcher(0, NFSPROC3_LINK, (char *)args, &exp, rp, crp);
1421     if (call > 1)
1422         afs_nfs3_noaccess((struct afs_nfs3_resp *)xp);
1423     else
1424         (*afs_rfs3_disp_tbl[NFSPROC3_LINK].orig_proc) (args, xp, exp, rp,
1425                                                        crp);
1426     curthread->t_cred = svcred;
1427     return;
1428 }
1429
1430 void
1431 afs_nfs3_readdir(char *args, char *xp, char *exp, char *rp, char *crp)
1432 {
1433     u_int call;
1434     afs_nfs3_resp dummy;
1435     struct AFS_UCRED *svcred = curthread->t_cred;
1436     curthread->t_cred = (struct AFS_UCRED *)crp;
1437     call =
1438         afs_nfs3_dispatcher(0, NFSPROC3_READDIR, (char *)args, &exp, rp, crp);
1439     if (call > 1)
1440         afs_nfs3_noaccess((struct afs_nfs3_resp *)xp);
1441     else
1442         (*afs_rfs3_disp_tbl[NFSPROC3_READDIR].orig_proc) (args, xp, exp, rp,
1443                                                           crp);
1444     curthread->t_cred = svcred;
1445     return;
1446 }
1447
1448 void
1449 afs_nfs3_readdirplus(char *args, char *xp, char *exp, char *rp, char *crp)
1450 {
1451     u_int call;
1452     afs_nfs3_resp dummy;
1453     struct AFS_UCRED *svcred = curthread->t_cred;
1454     curthread->t_cred = (struct AFS_UCRED *)crp;
1455     call =
1456         afs_nfs3_dispatcher(0, NFSPROC3_READDIRPLUS, (char *)args, &exp, rp,
1457                             crp);
1458     if (call > 1)
1459         afs_nfs3_noaccess((struct afs_nfs3_resp *)xp);
1460     else if (call == 1)
1461         afs_nfs3_notsupp((struct afs_nfs3_resp *)xp);
1462     else
1463         (*afs_rfs3_disp_tbl[NFSPROC3_READDIRPLUS].orig_proc) (args, xp, exp,
1464                                                               rp, crp);
1465     curthread->t_cred = svcred;
1466     return;
1467 }
1468
1469 void
1470 afs_nfs3_fsstat(char *args, char *xp, char *exp, char *rp, char *crp)
1471 {
1472     u_int call;
1473     afs_nfs3_resp dummy;
1474     struct AFS_UCRED *svcred = curthread->t_cred;
1475     curthread->t_cred = (struct AFS_UCRED *)crp;
1476     call =
1477         afs_nfs3_dispatcher(0, NFSPROC3_FSSTAT, (char *)args, &exp, rp, crp);
1478     if (call > 1)
1479         afs_nfs3_noaccess((struct afs_nfs3_resp *)xp);
1480     else
1481         (*afs_rfs3_disp_tbl[NFSPROC3_FSSTAT].orig_proc) (args, xp, exp, rp,
1482                                                          crp);
1483     curthread->t_cred = svcred;
1484     return;
1485 }
1486
1487 void
1488 afs_nfs3_fsinfo(char *args, char *xp, char *exp, char *rp, char *crp)
1489 {
1490     u_int call;
1491     afs_nfs3_resp dummy;
1492     struct AFS_UCRED *svcred = curthread->t_cred;
1493     curthread->t_cred = (struct AFS_UCRED *)crp;
1494     call =
1495         afs_nfs3_dispatcher(0, NFSPROC3_FSINFO, (char *)args, &exp, rp, crp);
1496     if (call > 1)
1497         afs_nfs3_noaccess((struct afs_nfs3_resp *)xp);
1498     else
1499         (*afs_rfs3_disp_tbl[NFSPROC3_FSINFO].orig_proc) (args, xp, exp, rp,
1500                                                          crp);
1501     curthread->t_cred = svcred;
1502     return;
1503 }
1504
1505 void
1506 afs_nfs3_pathconf(char *args, char *xp, char *exp, char *rp, char *crp)
1507 {
1508     u_int call;
1509     afs_nfs3_resp dummy;
1510     struct AFS_UCRED *svcred = curthread->t_cred;
1511     curthread->t_cred = (struct AFS_UCRED *)crp;
1512     call =
1513         afs_nfs3_dispatcher(0, NFSPROC3_PATHCONF, (char *)args, &exp, rp,
1514                             crp);
1515     if (call > 1)
1516         afs_nfs3_noaccess((struct afs_nfs3_resp *)xp);
1517     else
1518         (*afs_rfs3_disp_tbl[NFSPROC3_PATHCONF].orig_proc) (args, xp, exp, rp,
1519                                                            crp);
1520     curthread->t_cred = svcred;
1521     return;
1522 }
1523
1524 void
1525 afs_nfs3_commit(char *args, char *xp, char *exp, char *rp, char *crp)
1526 {
1527     u_int call;
1528     afs_nfs3_resp dummy;
1529     struct AFS_UCRED *svcred = curthread->t_cred;
1530     curthread->t_cred = (struct AFS_UCRED *)crp;
1531     call =
1532         afs_nfs3_dispatcher(0, NFSPROC3_COMMIT, (char *)args, &exp, rp, crp);
1533     if (call > 1)
1534         afs_nfs3_noaccess((struct afs_nfs3_resp *)xp);
1535     else
1536         (*afs_rfs3_disp_tbl[NFSPROC3_COMMIT].orig_proc) (args, xp, exp, rp,
1537                                                          crp);
1538     curthread->t_cred = svcred;
1539     return;
1540 }
1541
1542 struct afs_nfs_disp_tbl afs_rfs3_disp_tbl[22] = {
1543     {afs_nfs2_null},
1544     {afs_nfs3_getattr},
1545     {afs_nfs3_setattr},
1546     {afs_nfs3_lookup},
1547     {afs_nfs3_access},
1548     {afs_nfs3_readlink},
1549     {afs_nfs3_read},
1550     {afs_nfs3_write},
1551     {afs_nfs3_create},
1552     {afs_nfs3_mkdir},
1553     {afs_nfs3_symlink},
1554     {afs_nfs3_mknod},
1555     {afs_nfs3_remove},
1556     {afs_nfs3_rmdir},
1557     {afs_nfs3_rename},
1558     {afs_nfs3_link},
1559     {afs_nfs3_readdir},
1560     {afs_nfs3_readdirplus},
1561     {afs_nfs3_fsstat},
1562     {afs_nfs3_fsinfo},
1563     {afs_nfs3_pathconf},
1564     {afs_nfs3_commit}
1565 };
1566
1567 void
1568 afs_acl3_getacl(char *args, char *xp, char *exp, char *rp, char *crp)
1569 {
1570     u_int call;
1571     struct AFS_UCRED *svcred = curthread->t_cred;
1572     curthread->t_cred = (struct AFS_UCRED *)crp;
1573     call =
1574         afs_nfs3_dispatcher(1, ACLPROC3_GETACL, (char *)args, &exp, rp, crp);
1575     if (call > 1)
1576         afs_nfs3_noaccess((struct afs_nfs3_resp *)xp);
1577     else
1578         (*afs_acl3_disp_tbl[ACLPROC3_GETACL].orig_proc) (args, xp, exp, rp,
1579                                                          crp);
1580     curthread->t_cred = svcred;
1581     return;
1582 }
1583
1584 void
1585 afs_acl3_setacl(char *args, char *xp, char *exp, char *rp, char *crp)
1586 {
1587     u_int call;
1588     struct AFS_UCRED *svcred = curthread->t_cred;
1589     curthread->t_cred = (struct AFS_UCRED *)crp;
1590     call =
1591         afs_nfs3_dispatcher(1, ACLPROC3_SETACL, (char *)args, &exp, rp, crp);
1592     if (call > 1)
1593         afs_nfs3_noaccess((struct afs_nfs3_resp *)xp);
1594     else
1595         (*afs_acl3_disp_tbl[ACLPROC3_SETACL].orig_proc) (args, xp, exp, rp,
1596                                                          crp);
1597     curthread->t_cred = svcred;
1598     return;
1599 }
1600
1601 #if defined(AFS_SUN510_ENV) 
1602 void
1603 afs_acl3_getxattrdir(char *args, char *xp, char *exp, char *rp, char *crp)
1604 {
1605     u_int call;
1606     struct AFS_UCRED *svcred = curthread->t_cred;
1607     curthread->t_cred = (struct AFS_UCRED *)crp;
1608     call =
1609         afs_nfs3_dispatcher(1, ACLPROC3_GETXATTRDIR, (char *)args, &exp, rp, crp);
1610     if (call > 1)
1611         afs_nfs3_noaccess((struct afs_nfs3_resp *)xp);
1612     else
1613         (*afs_acl3_disp_tbl[ACLPROC3_GETXATTRDIR].orig_proc) (args, xp, exp, rp,
1614                                                          crp);
1615     curthread->t_cred = svcred;
1616     return;
1617 }
1618 #endif
1619
1620 struct afs_nfs_disp_tbl afs_acl3_disp_tbl[ACL3_NPROC] = {
1621     {afs_nfs2_null},
1622     {afs_acl3_getacl},
1623     {afs_acl3_setacl},
1624 #if defined(AFS_SUN510_ENV) 
1625     {afs_acl3_getxattrdir},
1626 #endif
1627 };
1628
1629 /* Munge the dispatch tables to link us in first */
1630 void
1631 afs_xlatorinit_v3(struct rfs_disp_tbl *_rfs_tbl,
1632                   struct rfs_disp_tbl *_acl_tbl)
1633 {
1634     int i;
1635
1636     if (xlatorinit_v3_done++)
1637         return;
1638
1639     for (i = 0; i < 22; i++) {
1640         afs_rfs3_disp_tbl[i].orig_proc = _rfs_tbl[i].dis_proc;
1641         _rfs_tbl[i].dis_proc = afs_rfs3_disp_tbl[i].afs_proc;
1642     }
1643
1644     for (i = 0; i < 3; i++) {
1645         afs_acl3_disp_tbl[i].orig_proc = _acl_tbl[i].dis_proc;
1646         _acl_tbl[i].dis_proc = afs_acl3_disp_tbl[i].afs_proc;
1647     }
1648 }
1649 #endif /* !defined(AFS_NONFSTRANS) */