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