linux24-update-20040713
[openafs.git] / src / afs / LINUX / osi_groups.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  * Implements:
12  * setgroups (syscall)
13  * setpag
14  *
15  */
16 #include <afsconfig.h>
17 #include "afs/param.h"
18
19 RCSID
20     ("$Header$");
21
22 #include "afs/sysincludes.h"
23 #include "afsincludes.h"
24 #include "afs/afs_stats.h"      /* statistics */
25 #ifdef AFS_LINUX22_ENV
26 #include "h/smp_lock.h"
27 #endif
28
29 #if defined(AFS_LINUX26_ENV)
30 static int
31 afs_setgroups(cred_t **cr, struct group_info *group_info, int change_parent)
32 {
33     struct group_info *old_info;
34
35     AFS_STATCNT(afs_setgroups);
36
37     old_info = (*cr)->cr_group_info;
38     get_group_info(group_info);
39     (*cr)->cr_group_info = group_info;
40     put_group_info(old_info);
41
42     crset(*cr);
43
44     if (change_parent) {
45         old_info = current->parent->group_info;
46         get_group_info(group_info);
47         current->parent->group_info = group_info;
48         put_group_info(old_info);
49     }
50
51     return (0);
52 }
53 #else
54 static int
55 afs_setgroups(cred_t **cr, int ngroups, gid_t * gidset, int change_parent)
56 {
57     int ngrps;
58     int i;
59     gid_t *gp;
60
61     AFS_STATCNT(afs_setgroups);
62
63     if (ngroups > NGROUPS)
64         return EINVAL;
65
66     gp = (*cr)->cr_groups;
67     if (ngroups < NGROUPS)
68         gp[ngroups] = (gid_t) NOGROUP;
69
70     for (i = ngroups; i > 0; i--) {
71         *gp++ = *gidset++;
72     }
73
74     (*cr)->cr_ngroups = ngroups;
75     crset(*cr);
76     return (0);
77 }
78 #endif
79
80 #if defined(AFS_LINUX26_ENV)
81 static struct group_info *
82 afs_getgroups(cred_t * cr)
83 {
84     AFS_STATCNT(afs_getgroups);
85
86     get_group_info(cr->cr_group_info);
87     return cr->cr_group_info;
88 }
89 #else
90 /* Returns number of groups. And we trust groups to be large enough to
91  * hold all the groups.
92  */
93 static int
94 afs_getgroups(cred_t *cr, gid_t *groups)
95 {
96     int i;
97     int n;
98     gid_t *gp;
99
100     AFS_STATCNT(afs_getgroups);
101
102     gp = cr->cr_groups;
103     n = cr->cr_ngroups;
104
105     for (i = 0; (i < n) && (*gp != (gid_t) NOGROUP); i++)
106         *groups++ = *gp++;
107     return i;
108 }
109 #endif
110
111 #if !defined(AFS_LINUX26_ENV)
112 /* Only propogate the PAG to the parent process. Unix's propogate to 
113  * all processes sharing the cred.
114  */
115 int
116 set_pag_in_parent(int pag, int g0, int g1)
117 {
118     int i;
119 #ifdef STRUCT_TASK_STRUCT_HAS_PARENT
120     gid_t *gp = current->parent->groups;
121     int ngroups = current->parent->ngroups;
122 #else
123     gid_t *gp = current->p_pptr->groups;
124     int ngroups = current->p_pptr->ngroups;
125 #endif
126
127     if ((ngroups < 2) || (afs_get_pag_from_groups(gp[0], gp[1]) == NOPAG)) {
128         /* We will have to shift grouplist to make room for pag */
129         if (ngroups + 2 > NGROUPS) {
130             return EINVAL;
131         }
132         for (i = ngroups - 1; i >= 0; i--) {
133             gp[i + 2] = gp[i];
134         }
135         ngroups += 2;
136     }
137     gp[0] = g0;
138     gp[1] = g1;
139     if (ngroups < NGROUPS)
140         gp[ngroups] = NOGROUP;
141
142 #ifdef STRUCT_TASK_STRUCT_HAS_PARENT
143     current->parent->ngroups = ngroups;
144 #else
145     current->p_pptr->ngroups = ngroups;
146 #endif
147     return 0;
148 }
149 #endif
150
151 int
152 setpag(cred_t ** cr, afs_uint32 pagvalue, afs_uint32 * newpag,
153        int change_parent)
154 {
155 #if defined(AFS_LINUX26_ENV)
156     struct group_info *group_info;
157     gid_t g0, g1;
158
159     AFS_STATCNT(setpag);
160
161     group_info = afs_getgroups(*cr);
162     if (group_info->ngroups < 2
163         ||  afs_get_pag_from_groups(GROUP_AT(group_info, 0),
164                                     GROUP_AT(group_info, 1)) == NOPAG) {
165         /* We will have to make sure group_info is big enough for pag */
166         struct group_info *tmp;
167         int i;
168         
169         tmp = groups_alloc(group_info->ngroups + 2);
170         for (i = 0; i < group_info->ngroups; ++i)
171                 GROUP_AT(tmp, i + 2) = GROUP_AT(group_info, i);
172         put_group_info(group_info);
173         group_info = tmp;
174     }
175
176     *newpag = (pagvalue == -1 ? genpag() : pagvalue);
177     afs_get_groups_from_pag(*newpag, &g0, &g1);
178     GROUP_AT(group_info, 0) = g0;
179     GROUP_AT(group_info, 1) = g1;
180
181     afs_setgroups(cr, group_info, change_parent);
182
183     put_group_info(group_info);
184
185     return 0;
186 #else
187     gid_t *gidset;
188     afs_int32 ngroups, code = 0;
189     int j;
190
191     AFS_STATCNT(setpag);
192
193     gidset = (gid_t *) osi_Alloc(NGROUPS * sizeof(gidset[0]));
194     ngroups = afs_getgroups(*cr, gidset);
195
196     if (afs_get_pag_from_groups(gidset[0], gidset[1]) == NOPAG) {
197         /* We will have to shift grouplist to make room for pag */
198         if (ngroups + 2 > NGROUPS) {
199             osi_Free((char *)gidset, NGROUPS * sizeof(int));
200             return EINVAL;
201         }
202         for (j = ngroups - 1; j >= 0; j--) {
203             gidset[j + 2] = gidset[j];
204         }
205         ngroups += 2;
206     }
207     *newpag = (pagvalue == -1 ? genpag() : pagvalue);
208     afs_get_groups_from_pag(*newpag, &gidset[0], &gidset[1]);
209     code = afs_setgroups(cr, ngroups, gidset, change_parent);
210
211     /* If change_parent is set, then we should set the pag in the parent as
212      * well.
213      */
214     if (change_parent && !code) {
215         code = set_pag_in_parent(*newpag, gidset[0], gidset[1]);
216     }
217
218     osi_Free((char *)gidset, NGROUPS * sizeof(int));
219     return code;
220 #endif
221 }
222
223
224 /* Intercept the standard system call. */
225 extern long (*sys_setgroupsp) (int gidsetsize, gid_t * grouplist);
226 asmlinkage long
227 afs_xsetgroups(int gidsetsize, gid_t * grouplist)
228 {
229     long code;
230     cred_t *cr = crref();
231     afs_uint32 junk;
232     int old_pag;
233
234     lock_kernel();
235     old_pag = PagInCred(cr);
236     crfree(cr);
237     unlock_kernel();
238
239     code = (*sys_setgroupsp) (gidsetsize, grouplist);
240     if (code) {
241         return code;
242     }
243
244     lock_kernel();
245     cr = crref();
246     if (old_pag != NOPAG && PagInCred(cr) == NOPAG) {
247         /* re-install old pag if there's room. */
248         code = setpag(&cr, old_pag, &junk, 0);
249     }
250     crfree(cr);
251     unlock_kernel();
252
253     /* Linux syscall ABI returns errno as negative */
254     return (-code);
255 }
256
257 #if defined(AFS_LINUX24_ENV)
258 /* Intercept the standard uid32 system call. */
259 extern long (*sys_setgroups32p) (int gidsetsize, gid_t * grouplist);
260 asmlinkage long
261 afs_xsetgroups32(int gidsetsize, gid_t * grouplist)
262 {
263     long code;
264     cred_t *cr = crref();
265     afs_uint32 junk;
266     int old_pag;
267
268     lock_kernel();
269     old_pag = PagInCred(cr);
270     crfree(cr);
271     unlock_kernel();
272
273     code = (*sys_setgroups32p) (gidsetsize, grouplist);
274
275     if (code) {
276         return code;
277     }
278
279     lock_kernel();
280     cr = crref();
281     if (old_pag != NOPAG && PagInCred(cr) == NOPAG) {
282         /* re-install old pag if there's room. */
283         code = setpag(&cr, old_pag, &junk, 0);
284     }
285     crfree(cr);
286     unlock_kernel();
287
288     /* Linux syscall ABI returns errno as negative */
289     return (-code);
290 }
291 #endif
292
293 #if defined(AFS_PPC64_LINUX20_ENV)
294 /* Intercept the uid16 system call as used by 32bit programs. */
295 extern long (*sys32_setgroupsp)(int gidsetsize, gid_t *grouplist);
296 asmlinkage long afs32_xsetgroups(int gidsetsize, gid_t *grouplist)
297 {
298     long code;
299     cred_t *cr = crref();
300     afs_uint32 junk;
301     int old_pag;
302     
303     lock_kernel();
304     old_pag = PagInCred(cr);
305     crfree(cr);
306     unlock_kernel();
307     
308     code = (*sys32_setgroupsp)(gidsetsize, grouplist);
309     if (code) {
310         return code;
311     }
312     
313     lock_kernel();
314     cr = crref();
315     if (old_pag != NOPAG && PagInCred(cr) == NOPAG) {
316         /* re-install old pag if there's room. */
317         code = setpag(&cr, old_pag, &junk, 0);
318     }
319     crfree(cr);
320     unlock_kernel();
321     
322     /* Linux syscall ABI returns errno as negative */
323     return (-code);
324 }
325 #endif
326
327 #if defined(AFS_SPARC64_LINUX20_ENV) || defined(AFS_AMD64_LINUX20_ENV)
328 /* Intercept the uid16 system call as used by 32bit programs. */
329 extern long (*sys32_setgroupsp) (int gidsetsize, u16 * grouplist);
330 asmlinkage long
331 afs32_xsetgroups(int gidsetsize, u16 * grouplist)
332 {
333     long code;
334     cred_t *cr = crref();
335     afs_uint32 junk;
336     int old_pag;
337     
338     lock_kernel();
339     old_pag = PagInCred(cr);
340     crfree(cr);
341     unlock_kernel();
342     
343     code = (*sys32_setgroupsp) (gidsetsize, grouplist);
344     if (code) {
345         return code;
346     }
347     
348     lock_kernel();
349     cr = crref();
350     if (old_pag != NOPAG && PagInCred(cr) == NOPAG) {
351         /* re-install old pag if there's room. */
352         code = setpag(&cr, old_pag, &junk, 0);
353     }
354     crfree(cr);
355     unlock_kernel();
356     
357     /* Linux syscall ABI returns errno as negative */
358     return (-code);
359 }
360
361 #ifdef AFS_LINUX24_ENV
362 /* Intercept the uid32 system call as used by 32bit programs. */
363 extern long (*sys32_setgroups32p) (int gidsetsize, gid_t * grouplist);
364 asmlinkage long
365 afs32_xsetgroups32(int gidsetsize, gid_t * grouplist)
366 {
367     long code;
368     cred_t *cr = crref();
369     afs_uint32 junk;
370     int old_pag;
371
372     lock_kernel();
373     old_pag = PagInCred(cr);
374     crfree(cr);
375     unlock_kernel();
376
377     code = (*sys32_setgroups32p) (gidsetsize, grouplist);
378     if (code) {
379         return code;
380     }
381
382     lock_kernel();
383     cr = crref();
384     if (old_pag != NOPAG && PagInCred(cr) == NOPAG) {
385         /* re-install old pag if there's room. */
386         code = setpag(&cr, old_pag, &junk, 0);
387     }
388     crfree(cr);
389     unlock_kernel();
390
391     /* Linux syscall ABI returns errno as negative */
392     return (-code);
393 }
394 #endif
395 #endif
396