libafs-prototypes-20081129
[openafs.git] / src / afs / afs_nfsclnt.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  * 
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 #include <afsconfig.h>
11 #include "afs/param.h"
12
13 RCSID
14     ("$Header$");
15
16 #if !defined(AFS_NONFSTRANS) || defined(AFS_AIX_IAUTH_ENV)
17 #include "afs/sysincludes.h"    /* Standard vendor system headers */
18 #include "afsincludes.h"        /* Afs-based standard headers */
19 #include "afs/afs_stats.h"      /* statistics */
20 #include "afs/nfsclient.h"
21 #include "rx/rx_globals.h"
22 #include "afs/pagcb.h"
23
24 void afs_nfsclient_hold(), afs_PutNfsClientPag(), afs_nfsclient_GC();
25 static void afs_nfsclient_getcreds();
26 int afs_nfsclient_sysname(), afs_nfsclient_stats(), afs_nfsclient_checkhost();
27 afs_int32 afs_nfsclient_gethost();
28 #ifdef AFS_AIX_IAUTH_ENV
29 int afs_allnfsreqs, afs_nfscalls;
30 #endif
31
32 /* routines exported to the "AFS exporter" layer */
33 struct exporterops nfs_exportops = {
34     afs_nfsclient_reqhandler,
35     afs_nfsclient_hold,
36     afs_PutNfsClientPag,        /* Used to be afs_nfsclient_rele */
37     afs_nfsclient_sysname,
38     afs_nfsclient_GC,
39     afs_nfsclient_stats,
40     afs_nfsclient_checkhost,
41     afs_nfsclient_gethost
42 };
43
44
45 struct nfsclientpag *afs_nfspags[NNFSCLIENTS];
46 afs_lock_t afs_xnfspag /*, afs_xnfsreq */ ;
47 extern struct afs_exporter *afs_nfsexporter;
48
49 /* Creates an nfsclientpag structure for the (uid, host) pair if one doesn't 
50  * exist. RefCount is incremented and it's time stamped. */
51 static struct nfsclientpag *
52 afs_GetNfsClientPag(register afs_int32 uid, register afs_int32 host)
53 {
54     register struct nfsclientpag *np;
55     register afs_int32 i, now;
56
57 #if defined(AFS_SGIMP_ENV)
58     osi_Assert(ISAFS_GLOCK());
59 #endif
60     AFS_STATCNT(afs_GetNfsClientPag);
61     i = NHash(host);
62     now = osi_Time();
63     MObtainWriteLock(&afs_xnfspag, 314);
64     for (np = afs_nfspags[i]; np; np = np->next) {
65         if (np->uid == uid && np->host == host) {
66             np->refCount++;
67             np->lastcall = now;
68             MReleaseWriteLock(&afs_xnfspag);
69             return np;
70         }
71     }
72     /* next try looking for NOPAG dude, if we didn't find an exact match */
73     for (np = afs_nfspags[i]; np; np = np->next) {
74         if (np->uid == NOPAG && np->host == host) {
75             np->refCount++;
76             np->lastcall = now;
77             MReleaseWriteLock(&afs_xnfspag);
78             return np;
79         }
80     }
81     np = (struct nfsclientpag *)afs_osi_Alloc(sizeof(struct nfsclientpag));
82     memset((char *)np, 0, sizeof(struct nfsclientpag));
83     /* Copy the necessary afs_exporter fields */
84     memcpy((char *)np, (char *)afs_nfsexporter, sizeof(struct afs_exporter));
85     np->next = afs_nfspags[i];
86     afs_nfspags[i] = np;
87     np->uid = uid;
88     np->host = host;
89     np->refCount = 1;
90     np->lastcall = now;
91     MReleaseWriteLock(&afs_xnfspag);
92     return np;
93 }
94
95
96 /* Decrement refCount; must always match a previous afs_FindNfsClientPag/afs_GetNfsClientPag call .
97 It's also called whenever a unixuser structure belonging to the remote user associated with the nfsclientpag structure, np, is garbage collected. */
98 void
99 afs_PutNfsClientPag(np)
100      register struct nfsclientpag *np;
101 {
102 #if defined(AFS_SGIMP_ENV)
103     osi_Assert(ISAFS_GLOCK());
104 #endif
105     AFS_STATCNT(afs_PutNfsClientPag);
106     --np->refCount;
107 }
108
109
110 /* Return the nfsclientpag structure associated with the (uid, host) or 
111  * {pag, host} pair, if pag is nonzero. RefCount is incremented and it's 
112  * time stamped. */
113 static struct nfsclientpag *
114 afs_FindNfsClientPag(afs_int32 uid, afs_int32 host, afs_int32 pag)
115 {
116     register struct nfsclientpag *np;
117     register afs_int32 i;
118
119 #if defined(AFS_SGIMP_ENV)
120     osi_Assert(ISAFS_GLOCK());
121 #endif
122     AFS_STATCNT(afs_FindNfsClientPag);
123     i = NHash(host);
124     MObtainWriteLock(&afs_xnfspag, 315);
125     for (np = afs_nfspags[i]; np; np = np->next) {
126         if (np->host == host) {
127             if ((pag && pag == np->pag) || (!pag && (uid == np->uid))) {
128                 np->refCount++;
129                 np->lastcall = osi_Time();
130                 MReleaseWriteLock(&afs_xnfspag);
131                 return np;
132             }
133         }
134     }
135     /* still not there, try looking for a wildcard dude */
136     for (np = afs_nfspags[i]; np; np = np->next) {
137         if (np->host == host) {
138             if (np->uid == NOPAG) {
139                 np->refCount++;
140                 np->lastcall = osi_Time();
141                 MReleaseWriteLock(&afs_xnfspag);
142                 return np;
143             }
144         }
145     }
146     MReleaseWriteLock(&afs_xnfspag);
147     return NULL;
148 }
149
150
151 /* routine to initialize the exporter, made global so we can call it
152  * from pioctl calls.
153  */
154 struct afs_exporter *afs_nfsexported = 0;
155 static afs_int32 init_nfsexporter = 0;
156
157 void
158 afs_nfsclient_init(void)
159 {
160 #if defined(AFS_SGIMP_ENV)
161     osi_Assert(ISAFS_GLOCK());
162 #endif
163     if (!init_nfsexporter) {
164         extern struct afs_exporter *exporter_add();
165
166         init_nfsexporter = 1;
167         LOCK_INIT(&afs_xnfspag, "afs_xnfspag");
168         afs_nfsexported =
169             exporter_add(0, &nfs_exportops, EXP_EXPORTED, EXP_NFS, NULL);
170     }
171 }
172
173
174 /* Main handler routine for the NFS exporter. It's called in the early
175  * phases of any remote call (via the NFS server or pioctl).
176  */
177 int
178 afs_nfsclient_reqhandler(struct afs_exporter *exporter,
179                          struct AFS_UCRED **cred,
180                          afs_int32 host, afs_int32 *pagparam,
181                          struct afs_exporter **outexporter)
182 {
183     register struct nfsclientpag *np, *tnp;
184     extern struct unixuser *afs_FindUser(), *afs_GetUser();
185     register struct unixuser *au = 0;
186     afs_int32 uid, pag, code = 0;
187
188     AFS_ASSERT_GLOCK();
189     AFS_STATCNT(afs_nfsclient_reqhandler);
190     if (!afs_nfsexporter)
191         afs_nfsexporter = afs_nfsexported;
192
193     afs_nfsexporter->exp_stats.calls++;
194     if (!(afs_nfsexporter->exp_states & EXP_EXPORTED)) {
195         /* No afs requests accepted as long as EXPORTED flag is turned 'off'. 
196          * Set/Reset via a pioctl call (fs exportafs). Note that this is on 
197          * top of the /etc/exports nfs requirement (i.e. /afs must be 
198          * exported to all or whomever there too!)
199          */
200         afs_nfsexporter->exp_stats.rejectedcalls++;
201         return EINVAL;
202     }
203 /*    ObtainWriteLock(&afs_xnfsreq); */
204     pag = PagInCred(*cred);
205 #if defined(AFS_SUN510_ENV)
206     uid = crgetuid(*cred);
207 #else
208     uid = (*cred)->cr_uid;
209 #endif
210     /* Do this early, so pag management knows */
211 #ifdef  AFS_OSF_ENV
212     (*cred)->cr_ruid = NFSXLATOR_CRED;  /* Identify it as nfs xlator call */
213 #else
214     (*cred)->cr_rgid = NFSXLATOR_CRED;  /* Identify it as nfs xlator call */
215 #endif
216     if ((afs_nfsexporter->exp_states & EXP_CLIPAGS) && pag != NOPAG) {
217         uid = pag;
218     } else if (pag != NOPAG) {
219         /* Do some minimal pag verification */
220         if (pag > getpag()) {
221             pag = NOPAG;        /* treat it as not paged since couldn't be good  */
222         } else {
223             if ((au = afs_FindUser(pag, -1, READ_LOCK))) {
224                 if (!au->exporter) {
225                     pag = NOPAG;
226                     afs_PutUser(au, READ_LOCK);
227                     au = NULL;
228                 }
229             } else
230                 pag = NOPAG;    /*  No unixuser struct so pag not trusted  */
231         }
232     }
233     np = afs_FindNfsClientPag(uid, host, 0);
234     afs_Trace4(afs_iclSetp, CM_TRACE_NFSREQH, ICL_TYPE_INT32, pag,
235                ICL_TYPE_LONG, (*cred)->cr_uid, ICL_TYPE_INT32, host,
236                ICL_TYPE_POINTER, np);
237     /* If remote-pags are enabled, we are no longer interested in what PAG
238      * they claimed, and from here on we should behave as if they claimed
239      * none at all, which is to say we use the (local) pag named in the
240      * nfsclientpag structure (if any).  This is deferred until here so
241      * that we can log the PAG they claimed.
242      */
243     if ((afs_nfsexporter->exp_states & EXP_CLIPAGS))
244         pag = NOPAG;
245     if (!np) {
246         /* Even if there is a "good" pag coming in we don't accept it if no 
247          * nfsclientpag struct exists for the user since that would mean 
248          * that the translator rebooted and therefore we ignore all older 
249          * pag values 
250          */
251 #ifdef  AFS_OSF_ENV
252         if (code = setpag(u.u_procp, cred, -1, &pag, 0)) {      /* XXX u.u_procp is a no-op XXX */
253 #else
254         if ((code = setpag(cred, -1, &pag, 0))) {
255 #endif
256             if (au)
257                 afs_PutUser(au, READ_LOCK);
258 /*          ReleaseWriteLock(&afs_xnfsreq);             */
259 #if defined(KERNEL_HAVE_UERROR)
260             setuerror(code);
261 #endif
262             return (code);
263         }
264         np = afs_GetNfsClientPag(uid, host);
265         np->pag = pag;
266         np->client_uid = (*cred)->cr_uid;
267     } else {
268         if (pag == NOPAG) {
269 #ifdef  AFS_OSF_ENV
270             if (code = setpag(u.u_procp, cred, np->pag, &pag, 0)) {     /* XXX u.u_procp is a no-op XXX */
271 #else
272             if ((code = setpag(cred, np->pag, &pag, 0))) {
273 #endif
274                 afs_PutNfsClientPag(np);
275 /*              ReleaseWriteLock(&afs_xnfsreq); */
276 #if defined(KERNEL_HAVE_UERROR)
277                 setuerror(code);
278 #endif
279                 return (code);
280             }
281         } else if (au->exporter
282                    && ((struct afs_exporter *)np != au->exporter)) {
283             tnp = (struct nfsclientpag *)au->exporter;
284             if (tnp->uid && (tnp->uid != (afs_int32) - 2)) {    /* allow "root" initiators */
285                 /* Pag doesn't belong to caller; treat it as an unpaged call too */
286 #ifdef  AFS_OSF_ENV
287                 if (code = setpag(u.u_procp, cred, np->pag, &pag, 0)) { /* XXX u.u_procp is a no-op XXX */
288 #else
289                 if ((code = setpag(cred, np->pag, &pag, 0))) {
290 #endif
291                     afs_PutNfsClientPag(np);
292                     afs_PutUser(au, READ_LOCK);
293                     /*      ReleaseWriteLock(&afs_xnfsreq);     */
294 #if defined(KERNEL_HAVE_UERROR)
295                     setuerror(code);
296 #endif
297                     return (code);
298                 }
299                 afs_nfsexporter->exp_stats.invalidpag++;
300             }
301         }
302     }
303     if (au)
304         afs_PutUser(au, READ_LOCK);
305     au = afs_GetUser(pag, -1, WRITE_LOCK);
306     if (!(au->exporter)) {      /* Created new unixuser struct */
307         np->refCount++;         /* so it won't disappear */
308         au->exporter = (struct afs_exporter *)np;
309         if ((afs_nfsexporter->exp_states & EXP_CALLBACK))
310             afs_nfsclient_getcreds(au);
311     } else while (au->states & UNFSGetCreds) {
312         afs_osi_Sleep((void *)au);
313     }
314     *pagparam = pag;
315     *outexporter = (struct afs_exporter *)np;
316     afs_PutUser(au, WRITE_LOCK);
317 /*    ReleaseWriteLock(&afs_xnfsreq);   */
318     return 0;
319 }
320
321 void
322 afs_nfsclient_getcreds(au)
323     struct unixuser *au;
324 {
325     struct nfsclientpag *np = (struct nfsclientpag *)(au->exporter);
326     struct rx_securityClass *csec;
327     struct rx_connection *tconn;
328     SysNameList tsysnames;
329     CredInfos tcreds;
330     CredInfo *tcred;
331     struct unixuser *tu;
332     struct cell *tcell;
333     int code, i, cellnum;
334
335     au->states |= UNFSGetCreds;
336     memset(&tcreds, 0, sizeof(tcreds));
337     memset(&tsysnames, 0, sizeof(tsysnames));
338
339     /* Get a connection */
340     /* This sucks a little.  We should cache the connections or something.
341      * But at this point I don't yet think it's worth the effort.
342      */
343     csec = rxnull_NewClientSecurityObject();
344     AFS_GUNLOCK();
345     tconn = rx_NewConnection(np->host, htons(7001), PAGCB_SERVICEID, csec, 0);
346     AFS_GLOCK();
347
348     /* Get the sysname, if needed */
349     if (!np->sysnamecount) {
350         AFS_GUNLOCK();
351         code = PAGCB_GetSysName(tconn, np->uid, &tsysnames);
352         AFS_GLOCK();
353         if (code ||
354             tsysnames.SysNameList_len <= 0 ||
355             tsysnames.SysNameList_len > MAXNUMSYSNAMES)
356             goto done;
357     
358         for(i = 0; i < np->sysnamecount; i++)
359             afs_osi_Free(np->sysname[i], MAXSYSNAME);
360
361         np->sysnamecount = tsysnames.SysNameList_len;
362         for(i = 0; i < np->sysnamecount; i++)
363             np->sysname[i] = tsysnames.SysNameList_val[i].sysname;
364         afs_osi_Free(tsysnames.SysNameList_val,
365                      tsysnames.SysNameList_len * sizeof(SysNameEnt));
366     }
367
368     /* Get credentials */
369     AFS_GUNLOCK();
370     code = PAGCB_GetCreds(tconn, np->uid, &tcreds);
371     AFS_GLOCK();
372     if (code)
373         goto done;
374
375     /* Now, set the credentials they gave us... */
376     for (i = 0; i < tcreds.CredInfos_len; i++) {
377         tcred = &tcreds.CredInfos_val[i];
378
379         /* Find the cell.  If it is unknown to us, punt this entry. */
380         tcell = afs_GetCellByName(tcred->cellname, READ_LOCK);
381         afs_osi_Free(tcred->cellname, strlen(tcred->cellname) + 1);
382         if (!tcell) {
383             memset(tcred->ct.HandShakeKey, 0, 8);
384             memset(tcred->st.st_val, 0, tcred->st.st_len);
385             afs_osi_Free(tcred->st.st_val, tcred->st.st_len);
386             continue;
387         }
388         cellnum = tcell->cellNum;
389         afs_PutCell(tcell, READ_LOCK);
390
391         /* Find the appropriate unixuser.  This might be the same as
392          * the one we were passed (au), but that's OK.
393          */
394         tu = afs_GetUser(np->pag, cellnum, WRITE_LOCK);
395         if (!(tu->exporter)) {  /* Created new unixuser struct */
396             np->refCount++;             /* so it won't disappear */
397             tu->exporter = (struct afs_exporter *)np;
398         }
399
400         /* free any old secret token, and keep the new one */
401         if (tu->stp != NULL) {
402             afs_osi_Free(tu->stp, tu->stLen);
403         }
404         tu->stp = tcred->st.st_val;
405         tu->stLen = tcred->st.st_len;
406
407         /* copy the clear token */
408         memset(&tu->ct, 0, sizeof(tu->ct));
409         memcpy(tu->ct.HandShakeKey, tcred->ct.HandShakeKey, 8);
410         memset(tcred->ct.HandShakeKey, 0, 8);
411         tu->ct.AuthHandle     = tcred->ct.AuthHandle;
412         tu->ct.ViceId         = tcred->ct.ViceId;
413         tu->ct.BeginTimestamp = tcred->ct.BeginTimestamp;
414         tu->ct.EndTimestamp   = tcred->ct.EndTimestamp;
415
416         /* Set everything else, reset connections, and move on. */
417         tu->vid = tcred->vid;
418         tu->states |= UHasTokens;
419         tu->states &= ~UTokensBad;
420         afs_SetPrimary(tu, !!(tcred->states & UPrimary));
421         tu->tokenTime = osi_Time();
422         afs_ResetUserConns(tu);
423         afs_PutUser(tu, WRITE_LOCK);
424     }
425     afs_osi_Free(tcreds.CredInfos_val, tcreds.CredInfos_len * sizeof(CredInfo));
426
427 done:
428     AFS_GUNLOCK();
429     rx_DestroyConnection(tconn);
430     AFS_GLOCK();
431     au->states &= ~UNFSGetCreds;
432     afs_osi_Wakeup((void *)au);
433 }
434
435
436 /* It's called whenever a new unixuser structure is created for the remote user associated with the nfsclientpag structure, np */
437 void
438 afs_nfsclient_hold(np)
439      register struct nfsclientpag *np;
440 {
441 #if defined(AFS_SGIMP_ENV)
442     osi_Assert(ISAFS_GLOCK());
443 #endif
444     AFS_STATCNT(afs_nfsclient_hold);
445     np->refCount++;
446 }
447
448
449 /* check if this exporter corresponds to the specified host */
450 int
451 afs_nfsclient_checkhost(np, host)
452     register struct nfsclientpag *np;
453 {
454     if (np->type != EXP_NFS)
455         return 0;
456     return np->host == host;
457 }
458
459
460 /* get the host for this exporter, or 0 if there is an error */
461 afs_int32
462 afs_nfsclient_gethost(np)
463     register struct nfsclientpag *np;
464 {
465     if (np->type != EXP_NFS)
466         return 0;
467     return np->host;
468 }
469
470
471 /* if inname is non-null, a new system name value is set for the remote user (inname contains the new sysname). In all cases, outname returns the current sysname value for this remote user */
472 int 
473 afs_nfsclient_sysname(register struct nfsclientpag *np, char *inname, 
474                       char ***outname, int *num, int allpags)
475 {
476     register struct nfsclientpag *tnp;
477     register afs_int32 i;
478     char *cp;
479     int count, t;
480 #if defined(AFS_SGIMP_ENV)
481     osi_Assert(ISAFS_GLOCK());
482 #endif
483     AFS_STATCNT(afs_nfsclient_sysname);
484     if (allpags > 0) {
485         /* update every client, not just the one making the request */
486         i = NHash(np->host);
487         MObtainWriteLock(&afs_xnfspag, 315);
488         for (tnp = afs_nfspags[i]; tnp; tnp = tnp->next) {
489             if (tnp != np && tnp->host == np->host)
490                 afs_nfsclient_sysname(tnp, inname, outname, num, -1);
491         }
492         MReleaseWriteLock(&afs_xnfspag);
493     }
494     if (inname) {
495             for(count=0; count < np->sysnamecount;++count) {
496                 afs_osi_Free(np->sysname[count], MAXSYSNAME);
497                 np->sysname[count] = NULL;
498             }
499         for(count=0; count < *num;++count) {
500             np->sysname[count]= afs_osi_Alloc(MAXSYSNAME);
501         }
502         cp = inname;
503         for(count=0; count < *num;++count) {
504             t = strlen(cp);
505             memcpy(np->sysname[count], cp, t+1); /* include null */
506             cp += t+1;
507         }
508         np->sysnamecount = *num;
509     }
510     if (allpags >= 0) {
511         /* Don't touch our arguments when called recursively */
512         *outname = np->sysname;
513         *num = np->sysnamecount;
514         if (!np->sysname[0])
515             return ENODEV; /* XXX */
516     }
517     return 0;
518 }
519
520
521 /* Garbage collect routine for the nfs exporter. When pag is -1 then all entries are removed (used by the nfsclient_shutdown routine); else if it's non zero then only the entry with that pag is removed, else all "timedout" entries are removed. TimedOut entries are those who have no "unixuser" structures associated with them (i.e. unixusercnt == 0) and they haven't had any activity the last NFSCLIENTGC seconds */
522 void
523 afs_nfsclient_GC(exporter, pag)
524      register struct afs_exporter *exporter;
525      register afs_int32 pag;
526 {
527     register struct nfsclientpag *np, **tnp, *nnp;
528     register afs_int32 i, delflag;
529         int count;
530
531 #if defined(AFS_SGIMP_ENV)
532     osi_Assert(ISAFS_GLOCK());
533 #endif
534     AFS_STATCNT(afs_nfsclient_GC);
535     MObtainWriteLock(&afs_xnfspag, 316);
536     for (i = 0; i < NNFSCLIENTS; i++) {
537         for (tnp = &afs_nfspags[i], np = *tnp; np; np = nnp) {
538             nnp = np->next;
539             delflag = 0;
540             if (np->refCount == 0 && np->lastcall < osi_Time() - NFSCLIENTGC)
541                 delflag = 1;
542             if ((pag == -1) || (!pag && delflag)
543                 || (pag && (np->refCount == 0) && (np->pag == pag))) {
544                 *tnp = np->next;
545                 for(count=0; count < np->sysnamecount;++count) {
546                         afs_osi_Free(np->sysname[count], MAXSYSNAME);
547                 }
548                 afs_osi_Free(np, sizeof(struct nfsclientpag));
549             } else {
550                 tnp = &np->next;
551             }
552         }
553     }
554     MReleaseWriteLock(&afs_xnfspag);
555 }
556
557
558 int
559 afs_nfsclient_stats(register struct afs_exporter *export)
560 {
561     /* Nothing much to do here yet since most important stats are collected 
562      * directly in the afs_exporter structure itself */
563     AFS_STATCNT(afs_nfsclient_stats);
564     return 0;
565 }
566
567 #ifdef AFS_AIX41_ENV
568 /* This is exposed so that vop_fid can test it, even if iauth is not
569  *  installed.
570  */
571 extern int afs_iauth_initd;
572 #endif
573
574 #ifdef AFS_AIX_IAUTH_ENV
575 char *afs_nfs_id = "AFSNFSTRANS";
576 /* afs_iauth_verify is the AFS authenticator for NFS.
577  *
578  * always returns 0.
579  */
580 int
581 afs_iauth_verify(long id, fsid_t * fsidp, long host, int uid,
582                  struct AFS_UCRED *credp, struct exportinfo *exp)
583 {
584     int code;
585     struct nfsclientpag *nfs_pag;
586     afs_int32 dummypag;
587     struct afs_exporter *outexporter = 0;
588
589
590     /* Still needs basic test to see if exporter is on. And need to check the
591      * whole no submounts bit.
592      */
593
594     if (id != (long)id)
595         return 0;               /* not us. */
596
597     /* Only care if it's AFS */
598     if ((fsidp->val[0] != AFS_VFSMAGIC) || (fsidp->val[1] != AFS_VFSFSID)) {
599         return 0;
600     }
601
602     AFS_GLOCK();
603     code =
604         afs_nfsclient_reqhandler((struct afs_exporter *)0, &credp, host,
605                                  &dummypag, &outexporter);
606     if (!code && outexporter)
607         EXP_RELE(outexporter);
608
609     if (code) {
610         /* ensure anonymous cred. */
611         credp->cr_uid = credp->cr_ruid = (uid_t) - 2;   /* anonymous */
612     }
613
614     /* Mark this thread as an NFS translator thread. */
615     credp->cr_rgid = NFSXLATOR_CRED;
616
617     AFS_GUNLOCK();
618     return 0;
619 }
620
621 /* afs_iauth_register - register the iauth verify routine. Returns 0 on success
622  * and -1 on failure. Can fail because DFS has already registered.
623  */
624 int
625 afs_iauth_register()
626 {
627     if (nfs_iauth_register((unsigned long)afs_nfs_id, afs_iauth_verify))
628         return -1;
629     else {
630         afs_iauth_initd = 1;
631         return 0;
632     }
633 }
634
635 /* afs_iauth_unregister - unregister the iauth verify routine. Called on shutdown. 
636  */
637 void
638 afs_iauth_unregister()
639 {
640     if (afs_iauth_initd)
641         nfs_iauth_unregister((unsigned long)afs_nfs_id);
642     afs_iauth_initd = 0;
643 }
644 #endif /* AFS_AIX_IAUTH_ENV */
645
646
647
648 void
649 shutdown_nfsclnt()
650 {
651 #if defined(AFS_SGIMP_ENV)
652     osi_Assert(ISAFS_GLOCK());
653 #endif
654     AFS_STATCNT(afs_nfsclient_shutdown);
655 #ifdef AFS_AIX_IAUTH_ENV
656     afs_iauth_register();
657 #endif
658     afs_nfsclient_GC(afs_nfsexporter, -1);
659     init_nfsexporter = 0;
660 }
661 #endif /* AFS_NONFSTRANS */