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     struct group_info *tmp;
 159     int i;
 160     int need_space = 0;
 161
 162     AFS_STATCNT(setpag);
 163
 164     group_info = afs_getgroups(*cr);
 165     if (group_info->ngroups < 2
 166         ||  afs_get_pag_from_groups(GROUP_AT(group_info, 0),
 167                                     GROUP_AT(group_info, 1)) == NOPAG)
 168         /* We will have to make sure group_info is big enough for pag */
 169       need_space = 2;
 170
 171     tmp = groups_alloc(group_info->ngroups + need_space);
 172
 173     for (i = 0; i < group_info->ngroups; ++i)
 174       GROUP_AT(tmp, i + need_space) = GROUP_AT(group_info, i);
 175     group_info = tmp;
 176
 177     *newpag = (pagvalue == -1 ? genpag() : pagvalue);
 178     afs_get_groups_from_pag(*newpag, &g0, &g1);
 179     GROUP_AT(group_info, 0) = g0;
 180     GROUP_AT(group_info, 1) = g1;
 181
 182     afs_setgroups(cr, group_info, change_parent);
 183
 184     put_group_info(group_info);
 185
 186     return 0;
 187 #else
 188     gid_t *gidset;
 189     afs_int32 ngroups, code = 0;
 190     int j;
 191
 192     AFS_STATCNT(setpag);
 193
 194     gidset = (gid_t *) osi_Alloc(NGROUPS * sizeof(gidset[0]));
 195     ngroups = afs_getgroups(*cr, gidset);
 196
 197     if (afs_get_pag_from_groups(gidset[0], gidset[1]) == NOPAG) {
 198         /* We will have to shift grouplist to make room for pag */
 199         if (ngroups + 2 > NGROUPS) {
 200             osi_Free((char *)gidset, NGROUPS * sizeof(int));
 201             return EINVAL;
 202         }
 203         for (j = ngroups - 1; j >= 0; j--) {
 204             gidset[j + 2] = gidset[j];
 205         }
 206         ngroups += 2;
 207     }
 208     *newpag = (pagvalue == -1 ? genpag() : pagvalue);
 209     afs_get_groups_from_pag(*newpag, &gidset[0], &gidset[1]);
 210     code = afs_setgroups(cr, ngroups, gidset, change_parent);
 211
 212     /* If change_parent is set, then we should set the pag in the parent as
 213      * well.
 214      */
 215     if (change_parent && !code) {
 216         code = set_pag_in_parent(*newpag, gidset[0], gidset[1]);
 217     }
 218
 219     osi_Free((char *)gidset, NGROUPS * sizeof(int));
 220     return code;
 221 #endif
 222 }
 223
 224
 225 /* Intercept the standard system call. */
 226 extern asmlinkage long (*sys_setgroupsp) (int gidsetsize, gid_t * grouplist);
 227 asmlinkage long
 228 afs_xsetgroups(int gidsetsize, gid_t * grouplist)
 229 {
 230     long code;
 231     cred_t *cr = crref();
 232     afs_uint32 junk;
 233     int old_pag;
 234
 235     lock_kernel();
 236     old_pag = PagInCred(cr);
 237     crfree(cr);
 238     unlock_kernel();
 239
 240     code = (*sys_setgroupsp) (gidsetsize, grouplist);
 241     if (code) {
 242         return code;
 243     }
 244
 245     lock_kernel();
 246     cr = crref();
 247     if (old_pag != NOPAG && PagInCred(cr) == NOPAG) {
 248         /* re-install old pag if there's room. */
 249         code = setpag(&cr, old_pag, &junk, 0);
 250     }
 251     crfree(cr);
 252     unlock_kernel();
 253
 254     /* Linux syscall ABI returns errno as negative */
 255     return (-code);
 256 }
 257
 258 #if defined(AFS_LINUX24_ENV)
 259 /* Intercept the standard uid32 system call. */
 260 extern asmlinkage long (*sys_setgroups32p) (int gidsetsize, gid_t * grouplist);
 261 asmlinkage long
 262 afs_xsetgroups32(int gidsetsize, gid_t * grouplist)
 263 {
 264     long code;
 265     cred_t *cr = crref();
 266     afs_uint32 junk;
 267     int old_pag;
 268
 269     lock_kernel();
 270     old_pag = PagInCred(cr);
 271     crfree(cr);
 272     unlock_kernel();
 273
 274     code = (*sys_setgroups32p) (gidsetsize, grouplist);
 275
 276     if (code) {
 277         return code;
 278     }
 279
 280     lock_kernel();
 281     cr = crref();
 282     if (old_pag != NOPAG && PagInCred(cr) == NOPAG) {
 283         /* re-install old pag if there's room. */
 284         code = setpag(&cr, old_pag, &junk, 0);
 285     }
 286     crfree(cr);
 287     unlock_kernel();
 288
 289     /* Linux syscall ABI returns errno as negative */
 290     return (-code);
 291 }
 292 #endif
 293
 294 #if defined(AFS_PPC64_LINUX20_ENV)
 295 /* Intercept the uid16 system call as used by 32bit programs. */
 296 extern long (*sys32_setgroupsp)(int gidsetsize, gid_t *grouplist);
 297 asmlinkage long afs32_xsetgroups(int gidsetsize, gid_t *grouplist)
 298 {
 299     long code;
 300     cred_t *cr = crref();
 301     afs_uint32 junk;
 302     int old_pag;
 303
 304     lock_kernel();
 305     old_pag = PagInCred(cr);
 306     crfree(cr);
 307     unlock_kernel();
 308
 309     code = (*sys32_setgroupsp)(gidsetsize, grouplist);
 310     if (code) {
 311         return code;
 312     }
 313
 314     lock_kernel();
 315     cr = crref();
 316     if (old_pag != NOPAG && PagInCred(cr) == NOPAG) {
 317         /* re-install old pag if there's room. */
 318         code = setpag(&cr, old_pag, &junk, 0);
 319     }
 320     crfree(cr);
 321     unlock_kernel();
 322
 323     /* Linux syscall ABI returns errno as negative */
 324     return (-code);
 325 }
 326 #endif
 327
 328 #if defined(AFS_SPARC64_LINUX20_ENV) || defined(AFS_AMD64_LINUX20_ENV)
 329 /* Intercept the uid16 system call as used by 32bit programs. */
 330 extern long (*sys32_setgroupsp) (int gidsetsize, u16 * grouplist);
 331 asmlinkage long
 332 afs32_xsetgroups(int gidsetsize, u16 * grouplist)
 333 {
 334     long code;
 335     cred_t *cr = crref();
 336     afs_uint32 junk;
 337     int old_pag;
 338
 339     lock_kernel();
 340     old_pag = PagInCred(cr);
 341     crfree(cr);
 342     unlock_kernel();
 343
 344     code = (*sys32_setgroupsp) (gidsetsize, grouplist);
 345     if (code) {
 346         return code;
 347     }
 348
 349     lock_kernel();
 350     cr = crref();
 351     if (old_pag != NOPAG && PagInCred(cr) == NOPAG) {
 352         /* re-install old pag if there's room. */
 353         code = setpag(&cr, old_pag, &junk, 0);
 354     }
 355     crfree(cr);
 356     unlock_kernel();
 357
 358     /* Linux syscall ABI returns errno as negative */
 359     return (-code);
 360 }
 361
 362 #ifdef AFS_LINUX24_ENV
 363 /* Intercept the uid32 system call as used by 32bit programs. */
 364 extern long (*sys32_setgroups32p) (int gidsetsize, gid_t * grouplist);
 365 asmlinkage long
 366 afs32_xsetgroups32(int gidsetsize, gid_t * grouplist)
 367 {
 368     long code;
 369     cred_t *cr = crref();
 370     afs_uint32 junk;
 371     int old_pag;
 372
 373     lock_kernel();
 374     old_pag = PagInCred(cr);
 375     crfree(cr);
 376     unlock_kernel();
 377
 378     code = (*sys32_setgroups32p) (gidsetsize, grouplist);
 379     if (code) {
 380         return code;
 381     }
 382
 383     lock_kernel();
 384     cr = crref();
 385     if (old_pag != NOPAG && PagInCred(cr) == NOPAG) {
 386         /* re-install old pag if there's room. */
 387         code = setpag(&cr, old_pag, &junk, 0);
 388     }
 389     crfree(cr);
 390     unlock_kernel();
 391
 392     /* Linux syscall ABI returns errno as negative */
 393     return (-code);
 394 }
 395 #endif
 396 #endif
 397