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 #ifdef LINUX_KEYRING_SUPPORT
  19 #include <linux/seq_file.h>
  20 #endif
  21
  22 RCSID
  23     ("$Header$");
  24
  25 #include "afs/sysincludes.h"
  26 #include "afsincludes.h"
  27 #include "afs/afs_stats.h"      /* statistics */
  28 #include "afs/nfsclient.h"
  29 #ifdef AFS_LINUX22_ENV
  30 #include "h/smp_lock.h"
  31 #endif
  32
  33 #ifdef AFS_LINUX26_ONEGROUP_ENV
  34 #define NUMPAGGROUPS 1
  35 #else
  36 #define NUMPAGGROUPS 2
  37 #endif
  38
  39 #if defined(AFS_LINUX26_ENV)
  40 static int
  41 afs_setgroups(cred_t **cr, struct group_info *group_info, int change_parent)
  42 {
  43     struct group_info *old_info;
  44
  45     AFS_STATCNT(afs_setgroups);
  46
  47     old_info = (*cr)->cr_group_info;
  48     get_group_info(group_info);
  49     (*cr)->cr_group_info = group_info;
  50     put_group_info(old_info);
  51
  52     crset(*cr);
  53
  54     if (change_parent) {
  55         old_info = current->parent->group_info;
  56         get_group_info(group_info);
  57         current->parent->group_info = group_info;
  58         put_group_info(old_info);
  59     }
  60
  61     return (0);
  62 }
  63 #else
  64 static int
  65 afs_setgroups(cred_t **cr, int ngroups, gid_t * gidset, int change_parent)
  66 {
  67     int ngrps;
  68     int i;
  69     gid_t *gp;
  70
  71     AFS_STATCNT(afs_setgroups);
  72
  73     if (ngroups > NGROUPS)
  74         return EINVAL;
  75
  76     gp = (*cr)->cr_groups;
  77     if (ngroups < NGROUPS)
  78         gp[ngroups] = (gid_t) NOGROUP;
  79
  80     for (i = ngroups; i > 0; i--) {
  81         *gp++ = *gidset++;
  82     }
  83
  84     (*cr)->cr_ngroups = ngroups;
  85     crset(*cr);
  86     return (0);
  87 }
  88 #endif
  89
  90 #if defined(AFS_LINUX26_ENV)
  91 static struct group_info *
  92 afs_getgroups(cred_t * cr)
  93 {
  94     AFS_STATCNT(afs_getgroups);
  95
  96     get_group_info(cr->cr_group_info);
  97     return cr->cr_group_info;
  98 }
  99 #else
 100 /* Returns number of groups. And we trust groups to be large enough to
 101  * hold all the groups.
 102  */
 103 static int
 104 afs_getgroups(cred_t *cr, gid_t *groups)
 105 {
 106     int i;
 107     int n;
 108     gid_t *gp;
 109
 110     AFS_STATCNT(afs_getgroups);
 111
 112     gp = cr->cr_groups;
 113     n = cr->cr_ngroups;
 114
 115     for (i = 0; (i < n) && (*gp != (gid_t) NOGROUP); i++)
 116         *groups++ = *gp++;
 117     return i;
 118 }
 119 #endif
 120
 121 #if !defined(AFS_LINUX26_ENV)
 122 /* Only propogate the PAG to the parent process. Unix's propogate to
 123  * all processes sharing the cred.
 124  */
 125 int
 126 set_pag_in_parent(int pag, int g0, int g1)
 127 {
 128     int i;
 129 #ifdef STRUCT_TASK_STRUCT_HAS_PARENT
 130     gid_t *gp = current->parent->groups;
 131     int ngroups = current->parent->ngroups;
 132 #else
 133     gid_t *gp = current->p_pptr->groups;
 134     int ngroups = current->p_pptr->ngroups;
 135 #endif
 136
 137     if ((ngroups < 2) || (afs_get_pag_from_groups(gp[0], gp[1]) == NOPAG)) {
 138         /* We will have to shift grouplist to make room for pag */
 139         if (ngroups + 2 > NGROUPS) {
 140             return EINVAL;
 141         }
 142         for (i = ngroups - 1; i >= 0; i--) {
 143             gp[i + 2] = gp[i];
 144         }
 145         ngroups += 2;
 146     }
 147     gp[0] = g0;
 148     gp[1] = g1;
 149     if (ngroups < NGROUPS)
 150         gp[ngroups] = NOGROUP;
 151
 152 #ifdef STRUCT_TASK_STRUCT_HAS_PARENT
 153     current->parent->ngroups = ngroups;
 154 #else
 155     current->p_pptr->ngroups = ngroups;
 156 #endif
 157     return 0;
 158 }
 159 #endif
 160
 161 #if defined(AFS_LINUX26_ENV)
 162 int
 163 __setpag(cred_t **cr, afs_uint32 pagvalue, afs_uint32 *newpag,
 164          int change_parent)
 165 {
 166     struct group_info *group_info;
 167     gid_t g0, g1;
 168     struct group_info *tmp;
 169     int i;
 170 #ifdef AFS_LINUX26_ONEGROUP_ENV
 171     int j;
 172 #endif
 173     int need_space = 0;
 174
 175     group_info = afs_getgroups(*cr);
 176     if (group_info->ngroups < NUMPAGGROUPS
 177         ||  afs_get_pag_from_groups(
 178 #ifdef AFS_LINUX26_ONEGROUP_ENV
 179             group_info
 180 #else
 181             GROUP_AT(group_info, 0) ,GROUP_AT(group_info, 1)
 182 #endif
 183                                     ) == NOPAG)
 184         /* We will have to make sure group_info is big enough for pag */
 185         need_space = NUMPAGGROUPS;
 186
 187     tmp = groups_alloc(group_info->ngroups + need_space);
 188
 189     *newpag = (pagvalue == -1 ? genpag() : pagvalue);
 190 #ifdef AFS_LINUX26_ONEGROUP_ENV
 191     for (i = 0, j = 0; i < group_info->ngroups; ++i) {
 192         int ths = GROUP_AT(group_info, i);
 193         int last = i > 0 ? GROUP_AT(group_info, i-1) : 0;
 194         if ((ths >> 24) == 'A')
 195             continue;
 196         if (last <= *newpag && ths > *newpag) {
 197            GROUP_AT(tmp, j) = *newpag;
 198            j++;
 199         }
 200         GROUP_AT(tmp, j) = ths;
 201         j++;
 202     }
 203     if (j != i + need_space)
 204         GROUP_AT(tmp, j) = *newpag;
 205 #else
 206     for (i = 0; i < group_info->ngroups; ++i)
 207       GROUP_AT(tmp, i + need_space) = GROUP_AT(group_info, i);
 208 #endif
 209     put_group_info(group_info);
 210     group_info = tmp;
 211
 212 #ifndef AFS_LINUX26_ONEGROUP_ENV
 213     afs_get_groups_from_pag(*newpag, &g0, &g1);
 214     GROUP_AT(group_info, 0) = g0;
 215     GROUP_AT(group_info, 1) = g1;
 216 #endif
 217
 218     afs_setgroups(cr, group_info, change_parent);
 219
 220     put_group_info(group_info);
 221
 222     return 0;
 223 }
 224
 225 #ifdef LINUX_KEYRING_SUPPORT
 226 extern struct key_type key_type_keyring __attribute__((weak));
 227 static struct key_type *__key_type_keyring = &key_type_keyring;
 228
 229 static int
 230 install_session_keyring(struct task_struct *task, struct key *keyring)
 231 {
 232     struct key *old;
 233     char desc[20];
 234     unsigned long not_in_quota;
 235     int code = -EINVAL;
 236
 237     if (!__key_type_keyring)
 238         return code;
 239
 240     if (!keyring) {
 241
 242         /* create an empty session keyring */
 243         not_in_quota = KEY_ALLOC_IN_QUOTA;
 244         sprintf(desc, "_ses.%u", task->tgid);
 245
 246 #ifdef KEY_ALLOC_NEEDS_STRUCT_TASK
 247         keyring = key_alloc(__key_type_keyring, desc,
 248                             task->uid, task->gid, task,
 249                             (KEY_POS_ALL & ~KEY_POS_SETATTR) | KEY_USR_ALL,
 250                             not_in_quota);
 251 #else
 252         keyring = key_alloc(__key_type_keyring, desc,
 253                             task->uid, task->gid,
 254                             (KEY_POS_ALL & ~KEY_POS_SETATTR) | KEY_USR_ALL,
 255                             not_in_quota);
 256 #endif
 257         if (IS_ERR(keyring)) {
 258             code = PTR_ERR(keyring);
 259             goto out;
 260         }
 261     }
 262
 263     code = key_instantiate_and_link(keyring, NULL, 0, NULL, NULL);
 264     if (code < 0) {
 265         key_put(keyring);
 266         goto out;
 267     }
 268
 269     /* install the keyring */
 270     spin_lock_irq(&task->sighand->siglock);
 271     old = task->signal->session_keyring;
 272     smp_wmb();
 273     task->signal->session_keyring = keyring;
 274     spin_unlock_irq(&task->sighand->siglock);
 275
 276     if (old)
 277             key_put(old);
 278
 279 out:
 280     return code;
 281 }
 282 #endif /* LINUX_KEYRING_SUPPORT */
 283
 284 #else
 285 int
 286 __setpag(cred_t **cr, afs_uint32 pagvalue, afs_uint32 *newpag,
 287          int change_parent)
 288 {
 289     gid_t *gidset;
 290     afs_int32 ngroups, code = 0;
 291     int j;
 292
 293     gidset = (gid_t *) osi_Alloc(NGROUPS * sizeof(gidset[0]));
 294     ngroups = afs_getgroups(*cr, gidset);
 295
 296     if (afs_get_pag_from_groups(gidset[0], gidset[1]) == NOPAG) {
 297         /* We will have to shift grouplist to make room for pag */
 298         if (ngroups + 2 > NGROUPS) {
 299             osi_Free((char *)gidset, NGROUPS * sizeof(int));
 300             return EINVAL;
 301         }
 302         for (j = ngroups - 1; j >= 0; j--) {
 303             gidset[j + 2] = gidset[j];
 304         }
 305         ngroups += 2;
 306     }
 307     *newpag = (pagvalue == -1 ? genpag() : pagvalue);
 308     afs_get_groups_from_pag(*newpag, &gidset[0], &gidset[1]);
 309     code = afs_setgroups(cr, ngroups, gidset, change_parent);
 310
 311     /* If change_parent is set, then we should set the pag in the parent as
 312      * well.
 313      */
 314     if (change_parent && !code) {
 315         code = set_pag_in_parent(*newpag, gidset[0], gidset[1]);
 316     }
 317
 318     osi_Free((char *)gidset, NGROUPS * sizeof(int));
 319     return code;
 320 }
 321 #endif
 322
 323
 324 int
 325 setpag(cred_t **cr, afs_uint32 pagvalue, afs_uint32 *newpag,
 326        int change_parent)
 327 {
 328     int code;
 329
 330     AFS_STATCNT(setpag);
 331
 332     code = __setpag(cr, pagvalue, newpag, change_parent);
 333
 334 #ifdef LINUX_KEYRING_SUPPORT
 335     if (code == 0 && (*cr)->cr_rgid != NFSXLATOR_CRED) {
 336         (void) install_session_keyring(current, NULL);
 337
 338         if (current->signal->session_keyring) {
 339             struct key *key;
 340             key_perm_t perm;
 341
 342             perm = KEY_POS_VIEW | KEY_POS_SEARCH;
 343             perm |= KEY_USR_VIEW | KEY_USR_SEARCH;
 344
 345 #ifdef KEY_ALLOC_NEEDS_STRUCT_TASK
 346             key = key_alloc(&key_type_afs_pag, "_pag", 0, 0, current, perm, 1);
 347 #else
 348             key = key_alloc(&key_type_afs_pag, "_pag", 0, 0, perm, 1);
 349 #endif
 350
 351             if (!IS_ERR(key)) {
 352                 key_instantiate_and_link(key, (void *) newpag, sizeof(afs_uint32),
 353                                          current->signal->session_keyring, NULL);
 354                 key_put(key);
 355             }
 356         }
 357     }
 358 #endif /* LINUX_KEYRING_SUPPORT */
 359
 360     return code;
 361 }
 362
 363
 364 /* Intercept the standard system call. */
 365 extern asmlinkage long (*sys_setgroupsp) (int gidsetsize, gid_t * grouplist);
 366 asmlinkage long
 367 afs_xsetgroups(int gidsetsize, gid_t * grouplist)
 368 {
 369     long code;
 370     cred_t *cr = crref();
 371     afs_uint32 junk;
 372     int old_pag;
 373
 374     lock_kernel();
 375     old_pag = PagInCred(cr);
 376     crfree(cr);
 377     unlock_kernel();
 378
 379     code = (*sys_setgroupsp) (gidsetsize, grouplist);
 380     if (code) {
 381         return code;
 382     }
 383
 384     lock_kernel();
 385     cr = crref();
 386     if (old_pag != NOPAG && PagInCred(cr) == NOPAG) {
 387         /* re-install old pag if there's room. */
 388         code = __setpag(&cr, old_pag, &junk, 0);
 389     }
 390     crfree(cr);
 391     unlock_kernel();
 392
 393     /* Linux syscall ABI returns errno as negative */
 394     return (-code);
 395 }
 396
 397 #if defined(AFS_LINUX24_ENV)
 398 /* Intercept the standard uid32 system call. */
 399 extern asmlinkage long (*sys_setgroups32p) (int gidsetsize, gid_t * grouplist);
 400 asmlinkage long
 401 afs_xsetgroups32(int gidsetsize, gid_t * grouplist)
 402 {
 403     long code;
 404     cred_t *cr = crref();
 405     afs_uint32 junk;
 406     int old_pag;
 407
 408     lock_kernel();
 409     old_pag = PagInCred(cr);
 410     crfree(cr);
 411     unlock_kernel();
 412
 413     code = (*sys_setgroups32p) (gidsetsize, grouplist);
 414
 415     if (code) {
 416         return code;
 417     }
 418
 419     lock_kernel();
 420     cr = crref();
 421     if (old_pag != NOPAG && PagInCred(cr) == NOPAG) {
 422         /* re-install old pag if there's room. */
 423         code = __setpag(&cr, old_pag, &junk, 0);
 424     }
 425     crfree(cr);
 426     unlock_kernel();
 427
 428     /* Linux syscall ABI returns errno as negative */
 429     return (-code);
 430 }
 431 #endif
 432
 433 #if defined(AFS_PPC64_LINUX20_ENV)
 434 /* Intercept the uid16 system call as used by 32bit programs. */
 435 extern long (*sys32_setgroupsp)(int gidsetsize, gid_t *grouplist);
 436 asmlinkage long afs32_xsetgroups(int gidsetsize, gid_t *grouplist)
 437 {
 438     long code;
 439     cred_t *cr = crref();
 440     afs_uint32 junk;
 441     int old_pag;
 442
 443     lock_kernel();
 444     old_pag = PagInCred(cr);
 445     crfree(cr);
 446     unlock_kernel();
 447
 448     code = (*sys32_setgroupsp)(gidsetsize, grouplist);
 449     if (code) {
 450         return code;
 451     }
 452
 453     lock_kernel();
 454     cr = crref();
 455     if (old_pag != NOPAG && PagInCred(cr) == NOPAG) {
 456         /* re-install old pag if there's room. */
 457         code = __setpag(&cr, old_pag, &junk, 0);
 458     }
 459     crfree(cr);
 460     unlock_kernel();
 461
 462     /* Linux syscall ABI returns errno as negative */
 463     return (-code);
 464 }
 465 #endif
 466
 467 #if defined(AFS_SPARC64_LINUX20_ENV) || defined(AFS_AMD64_LINUX20_ENV)
 468 /* Intercept the uid16 system call as used by 32bit programs. */
 469 extern long (*sys32_setgroupsp) (int gidsetsize, u16 * grouplist);
 470 asmlinkage long
 471 afs32_xsetgroups(int gidsetsize, u16 * grouplist)
 472 {
 473     long code;
 474     cred_t *cr = crref();
 475     afs_uint32 junk;
 476     int old_pag;
 477
 478     lock_kernel();
 479     old_pag = PagInCred(cr);
 480     crfree(cr);
 481     unlock_kernel();
 482
 483     code = (*sys32_setgroupsp) (gidsetsize, grouplist);
 484     if (code) {
 485         return code;
 486     }
 487
 488     lock_kernel();
 489     cr = crref();
 490     if (old_pag != NOPAG && PagInCred(cr) == NOPAG) {
 491         /* re-install old pag if there's room. */
 492         code = __setpag(&cr, old_pag, &junk, 0);
 493     }
 494     crfree(cr);
 495     unlock_kernel();
 496
 497     /* Linux syscall ABI returns errno as negative */
 498     return (-code);
 499 }
 500
 501 #ifdef AFS_LINUX24_ENV
 502 /* Intercept the uid32 system call as used by 32bit programs. */
 503 extern long (*sys32_setgroups32p) (int gidsetsize, gid_t * grouplist);
 504 asmlinkage long
 505 afs32_xsetgroups32(int gidsetsize, gid_t * grouplist)
 506 {
 507     long code;
 508     cred_t *cr = crref();
 509     afs_uint32 junk;
 510     int old_pag;
 511
 512     lock_kernel();
 513     old_pag = PagInCred(cr);
 514     crfree(cr);
 515     unlock_kernel();
 516
 517     code = (*sys32_setgroups32p) (gidsetsize, grouplist);
 518     if (code) {
 519         return code;
 520     }
 521
 522     lock_kernel();
 523     cr = crref();
 524     if (old_pag != NOPAG && PagInCred(cr) == NOPAG) {
 525         /* re-install old pag if there's room. */
 526         code = __setpag(&cr, old_pag, &junk, 0);
 527     }
 528     crfree(cr);
 529     unlock_kernel();
 530
 531     /* Linux syscall ABI returns errno as negative */
 532     return (-code);
 533 }
 534 #endif
 535 #endif
 536
 537
 538 #ifdef LINUX_KEYRING_SUPPORT
 539 static void afs_pag_describe(const struct key *key, struct seq_file *m)
 540 {
 541     seq_puts(m, key->description);
 542
 543     seq_printf(m, ": %u", key->datalen);
 544 }
 545
 546 static int afs_pag_instantiate(struct key *key, const void *data, size_t datalen)
 547 {
 548     int code;
 549     afs_uint32 *userpag, pag = NOPAG;
 550     int g0, g1;
 551
 552     if (key->uid != 0 || key->gid != 0)
 553         return -EPERM;
 554
 555     code = -EINVAL;
 556     get_group_info(current->group_info);
 557
 558     if (datalen != sizeof(afs_uint32) || !data)
 559         goto error;
 560
 561     if (current->group_info->ngroups < NUMPAGGROUPS)
 562         goto error;
 563
 564     /* ensure key being set matches current pag */
 565 #ifdef AFS_LINUX26_ONEGROUP_ENV
 566     pag = afs_get_pag_from_groups(current->group_info);
 567 #else
 568     g0 = GROUP_AT(current->group_info, 0);
 569     g1 = GROUP_AT(current->group_info, 1);
 570
 571     pag = afs_get_pag_from_groups(g0, g1);
 572 #endif
 573     if (pag == NOPAG)
 574         goto error;
 575
 576     userpag = (afs_uint32 *) data;
 577     if (*userpag != pag)
 578         goto error;
 579
 580     key->payload.value = (unsigned long) *userpag;
 581     key->datalen = sizeof(afs_uint32);
 582     code = 0;
 583
 584 error:
 585     put_group_info(current->group_info);
 586     return code;
 587 }
 588
 589 static int afs_pag_match(const struct key *key, const void *description)
 590 {
 591         return strcmp(key->description, description) == 0;
 592 }
 593
 594 static void afs_pag_destroy(struct key *key)
 595 {
 596     afs_uint32 pag = key->payload.value;
 597     struct unixuser *pu;
 598     int locked = ISAFS_GLOCK();
 599
 600     if (!locked)
 601         AFS_GLOCK();
 602     pu = afs_FindUser(pag, -1, READ_LOCK);
 603     if (pu) {
 604         pu->ct.EndTimestamp = 0;
 605         pu->tokenTime = 0;
 606         afs_PutUser(pu, READ_LOCK);
 607     }
 608     if (!locked)
 609         AFS_GUNLOCK();
 610 }
 611
 612 struct key_type key_type_afs_pag =
 613 {
 614     .name        = "afs_pag",
 615     .describe    = afs_pag_describe,
 616     .instantiate = afs_pag_instantiate,
 617     .match       = afs_pag_match,
 618     .destroy     = afs_pag_destroy,
 619 };
 620
 621 #ifdef EXPORTED_TASKLIST_LOCK
 622 extern rwlock_t tasklist_lock __attribute__((weak));
 623 #endif
 624
 625 void osi_keyring_init(void)
 626 {
 627     struct task_struct *p;
 628
 629     if (__key_type_keyring == NULL) {
 630 #ifdef EXPORTED_TASKLIST_LOCK
 631         if (&tasklist_lock)
 632             read_lock(&tasklist_lock);
 633 #endif
 634 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
 635 # ifdef EXPORTED_TASKLIST_LOCK
 636         else
 637 # endif
 638             rcu_read_lock();
 639 #endif
 640         p = find_task_by_pid(1);
 641         if (p && p->user->session_keyring)
 642             __key_type_keyring = p->user->session_keyring->type;
 643 #ifdef EXPORTED_TASKLIST_LOCK
 644         if (&tasklist_lock)
 645             read_unlock(&tasklist_lock);
 646 #endif
 647 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
 648 # ifdef EXPORTED_TASKLIST_LOCK
 649         else
 650 # endif
 651             rcu_read_unlock();
 652 #endif
 653     }
 654
 655     register_key_type(&key_type_afs_pag);
 656 }
 657
 658 void osi_keyring_shutdown(void)
 659 {
 660     unregister_key_type(&key_type_afs_pag);
 661 }
 662
 663 #else
 664 void osi_keyring_init(void)
 665 {
 666         return;
 667 }
 668
 669 void osi_keyring_shutdown(void)
 670 {
 671         return;
 672 }
 673 #endif