src/ptserver/ptprocs.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 RCSID("$Header$");
  14
  15 #include <afs/stds.h>
  16 #include <ctype.h>
  17 #include <stdio.h>
  18 #include <lock.h>
  19 #include <afs/afsutil.h>
  20 #include <ubik.h>
  21 #include <rx/xdr.h>
  22 #include <rx/rx.h>
  23 #include <rx/rxkad.h>
  24 #include <afs/auth.h>
  25 #ifdef AFS_NT40_ENV
  26 #include <winsock2.h>
  27 #else
  28 #include <netinet/in.h>
  29 #endif
  30 #ifdef HAVE_STRING_H
  31 #include <string.h>
  32 #else
  33 #ifdef HAVE_STRINGS_H
  34 #include <strings.h>
  35 #endif
  36 #endif
  37 #include "ptserver.h"
  38 #include "pterror.h"
  39 #include "afs/audit.h"
  40
  41 #ifdef AFS_ATHENA_STDENV
  42 #include <krb.h>
  43 #endif
  44
  45
  46 #define IP_WILDCARDS    1               /* XXX Should be defined outside of here XXX */
  47
  48 extern struct ubik_dbase *dbase;
  49 extern afs_int32 Initdb();
  50 extern int pr_noAuth;
  51 extern afs_int32 initd;
  52 afs_int32 iNewEntry(), newEntry(), whereIsIt(), dumpEntry(), addToGroup(), nameToID(), Delete(), removeFromGroup();
  53 afs_int32 getCPS(), getCPS2(), getHostCPS(), listMax(), setMax(), listEntry();
  54 afs_int32 listEntries(), changeEntry(), setFieldsEntry(), put_prentries();
  55 afs_int32 listElements(), listOwned(), isAMemberOf(), idToName();
  56
  57 static stolower();
  58 extern int IDCmp();
  59
  60 /* When abort, reset initd so that the header is read in on next call.
  61  * Abort the transarction and return the code.
  62  */
  63 #define ABORT_WITH(tt,code) return(initd=0,ubik_AbortTrans(tt),code)
  64
  65 static int CreateOK (ut, cid, oid, flag, admin)
  66   struct ubik_trans *ut;
  67   afs_int32 cid;                                /* id of caller */
  68   afs_int32 oid;                                /* id of owner */
  69   afs_int32 flag;                               /* indicates type of entry */
  70   int  admin;                           /* sysadmin membership */
  71 {
  72     if (flag & PRFOREIGN) {
  73        /* Foreign users are recognized by the '@' sign and
  74         * not by the PRFOREIGN flag.
  75         */
  76        return 0;
  77     }
  78     else if (flag & PRGRP) {
  79         /* Allow anonymous group creation only if owner specified
  80          * and running noAuth.
  81          */
  82         if (cid == ANONYMOUSID) {
  83             if ((oid == 0) || !pr_noAuth) return 0;
  84         }
  85     }
  86     else { /* creating a user */
  87         if (!admin && !pr_noAuth) return 0;
  88     }
  89     return 1;                           /* OK! */
  90 }
  91
  92 afs_int32 WhoIsThis (acall, at, aid)
  93   struct rx_call *acall;
  94   struct ubik_trans *at;
  95   afs_int32 *aid;
  96 {
  97     int foreign = 0;
  98     /* aid is set to the identity of the caller, if known, else ANONYMOUSID */
  99     /* returns -1 and sets aid to ANONYMOUSID on any failure */
 100     register struct rx_connection *tconn;
 101     register afs_int32 code;
 102     char tcell[MAXKTCREALMLEN];
 103     char name[MAXKTCNAMELEN];
 104     char inst[MAXKTCNAMELEN];
 105     int  ilen;
 106     char vname[256];
 107
 108     *aid = ANONYMOUSID;
 109     tconn = rx_ConnectionOf(acall);
 110     code = rx_SecurityClassOf(tconn);
 111     if (code == 0) return 0;
 112     else if (code == 1) {               /* vab class */
 113         goto done;                      /* no longer supported */
 114     }
 115     else if (code == 2) {               /* kad class */
 116         if ((code = rxkad_GetServerInfo
 117             (acall->conn, (afs_int32 *) 0, 0/*was &exp*/,
 118              name, inst, tcell, (afs_int32 *) 0)))
 119             goto done;
 120 #if 0
 121         /* This test is unnecessary, since rxkad_GetServerInfo already check.
 122          * In addition, this is wrong since exp must be unsigned. */
 123         if (exp < FT_ApproxTime()) goto done;
 124 #endif
 125         if (strlen (tcell)) {
 126             extern char *pr_realmName;
 127 #if     defined(AFS_ATHENA_STDENV) || defined(AFS_KERBREALM_ENV)
 128             static char local_realm[AFS_REALM_SZ] = "";
 129             if (!local_realm[0]) {
 130                 if (afs_krb_get_lrealm(local_realm, 0) != 0/*KSUCCESS*/)
 131                     strncpy(local_realm, pr_realmName, AFS_REALM_SZ);
 132             }
 133 #endif
 134             if (
 135 #if     defined(AFS_ATHENA_STDENV) || defined(AFS_KERBREALM_ENV)
 136                 strcasecmp (local_realm, tcell) &&
 137 #endif
 138                 strcasecmp (pr_realmName, tcell))
 139                 foreign = 1;
 140         }
 141         strncpy (vname, name, sizeof(vname));
 142         if (ilen = strlen (inst)) {
 143             if (strlen(vname) + 1 + ilen >= sizeof(vname)) goto done;
 144             strcat (vname, ".");
 145             strcat (vname, inst);
 146         }
 147         if (foreign) {
 148             if (strlen(vname) + strlen(tcell) + 1 >= sizeof(vname)) goto done;
 149             strcat (vname, "@");
 150             strcat (vname, tcell);
 151         }
 152         if (strcmp (AUTH_SUPERUSER, vname) == 0)
 153             *aid = SYSADMINID;          /* special case for the fileserver */
 154         else {
 155             lcstring(vname, vname, sizeof(vname));
 156             code = NameToID(at,vname,aid);
 157         }
 158     }
 159   done:
 160     if (code && !pr_noAuth) return -1;
 161     return 0;
 162 }
 163
 164 afs_int32 PR_INewEntry (call,aname,aid,oid)
 165   struct rx_call *call;
 166   char aname[PR_MAXNAMELEN];
 167   afs_int32 aid;
 168   afs_int32 oid;
 169 {
 170   afs_int32 code;
 171
 172   code = iNewEntry (call,aname,aid,oid);
 173   osi_auditU (call, PTS_INewEntEvent, code, AUD_LONG, aid, AUD_STR, aname, AUD_LONG, oid, AUD_END);
 174   return code;
 175 }
 176
 177 afs_int32 iNewEntry (call,aname,aid,oid)
 178   struct rx_call *call;
 179   char aname[PR_MAXNAMELEN];
 180   afs_int32 aid;
 181   afs_int32 oid;
 182 {
 183     /* used primarily for conversion - not intended to be used as usual means
 184        of entering people into the database. */
 185     struct ubik_trans *tt;
 186     register afs_int32 code;
 187     afs_int32 gflag = 0;
 188     afs_int32 cid;
 189     int  admin;
 190
 191     stolower(aname);
 192     code = Initdb();
 193     if (code != PRSUCCESS) return code;
 194     code = ubik_BeginTrans(dbase,UBIK_WRITETRANS, &tt);
 195     if (code) return code;
 196     code = ubik_SetLock(tt, 1,1,LOCKWRITE);
 197     if (code) ABORT_WITH(tt,code);
 198     code = read_DbHeader(tt);
 199     if (code) ABORT_WITH(tt,code);
 200
 201     code = WhoIsThis(call,tt,&cid);
 202     if (code) ABORT_WITH(tt,PRPERM);
 203     admin = IsAMemberOf(tt,cid,SYSADMINID);
 204
 205     /* first verify the id is good */
 206     if (aid == 0) ABORT_WITH(tt,PRPERM);
 207     if (aid < 0) {
 208         gflag |= PRGRP;
 209         /* only sysadmin can reuse a group id */
 210         if (!admin && !pr_noAuth && (aid != ntohl(cheader.maxGroup)-1))
 211             ABORT_WITH(tt,PRPERM);
 212     }
 213     if (FindByID (tt, aid)) ABORT_WITH(tt,PRIDEXIST);
 214
 215     /* check a few other things */
 216     if (!CreateOK (tt, cid, oid, gflag, admin)) ABORT_WITH(tt,PRPERM);
 217
 218     code = CreateEntry (tt,aname,&aid,1,gflag,oid,cid);
 219     if (code != PRSUCCESS) ABORT_WITH(tt,code);
 220
 221     /* finally, commit transaction */
 222     code = ubik_EndTrans(tt);
 223     if (code) return code;
 224     return PRSUCCESS;
 225 }
 226
 227
 228 afs_int32 PR_NewEntry (call, aname, flag, oid, aid)
 229   struct rx_call *call;
 230   char aname[PR_MAXNAMELEN];
 231   afs_int32 flag;
 232   afs_int32 oid;
 233   afs_int32 *aid;
 234 {
 235   afs_int32 code;
 236
 237   code = newEntry (call, aname, flag, oid, aid);
 238   osi_auditU (call, PTS_NewEntEvent, code, AUD_LONG, *aid, AUD_STR, aname, AUD_LONG, oid, AUD_END);
 239   return code;
 240 }
 241
 242 afs_int32 newEntry (call, aname, flag, oid, aid)
 243   struct rx_call *call;
 244   char aname[PR_MAXNAMELEN];
 245   afs_int32 flag;
 246   afs_int32 oid;
 247   afs_int32 *aid;
 248 {
 249     register afs_int32 code;
 250     struct ubik_trans *tt;
 251     afs_int32 cid;
 252     int  admin;
 253     extern afs_int32 WhoIsThisWithName();
 254     char cname[PR_MAXNAMELEN];
 255     stolower(aname);
 256     code = Initdb();
 257     if (code) return code;
 258     code = ubik_BeginTrans(dbase,UBIK_WRITETRANS,&tt);
 259     if (code) return code;
 260     code = ubik_SetLock(tt,1,1,LOCKWRITE);
 261     if (code) ABORT_WITH(tt,code);
 262     code = read_DbHeader(tt);
 263     if (code) ABORT_WITH(tt,code);
 264
 265     /* this is for cross-cell self registration. It is not added in the
 266      * PR_INewEntry because we want self-registration to only do
 267      * automatic id assignment.
 268      */
 269     code = WhoIsThisWithName(call,tt,&cid,cname);
 270     if (code != 2) {/* 2 specifies that this is a foreign cell request */
 271         if (code) ABORT_WITH(tt,PRPERM);
 272         admin = IsAMemberOf(tt,cid,SYSADMINID);
 273     } else {
 274         admin = (!strcmp(aname,cname)) || IsAMemberOf(tt,cid,SYSADMINID);
 275         oid = cid = SYSADMINID;
 276     }
 277     if (!CreateOK (tt, cid, oid, flag, admin)) ABORT_WITH(tt,PRPERM);
 278
 279     code = CreateEntry (tt,aname,aid,0,flag,oid,cid);
 280     if (code != PRSUCCESS) ABORT_WITH(tt,code);
 281
 282     code = ubik_EndTrans(tt);
 283     if (code) return code;
 284     return PRSUCCESS;
 285 }
 286
 287
 288
 289 afs_int32 PR_WhereIsIt (call,aid,apos)
 290 struct rx_call *call;
 291 afs_int32 aid;
 292 afs_int32 *apos;
 293 {
 294   afs_int32 code;
 295
 296   code = whereIsIt(call,aid,apos);
 297   osi_auditU (call, PTS_WheIsItEvent, code, AUD_LONG, aid, AUD_LONG, *apos, AUD_END);
 298   return code;
 299 }
 300
 301 afs_int32 whereIsIt (call,aid,apos)
 302 struct rx_call *call;
 303 afs_int32 aid;
 304 afs_int32 *apos;
 305 {
 306     register afs_int32 code;
 307     struct ubik_trans *tt;
 308     afs_int32 temp;
 309
 310     code = Initdb();
 311     if (code != PRSUCCESS) return code;
 312     code = ubik_BeginTransReadAny(dbase,UBIK_READTRANS,&tt);
 313     if (code) return code;
 314     code = ubik_SetLock(tt,1,1,LOCKREAD);
 315     if (code) ABORT_WITH(tt,code);
 316     code = read_DbHeader(tt);
 317     if (code) ABORT_WITH(tt,code);
 318
 319     temp = FindByID(tt,aid);
 320     if (!temp) ABORT_WITH(tt,PRNOENT);
 321     *apos = temp;
 322     code = ubik_EndTrans(tt);
 323     if (code) return code;
 324     return PRSUCCESS;
 325 }
 326
 327
 328 afs_int32 PR_DumpEntry (call,apos, aentry)
 329 struct rx_call *call;
 330 afs_int32 apos;
 331 struct prdebugentry *aentry;
 332 {
 333   afs_int32 code;
 334
 335   code = dumpEntry(call,apos, aentry);
 336   osi_auditU (call, PTS_DmpEntEvent, code, AUD_LONG, apos, AUD_END);
 337   return code;
 338 }
 339
 340 afs_int32 dumpEntry (call,apos, aentry)
 341 struct rx_call *call;
 342 afs_int32 apos;
 343 struct prdebugentry *aentry;
 344 {
 345     register afs_int32 code;
 346     afs_int32 cid;
 347     struct ubik_trans *tt;
 348
 349     code = Initdb();
 350     if (code != PRSUCCESS) return code;
 351     code = ubik_BeginTransReadAny(dbase,UBIK_READTRANS,&tt);
 352     if (code) return code;
 353     code = ubik_SetLock(tt,1,1,LOCKREAD);
 354     if (code) ABORT_WITH(tt,code);
 355     code = read_DbHeader(tt);
 356     if (code) ABORT_WITH(tt,code);
 357
 358     code = WhoIsThis(call,tt,&cid);
 359     if (code) ABORT_WITH(tt,PRPERM);
 360     code = pr_ReadEntry(tt, 0, apos, aentry);
 361     if (code) ABORT_WITH(tt,code);
 362
 363     if (!AccessOK (tt, cid, aentry, PRP_STATUS_MEM, PRP_STATUS_ANY))
 364         ABORT_WITH(tt,PRPERM);
 365
 366     /* Since prdebugentry is in the form of a prentry not a coentry, we will
 367      * return the coentry slots in network order where the string is. */
 368 #if 0
 369     if (aentry->flags & PRCONT) {       /* wrong type, get coentry instead */
 370         code = pr_ReadCoEntry(tt, 0, apos, aentry);
 371         if (code) ABORT_WITH(tt,code);
 372     }
 373 #endif
 374     code = ubik_EndTrans(tt);
 375     if (code) return code;
 376     return PRSUCCESS;
 377 }
 378
 379 afs_int32 PR_AddToGroup (call,aid,gid)
 380 struct rx_call *call;
 381 afs_int32 aid;
 382 afs_int32 gid;
 383 {
 384   afs_int32 code;
 385
 386   code = addToGroup (call,aid,gid);
 387   osi_auditU (call, PTS_AdToGrpEvent, code, AUD_LONG, gid, AUD_LONG, aid, AUD_END);
 388   return code;
 389 }
 390
 391 afs_int32 addToGroup (call,aid,gid)
 392 struct rx_call *call;
 393 afs_int32 aid;
 394 afs_int32 gid;
 395 {
 396     register afs_int32 code;
 397     struct ubik_trans *tt;
 398     afs_int32 tempu;
 399     afs_int32 tempg;
 400     struct prentry tentry;
 401     struct prentry uentry;
 402     afs_int32 cid;
 403
 404     code = Initdb();
 405     if (code != PRSUCCESS) return code;
 406     if (gid == ANYUSERID || gid == AUTHUSERID) return PRPERM;
 407     if (aid == ANONYMOUSID) return PRPERM;
 408     code = ubik_BeginTrans(dbase,UBIK_WRITETRANS,&tt);
 409     if (code) return code;
 410     code = ubik_SetLock(tt,1,1,LOCKWRITE);
 411     if (code) ABORT_WITH(tt,code);
 412     code = read_DbHeader(tt);
 413     if (code) ABORT_WITH(tt,code);
 414
 415     code = WhoIsThis(call, tt, &cid);
 416     if (code) ABORT_WITH(tt,PRPERM);
 417     tempu = FindByID(tt,aid);
 418     if (!tempu) ABORT_WITH(tt,PRNOENT);
 419     memset(&uentry, 0, sizeof(uentry));
 420     code = pr_ReadEntry(tt,0,tempu,&uentry);
 421     if (code != 0)  ABORT_WITH(tt,code);
 422     /* we don't allow groups as members of groups at present */
 423     if (uentry.flags & PRGRP) ABORT_WITH(tt,PRNOTUSER);
 424     tempg = FindByID(tt,gid);
 425     if (!tempg) ABORT_WITH(tt,PRNOENT);
 426     code = pr_ReadEntry(tt,0,tempg,&tentry);
 427     if (code != 0) ABORT_WITH(tt,code);
 428     /* make sure that this is a group */
 429     if (!(tentry.flags & PRGRP)) ABORT_WITH(tt,PRNOTGROUP);
 430     if (!AccessOK (tt, cid, &tentry, PRP_ADD_MEM, PRP_ADD_ANY)) ABORT_WITH(tt,PRPERM);
 431
 432     code = AddToEntry (tt, &tentry, tempg, aid);
 433     if (code != PRSUCCESS) ABORT_WITH(tt,code);
 434     /* now, modify the user's entry as well */
 435     code = AddToEntry (tt, &uentry, tempu, gid);
 436     if (code != PRSUCCESS) ABORT_WITH(tt,code);
 437     code = ubik_EndTrans(tt);
 438     if (code) return code;
 439     return PRSUCCESS;
 440 }
 441
 442 afs_int32 PR_NameToID (call, aname, aid)
 443   struct rx_call *call;
 444   namelist *aname;
 445   idlist *aid;
 446 {
 447   afs_int32 code;
 448
 449   code = nameToID (call, aname, aid);
 450   osi_auditU (call, PTS_NmToIdEvent, code, AUD_END);
 451   return code;
 452 }
 453
 454 afs_int32 nameToID (call, aname, aid)
 455   struct rx_call *call;
 456   namelist *aname;
 457   idlist *aid;
 458 {
 459     register afs_int32 code;
 460     struct ubik_trans *tt;
 461     afs_int32 i;
 462     int size;
 463     int count = 0;
 464
 465     /* Initialize return struct */
 466     aid->idlist_len = 0;
 467     aid->idlist_val = (afs_int32 *)0;
 468
 469     size = aname->namelist_len;
 470     if (size == 0) return 0;
 471     if (size <  0) return PRTOOMANY;
 472
 473     aid->idlist_val = (afs_int32 *)malloc(size*sizeof(afs_int32));
 474     if (!aid->idlist_val) return PRNOMEM;
 475
 476     code = Initdb();
 477     if (code != PRSUCCESS) return code;
 478     code = ubik_BeginTransReadAny(dbase,UBIK_READTRANS,&tt);
 479     if (code) return code;
 480     code = ubik_SetLock(tt,1,1,LOCKREAD);
 481     if (code) ABORT_WITH(tt,code);
 482     code = read_DbHeader(tt);
 483     if (code) ABORT_WITH(tt,code);
 484
 485     for (i=0;i<aname->namelist_len;i++) {
 486         code = NameToID(tt,aname->namelist_val[i],&aid->idlist_val[i]);
 487         if (code != PRSUCCESS) aid->idlist_val[i] = ANONYMOUSID;
 488         if (count++ > 50) IOMGR_Poll(), count = 0;
 489     }
 490     aid->idlist_len = aname->namelist_len;
 491
 492     code = ubik_EndTrans(tt);
 493     if (code) return code;
 494     return PRSUCCESS;
 495 }
 496
 497 /*
 498  * PR_IDToName
 499  * Given an array of ids, find the name for each of them.
 500  * The array of ids and names is unlimited.
 501  */
 502 afs_int32 PR_IDToName (call, aid, aname)
 503   struct rx_call *call;
 504   idlist *aid;
 505   namelist *aname;
 506 {
 507   afs_int32 code;
 508
 509   code = idToName (call, aid, aname);
 510   osi_auditU (call, PTS_IdToNmEvent, code, AUD_LONG, aid, AUD_END);
 511   return code;
 512 }
 513
 514 afs_int32 idToName (call, aid, aname)
 515   struct rx_call *call;
 516   idlist *aid;
 517   namelist *aname;
 518 {
 519     register afs_int32 code;
 520     struct ubik_trans *tt;
 521     afs_int32 i;
 522     int size;
 523     int count = 0;
 524
 525     /* leave this first for rpc stub */
 526     size = aid->idlist_len;
 527     if (size <= 0) size = 0;
 528     aname->namelist_val = (prname *)malloc(size*PR_MAXNAMELEN);
 529     aname->namelist_len = 0;
 530     if (aid->idlist_len == 0) return 0;
 531     if (size == 0) return PRTOOMANY;    /* rxgen will probably handle this */
 532
 533     code = Initdb();
 534     if (code != PRSUCCESS) return code;
 535     code = ubik_BeginTransReadAny(dbase,UBIK_READTRANS,&tt);
 536     if (code) return code;
 537     code = ubik_SetLock(tt,1,1,LOCKREAD);
 538     if (code) ABORT_WITH(tt,code);
 539     code = read_DbHeader(tt);
 540     if (code) ABORT_WITH(tt,code);
 541
 542     for (i=0;i<aid->idlist_len;i++) {
 543         code = IDToName(tt,aid->idlist_val[i],aname->namelist_val[i]);
 544         if (code != PRSUCCESS)
 545             sprintf(aname->namelist_val[i],"%d",aid->idlist_val[i]);
 546         if (count++ > 50) IOMGR_Poll(), count = 0;
 547     }
 548     aname->namelist_len = aid->idlist_len;
 549
 550     code = ubik_EndTrans(tt);
 551     if (code) return code;
 552     return PRSUCCESS;
 553 }
 554
 555 afs_int32 PR_Delete (call, aid)
 556   struct rx_call *call;
 557   afs_int32 aid;
 558 {
 559   afs_int32 code;
 560
 561   code = Delete (call, aid);
 562   osi_auditU (call, PTS_DelEvent, code, AUD_LONG, aid, AUD_END);
 563   return code;
 564 }
 565
 566 afs_int32 Delete (call, aid)
 567   struct rx_call *call;
 568   afs_int32 aid;
 569 {
 570     register afs_int32 code;
 571     struct ubik_trans *tt;
 572     afs_int32 cid;
 573     struct prentry tentry;
 574     afs_int32 loc, nptr;
 575     int count;
 576
 577     code = Initdb();
 578     if (code) return code;
 579     if (code != PRSUCCESS) return code;
 580     if (aid == SYSADMINID || aid == ANYUSERID || aid == AUTHUSERID ||
 581         aid == ANONYMOUSID) return PRPERM;
 582     code = ubik_BeginTrans(dbase,UBIK_WRITETRANS,&tt);
 583     if (code) return code;
 584     code = ubik_SetLock(tt,1,1,LOCKWRITE);
 585     if (code) ABORT_WITH(tt,code);
 586     code = read_DbHeader(tt);
 587     if (code) ABORT_WITH(tt,code);
 588
 589     code = WhoIsThis(call,tt,&cid);
 590     if (code) ABORT_WITH(tt,PRPERM);
 591
 592     /* Read in entry to be deleted */
 593     loc = FindByID (tt, aid);
 594     if (loc == 0) ABORT_WITH(tt,PRNOENT);
 595     code = pr_ReadEntry (tt, 0, loc, &tentry);
 596     if (code) ABORT_WITH(tt,PRDBFAIL);
 597
 598     /* Do some access checking */
 599     if (tentry.owner != cid &&
 600         !IsAMemberOf (tt, cid, SYSADMINID) &&
 601         !IsAMemberOf (tt, cid, tentry.owner) && !pr_noAuth)
 602         ABORT_WITH(tt,PRPERM);
 603
 604     /* Delete each continuation block as a separate transaction so that no one
 605      * transaction become to large to complete. */
 606     nptr = tentry.next;
 607     while (nptr != (afs_int32)NULL) {
 608         struct contentry centry;
 609         int i;
 610
 611         code = pr_ReadCoEntry(tt, 0, nptr, &centry);
 612         if (code != 0) ABORT_WITH(tt,PRDBFAIL);
 613         for (i=0;i<COSIZE;i++) {
 614             if (centry.entries[i] == PRBADID) continue;
 615             if (centry.entries[i] == 0) break;
 616             code = RemoveFromEntry (tt, aid, centry.entries[i]);
 617             if (code) ABORT_WITH(tt,code);
 618             tentry.count--;             /* maintain count */
 619             if ((i&3) == 0) IOMGR_Poll();
 620         }
 621         tentry.next = centry.next;      /* thread out this block */
 622         code = FreeBlock (tt, nptr);    /* free continuation block */
 623         if (code) ABORT_WITH(tt,code);
 624         code = pr_WriteEntry (tt, 0, loc, &tentry); /* update main entry */
 625         if (code) ABORT_WITH(tt,code);
 626
 627         /* end this trans and start a new one */
 628         code = ubik_EndTrans(tt);
 629         if (code) return code;
 630         IOMGR_Poll();                   /* just to keep the connection alive */
 631         code = ubik_BeginTrans(dbase,UBIK_WRITETRANS,&tt);
 632         if (code) return code;
 633         code = ubik_SetLock(tt,1,1,LOCKWRITE);
 634         if (code) ABORT_WITH(tt,code);
 635
 636         /* re-read entry to get consistent uptodate info */
 637         loc = FindByID (tt, aid);
 638         if (loc == 0) ABORT_WITH(tt,PRNOENT);
 639         code = pr_ReadEntry (tt, 0, loc, &tentry);
 640         if (code) ABORT_WITH(tt,PRDBFAIL);
 641
 642         nptr = tentry.next;
 643     }
 644
 645     /* Then move the owned chain, except possibly ourself to the orphan list.
 646      * Because this list can be very long and so exceed the size of a ubik
 647      * transaction, we start a new transaction every 50 entries. */
 648     count = 0;
 649     nptr = tentry.owned;
 650     while (nptr != (afs_int32)NULL) {
 651         struct prentry nentry;
 652
 653         code = pr_ReadEntry (tt, 0, nptr, &nentry);
 654         if (code) ABORT_WITH(tt,PRDBFAIL);
 655         nptr = tentry.owned = nentry.nextOwned; /* thread out */
 656
 657         if (nentry.id != tentry.id) {   /* don't add us to orphan chain! */
 658             code = AddToOrphan (tt, nentry.id);
 659             if (code) ABORT_WITH(tt,code);
 660             count++;
 661             if ((count & 3) == 0) IOMGR_Poll();
 662         }
 663         if (count < 50) continue;
 664         code = pr_WriteEntry (tt, 0, loc, &tentry); /* update main entry */
 665         if (code) ABORT_WITH(tt,code);
 666
 667         /* end this trans and start a new one */
 668         code = ubik_EndTrans(tt);
 669         if (code) return code;
 670         IOMGR_Poll();                   /* just to keep the connection alive */
 671         code = ubik_BeginTrans(dbase,UBIK_WRITETRANS,&tt);
 672         if (code) return code;
 673         code = ubik_SetLock(tt,1,1,LOCKWRITE);
 674         if (code) ABORT_WITH(tt,code);
 675
 676         /* re-read entry to get consistent uptodate info */
 677         loc = FindByID (tt, aid);
 678         if (loc == 0) ABORT_WITH(tt,PRNOENT);
 679         code = pr_ReadEntry (tt, 0, loc, &tentry);
 680         if (code) ABORT_WITH(tt,PRDBFAIL);
 681
 682         nptr = tentry.owned;
 683     }
 684
 685     /* now do what's left of the deletion stuff */
 686     code = DeleteEntry (tt, &tentry, loc);
 687     if (code != PRSUCCESS) ABORT_WITH(tt,code);
 688
 689     code = ubik_EndTrans(tt);
 690     if (code) return code;
 691     return PRSUCCESS;
 692 }
 693
 694 afs_int32 PR_UpdateEntry (call, aid, name, uentry)
 695   struct rx_call *call;
 696   afs_int32 aid;
 697   char *name;
 698   struct PrUpdateEntry *uentry;
 699 {
 700     register afs_int32 code;
 701     struct ubik_trans *tt;
 702     afs_int32 cid;
 703     struct prentry tentry;
 704     afs_int32 loc, nptr;
 705     int count, id=0;
 706
 707     code = Initdb();
 708     if (code) return code;
 709     if (code != PRSUCCESS) return code;
 710     if (aid) {
 711         id = aid;
 712         if (aid == SYSADMINID || aid == ANYUSERID || aid == AUTHUSERID ||
 713             aid == ANONYMOUSID) return PRPERM;
 714     }
 715     code = ubik_BeginTrans(dbase,UBIK_WRITETRANS,&tt);
 716     if (code) return code;
 717     code = ubik_SetLock(tt,1,1,LOCKWRITE);
 718     if (code) ABORT_WITH(tt,code);
 719     code = read_DbHeader(tt);
 720     if (code) ABORT_WITH(tt,code);
 721
 722     code = WhoIsThis(call,tt,&cid);
 723     if (code) ABORT_WITH(tt,PRPERM);
 724     code = IsAMemberOf (tt, cid, SYSADMINID);
 725     if (!code && !pr_noAuth) ABORT_WITH(tt,PRPERM);
 726
 727     /* Read in entry to be deleted */
 728     if (id) {
 729         loc = FindByID (tt, aid);
 730     } else {
 731         loc = FindByName(tt, name, &tentry);
 732     }
 733     if (loc == 0) ABORT_WITH(tt,PRNOENT);
 734     code = pr_ReadEntry (tt, 0, loc, &tentry);
 735     if (code) ABORT_WITH(tt,PRDBFAIL);
 736
 737     if (uentry->Mask & PRUPDATE_NAMEHASH) {
 738         int tloc;
 739         code = RemoveFromNameHash(tt, tentry.name, &tloc);
 740         if (code != PRSUCCESS) ABORT_WITH(tt,PRDBFAIL);
 741         code = AddToNameHash(tt, tentry.name, loc);
 742         if (code) ABORT_WITH(tt,code);
 743     }
 744
 745     if (uentry->Mask & PRUPDATE_IDHASH) {
 746         int tloc;
 747         if (!id) id = tentry.id;
 748         code = RemoveFromIDHash(tt, id, &tloc);
 749         if (code != PRSUCCESS) ABORT_WITH(tt,PRDBFAIL);
 750         code = AddToIDHash(tt, id, loc);
 751         if (code) ABORT_WITH(tt,code);
 752     }
 753
 754     code = ubik_EndTrans(tt);
 755     if (code) return code;
 756     return PRSUCCESS;
 757 }
 758
 759 afs_int32 PR_RemoveFromGroup (call,aid,gid)
 760 struct rx_call *call;
 761 afs_int32 aid;
 762 afs_int32 gid;
 763 {
 764   afs_int32 code;
 765
 766   code = removeFromGroup (call,aid,gid);
 767   osi_auditU (call, PTS_RmFmGrpEvent, code, AUD_LONG, gid, AUD_LONG, aid, AUD_END);
 768   return code;
 769 }
 770
 771 afs_int32 removeFromGroup (call,aid,gid)
 772 struct rx_call *call;
 773 afs_int32 aid;
 774 afs_int32 gid;
 775 {
 776     register afs_int32 code;
 777     struct ubik_trans *tt;
 778     afs_int32 tempu;
 779     afs_int32 tempg;
 780     struct prentry uentry;
 781     struct prentry gentry;
 782     afs_int32 cid;
 783
 784     code = Initdb();
 785     if (code != PRSUCCESS) return code;
 786     code = ubik_BeginTrans(dbase,UBIK_WRITETRANS,&tt);
 787     if (code) return code;
 788     code = ubik_SetLock(tt,1,1,LOCKWRITE);
 789     if (code) ABORT_WITH(tt,code);
 790     code = read_DbHeader(tt);
 791     if (code) ABORT_WITH(tt,code);
 792
 793     code = WhoIsThis(call,tt,&cid);
 794     if (code) ABORT_WITH(tt,PRPERM);
 795     tempu = FindByID(tt,aid);
 796     if (!tempu) ABORT_WITH(tt,PRNOENT);
 797     tempg = FindByID(tt,gid);
 798     if (!tempg) ABORT_WITH(tt,PRNOENT);
 799     memset(&uentry, 0, sizeof(uentry));
 800     memset(&gentry, 0, sizeof(gentry));
 801     code = pr_ReadEntry(tt,0,tempu,&uentry);
 802     if (code != 0) ABORT_WITH(tt,code);
 803     code = pr_ReadEntry(tt,0,tempg,&gentry);
 804     if (code != 0) ABORT_WITH(tt,code);
 805     if (!(gentry.flags & PRGRP)) ABORT_WITH(tt,PRNOTGROUP);
 806     if (uentry.flags & PRGRP) ABORT_WITH(tt,PRNOTUSER);
 807     if (!AccessOK (tt, cid, &gentry, PRP_REMOVE_MEM, 0)) ABORT_WITH(tt,PRPERM);
 808     code = RemoveFromEntry(tt,aid,gid);
 809     if (code != PRSUCCESS) ABORT_WITH(tt,code);
 810     code = RemoveFromEntry(tt,gid,aid);
 811     if (code != PRSUCCESS) ABORT_WITH(tt,code);
 812
 813     code = ubik_EndTrans(tt);
 814     if (code) return code;
 815     return PRSUCCESS;
 816 }
 817
 818
 819 afs_int32 PR_GetCPS (call, aid, alist, over)
 820   struct rx_call *call;
 821   afs_int32 aid;
 822   prlist *alist;
 823   afs_int32 *over;
 824 {
 825   afs_int32 code;
 826
 827   code = getCPS (call, aid, alist, over);
 828   osi_auditU (call, PTS_GetCPSEvent, code, AUD_LONG, aid, AUD_END);
 829   return code;
 830 }
 831
 832 afs_int32 getCPS (call, aid, alist, over)
 833   struct rx_call *call;
 834   afs_int32 aid;
 835   prlist *alist;
 836   afs_int32 *over;
 837 {
 838     register afs_int32 code;
 839     struct ubik_trans *tt;
 840     afs_int32 temp;
 841     afs_int32 cid;
 842     struct prentry tentry;
 843
 844     *over = 0;
 845     alist->prlist_len = 0;
 846     alist->prlist_val = (afs_int32 *) 0;
 847     code = Initdb();
 848     if (code != PRSUCCESS) return code;
 849     code = ubik_BeginTransReadAny(dbase,UBIK_READTRANS,&tt);
 850     if (code) return code;
 851     code = ubik_SetLock(tt,1,1,LOCKREAD);
 852     if (code) ABORT_WITH(tt,code);
 853     code = read_DbHeader(tt);
 854     if (code) ABORT_WITH(tt,code);
 855
 856     temp = FindByID (tt, aid);
 857     if (!temp) ABORT_WITH(tt,PRNOENT);
 858     code = pr_ReadEntry (tt, 0, temp, &tentry);
 859     if (code) ABORT_WITH(tt,code);
 860
 861     /* afs does authenticate now */
 862     code = WhoIsThis (call, tt, &cid);
 863     if (code || !AccessOK (tt, cid, &tentry, PRP_MEMBER_MEM, PRP_MEMBER_ANY))
 864         ABORT_WITH(tt,PRPERM);
 865
 866     code = GetList(tt, &tentry, alist, 1);
 867     if (code != PRSUCCESS) ABORT_WITH(tt,code);
 868
 869     code = ubik_EndTrans(tt);
 870     return code;
 871 }
 872
 873
 874 #ifdef IP_WILDCARDS
 875 int inCPS (CPS,id)
 876     prlist CPS;
 877     afs_int32 id;
 878 {
 879     int i;
 880
 881     for (i = (CPS.prlist_len-1) ; i >= 0; i--) {
 882         if (CPS.prlist_val[i] == id)
 883             return(1);
 884     }
 885     return(0);
 886 }
 887 #endif /* IP_WILDCARDS */
 888
 889
 890 afs_int32 PR_GetCPS2 (call, aid, ahost, alist, over)
 891   struct rx_call *call;
 892   afs_int32 aid;
 893   afs_int32 ahost;
 894   prlist *alist;
 895   afs_int32 *over;
 896 {
 897   afs_int32 code;
 898
 899   code = getCPS2 (call, aid, ahost, alist, over);
 900   osi_auditU (call, PTS_GetCPS2Event, code, AUD_LONG, aid, AUD_HOST, ahost, AUD_END);
 901   return code;
 902 }
 903
 904 afs_int32 getCPS2 (call, aid, ahost, alist, over)
 905   struct rx_call *call;
 906   afs_int32 aid;
 907   afs_int32 ahost;
 908   prlist *alist;
 909   afs_int32 *over;
 910 {
 911     register afs_int32 code;
 912     struct ubik_trans *tt;
 913     afs_int32 temp;
 914     afs_int32 cid;
 915     struct prentry tentry;
 916     struct prentry host_tentry;
 917     afs_int32 hostid;
 918     int host_list = 0;
 919     struct in_addr iaddr;
 920 #if IP_WILDCARDS
 921     extern afs_int32 addWildCards();
 922 #endif /* IP_WILDCARDS */
 923
 924     *over = 0;
 925     iaddr.s_addr = ntohl(ahost);
 926     alist->prlist_len = 0;
 927     alist->prlist_val = (afs_int32 *) 0;
 928     code = Initdb();
 929     if (code != PRSUCCESS) return code;
 930     code = ubik_BeginTransReadAny(dbase,UBIK_READTRANS,&tt);
 931     if (code) return code;
 932     code = ubik_SetLock(tt,1,1,LOCKREAD);
 933     if (code) ABORT_WITH(tt,code);
 934     code = read_DbHeader(tt);
 935     if (code) ABORT_WITH(tt,code);
 936
 937     if (aid != PRBADID) {
 938         temp = FindByID(tt,aid);
 939         if (!temp) ABORT_WITH(tt,PRNOENT);
 940         code = pr_ReadEntry (tt, 0, temp, &tentry);
 941         if (code) ABORT_WITH(tt,code);
 942
 943         /* afs does authenticate now */
 944         code = WhoIsThis (call, tt, &cid);
 945         if (code || !AccessOK (tt, cid, &tentry, PRP_MEMBER_MEM, PRP_MEMBER_ANY))
 946             ABORT_WITH(tt,PRPERM);
 947     }
 948     code = NameToID(tt, inet_ntoa(iaddr),&hostid);
 949     if (code == PRSUCCESS && hostid != 0) {
 950             temp = FindByID(tt,hostid);
 951             if (temp){
 952                code = pr_ReadEntry (tt, 0, temp, &host_tentry);
 953                if (code == PRSUCCESS)
 954                   host_list = 1;
 955                else
 956                  fprintf(stderr,"pr_ReadEntry returned %d\n",code);
 957             } else
 958                 fprintf(stderr,"FindByID Failed -- Not found\n");
 959     }
 960     if (host_list)
 961         code = GetList2(tt, &tentry, &host_tentry, alist, 1);
 962     else
 963         code = GetList(tt, &tentry, alist, 1);
 964 #if IP_WILDCARDS
 965     if (!code)
 966         code = addWildCards(tt,alist,ntohl(ahost));
 967 #endif /* IP_WILDCARDS */
 968     if (code != PRSUCCESS) ABORT_WITH(tt,code);
 969
 970     code = ubik_EndTrans(tt);
 971     return code;
 972 }
 973
 974
 975 afs_int32 PR_GetHostCPS (call, ahost, alist, over)
 976   struct rx_call *call;
 977   afs_int32 ahost;
 978   prlist *alist;
 979   afs_int32 *over;
 980 {
 981   afs_int32 code;
 982
 983   code = getHostCPS (call, ahost, alist, over);
 984   osi_auditU (call, PTS_GetHCPSEvent, code, AUD_HOST, ahost, AUD_END);
 985   return code;
 986 }
 987
 988 afs_int32 getHostCPS (call, ahost, alist, over)
 989   struct rx_call *call;
 990   afs_int32 ahost;
 991   prlist *alist;
 992   afs_int32 *over;
 993 {
 994     register afs_int32 code, temp;
 995     struct ubik_trans *tt;
 996     struct prentry host_tentry;
 997     afs_int32 hostid;
 998     struct in_addr iaddr;
 999 #if IP_WILDCARDS
1000     extern afs_int32 addWildCards();
1001 #endif /* IP_WILDCARDS */
1002
1003     *over = 0;
1004     iaddr.s_addr = ntohl(ahost);
1005     alist->prlist_len = 0;
1006     alist->prlist_val = (afs_int32 *) 0;
1007     code = Initdb();
1008     if (code != PRSUCCESS) return code;
1009     code = ubik_BeginTransReadAny(dbase,UBIK_READTRANS,&tt);
1010     if (code) return code;
1011     code = ubik_SetLock(tt,1,1,LOCKREAD);
1012     if (code) ABORT_WITH(tt,code);
1013     code = read_DbHeader(tt);
1014     if (code) ABORT_WITH(tt,code);
1015
1016     code = NameToID(tt, inet_ntoa(iaddr), &hostid);
1017     if (code == PRSUCCESS && hostid != 0) {
1018         temp = FindByID(tt,hostid);
1019         if (temp) {
1020             code = pr_ReadEntry (tt, 0, temp, &host_tentry);
1021             if (code == PRSUCCESS) {
1022                 code = GetList(tt, &host_tentry, alist, 0);
1023                 if (code) goto bad;
1024             } else
1025                 fprintf(stderr,"pr_ReadEntry returned %d\n",code);
1026         } else
1027             fprintf(stderr,"FindByID Failed -- Not found\n");
1028     }
1029 #if IP_WILDCARDS
1030     code = addWildCards(tt,alist,ntohl(ahost));
1031 #endif /* IP_WILDCARDS */
1032 bad:
1033     if (code != PRSUCCESS) ABORT_WITH(tt,code);
1034
1035     code = ubik_EndTrans(tt);
1036     return code;
1037 }
1038
1039
1040 afs_int32 PR_ListMax (call,uid,gid)
1041 struct rx_call *call;
1042 afs_int32 *uid;
1043 afs_int32 *gid;
1044 {
1045   afs_int32 code;
1046
1047   code = listMax(call,uid,gid);
1048   osi_auditU (call, PTS_LstMaxEvent, code, AUD_END);
1049   return code;
1050 }
1051
1052 afs_int32 listMax (call,uid,gid)
1053 struct rx_call *call;
1054 afs_int32 *uid;
1055 afs_int32 *gid;
1056 {
1057     register afs_int32 code;
1058     struct ubik_trans *tt;
1059
1060     code = Initdb();
1061     if (code != PRSUCCESS) return code;
1062     code = ubik_BeginTransReadAny(dbase,UBIK_READTRANS,&tt);
1063     if (code) return code;
1064     code = ubik_SetLock(tt,1,1,LOCKREAD);
1065     if (code) ABORT_WITH(tt,code);
1066     code = read_DbHeader(tt);
1067     if (code) ABORT_WITH(tt,code);
1068
1069     code = GetMax(tt,uid,gid);
1070     if (code != PRSUCCESS) ABORT_WITH(tt,code);
1071
1072     code = ubik_EndTrans(tt);
1073     if (code) return code;
1074     return PRSUCCESS;
1075 }
1076
1077 afs_int32 PR_SetMax (call,aid,gflag)
1078 struct rx_call *call;
1079 afs_int32 aid;
1080 afs_int32 gflag;
1081 {
1082   afs_int32 code;
1083
1084   code = setMax (call,aid,gflag);
1085   osi_auditU (call, PTS_SetMaxEvent, code, AUD_LONG, aid, AUD_LONG, gflag, AUD_END);
1086   return code;
1087 }
1088
1089 afs_int32 setMax (call,aid,gflag)
1090 struct rx_call *call;
1091 afs_int32 aid;
1092 afs_int32 gflag;
1093 {
1094     register afs_int32 code;
1095     struct ubik_trans *tt;
1096     afs_int32 cid;
1097
1098     code = Initdb();
1099     if (code != PRSUCCESS) return code;
1100     code = ubik_BeginTrans(dbase,UBIK_WRITETRANS,&tt);
1101     if (code) return code;
1102     code = ubik_SetLock(tt,1,1,LOCKWRITE);
1103     if (code) ABORT_WITH(tt,code);
1104     code = read_DbHeader(tt);
1105     if (code) ABORT_WITH(tt,code);
1106
1107     code = WhoIsThis(call,tt,&cid);
1108     if (code) ABORT_WITH(tt,PRPERM);
1109     if (!AccessOK (tt, cid, 0, 0, 0)) ABORT_WITH(tt,PRPERM);
1110     if (((gflag & PRGRP) && (aid > 0)) || (!(gflag & PRGRP) && (aid < 0))) ABORT_WITH(tt,PRBADARG);
1111
1112     code = SetMax(tt,aid,gflag);
1113     if (code != PRSUCCESS) ABORT_WITH(tt,code);
1114
1115     code = ubik_EndTrans(tt);
1116     if (code) return code;
1117     return PRSUCCESS;
1118 }
1119
1120 afs_int32 PR_ListEntry (call,aid,aentry)
1121 struct rx_call *call;
1122 afs_int32 aid;
1123 struct prcheckentry *aentry;
1124 {
1125   afs_int32 code;
1126
1127   code = listEntry (call,aid,aentry);
1128   osi_auditU (call, PTS_LstEntEvent, code, AUD_LONG, aid, AUD_END);
1129   return code;
1130 }
1131
1132 afs_int32 listEntry (call,aid,aentry)
1133 struct rx_call *call;
1134 afs_int32 aid;
1135 struct prcheckentry *aentry;
1136 {
1137     register afs_int32 code;
1138     struct ubik_trans *tt;
1139     afs_int32 cid;
1140     afs_int32 temp;
1141     struct prentry tentry;
1142
1143     code = Initdb();
1144     if (code != PRSUCCESS) return code;
1145     code = ubik_BeginTransReadAny(dbase,UBIK_READTRANS,&tt);
1146     if (code) return code;
1147     code = ubik_SetLock(tt,1,1,LOCKREAD);
1148     if (code) ABORT_WITH(tt,code);
1149     code = read_DbHeader(tt);
1150     if (code) ABORT_WITH(tt,code);
1151
1152     code = WhoIsThis(call,tt,&cid);
1153     if (code) ABORT_WITH(tt,PRPERM);
1154     temp = FindByID(tt,aid);
1155     if (!temp) ABORT_WITH(tt,PRNOENT);
1156     code = pr_ReadEntry(tt, 0, temp, &tentry);
1157     if (code != 0) ABORT_WITH(tt,code);
1158     if (!AccessOK (tt, cid, &tentry, PRP_STATUS_MEM, PRP_STATUS_ANY))
1159         ABORT_WITH(tt,PRPERM);
1160
1161     aentry->flags = tentry.flags >> PRIVATE_SHIFT;
1162     if (aentry->flags == 0) {
1163         if (tentry.flags & PRGRP)
1164             aentry->flags = PRP_GROUP_DEFAULT >> PRIVATE_SHIFT;
1165         else aentry->flags = PRP_USER_DEFAULT >> PRIVATE_SHIFT;
1166     }
1167     aentry->owner = tentry.owner;
1168     aentry->id = tentry.id;
1169     strncpy(aentry->name,tentry.name,PR_MAXNAMELEN);
1170     aentry->creator = tentry.creator;
1171     aentry->ngroups = tentry.ngroups;
1172     aentry->nusers = tentry.nusers;
1173     aentry->count = tentry.count;
1174     memset(aentry->reserved, 0, sizeof(aentry->reserved));
1175     code = ubik_EndTrans(tt);
1176     if (code) return code;
1177     return PRSUCCESS;
1178 }
1179
1180 afs_int32 PR_ListEntries(call, flag, startindex, bulkentries, nextstartindex)
1181   struct rx_call *call;
1182   afs_int32          flag;
1183   afs_int32          startindex;
1184   prentries      *bulkentries;
1185   afs_int32          *nextstartindex;
1186 {
1187   afs_int32 code;
1188
1189   code = listEntries(call, flag, startindex, bulkentries, nextstartindex);
1190   osi_auditU (call, PTS_LstEntsEvent, code, AUD_LONG, flag, AUD_END);
1191   return code;
1192 }
1193
1194 afs_int32 listEntries(call, flag, startindex, bulkentries, nextstartindex)
1195   struct rx_call *call;
1196   afs_int32          flag;
1197   afs_int32          startindex;
1198   prentries      *bulkentries;
1199   afs_int32          *nextstartindex;
1200 {
1201   afs_int32 code;
1202   struct ubik_trans *tt;
1203   afs_int32 cid;
1204   afs_int32 i, eof, pos, maxentries, f;
1205   struct prentry tentry;
1206   afs_int32 pollcount=0;
1207
1208   *nextstartindex = -1;
1209   bulkentries->prentries_val = 0;
1210   bulkentries->prentries_len = 0;
1211
1212   code = Initdb();
1213   if (code != PRSUCCESS) return code;
1214   code = ubik_BeginTransReadAny(dbase,UBIK_READTRANS,&tt);
1215   if (code) return code;
1216   code = ubik_SetLock(tt,1,1,LOCKREAD);
1217   if (code) ABORT_WITH(tt,code);
1218   code = read_DbHeader(tt);
1219   if (code) ABORT_WITH(tt,code);
1220
1221   /* Make sure we are an authenticated caller and that we are on the
1222    * SYSADMIN list.
1223    */
1224   code = WhoIsThis(call,tt,&cid);
1225   if (code) ABORT_WITH(tt,PRPERM);
1226   code = IsAMemberOf (tt, cid, SYSADMINID);
1227   if (!code && !pr_noAuth) ABORT_WITH(tt,PRPERM);
1228
1229   eof = ntohl(cheader.eofPtr) - sizeof(cheader);
1230   maxentries = eof / sizeof(struct prentry);
1231   for (i=startindex; i<maxentries; i++) {
1232      pos = i * sizeof(struct prentry) + sizeof(cheader);
1233      code = pr_ReadEntry (tt, 0, pos, &tentry);
1234      if (code) goto done;
1235
1236      if (++pollcount > 50) {
1237         IOMGR_Poll();
1238         pollcount = 0;
1239      }
1240
1241      f = (tentry.flags & PRTYPE);
1242      if ( ((flag & PRUSERS ) && (f == 0)   ) ||    /* User  entry */
1243           ((flag & PRGROUPS) && (f & PRGRP)) ) {   /* Group entry */
1244         code = put_prentries(&tentry, bulkentries);
1245         if (code == -1) break;   /* Filled return array */
1246         if (code) goto done;
1247      }
1248   }
1249   code = 0;
1250   if (i < maxentries)
1251      *nextstartindex = i;
1252
1253  done:
1254   if (code) {
1255      if (bulkentries->prentries_val)
1256         free(bulkentries->prentries_val);
1257      bulkentries->prentries_val = 0;
1258      bulkentries->prentries_len = 0;
1259      ABORT_WITH(tt, code);
1260   }
1261   else {
1262      code = ubik_EndTrans(tt);
1263   }
1264   if (code) return code;
1265   return PRSUCCESS;
1266 }
1267
1268 #define PR_MAXENTRIES 500
1269 afs_int32 put_prentries(tentry, bulkentries)
1270   struct prentry *tentry;
1271   prentries      *bulkentries;
1272 {
1273   struct prlistentries *entry;
1274
1275   if (bulkentries->prentries_val == 0) {
1276      bulkentries->prentries_len = 0;
1277      bulkentries->prentries_val = (struct prlistentries *)malloc(PR_MAXENTRIES * sizeof(struct prentry));
1278      if (!bulkentries->prentries_val) {
1279         return(PRNOMEM);
1280      }
1281   }
1282
1283   if (bulkentries->prentries_len >= PR_MAXENTRIES) {
1284      return(-1);
1285   }
1286
1287   entry  = (struct prlistentries *)bulkentries->prentries_val;
1288   entry += bulkentries->prentries_len;
1289
1290   entry->flags   = tentry->flags >> PRIVATE_SHIFT;
1291   if (entry->flags == 0) {
1292      entry->flags = ( (tentry->flags & PRGRP)?PRP_GROUP_DEFAULT
1293                                              :PRP_USER_DEFAULT ) >> PRIVATE_SHIFT;
1294   }
1295   entry->owner   = tentry->owner;
1296   entry->id      = tentry->id;
1297   entry->creator = tentry->creator;
1298   entry->ngroups = tentry->ngroups;
1299   entry->nusers  = tentry->nusers;
1300   entry->count   = tentry->count;
1301   strncpy(entry->name,tentry->name,PR_MAXNAMELEN);
1302   memset(entry->reserved, 0, sizeof(entry->reserved));
1303   bulkentries->prentries_len++;
1304   return 0;
1305 }
1306
1307 afs_int32 PR_ChangeEntry (call,aid,name,oid,newid)
1308 struct rx_call *call;
1309 afs_int32 aid;
1310 char *name;
1311 afs_int32 oid;
1312 afs_int32 newid;
1313 {
1314   afs_int32 code;
1315
1316   code = changeEntry (call,aid,name,oid,newid);
1317   osi_auditU (call, PTS_ChgEntEvent, code, AUD_LONG, aid, AUD_STR,  name,
1318                                                           AUD_LONG, oid,
1319                                                           AUD_LONG, newid, AUD_END);
1320   return code;
1321 }
1322
1323 afs_int32 changeEntry (call,aid,name,oid,newid)
1324 struct rx_call *call;
1325 afs_int32 aid;
1326 char *name;
1327 afs_int32 oid;
1328 afs_int32 newid;
1329 {
1330     register afs_int32 code;
1331     struct ubik_trans *tt;
1332     afs_int32 pos;
1333     afs_int32 cid;
1334
1335     if (!name) return PRPERM;
1336     stolower(name);
1337
1338     code = Initdb();
1339     if (code) return code;
1340     if (aid == ANYUSERID || aid == AUTHUSERID || aid == ANONYMOUSID ||
1341         aid == SYSADMINID) return PRPERM;
1342     if (code != PRSUCCESS) return code;
1343     code = ubik_BeginTrans(dbase,UBIK_WRITETRANS,&tt);
1344     if (code) return code;
1345     code = ubik_SetLock(tt,1,1,LOCKWRITE);
1346     if (code) ABORT_WITH(tt,code);
1347     code = read_DbHeader(tt);
1348     if (code) ABORT_WITH(tt,code);
1349
1350     code = WhoIsThis(call,tt,&cid);
1351     if (code) ABORT_WITH(tt,PRPERM);
1352     pos = FindByID(tt,aid);
1353     if (!pos) ABORT_WITH(tt,PRNOENT);
1354     /* protection check in changeentry */
1355     code = ChangeEntry(tt,aid,cid,name,oid,newid);
1356     if (code != PRSUCCESS) ABORT_WITH(tt,code);
1357
1358     code = ubik_EndTrans(tt);
1359     return code;
1360 }
1361
1362 afs_int32 PR_SetFieldsEntry (call, id, mask, flags, ngroups, nusers, spare1, spare2)
1363   struct rx_call *call;
1364   afs_int32 id;
1365   afs_int32 mask;                               /* specify which fields to update */
1366   afs_int32 flags, ngroups, nusers;
1367   afs_int32 spare1, spare2;
1368 {
1369   afs_int32 code;
1370
1371   code = setFieldsEntry (call, id, mask, flags, ngroups, nusers, spare1, spare2);
1372   osi_auditU (call, PTS_SetFldEntEvent, code, AUD_LONG, id, AUD_END);
1373   return code;
1374 }
1375
1376 afs_int32 setFieldsEntry (call, id, mask, flags, ngroups, nusers, spare1, spare2)
1377   struct rx_call *call;
1378   afs_int32 id;
1379   afs_int32 mask;                               /* specify which fields to update */
1380   afs_int32 flags, ngroups, nusers;
1381   afs_int32 spare1, spare2;
1382 {
1383     register afs_int32 code;
1384     struct ubik_trans *tt;
1385     afs_int32 pos;
1386     afs_int32 cid;
1387     struct prentry tentry;
1388     afs_int32 tflags;
1389
1390     if (mask == 0) return 0;            /* no-op */
1391     code = Initdb();
1392     if (code) return code;
1393     if (id == ANYUSERID || id == AUTHUSERID || id == ANONYMOUSID)
1394         return PRPERM;
1395     if (code != PRSUCCESS) return code;
1396     code = ubik_BeginTrans(dbase,UBIK_WRITETRANS,&tt);
1397     if (code) return code;
1398     code = ubik_SetLock(tt,1,1,LOCKWRITE);
1399     if (code) ABORT_WITH(tt,code);
1400     code = read_DbHeader(tt);
1401     if (code) ABORT_WITH(tt,code);
1402
1403     code = WhoIsThis(call,tt,&cid);
1404     if (code) ABORT_WITH(tt,PRPERM);
1405     pos = FindByID(tt,id);
1406     if (!pos) ABORT_WITH(tt,PRNOENT);
1407     code = pr_ReadEntry (tt, 0, pos, &tentry);
1408     if (code) ABORT_WITH(tt,code);
1409     tflags = tentry.flags;
1410
1411     if (mask & (PR_SF_NGROUPS | PR_SF_NUSERS)) {
1412         if (!AccessOK (tt, cid, 0, 0, 0)) ABORT_WITH(tt,PRPERM);
1413         if ((tflags & PRQUOTA) == 0) {  /* default if only setting one */
1414             tentry.ngroups = tentry.nusers = 20;
1415         }
1416     } else {
1417         if (!AccessOK (tt, cid, &tentry, 0, 0)) ABORT_WITH(tt,PRPERM);
1418     }
1419
1420     if (mask & 0xffff) {                /* if setting flag bits */
1421         afs_int32 flagsMask = mask & 0xffff;
1422         tflags &= ~(flagsMask << PRIVATE_SHIFT);
1423         tflags |= (flags & flagsMask) << PRIVATE_SHIFT;
1424         tflags |= PRACCESS;
1425     }
1426
1427     if (mask & PR_SF_NGROUPS) {         /* setting group limit */
1428         if (ngroups < 0) ABORT_WITH(tt,PRBADARG);
1429         tentry.ngroups = ngroups;
1430         tflags |= PRQUOTA;
1431     }
1432
1433     if (mask & PR_SF_NUSERS) {          /* setting foreign user limit */
1434         if (nusers < 0) ABORT_WITH(tt,PRBADARG);
1435         tentry.nusers = nusers;
1436         tflags |= PRQUOTA;
1437     }
1438     tentry.flags = tflags;
1439
1440     code = pr_WriteEntry (tt, 0, pos, &tentry);
1441     if (code) ABORT_WITH(tt,code);
1442
1443     code = ubik_EndTrans(tt);
1444     return code;
1445 }
1446
1447 afs_int32 PR_ListElements (call, aid, alist, over)
1448   struct rx_call *call;
1449   afs_int32 aid;
1450   prlist *alist;
1451   afs_int32 *over;
1452 {
1453   afs_int32 code;
1454
1455   code = listElements (call, aid, alist, over);
1456   osi_auditU (call, PTS_LstEleEvent, code, AUD_LONG, aid, AUD_END);
1457   return code;
1458 }
1459
1460 afs_int32 listElements (call, aid, alist, over)
1461   struct rx_call *call;
1462   afs_int32 aid;
1463   prlist *alist;
1464   afs_int32 *over;
1465 {
1466     register afs_int32 code;
1467     struct ubik_trans *tt;
1468     afs_int32 cid;
1469     afs_int32 temp;
1470     struct prentry tentry;
1471
1472     *over = 0;
1473     alist->prlist_len = 0;
1474     alist->prlist_val = (afs_int32 *) 0;
1475
1476     code = Initdb();
1477     if (code != PRSUCCESS) return code;
1478     code = ubik_BeginTransReadAny(dbase,UBIK_READTRANS,&tt);
1479     if (code) return code;
1480     code = ubik_SetLock(tt,1,1,LOCKREAD);
1481     if (code) ABORT_WITH(tt,code);
1482     code = read_DbHeader(tt);
1483     if (code) ABORT_WITH(tt,code);
1484
1485     code = WhoIsThis(call,tt,&cid);
1486     if (code) ABORT_WITH(tt,PRPERM);
1487
1488     temp = FindByID(tt,aid);
1489     if (!temp) ABORT_WITH(tt,PRNOENT);
1490     code = pr_ReadEntry (tt, 0, temp, &tentry);
1491     if (code) ABORT_WITH(tt,code);
1492     if (!AccessOK (tt, cid, &tentry, PRP_MEMBER_MEM, PRP_MEMBER_ANY))
1493         ABORT_WITH(tt,PRPERM);
1494
1495     code = GetList (tt, &tentry, alist, 0);
1496     if (code != PRSUCCESS) ABORT_WITH(tt,code);
1497
1498     code = ubik_EndTrans(tt);
1499     return code;
1500 }
1501
1502 /*
1503  * PR_istOwned
1504  * List the entries owned by this id.  If the id is zero,
1505  * return the orphans list. This will return up to PR_MAXGROUPS
1506  * at a time with the lastP available to get the rest. The
1507  * maximum value is enforced in GetOwnedChain().
1508  */
1509 afs_int32 PR_ListOwned (call, aid, alist, lastP)
1510   struct rx_call *call;
1511   afs_int32 aid;
1512   prlist *alist;
1513   afs_int32 *lastP;
1514 {
1515   afs_int32 code;
1516
1517   code = listOwned (call, aid, alist, lastP);
1518   osi_auditU (call, PTS_LstOwnEvent, code, AUD_LONG, aid, AUD_END);
1519   return code;
1520 }
1521
1522 afs_int32 listOwned (call, aid, alist, lastP)
1523   struct rx_call *call;
1524   afs_int32 aid;
1525   prlist *alist;
1526   afs_int32 *lastP;
1527 {
1528     register afs_int32 code;
1529     struct ubik_trans *tt;
1530     afs_int32 cid;
1531     struct prentry tentry;
1532     afs_int32 head=0;
1533     afs_int32 start;
1534
1535     alist->prlist_len = 0;
1536     alist->prlist_val = (afs_int32 *) 0;
1537
1538     if (!lastP) return PRBADARG;
1539     start = *lastP;
1540     *lastP = 0;
1541
1542     code = Initdb();
1543     if (code != PRSUCCESS) return code;
1544     code = ubik_BeginTransReadAny(dbase,UBIK_READTRANS,&tt);
1545     if (code) return code;
1546     code = ubik_SetLock(tt,1,1,LOCKREAD);
1547     if (code) ABORT_WITH(tt,code);
1548     code = read_DbHeader(tt);
1549     if (code) ABORT_WITH(tt,code);
1550
1551     code = WhoIsThis(call,tt,&cid);
1552     if (code) ABORT_WITH(tt,PRPERM);
1553
1554     if (start) {
1555        code = pr_ReadEntry (tt, 0, start, &tentry);
1556        if (!code && (tentry.owner == aid))
1557           head = start;                      /* pick up where we left off */
1558     }
1559
1560     if (!head) {
1561        if (aid) {
1562           afs_int32 loc = FindByID (tt, aid);
1563           if (loc == 0) ABORT_WITH(tt,PRNOENT);
1564           code = pr_ReadEntry (tt, 0, loc, &tentry);
1565           if (code) ABORT_WITH(tt,code);
1566
1567           if (!AccessOK (tt, cid, &tentry, -1, PRP_OWNED_ANY))
1568              ABORT_WITH(tt,PRPERM);
1569           head = tentry.owned;
1570        } else {
1571           if (!AccessOK (tt, cid, 0, 0, 0)) ABORT_WITH(tt,PRPERM);
1572           head = ntohl(cheader.orphan);
1573        }
1574     }
1575
1576     code = GetOwnedChain (tt, &head, alist);
1577     if (code) {
1578        if (code == PRTOOMANY) *lastP = head;
1579        else  ABORT_WITH(tt,code);
1580     }
1581
1582     code = ubik_EndTrans(tt);
1583     return code;
1584 }
1585
1586 afs_int32 PR_IsAMemberOf (call,uid,gid,flag)
1587 struct rx_call *call;
1588 afs_int32 uid;
1589 afs_int32 gid;
1590 afs_int32 *flag;
1591 {
1592   afs_int32 code;
1593
1594   code = isAMemberOf (call,uid,gid,flag);
1595   osi_auditU (call, PTS_IsMemOfEvent, code, AUD_LONG, uid, AUD_LONG, gid, AUD_END);
1596   return code;
1597 }
1598
1599 afs_int32 isAMemberOf (call,uid,gid,flag)
1600 struct rx_call *call;
1601 afs_int32 uid;
1602 afs_int32 gid;
1603 afs_int32 *flag;
1604 {
1605     register afs_int32 code;
1606     struct ubik_trans *tt;
1607
1608     code = Initdb();
1609     if (code != PRSUCCESS) return code;
1610     code = ubik_BeginTransReadAny(dbase,UBIK_READTRANS,&tt);
1611     if (code) return code;
1612     code = ubik_SetLock(tt,1,1,LOCKREAD);
1613     if (code) ABORT_WITH(tt,code);
1614     code = read_DbHeader(tt);
1615     if (code) ABORT_WITH(tt,code);
1616
1617     {   afs_int32 cid;
1618         afs_int32 uloc = FindByID (tt, uid);
1619         afs_int32 gloc = FindByID (tt, gid);
1620         struct prentry uentry, gentry;
1621
1622         if (!uloc || !gloc) ABORT_WITH(tt,PRNOENT);
1623         code = WhoIsThis(call, tt, &cid);
1624         if (code) ABORT_WITH(tt,PRPERM);
1625         code = pr_ReadEntry (tt, 0, uloc, &uentry);
1626         if (code) ABORT_WITH(tt,code);
1627         code = pr_ReadEntry (tt, 0, gloc, &gentry);
1628         if (code) ABORT_WITH(tt,code);
1629         if ((uentry.flags & PRGRP) || !(gentry.flags & PRGRP)) ABORT_WITH(tt,PRBADARG);
1630         if (!AccessOK (tt, cid, &uentry, 0, PRP_MEMBER_ANY) &&
1631             !AccessOK (tt, cid, &gentry, PRP_MEMBER_MEM, PRP_MEMBER_ANY))
1632             ABORT_WITH(tt,PRPERM);
1633     }
1634
1635     *flag = IsAMemberOf(tt,uid,gid);
1636     code = ubik_EndTrans(tt);
1637     return code;
1638 }
1639
1640
1641 static stolower(s)
1642 register char *s;
1643 {
1644     register int tc;
1645     while ((tc = *s)) {
1646         if (isupper(tc)) *s = tolower(tc);
1647         s++;
1648     }
1649 }
1650
1651 #if IP_WILDCARDS
1652 afs_int32 addWildCards(tt,alist,host)
1653     struct ubik_trans *tt;
1654     prlist *alist;
1655     afs_int32 host;
1656 {
1657     afs_int32 temp;
1658     struct prentry tentry;
1659     prlist wlist;
1660     unsigned wild = htonl(0xffffff00);
1661     struct in_addr iaddr;
1662     afs_int32 hostid;
1663     int size = 0, i, code;
1664     int added = 0;
1665
1666     while ((host = (host & wild))) {
1667         wild = htonl ( ntohl(wild) << 8) ;
1668         iaddr.s_addr = host;
1669         code = NameToID(tt, inet_ntoa(iaddr),&hostid);
1670         if (code == PRSUCCESS && hostid != 0) {
1671             temp = FindByID(tt,hostid);
1672             if (temp){
1673                 code = pr_ReadEntry (tt, 0, temp, &tentry);
1674                 if (code != PRSUCCESS)
1675                     continue;
1676             } else
1677                 continue;
1678         } else
1679             continue;
1680         wlist.prlist_len = 0;
1681         wlist.prlist_val = (afs_int32 *) 0;
1682
1683         code = GetList (tt, &tentry, &wlist, 0);
1684         if (code) return code;
1685         added +=  wlist.prlist_len;
1686         for (i=0; i< wlist.prlist_len; i++) {
1687             if (!inCPS(*alist,wlist.prlist_val[i]))
1688                 if ((code = AddToPRList (alist, &size, wlist.prlist_val[i] ))) {
1689                     free(wlist.prlist_val);
1690                     return(code);
1691                 }
1692         }
1693         if (wlist.prlist_val) free(wlist.prlist_val);
1694     }
1695     if (added)
1696         qsort(alist->prlist_val,alist->prlist_len,sizeof(afs_int32),IDCmp);
1697     return 0;
1698 }
1699 #endif /* IP_WILDCARDS */
1700
1701
1702 afs_int32 WhoIsThisWithName(acall, at, aid, aname)
1703   struct rx_call *acall;
1704   struct ubik_trans *at;
1705   afs_int32 *aid;
1706   char *aname;
1707 {
1708     /* aid is set to the identity of the caller, if known, else ANONYMOUSID */
1709     /* returns -1 and sets aid to ANONYMOUSID on any failure */
1710     register struct rx_connection *tconn;
1711     register afs_int32 code;
1712     char tcell[MAXKTCREALMLEN];
1713     char name[MAXKTCNAMELEN];
1714     char inst[MAXKTCNAMELEN];
1715     int  ilen;
1716     char vname[256];
1717
1718     *aid = ANONYMOUSID;
1719     tconn = rx_ConnectionOf(acall);
1720     code = rx_SecurityClassOf(tconn);
1721     if (code == 0) return 0;
1722     else if (code == 1) {               /* vab class */
1723         goto done;                      /* no longer supported */
1724     }
1725     else if (code == 2) {               /* kad class */
1726
1727         int clen;
1728         extern char *pr_realmName;
1729
1730         if ((code = rxkad_GetServerInfo
1731             (acall->conn, (afs_int32 *) 0, 0/*was &exp*/,
1732              name, inst, tcell, (afs_int32 *) 0)))
1733             goto done;
1734         strncpy (vname, name, sizeof(vname));
1735         if ((ilen = strlen(inst))) {
1736             if (strlen(vname) + 1 + ilen >= sizeof(vname)) goto done;
1737             strcat (vname, ".");
1738             strcat (vname, inst);
1739         }
1740         if ( (clen = strlen(tcell))) {
1741
1742 #if     defined(AFS_ATHENA_STDENV) || defined(AFS_KERBREALM_ENV)
1743             static char local_realm[AFS_REALM_SZ] = "";
1744             if (!local_realm[0]) {
1745                 if (afs_krb_get_lrealm(local_realm, 0) != 0/*KSUCCESS*/)
1746                     strncpy(local_realm, pr_realmName, AFS_REALM_SZ);
1747             }
1748 #endif
1749             if (
1750 #if     defined(AFS_ATHENA_STDENV) || defined(AFS_KERBREALM_ENV)
1751                 strcasecmp (local_realm, tcell) &&
1752 #endif
1753                 strcasecmp (pr_realmName, tcell))
1754           {
1755             if (strlen(vname) + 1 + clen >= sizeof(vname)) goto done;
1756             strcat(vname,"@");
1757             strcat(vname,tcell);
1758             lcstring(vname, vname, sizeof(vname));
1759             code = NameToID(at,vname,aid);
1760             strcpy(aname,vname);
1761             return 2;
1762           }
1763         }
1764
1765         if (strcmp (AUTH_SUPERUSER, vname) == 0)
1766             *aid = SYSADMINID;          /* special case for the fileserver */
1767         else {
1768             lcstring(vname, vname, sizeof(vname));
1769             code = NameToID(at,vname,aid);
1770         }
1771     }
1772   done:
1773     if (code && !pr_noAuth) return -1;
1774     return 0;
1775 }