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