9f209078e3686355e4165ad53a8c1782c1083d4a
[openafs.git] / src / WINNT / afsd / cm_user.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
11 #include <afsconfig.h>
12 #include <afs/param.h>
13 #include <roken.h>
14
15 #include <afs/stds.h>
16
17 #include <windows.h>
18 #include <malloc.h>
19 #include <string.h>
20
21 #include "afsd.h"
22 #include "smb.h"
23 #include <osi.h>
24 #include <rx/rx.h>
25
26
27 osi_rwlock_t cm_userLock;
28
29 cm_user_t *cm_rootUserp;
30
31 void cm_InitUser(void)
32 {
33     static osi_once_t once;
34
35     if (osi_Once(&once)) {
36         lock_InitializeRWLock(&cm_userLock, "cm_userLock", LOCK_HIERARCHY_USER_GLOBAL);
37         osi_EndOnce(&once);
38     }
39
40     cm_rootUserp = cm_NewUser();
41 }
42
43 cm_user_t *cm_NewUser(void)
44 {
45     cm_user_t *userp;
46
47     userp = malloc(sizeof(*userp));
48     memset(userp, 0, sizeof(*userp));
49     userp->refCount = 1;
50     lock_InitializeMutex(&userp->mx, "cm_user_t", LOCK_HIERARCHY_USER);
51     return userp;
52 }
53
54 /* must be called with locked userp */
55 cm_ucell_t *cm_GetUCell(cm_user_t *userp, cm_cell_t *cellp)
56 {
57     cm_ucell_t *ucp;
58
59     lock_AssertMutex(&userp->mx);
60     for (ucp = userp->cellInfop; ucp; ucp=ucp->nextp) {
61         if (ucp->cellp == cellp)
62             break;
63     }
64
65     if (!ucp) {
66         ucp = malloc(sizeof(*ucp));
67         memset(ucp, 0, sizeof(*ucp));
68         ucp->nextp = userp->cellInfop;
69         if (userp->cellInfop)
70             ucp->iterator = userp->cellInfop->iterator + 1;
71         else
72             ucp->iterator = 1;
73         userp->cellInfop = ucp;
74         ucp->cellp = cellp;
75         if (userp == cm_rootUserp)
76             ucp->flags |= CM_UCELLFLAG_ROOTUSER;
77     }
78
79     return ucp;
80 }
81
82 cm_ucell_t *cm_FindUCell(cm_user_t *userp, int iterator)
83 {
84     cm_ucell_t *ucp;
85     cm_ucell_t *best;
86
87     best = NULL;
88     lock_AssertMutex(&userp->mx);
89     for (ucp = userp->cellInfop; ucp; ucp = ucp->nextp) {
90         if (ucp->iterator >= iterator)
91             best = ucp;
92         else
93             break;
94     }
95     return best;
96 }
97
98 void cm_HoldUser(cm_user_t *up)
99 {
100     lock_ObtainWrite(&cm_userLock);
101     up->refCount++;
102     lock_ReleaseWrite(&cm_userLock);
103 }
104
105 void cm_ReleaseUser(cm_user_t *userp)
106 {
107     cm_ucell_t *ucp;
108     cm_ucell_t *ncp;
109
110     if (userp == NULL)
111         return;
112
113     lock_ObtainWrite(&cm_userLock);
114     osi_assertx(userp->refCount-- > 0, "cm_user_t refCount 0");
115     if (userp->refCount == 0) {
116         lock_FinalizeMutex(&userp->mx);
117         for (ucp = userp->cellInfop; ucp; ucp = ncp) {
118             ncp = ucp->nextp;
119             if (ucp->ticketp)
120                 free(ucp->ticketp);
121             free(ucp);
122         }
123         free(userp);
124     }
125     lock_ReleaseWrite(&cm_userLock);
126 }
127
128
129 void cm_HoldUserVCRef(cm_user_t *userp)
130 {
131     lock_ObtainMutex(&userp->mx);
132     userp->vcRefs++;
133     lock_ReleaseMutex(&userp->mx);
134 }
135
136 /* release the count of the # of connections that use this user structure.
137  * When this hits zero, we know we won't be getting any new requests from
138  * this user, and thus we can start GC'ing connections.  Ref count on user
139  * won't hit zero until all cm_conn_t's have been GC'd, since they hold
140  * refCount references to userp.
141  */
142 void cm_ReleaseUserVCRef(cm_user_t *userp)
143 {
144     lock_ObtainMutex(&userp->mx);
145     osi_assertx(userp->vcRefs-- > 0, "cm_user_t refCount 0");
146     lock_ReleaseMutex(&userp->mx);
147 }
148
149
150 /*
151  * Check if any users' tokens have expired and if they have then do the
152  * equivalent of unlogging the user for that particular cell for which
153  * the tokens have expired.
154  * ref. cm_IoctlDelToken() in cm_ioctl.c
155  * This routine is called by the cm_Daemon() ie. the periodic daemon.
156  * every cm_daemonTokenCheckInterval seconds
157  */
158 void cm_CheckTokenCache(time_t now)
159 {
160     extern smb_vc_t *smb_allVCsp; /* global vcp list */
161     smb_vc_t   *vcp;
162     smb_user_t *usersp;
163     cm_user_t  *userp = NULL;
164     cm_ucell_t *ucellp;
165     BOOL bExpired=FALSE;
166
167     /*
168      * For every vcp, get the user and check his tokens
169      */
170     lock_ObtainRead(&smb_rctLock);
171     for (vcp=smb_allVCsp; vcp; vcp=vcp->nextp) {
172         for (usersp=vcp->usersp; usersp; usersp=usersp->nextp) {
173             if (usersp->unp) {
174                 if ((userp=usersp->unp->userp)==0)
175                     continue;
176             } else
177                 continue;
178             lock_ObtainMutex(&userp->mx);
179             for (ucellp=userp->cellInfop; ucellp; ucellp=ucellp->nextp) {
180                 if (ucellp->flags & CM_UCELLFLAG_RXKAD) {
181                     if (ucellp->expirationTime < now) {
182                         /* this guy's tokens have expired */
183                         osi_Log3(afsd_logp, "cm_CheckTokens: Tokens for user:%s have expired expiration time:0x%x ucellp:%x",
184                                  ucellp->userName, ucellp->expirationTime, ucellp);
185                         if (ucellp->ticketp) {
186                             free(ucellp->ticketp);
187                             ucellp->ticketp = NULL;
188                         }
189                         _InterlockedAnd(&ucellp->flags, ~CM_UCELLFLAG_RXKAD);
190                         ucellp->gen++;
191                         lock_ReleaseMutex(&userp->mx);
192                         cm_ResetACLCache(ucellp->cellp, userp);
193                         lock_ObtainMutex(&userp->mx);
194                     }
195                 }
196             }
197             lock_ReleaseMutex(&userp->mx);
198         }
199     }
200     lock_ReleaseRead(&smb_rctLock);
201 }
202
203 #ifdef USE_ROOT_TOKENS
204 /*
205  * Service/Parameters/RootTokens/<cellname>/
206  * -> UseLSA
207  * -> Keytab (required if UseLSA is 0)
208  * -> Principal (required if there is more than one principal in the keytab)
209  * -> Realm (required if realm is not upper-case of <cellname>
210  * -> RequireEncryption
211  */
212
213 void
214 cm_RefreshRootTokens(void)
215 {
216
217 }
218 #endif