libafs: Implement unixuser RW locks
[openafs.git] / src / afs / afs_pag_cred.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
14 #include "afs/sysincludes.h"    /* Standard vendor system headers */
15 #include "afsincludes.h"        /* Afs-based standard headers */
16 #include "afs/afs_stats.h"
17 #include "afs/unified_afs.h"
18 #include "rx/rx_globals.h"
19 #include "pagcb.h"
20
21
22 struct afspag_cell {
23     struct afspag_cell *next;
24     char *cellname;
25     afs_int32 cellnum;
26 };
27
28 afs_rwlock_t afs_xpagcell;
29 afs_rwlock_t afs_xpagsys;
30 static int lastcell = 0;
31 static struct afspag_cell *cells = 0;
32 static struct afspag_cell *primary_cell = 0;
33
34
35 struct afspag_cell *
36 afspag_GetCell(char *acell)
37 {
38     struct afspag_cell *tcell;
39
40     ObtainWriteLock(&afs_xpagcell, 820);
41
42     for (tcell = cells; tcell; tcell = tcell->next) {
43         if (!strcmp(acell, tcell->cellname))
44             break;
45     }
46
47     if (!tcell) {
48         tcell = afs_osi_Alloc(sizeof(struct afspag_cell));
49         if (!tcell)
50             goto out;
51         tcell->cellname = afs_osi_Alloc(strlen(acell) + 1);
52         if (!tcell->cellname) {
53             afs_osi_Free(tcell, sizeof(struct afspag_cell));
54             tcell = 0;
55             goto out;
56         }
57         strcpy(tcell->cellname, acell);
58         tcell->cellnum = ++lastcell;
59         tcell->next = cells;
60         cells = tcell;
61         if (!primary_cell) primary_cell = tcell;
62     }
63
64 out:
65     ReleaseWriteLock(&afs_xpagcell);
66     return tcell;
67 }
68
69
70 struct afspag_cell *
71 afspag_GetPrimaryCell(void)
72 {
73     struct afspag_cell *tcell;
74
75     ObtainWriteLock(&afs_xpagcell, 821);
76     tcell = primary_cell;
77     ReleaseWriteLock(&afs_xpagcell);
78     return tcell;
79 }
80
81
82 void
83 afspag_SetPrimaryCell(char *acell)
84 {
85     struct afspag_cell *tcell;
86
87     tcell = afspag_GetCell(acell);
88     ObtainWriteLock(&afs_xpagcell, 822);
89     primary_cell = tcell;
90     ReleaseWriteLock(&afs_xpagcell);
91 }
92
93
94 int
95 afspag_PUnlog(char *ain, afs_int32 ainSize, afs_ucred_t **acred)
96 {
97     afs_int32 i;
98     struct unixuser *tu;
99     afs_int32 pag, uid;
100
101     AFS_STATCNT(PUnlog);
102     if (!afs_resourceinit_flag) /* afs daemons haven't started yet */
103         return EIO;             /* Inappropriate ioctl for device */
104
105     pag = PagInCred(*acred);
106     uid = (pag == NOPAG) ? afs_cr_uid(*acred) : pag;
107     i = UHash(uid);
108     ObtainWriteLock(&afs_xuser, 823);
109     for (tu = afs_users[i]; tu; tu = tu->next) {
110         if (tu->uid == uid) {
111             tu->refCount++;
112             ReleaseWriteLock(&afs_xuser);
113
114             afs_LockUser(tu, WRITE_LOCK, 368);
115
116             tu->states &= ~UHasTokens;
117             tu->viceId = UNDEFVID;
118             afs_FreeTokens(&tu->tokens);
119 #ifdef UKERNEL
120             /* set the expire times to 0, causes
121              * afs_GCUserData to remove this entry
122              */
123             tu->tokenTime = 0;
124 #endif /* UKERNEL */
125
126             afs_PutUser(tu, WRITE_LOCK);
127
128             ObtainWriteLock(&afs_xuser, 369);
129         }
130     }
131     ReleaseWriteLock(&afs_xuser);
132     return 0;
133 }
134
135
136 int
137 afspag_PSetTokens(char *ain, afs_int32 ainSize, afs_ucred_t **acred)
138 {
139     afs_int32 i;
140     struct unixuser *tu;
141     struct afspag_cell *tcell;
142     struct ClearToken clear;
143     char *stp;
144     int stLen;
145     afs_int32 flag, set_parent_pag = 0;
146     afs_int32 pag, uid;
147
148     AFS_STATCNT(PSetTokens);
149     if (!afs_resourceinit_flag) {
150         return EIO;
151     }
152     memcpy((char *)&i, ain, sizeof(afs_int32));
153     ain += sizeof(afs_int32);
154     stp = ain;                  /* remember where the ticket is */
155     if (i < 0 || i > MAXKTCTICKETLEN)
156         return EINVAL;          /* malloc may fail */
157     stLen = i;
158     ain += i;                   /* skip over ticket */
159     memcpy((char *)&i, ain, sizeof(afs_int32));
160     ain += sizeof(afs_int32);
161     if (i != sizeof(struct ClearToken)) {
162         return EINVAL;
163     }
164     memcpy((char *)&clear, ain, sizeof(struct ClearToken));
165     if (clear.AuthHandle == -1)
166         clear.AuthHandle = 999; /* more rxvab compat stuff */
167     ain += sizeof(struct ClearToken);
168     if (ainSize != 2 * sizeof(afs_int32) + stLen + sizeof(struct ClearToken)) {
169         /* still stuff left?  we've got primary flag and cell name.  Set these */
170         memcpy((char *)&flag, ain, sizeof(afs_int32));  /* primary id flag */
171         ain += sizeof(afs_int32);       /* skip id field */
172         /* rest is cell name, look it up */
173         /* some versions of gcc appear to need != 0 in order to get this right */
174         if ((flag & 0x8000) != 0) {     /* XXX Use Constant XXX */
175             flag &= ~0x8000;
176             set_parent_pag = 1;
177         }
178         tcell = afspag_GetCell(ain);
179     } else {
180         /* default to primary cell, primary id */
181         flag = 1;               /* primary id */
182         tcell = afspag_GetPrimaryCell();
183     }
184     if (!tcell) return ESRCH;
185     if (set_parent_pag) {
186 #if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
187         char procname[256];
188         osi_procname(procname, 256);
189
190         afs_warnuser("Process %d (%s) tried to change pags in PSetTokens\n",
191                      MyPidxx2Pid(MyPidxx), procname);
192         setpag(osi_curproc(), acred, -1, &pag, 1);
193 #else
194         setpag(acred, -1, &pag, 1);
195 #endif
196     }
197     pag = PagInCred(*acred);
198     uid = (pag == NOPAG) ? afs_cr_uid(*acred) : pag;
199     /* now we just set the tokens */
200     tu = afs_GetUser(uid, tcell->cellnum, WRITE_LOCK);
201     if (!tu->cellinfo)
202         tu->cellinfo = (void *)tcell;
203     afs_FreeTokens(&tu->tokens);
204     afs_AddRxkadToken(&tu->tokens, stp, stLen, &clear);
205 #ifndef AFS_NOSTATS
206     afs_stats_cmfullperf.authent.TicketUpdates++;
207     afs_ComputePAGStats();
208 #endif /* AFS_NOSTATS */
209     tu->states |= UHasTokens;
210     tu->states &= ~UTokensBad;
211     afs_SetPrimary(tu, flag);
212     tu->tokenTime = osi_Time();
213     afs_PutUser(tu, WRITE_LOCK);
214
215     return 0;
216 }
217
218
219 int
220 SPAGCB_GetCreds(struct rx_call *a_call, afs_int32 a_uid,
221                 CredInfos *a_creds)
222 {
223     struct unixuser *tu;
224     union tokenUnion *token;
225     CredInfo *tci;
226     int bucket, count, i = 0, clen;
227     char *cellname;
228
229     RX_AFS_GLOCK();
230
231     memset(a_creds, 0, sizeof(struct CredInfos));
232     if ((rx_HostOf(rx_PeerOf(rx_ConnectionOf(a_call))) != afs_nfs_server_addr
233         ||  rx_PortOf(rx_PeerOf(rx_ConnectionOf(a_call))) != htons(7001))
234 #if 0 /* for debugging ONLY! */
235         &&  rx_PortOf(rx_PeerOf(rx_ConnectionOf(a_call))) != htons(7901)
236 #endif
237         ) {
238         RX_AFS_GUNLOCK();
239         return UAEPERM;
240     }
241
242     ObtainWriteLock(&afs_xuser, 823);
243
244     /* count them first */
245     bucket = UHash(a_uid);
246     for (count = 0, tu = afs_users[bucket]; tu; tu = tu->next) {
247         if (tu->uid == a_uid) count++;
248     }
249
250     if (!count) {
251         ReleaseWriteLock(&afs_xuser);
252         RX_AFS_GUNLOCK();
253         return UAESRCH;
254     }
255
256     a_creds->CredInfos_val = afs_osi_Alloc(count * sizeof(CredInfo));
257     if (!a_creds->CredInfos_val)
258         goto out;
259     a_creds->CredInfos_len = count;
260     memset(a_creds->CredInfos_val, 0, count * sizeof(CredInfo));
261
262     for (i = 0, tu = afs_users[bucket]; tu; tu = tu->next, i++) {
263         if (tu->uid == a_uid && tu->cellinfo &&
264             (tu->states & UHasTokens) && !(tu->states & UTokensBad)) {
265
266             tu->refCount++;
267             ReleaseWriteLock(&afs_xuser);
268
269             afs_LockUser(tu, READ_LOCK, 0);
270
271             token = afs_FindToken(tu->tokens, RX_SECIDX_KAD);
272
273             tci = &a_creds->CredInfos_val[i];
274             tci->vid               = token->rxkad.clearToken.ViceId;
275             tci->ct.AuthHandle     = token->rxkad.clearToken.AuthHandle;
276             memcpy(tci->ct.HandShakeKey,
277                    token->rxkad.clearToken.HandShakeKey, 8);
278             tci->ct.ViceId         = token->rxkad.clearToken.ViceId;
279             tci->ct.BeginTimestamp = token->rxkad.clearToken.BeginTimestamp;
280             tci->ct.EndTimestamp   = token->rxkad.clearToken.EndTimestamp;
281
282             cellname = ((struct afspag_cell *)(tu->cellinfo))->cellname;
283             clen = strlen(cellname) + 1;
284             tci->cellname = afs_osi_Alloc(clen);
285             if (!tci->cellname) {
286                 afs_PutUser(tu, READ_LOCK);
287                 ObtainWriteLock(&afs_xuser, 370);
288                 goto out;
289             }
290             memcpy(tci->cellname, cellname, clen);
291
292             tci->st.st_len = token->rxkad.ticketLen;
293             tci->st.st_val = afs_osi_Alloc(token->rxkad.ticketLen);
294             if (!tci->st.st_val) {
295                 afs_PutUser(tu, READ_LOCK);
296                 afs_osi_Free(tci->cellname, clen);
297                 ObtainWriteLock(&afs_xuser, 371);
298                 goto out;
299             }
300             memcpy(tci->st.st_val,
301                    token->rxkad.ticket, token->rxkad.ticketLen);
302             if (tu->states & UPrimary)
303                 tci->states |= UPrimary;
304
305             afs_PutUser(tu, READ_LOCK);
306             ObtainWriteLock(&afs_xuser, 372);
307         }
308     }
309
310     ReleaseWriteLock(&afs_xuser);
311     RX_AFS_GUNLOCK();
312     return 0;
313
314 out:
315     if (a_creds->CredInfos_val) {
316         while (i-- > 0) {
317             afs_osi_Free(a_creds->CredInfos_val[i].st.st_val,
318                          a_creds->CredInfos_val[i].st.st_len);
319             afs_osi_Free(a_creds->CredInfos_val[i].cellname,
320                          strlen(a_creds->CredInfos_val[i].cellname) + 1);
321         }
322         afs_osi_Free(a_creds->CredInfos_val, count * sizeof(CredInfo));
323     }
324
325     ReleaseWriteLock(&afs_xuser);
326     RX_AFS_GUNLOCK();
327     return UAENOMEM;
328 }
329
330
331 int
332 afspag_PSetSysName(char *ain, afs_int32 ainSize, afs_ucred_t **acred)
333 {
334     int setsysname, count, t;
335     char *cp, *setp;
336
337     setp = ain;
338     memcpy((char *)&setsysname, ain, sizeof(afs_int32));
339     ain += sizeof(afs_int32);
340     if (!setsysname)
341         return 0; /* nothing to do locally */
342
343     /* Check my args */
344     if (setsysname < 0 || setsysname > MAXNUMSYSNAMES)
345         return EINVAL;
346     if (!afs_osi_suser(*acred))
347         return EACCES;
348     for (cp = ain, count = 0; count < setsysname; count++) {
349         /* won't go past end of ain since maxsysname*num < ain length */
350         t = strlen(cp);
351         if (t >= MAXSYSNAME || t <= 0)
352             return EINVAL;
353         /* check for names that can shoot us in the foot */
354         if (*cp == '.' && (cp[1] == 0 || (cp[1] == '.' && cp[2] == 0)))
355             return EINVAL;
356         cp += t + 1;
357     }
358
359     ObtainWriteLock(&afs_xpagsys, 824);
360     for (cp = ain, count = 0; count < setsysname; count++) {
361         t = strlen(cp);
362         memcpy(afs_sysnamelist[count], cp, t + 1);
363         cp += t + 1;
364     }
365     afs_sysnamecount = setsysname;
366     afs_sysnamegen++;
367     ReleaseWriteLock(&afs_xpagsys);
368
369     /* Change the arguments so we pass the allpags flag to the server */
370     setsysname |= 0x8000;
371     memcpy(setp, (char *)&setsysname, sizeof(afs_int32));
372     return 0;
373 }
374
375
376 int
377 SPAGCB_GetSysName(struct rx_call *a_call, afs_int32 a_uid,
378                   SysNameList *a_sysnames)
379 {
380     int i = 0;
381
382     RX_AFS_GLOCK();
383
384     ObtainReadLock(&afs_xpagsys);
385     memset(a_sysnames, 0, sizeof(struct SysNameList));
386
387     a_sysnames->SysNameList_len = afs_sysnamecount;
388     a_sysnames->SysNameList_val =
389         afs_osi_Alloc(afs_sysnamecount * sizeof(SysNameEnt));
390     if (!a_sysnames->SysNameList_val)
391         goto out;
392
393     for (i = 0; i < afs_sysnamecount; i++) {
394         a_sysnames->SysNameList_val[i].sysname =
395             afs_osi_Alloc(strlen(afs_sysnamelist[i]) + 1);
396         if (!a_sysnames->SysNameList_val[i].sysname)
397             goto out;
398         strcpy(a_sysnames->SysNameList_val[i].sysname, afs_sysnamelist[i]);
399     }
400
401     ReleaseReadLock(&afs_xpagsys);
402     RX_AFS_GUNLOCK();
403     return 0;
404
405 out:
406     if (a_sysnames->SysNameList_val) {
407         while (i-- > 0) {
408             afs_osi_Free(a_sysnames->SysNameList_val[i].sysname,
409                          strlen(a_sysnames->SysNameList_val[i].sysname) + 1);
410         }
411         afs_osi_Free(a_sysnames->SysNameList_val,
412                      afs_sysnamecount * sizeof(SysNameEnt));
413     }
414
415     ReleaseWriteLock(&afs_xpagsys);
416     RX_AFS_GUNLOCK();
417     return UAENOMEM;
418 }