Bug Summary

File:ptserver/ptutils.c
Location:line 1978, column 6
Description:Value stored to 'code' is never read

Annotated Source Code

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 * (5) Add functions to process supergroups:
12 * ChangeIDEntry(), RemoveFromSGEntry(),
13 * AddToSGEntry(), GetListSG2().
14 * (6) Add code to existing functions to process
15 * supergroups.
16 * 2/1/98 jjm Add mdw's changes for bit mapping for supergroups
17 *
18 * 09/26/02 kwc Move depthsg definition here from ptserver.c since
19 * pt_util needs it defined also, and this file is
20 * common between the two programs.
21 */
22
23#include <afsconfig.h>
24#include <afs/param.h>
25#include <afs/stds.h>
26
27#include <roken.h>
28
29#include <lock.h>
30#include <ubik.h>
31#include <rx/xdr.h>
32#include <afs/com_err.h>
33#include <afs/cellconfig.h>
34
35#include "ptserver.h"
36#include "pterror.h"
37#include "ptprototypes.h"
38
39/* Foreign cells are represented by the group system:authuser@cell*/
40#define AUTHUSER_GROUP"system:authuser" "system:authuser"
41
42extern int restricted;
43extern struct ubik_dbase *dbase;
44extern struct afsconf_dir *prdir;
45extern int pr_noAuth;
46
47static int inRange(struct prentry *cellEntry, afs_int32 aid);
48static afs_int32 allocNextId(struct ubik_trans *, struct prentry *);
49static int AddAuthGroup(struct prentry *tentry, prlist *alist, afs_int32 *size);
50
51static char *whoami = "ptserver";
52
53int prp_user_default = PRP_USER_DEFAULT((0x80 << 16));
54int prp_group_default = PRP_GROUP_DEFAULT((0x80 << 16) | (0x10 << 16));
55
56#if defined(SUPERGROUPS1)
57
58#include "map.h"
59
60afs_int32 depthsg = 5; /* Maximum iterations used during IsAMemberOF */
61afs_int32 GetListSG2(struct ubik_trans *at, afs_int32 gid, prlist * alist,
62 afs_int32 * sizeP, afs_int32 depth);
63
64struct map *sg_flagged;
65struct map *sg_found;
66
67#define NIL_MAP((struct map *) 0) ((struct map *) 0)
68
69/* pt_mywrite hooks into the logic that writes ubik records to disk
70 * at a very low level. It invalidates mappings in sg_flagged/sg_found.
71 * By hoooking in at this level, we ensure that a ubik file reload
72 * invalidates our incore cache.
73 *
74 * We assert records, cheaders and everything else are 0 mod 64.
75 * So, we can always see the first 64 bytes of any record written.
76 * The stuff we're interested in (flags, id) are in the first 8 bytes.
77 * so we can always tell if we're writing a group record.
78 */
79
80int (*pt_save_dbase_write)(struct ubik_dbase *, afs_int32, void *, afs_int32,
81 afs_int32);
82
83int
84pt_mywrite(struct ubik_dbase *tdb, afs_int32 fno, void *bp, afs_int32 pos, afs_int32 count)
85{
86 afs_uint32 headersize = ntohl(cheader.headerSize)(__builtin_constant_p(cheader.headerSize) ? ((((__uint32_t)(cheader
.headerSize)) >> 24) | ((((__uint32_t)(cheader.headerSize
)) & (0xff << 16)) >> 8) | ((((__uint32_t)(cheader
.headerSize)) & (0xff << 8)) << 8) | (((__uint32_t
)(cheader.headerSize)) << 24)) : __bswap32_var(cheader.
headerSize));
87
88 if (fno == 0 && pos + count > headersize) {
89 afs_int32 p, l, c, o;
90 char *cp;
91 p = pos - headersize;
92 cp = bp;
93 l = count;
94 if (p < 0) {
95 l += p;
96 p = 0;
97 }
98 while (l > 0) {
99 o = p % ENTRYSIZE192;
100 c = ENTRYSIZE192 - o;
101 if (c > l)
102 c = l;
103#define xPT(p,x) ((((struct prentry *)(p))->flags & htonl(PRTYPE)(__builtin_constant_p(0x3f) ? ((((__uint32_t)(0x3f)) >>
24) | ((((__uint32_t)(0x3f)) & (0xff << 16)) >>
8) | ((((__uint32_t)(0x3f)) & (0xff << 8)) <<
8) | (((__uint32_t)(0x3f)) << 24)) : __bswap32_var(0x3f
))) == htonl(x)(__builtin_constant_p(x) ? ((((__uint32_t)(x)) >> 24) |
((((__uint32_t)(x)) & (0xff << 16)) >> 8) | (
(((__uint32_t)(x)) & (0xff << 8)) << 8) | (((
__uint32_t)(x)) << 24)) : __bswap32_var(x)))
104#if DEBUG_SG_MAP
105 if (o)
106 fprintf(stderr__stderrp, "Writing %d bytes of entry @ %#lx(+%d)\n", c,
107 p - o, o);
108 else if (c == ENTRYSIZE192)
109 fprintf(stderr__stderrp,
110 "Writing %d bytes of entry @ %#lx (%d<%s>,%d)\n",
111 c, p, ntohl(((struct prentry *)cp)->flags)(__builtin_constant_p(((struct prentry *)cp)->flags) ? (((
(__uint32_t)(((struct prentry *)cp)->flags)) >> 24) |
((((__uint32_t)(((struct prentry *)cp)->flags)) & (0xff
<< 16)) >> 8) | ((((__uint32_t)(((struct prentry
*)cp)->flags)) & (0xff << 8)) << 8) | (((
__uint32_t)(((struct prentry *)cp)->flags)) << 24)) :
__bswap32_var(((struct prentry *)cp)->flags)),
112 xPT(cp,PRUSER0) ? "user" : xPT(cp,PRFREE1) ? "free" :
113 xPT(cp,PRGRP2) ? "group" : xPT(cp,PRCONT4) ? "cont" :
114 xPT(cp,PRCELL8) ? "cell" : xPT(cp,PRFOREIGN16) ? "foreign" :
115 xPT(cp,PRINST32) ? "sub/super instance" : "?",
116 ntohl(((struct prentry *)cp)->id)(__builtin_constant_p(((struct prentry *)cp)->id) ? ((((__uint32_t
)(((struct prentry *)cp)->id)) >> 24) | ((((__uint32_t
)(((struct prentry *)cp)->id)) & (0xff << 16)) >>
8) | ((((__uint32_t)(((struct prentry *)cp)->id)) & (
0xff << 8)) << 8) | (((__uint32_t)(((struct prentry
*)cp)->id)) << 24)) : __bswap32_var(((struct prentry
*)cp)->id)));
117 else if (c >= 8)
118 fprintf(stderr__stderrp,
119 "Writing first %d bytes of entry @ %#lx (%d<%s>,%d)\n",
120 c, p, ntohl(((struct prentry *)cp)->flags)(__builtin_constant_p(((struct prentry *)cp)->flags) ? (((
(__uint32_t)(((struct prentry *)cp)->flags)) >> 24) |
((((__uint32_t)(((struct prentry *)cp)->flags)) & (0xff
<< 16)) >> 8) | ((((__uint32_t)(((struct prentry
*)cp)->flags)) & (0xff << 8)) << 8) | (((
__uint32_t)(((struct prentry *)cp)->flags)) << 24)) :
__bswap32_var(((struct prentry *)cp)->flags)),
121 xPT(cp,PRUSER0) ? "user" : xPT(cp,PRFREE1) ? "free" :
122 xPT(cp,PRGRP2) ? "group" : xPT(cp,PRCONT4) ? "cont" :
123 xPT(cp,PRCELL8) ? "cell" : xPT(cp,PRFOREIGN16) ? "foreign" :
124 xPT(cp,PRINST32) ? "sub/super instance" : "?",
125 ntohl(((struct prentry *)cp)->id)(__builtin_constant_p(((struct prentry *)cp)->id) ? ((((__uint32_t
)(((struct prentry *)cp)->id)) >> 24) | ((((__uint32_t
)(((struct prentry *)cp)->id)) & (0xff << 16)) >>
8) | ((((__uint32_t)(((struct prentry *)cp)->id)) & (
0xff << 8)) << 8) | (((__uint32_t)(((struct prentry
*)cp)->id)) << 24)) : __bswap32_var(((struct prentry
*)cp)->id)));
126 else
127 fprintf(stderr__stderrp, "Writing %d bytes of entry @ %#lx\n", c, p);
128#endif
129 if (!o && c >= 8 && xPT(cp,PRGRP2)) {
130#if DEBUG_SG_MAP
131 if (in_map(sg_found, -ntohl(((struct prentry *)cp)->id)(__builtin_constant_p(((struct prentry *)cp)->id) ? ((((__uint32_t
)(((struct prentry *)cp)->id)) >> 24) | ((((__uint32_t
)(((struct prentry *)cp)->id)) & (0xff << 16)) >>
8) | ((((__uint32_t)(((struct prentry *)cp)->id)) & (
0xff << 8)) << 8) | (((__uint32_t)(((struct prentry
*)cp)->id)) << 24)) : __bswap32_var(((struct prentry
*)cp)->id))))
132 fprintf(stderr__stderrp, "Unfound: Removing group %d\n",
133 ntohl(((struct prentry *)cp)->id)(__builtin_constant_p(((struct prentry *)cp)->id) ? ((((__uint32_t
)(((struct prentry *)cp)->id)) >> 24) | ((((__uint32_t
)(((struct prentry *)cp)->id)) & (0xff << 16)) >>
8) | ((((__uint32_t)(((struct prentry *)cp)->id)) & (
0xff << 8)) << 8) | (((__uint32_t)(((struct prentry
*)cp)->id)) << 24)) : __bswap32_var(((struct prentry
*)cp)->id)));
134 if (in_map(sg_flagged, -ntohl(((struct prentry *)cp)->id)(__builtin_constant_p(((struct prentry *)cp)->id) ? ((((__uint32_t
)(((struct prentry *)cp)->id)) >> 24) | ((((__uint32_t
)(((struct prentry *)cp)->id)) & (0xff << 16)) >>
8) | ((((__uint32_t)(((struct prentry *)cp)->id)) & (
0xff << 8)) << 8) | (((__uint32_t)(((struct prentry
*)cp)->id)) << 24)) : __bswap32_var(((struct prentry
*)cp)->id))))
135 fprintf(stderr__stderrp, "Unflag: Removing group %d\n",
136 ntohl(((struct prentry *)cp)->id)(__builtin_constant_p(((struct prentry *)cp)->id) ? ((((__uint32_t
)(((struct prentry *)cp)->id)) >> 24) | ((((__uint32_t
)(((struct prentry *)cp)->id)) & (0xff << 16)) >>
8) | ((((__uint32_t)(((struct prentry *)cp)->id)) & (
0xff << 8)) << 8) | (((__uint32_t)(((struct prentry
*)cp)->id)) << 24)) : __bswap32_var(((struct prentry
*)cp)->id)));
137#endif
138 sg_found =
139 bic_map(sg_found,
140 add_map(NIL_MAP((struct map *) 0), -ntohl(((struct prentry *)cp)->id)(__builtin_constant_p(((struct prentry *)cp)->id) ? ((((__uint32_t
)(((struct prentry *)cp)->id)) >> 24) | ((((__uint32_t
)(((struct prentry *)cp)->id)) & (0xff << 16)) >>
8) | ((((__uint32_t)(((struct prentry *)cp)->id)) & (
0xff << 8)) << 8) | (((__uint32_t)(((struct prentry
*)cp)->id)) << 24)) : __bswap32_var(((struct prentry
*)cp)->id))));
141 sg_flagged =
142 bic_map(sg_flagged,
143 add_map(NIL_MAP((struct map *) 0), -ntohl(((struct prentry *)cp)->id)(__builtin_constant_p(((struct prentry *)cp)->id) ? ((((__uint32_t
)(((struct prentry *)cp)->id)) >> 24) | ((((__uint32_t
)(((struct prentry *)cp)->id)) & (0xff << 16)) >>
8) | ((((__uint32_t)(((struct prentry *)cp)->id)) & (
0xff << 8)) << 8) | (((__uint32_t)(((struct prentry
*)cp)->id)) << 24)) : __bswap32_var(((struct prentry
*)cp)->id))));
144 }
145 cp += c;
146 p += c;
147 l -= c;
148#undef xPT
149 }
150 }
151 return (*pt_save_dbase_write) (tdb, fno, bp, pos, count);
152}
153
154/*
155 * this function attaches pt_mywrite. It's called once,
156 * just after ubik_ServerInit.
157 */
158
159void
160pt_hook_write(void)
161{
162 extern struct ubik_dbase *ubik_dbase;
163 if (ubik_dbase->write != pt_mywrite) {
164 pt_save_dbase_write = ubik_dbase->write;
165 ubik_dbase->write = pt_mywrite;
166 }
167}
168
169#endif /* SUPERGROUPS */
170
171/* CorrectUserName - Check to make sure a user name is OK. It must not include
172 * either a colon (or it would look like a group) or a newline (which can
173 * confuse some ptdb code, depending on the format we're reading from).
174 * This is a predicate, so it return one if name is OK and zero if name is
175 * bogus. */
176
177static int
178CorrectUserName(char *name)
179{
180 /* We accept foreign names, so we will deal with '@' later */
181 if (strchr(name, ':') || strchr(name, '\n'))
182 return 0;
183 if (strlen(name) >= PR_MAXNAMELEN64)
184 return 0;
185 return 1;
186}
187
188/* CorrectGroupName - Like the above but handles more complicated cases caused
189 * by including the ownership in the name. The interface works by calculating
190 * the correct name based on a given name and owner. This allows easy use by
191 * rename, which then compares the correct name with the requested new name. */
192
193static afs_int32
194CorrectGroupName(struct ubik_trans *ut, char aname[PR_MAXNAMELEN64], /* name for group */
195 afs_int32 cid, /* caller id */
196 afs_int32 oid, /* owner of group */
197 char cname[PR_MAXNAMELEN64]) /* correct name for group */
198{
199 afs_int32 code;
200 int admin;
201 char *prefix; /* ptr to group owner part */
202 char *suffix; /* ptr to group name part */
203 char name[PR_MAXNAMELEN64]; /* correct name for group */
204 struct prentry tentry;
205
206 if (strlen(aname) >= PR_MAXNAMELEN64)
207 return PRBADNAM(267272L);
208 admin = pr_noAuth || IsAMemberOf(ut, cid, SYSADMINID-204);
209
210 if (oid == 0)
211 oid = cid;
212
213 /* Determine the correct prefix for the name. */
214 if (oid == SYSADMINID-204)
215 prefix = "system";
216 else {
217 afs_int32 loc = FindByID(ut, oid);
218 if (loc == 0) {
219 /* let admin create groups owned by non-existent ids (probably
220 * setting a group to own itself). Check that they look like
221 * groups (with a colon) or otherwise are good user names. */
222 if (admin) {
223 strcpy(cname, aname);
224 goto done;
225 }
226 return PRNOENT(267268L);
227 }
228 code = pr_Read(ut, 0, loc, &tentry, sizeof(tentry));
229 if (code)
230 return code;
231 if (ntohl(tentry.flags)(__builtin_constant_p(tentry.flags) ? ((((__uint32_t)(tentry.
flags)) >> 24) | ((((__uint32_t)(tentry.flags)) & (
0xff << 16)) >> 8) | ((((__uint32_t)(tentry.flags
)) & (0xff << 8)) << 8) | (((__uint32_t)(tentry
.flags)) << 24)) : __bswap32_var(tentry.flags)) & PRGRP2) {
232 if ((tentry.count == 0) && !admin)
233 return PRGROUPEMPTY(267276L);
234 /* terminate prefix at colon if there is one */
235 if ((prefix = strchr(tentry.name, ':')))
236 *prefix = 0;
237 }
238 prefix = tentry.name;
239 }
240 /* only sysadmin allow to use 'system:' prefix */
241 if ((strcmp(prefix, "system") == 0) && !admin)
242 return PRPERM(267269L);
243
244 strcpy(name, aname); /* in case aname & cname are same */
245 suffix = strchr(name, ':');
246 if (suffix == 0) {
247 /* sysadmin can make groups w/o ':', but they must still look like
248 * legal user names. */
249 if (!admin)
250 return PRBADNAM(267272L);
251 strcpy(cname, name);
252 } else {
253 if (strlen(prefix) + strlen(suffix) >= PR_MAXNAMELEN64)
254 return PRBADNAM(267272L);
255 strcpy(cname, prefix);
256 strcat(cname, suffix);
257 }
258 done:
259 /* check for legal name with either group rules or user rules */
260 if ((suffix = strchr(cname, ':'))) {
261 /* check for confusing characters */
262 if (strchr(cname, '\n') || /* restrict so recreate can work */
263 strchr(suffix + 1, ':')) /* avoid multiple colons */
264 return PRBADNAM(267272L);
265 } else {
266 if (!CorrectUserName(cname))
267 return PRBADNAM(267272L);
268 }
269 return 0;
270}
271
272int
273AccessOK(struct ubik_trans *ut, afs_int32 cid, /* caller id */
274 struct prentry *tentry, /* object being accessed */
275 int mem, /* check membership in aid, if group */
276 int any) /* if set return true */
277{
278 afs_int32 flags;
279 afs_int32 oid;
280 afs_int32 aid;
281
282 if (pr_noAuth)
283 return 1;
284 if (cid == SYSADMINID-204)
285 return 1; /* special case fileserver */
286 if (restricted && ((mem == PRP_ADD_MEM(0x02 << 16)) || (mem == PRP_REMOVE_MEM(0x01 << 16))) && (any == 0))
287 return 0;
288 if (tentry) {
289 flags = tentry->flags;
290 oid = tentry->owner;
291 aid = tentry->id;
292 } else {
293 flags = oid = aid = 0;
294 }
295 if (!(flags & PRACCESS(1<<6))) { /* provide default access */
296 if (flags & PRGRP2)
297 flags |= prp_group_default;
298 else
299 flags |= prp_user_default;
300 }
301
302 if (flags & any)
303 return 1;
304 if (oid) {
305 if ((cid == oid) || IsAMemberOf(ut, cid, oid))
306 return 1;
307 }
308 if (aid > 0) { /* checking on a user */
309 if (aid == cid)
310 return 1;
311 } else if (aid < 0) { /* checking on group */
312 if ((flags & mem) && IsAMemberOf(ut, cid, aid))
313 return 1;
314 }
315 /* Allow members of SYSVIEWERID to get membership and status only */
316 if (((mem == PRP_STATUS_MEM(0x40 << 16)) || (mem == PRP_MEMBER_MEM(0x08 << 16))
317 || (any == PRP_OWNED_ANY(0x20 << 16))) && (IsAMemberOf(ut, cid, SYSVIEWERID-203)))
318 return 1;
319 if (IsAMemberOf(ut, cid, SYSADMINID-204))
320 return 1;
321 return 0; /* no access */
322}
323
324afs_int32
325CreateEntry(struct ubik_trans *at, char aname[PR_MAXNAMELEN64], afs_int32 *aid, afs_int32 idflag, afs_int32 flag, afs_int32 oid, afs_int32 creator)
326{
327 /* get and init a new entry */
328 afs_int32 code;
329 afs_int32 newEntry;
330 struct prentry tentry, tent;
331 char *atsign;
332
333 memset(&tentry, 0, sizeof(tentry));
334
335 if ((oid == 0) || (oid == ANONYMOUSID32766))
336 oid = creator;
337
338 if (flag & PRGRP2) {
339 code = CorrectGroupName(at, aname, creator, oid, tentry.name);
340 if (code)
341 return code;
342 if (strcmp(aname, tentry.name) != 0)
343 return PRBADNAM(267272L);
344 } else { /* non-group must not have colon */
345 if (!CorrectUserName(aname))
346 return PRBADNAM(267272L);
347 strcpy(tentry.name, aname);
348 }
349
350 if (FindByName(at, aname, &tent))
351 return PREXIST(267264L);
352
353 newEntry = AllocBlock(at);
354 if (!newEntry)
355 return PRDBFAIL(267267L);
356#ifdef PR_REMEMBER_TIMES1
357 tentry.createTime = time(0);
358#endif
359
360 if (flag & PRGRP2) {
361 tentry.flags = PRGRP2;
362 tentry.owner = oid;
363 } else if (flag == 0) {
364 tentry.flags = 0;
365 tentry.owner = SYSADMINID-204;
366 } else {
367 return PRBADARG(267273L);
368 }
369
370 atsign = strchr(aname, '@');
371 if (!atsign) {
372 /* A normal user or group. Pick an id for it */
373 if (idflag)
374 tentry.id = *aid;
375 else {
376 code = AllocID(at, flag, &tentry.id);
377 if (code != PRSUCCESS0)
378 return code;
379 }
380 } else if (flag & PRGRP2) {
381 /* A foreign group. Its format must be AUTHUSER_GROUP@cellname
382 * Then pick an id for the group.
383 */
384 int badFormat;
385
386 *atsign = '\0';
387 badFormat = strcmp(AUTHUSER_GROUP"system:authuser", aname);
388 *atsign = '@';
389 if (badFormat)
390 return PRBADNAM(267272L);
391
392 if (idflag)
393 tentry.id = *aid;
394 else {
395 code = AllocID(at, flag, &tentry.id);
396 if (code != PRSUCCESS0)
397 return code;
398 }
399 } else {
400 /* A foreign user: <name>@<cell>. The foreign user is added to
401 * its representing group. It is
402 */
403 char *cellGroup;
404 afs_int32 pos, n;
405 struct prentry centry;
406
407 /* To create the user <name>@<cell> the group AUTHUSER_GROUP@<cell>
408 * must exist.
409 */
410 cellGroup =
411 (char *)malloc(strlen(AUTHUSER_GROUP"system:authuser") + strlen(atsign) + 1);
412 strcpy(cellGroup, AUTHUSER_GROUP"system:authuser");
413 strcat(cellGroup, atsign);
414 pos = FindByName(at, cellGroup, &centry);
415 free(cellGroup);
416 if (!pos)
417 return PRBADNAM(267272L);
418 code = pr_Read(at, 0, pos, &centry, sizeof(centry));
419 if (code)
420 return code;
421
422 /* cellid is the id of the group representing the cell */
423 tentry.cellid = ntohl(centry.id)(__builtin_constant_p(centry.id) ? ((((__uint32_t)(centry.id)
) >> 24) | ((((__uint32_t)(centry.id)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(centry.id)) & (0xff <<
8)) << 8) | (((__uint32_t)(centry.id)) << 24)) :
__bswap32_var(centry.id));
424
425 if (idflag) {
426 /* Check if id is good */
427 if (!inRange(&centry, *aid))
428 return PRBADARG(267273L);
429 tentry.id = *aid;
430 } else {
431 /* Allocate an ID special for this foreign user. It is based
432 * on the representing group's id and nusers count.
433 */
434 tentry.id = allocNextId(at, &centry);
435 if (!tentry.id)
436 return PRNOIDS(267266L);
437 }
438
439 /* The foreign user will be added to the representing foreign
440 * group. The group can hold up to 30 entries.
441 */
442 if (!(ntohl(centry.flags)(__builtin_constant_p(centry.flags) ? ((((__uint32_t)(centry.
flags)) >> 24) | ((((__uint32_t)(centry.flags)) & (
0xff << 16)) >> 8) | ((((__uint32_t)(centry.flags
)) & (0xff << 8)) << 8) | (((__uint32_t)(centry
.flags)) << 24)) : __bswap32_var(centry.flags)) & PRQUOTA(1<<7))) {
443 centry.flags = htonl(ntohl(centry.flags) | PRQUOTA)(__builtin_constant_p((__builtin_constant_p(centry.flags) ? (
(((__uint32_t)(centry.flags)) >> 24) | ((((__uint32_t)(
centry.flags)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(centry.flags)) & (0xff << 8)) << 8) | (((__uint32_t
)(centry.flags)) << 24)) : __bswap32_var(centry.flags))
| (1<<7)) ? ((((__uint32_t)((__builtin_constant_p(centry
.flags) ? ((((__uint32_t)(centry.flags)) >> 24) | ((((__uint32_t
)(centry.flags)) & (0xff << 16)) >> 8) | ((((
__uint32_t)(centry.flags)) & (0xff << 8)) << 8
) | (((__uint32_t)(centry.flags)) << 24)) : __bswap32_var
(centry.flags)) | (1<<7))) >> 24) | ((((__uint32_t
)((__builtin_constant_p(centry.flags) ? ((((__uint32_t)(centry
.flags)) >> 24) | ((((__uint32_t)(centry.flags)) & (
0xff << 16)) >> 8) | ((((__uint32_t)(centry.flags
)) & (0xff << 8)) << 8) | (((__uint32_t)(centry
.flags)) << 24)) : __bswap32_var(centry.flags)) | (1<<
7))) & (0xff << 16)) >> 8) | ((((__uint32_t)(
(__builtin_constant_p(centry.flags) ? ((((__uint32_t)(centry.
flags)) >> 24) | ((((__uint32_t)(centry.flags)) & (
0xff << 16)) >> 8) | ((((__uint32_t)(centry.flags
)) & (0xff << 8)) << 8) | (((__uint32_t)(centry
.flags)) << 24)) : __bswap32_var(centry.flags)) | (1<<
7))) & (0xff << 8)) << 8) | (((__uint32_t)((__builtin_constant_p
(centry.flags) ? ((((__uint32_t)(centry.flags)) >> 24) |
((((__uint32_t)(centry.flags)) & (0xff << 16)) >>
8) | ((((__uint32_t)(centry.flags)) & (0xff << 8))
<< 8) | (((__uint32_t)(centry.flags)) << 24)) : __bswap32_var
(centry.flags)) | (1<<7))) << 24)) : __bswap32_var
((__builtin_constant_p(centry.flags) ? ((((__uint32_t)(centry
.flags)) >> 24) | ((((__uint32_t)(centry.flags)) & (
0xff << 16)) >> 8) | ((((__uint32_t)(centry.flags
)) & (0xff << 8)) << 8) | (((__uint32_t)(centry
.flags)) << 24)) : __bswap32_var(centry.flags)) | (1<<
7)));
444 centry.ngroups = htonl(30)(__builtin_constant_p(30) ? ((((__uint32_t)(30)) >> 24)
| ((((__uint32_t)(30)) & (0xff << 16)) >> 8)
| ((((__uint32_t)(30)) & (0xff << 8)) << 8) |
(((__uint32_t)(30)) << 24)) : __bswap32_var(30));
445 }
446 n = ntohl(centry.ngroups)(__builtin_constant_p(centry.ngroups) ? ((((__uint32_t)(centry
.ngroups)) >> 24) | ((((__uint32_t)(centry.ngroups)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(centry.ngroups
)) & (0xff << 8)) << 8) | (((__uint32_t)(centry
.ngroups)) << 24)) : __bswap32_var(centry.ngroups));
447 if ((n <= 0) && !pr_noAuth)
448 return PRNOMORE(267274L);
449 centry.ngroups = htonl(n - 1)(__builtin_constant_p(n - 1) ? ((((__uint32_t)(n - 1)) >>
24) | ((((__uint32_t)(n - 1)) & (0xff << 16)) >>
8) | ((((__uint32_t)(n - 1)) & (0xff << 8)) <<
8) | (((__uint32_t)(n - 1)) << 24)) : __bswap32_var(n -
1));
450
451 /* write updated entry for group */
452 code = pr_Write(at, 0, pos, &centry, sizeof(centry));
453
454 /* Now add the new user entry to the database */
455 tentry.creator = creator;
456 *aid = tentry.id;
457 code = pr_WriteEntry(at, 0, newEntry, &tentry);
458 if (code)
459 return PRDBFAIL(267267L);
460 code = AddToIDHash(at, *aid, newEntry);
461 if (code != PRSUCCESS0)
462 return code;
463 code = AddToNameHash(at, aname, newEntry);
464 if (code != PRSUCCESS0)
465 return code;
466 if (inc_header_word(at, foreigncount, 1)pr_Write ((at), 0, ((char *)&(cheader.foreigncount) - (char
*)&cheader), ((cheader.foreigncount = ((__builtin_constant_p
((__builtin_constant_p(cheader.foreigncount) ? ((((__uint32_t
)(cheader.foreigncount)) >> 24) | ((((__uint32_t)(cheader
.foreigncount)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(cheader.foreigncount)) & (0xff << 8)) << 8)
| (((__uint32_t)(cheader.foreigncount)) << 24)) : __bswap32_var
(cheader.foreigncount))+(1)) ? ((((__uint32_t)((__builtin_constant_p
(cheader.foreigncount) ? ((((__uint32_t)(cheader.foreigncount
)) >> 24) | ((((__uint32_t)(cheader.foreigncount)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(cheader.foreigncount
)) & (0xff << 8)) << 8) | (((__uint32_t)(cheader
.foreigncount)) << 24)) : __bswap32_var(cheader.foreigncount
))+(1))) >> 24) | ((((__uint32_t)((__builtin_constant_p
(cheader.foreigncount) ? ((((__uint32_t)(cheader.foreigncount
)) >> 24) | ((((__uint32_t)(cheader.foreigncount)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(cheader.foreigncount
)) & (0xff << 8)) << 8) | (((__uint32_t)(cheader
.foreigncount)) << 24)) : __bswap32_var(cheader.foreigncount
))+(1))) & (0xff << 16)) >> 8) | ((((__uint32_t
)((__builtin_constant_p(cheader.foreigncount) ? ((((__uint32_t
)(cheader.foreigncount)) >> 24) | ((((__uint32_t)(cheader
.foreigncount)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(cheader.foreigncount)) & (0xff << 8)) << 8)
| (((__uint32_t)(cheader.foreigncount)) << 24)) : __bswap32_var
(cheader.foreigncount))+(1))) & (0xff << 8)) <<
8) | (((__uint32_t)((__builtin_constant_p(cheader.foreigncount
) ? ((((__uint32_t)(cheader.foreigncount)) >> 24) | (((
(__uint32_t)(cheader.foreigncount)) & (0xff << 16))
>> 8) | ((((__uint32_t)(cheader.foreigncount)) & (
0xff << 8)) << 8) | (((__uint32_t)(cheader.foreigncount
)) << 24)) : __bswap32_var(cheader.foreigncount))+(1)))
<< 24)) : __bswap32_var((__builtin_constant_p(cheader.
foreigncount) ? ((((__uint32_t)(cheader.foreigncount)) >>
24) | ((((__uint32_t)(cheader.foreigncount)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(cheader.foreigncount)) &
(0xff << 8)) << 8) | (((__uint32_t)(cheader.foreigncount
)) << 24)) : __bswap32_var(cheader.foreigncount))+(1)))
)), (char *)&(cheader.foreigncount)), sizeof(afs_int32)))
467 return PRDBFAIL(267267L);
468
469 /* Now add the entry to the authuser group for this cell.
470 * We will reread the entries for the user and the group
471 * instead of modifying them before writing them in the
472 * previous steps. Although not very efficient, much simpler
473 */
474 pos = FindByID(at, tentry.cellid);
475 if (!pos)
476 return PRBADNAM(267272L);
477 code = pr_ReadEntry(at, 0, pos, &centry);
478 if (code)
479 return code;
480 code = AddToEntry(at, &centry, pos, *aid);
481 if (code)
482 return code;
483 /* and now the user entry */
484 pos = FindByID(at, *aid);
485 if (!pos)
486 return PRBADNAM(267272L);
487 code = pr_ReadEntry(at, 0, pos, &tentry);
488 if (code)
489 return code;
490 code = AddToEntry(at, &tentry, pos, tentry.cellid);
491 if (code)
492 return code;
493
494 return PRSUCCESS0;
495 }
496
497 /* Remember the largest group id or largest user id */
498 if (flag & PRGRP2) {
499 /* group ids are negative */
500 if (tentry.id < (afs_int32) ntohl(cheader.maxGroup)(__builtin_constant_p(cheader.maxGroup) ? ((((__uint32_t)(cheader
.maxGroup)) >> 24) | ((((__uint32_t)(cheader.maxGroup))
& (0xff << 16)) >> 8) | ((((__uint32_t)(cheader
.maxGroup)) & (0xff << 8)) << 8) | (((__uint32_t
)(cheader.maxGroup)) << 24)) : __bswap32_var(cheader.maxGroup
))) {
501 code = set_header_word(at, maxGroup, htonl(tentry.id))pr_Write ((at), 0, ((char *)&(cheader.maxGroup) - (char *
)&cheader), ((cheader.maxGroup = ((__builtin_constant_p(tentry
.id) ? ((((__uint32_t)(tentry.id)) >> 24) | ((((__uint32_t
)(tentry.id)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(tentry.id)) & (0xff << 8)) << 8) | (((__uint32_t
)(tentry.id)) << 24)) : __bswap32_var(tentry.id)))), (char
*)&(cheader.maxGroup)), sizeof(afs_int32));
502 if (code)
503 return PRDBFAIL(267267L);
504 }
505 } else {
506 if (tentry.id > (afs_int32) ntohl(cheader.maxID)(__builtin_constant_p(cheader.maxID) ? ((((__uint32_t)(cheader
.maxID)) >> 24) | ((((__uint32_t)(cheader.maxID)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(cheader.maxID
)) & (0xff << 8)) << 8) | (((__uint32_t)(cheader
.maxID)) << 24)) : __bswap32_var(cheader.maxID))) {
507 code = set_header_word(at, maxID, htonl(tentry.id))pr_Write ((at), 0, ((char *)&(cheader.maxID) - (char *)&
cheader), ((cheader.maxID = ((__builtin_constant_p(tentry.id)
? ((((__uint32_t)(tentry.id)) >> 24) | ((((__uint32_t)
(tentry.id)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(tentry.id)) & (0xff << 8)) << 8) | (((__uint32_t
)(tentry.id)) << 24)) : __bswap32_var(tentry.id)))), (char
*)&(cheader.maxID)), sizeof(afs_int32));
508 if (code)
509 return PRDBFAIL(267267L);
510 }
511 }
512
513 /* Charge the creator for this group */
514 if (flag & PRGRP2) {
515 afs_int32 loc = FindByID(at, creator);
516 struct prentry centry;
517 int admin;
518
519 if (loc) { /* this should only fail during initialization */
520 code = pr_Read(at, 0, loc, &centry, sizeof(centry));
521 if (code)
522 return code;
523
524 /* If quota is uninitialized, do it */
525 if (!(ntohl(centry.flags)(__builtin_constant_p(centry.flags) ? ((((__uint32_t)(centry.
flags)) >> 24) | ((((__uint32_t)(centry.flags)) & (
0xff << 16)) >> 8) | ((((__uint32_t)(centry.flags
)) & (0xff << 8)) << 8) | (((__uint32_t)(centry
.flags)) << 24)) : __bswap32_var(centry.flags)) & PRQUOTA(1<<7))) {
526 centry.flags = htonl(ntohl(centry.flags) | PRQUOTA)(__builtin_constant_p((__builtin_constant_p(centry.flags) ? (
(((__uint32_t)(centry.flags)) >> 24) | ((((__uint32_t)(
centry.flags)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(centry.flags)) & (0xff << 8)) << 8) | (((__uint32_t
)(centry.flags)) << 24)) : __bswap32_var(centry.flags))
| (1<<7)) ? ((((__uint32_t)((__builtin_constant_p(centry
.flags) ? ((((__uint32_t)(centry.flags)) >> 24) | ((((__uint32_t
)(centry.flags)) & (0xff << 16)) >> 8) | ((((
__uint32_t)(centry.flags)) & (0xff << 8)) << 8
) | (((__uint32_t)(centry.flags)) << 24)) : __bswap32_var
(centry.flags)) | (1<<7))) >> 24) | ((((__uint32_t
)((__builtin_constant_p(centry.flags) ? ((((__uint32_t)(centry
.flags)) >> 24) | ((((__uint32_t)(centry.flags)) & (
0xff << 16)) >> 8) | ((((__uint32_t)(centry.flags
)) & (0xff << 8)) << 8) | (((__uint32_t)(centry
.flags)) << 24)) : __bswap32_var(centry.flags)) | (1<<
7))) & (0xff << 16)) >> 8) | ((((__uint32_t)(
(__builtin_constant_p(centry.flags) ? ((((__uint32_t)(centry.
flags)) >> 24) | ((((__uint32_t)(centry.flags)) & (
0xff << 16)) >> 8) | ((((__uint32_t)(centry.flags
)) & (0xff << 8)) << 8) | (((__uint32_t)(centry
.flags)) << 24)) : __bswap32_var(centry.flags)) | (1<<
7))) & (0xff << 8)) << 8) | (((__uint32_t)((__builtin_constant_p
(centry.flags) ? ((((__uint32_t)(centry.flags)) >> 24) |
((((__uint32_t)(centry.flags)) & (0xff << 16)) >>
8) | ((((__uint32_t)(centry.flags)) & (0xff << 8))
<< 8) | (((__uint32_t)(centry.flags)) << 24)) : __bswap32_var
(centry.flags)) | (1<<7))) << 24)) : __bswap32_var
((__builtin_constant_p(centry.flags) ? ((((__uint32_t)(centry
.flags)) >> 24) | ((((__uint32_t)(centry.flags)) & (
0xff << 16)) >> 8) | ((((__uint32_t)(centry.flags
)) & (0xff << 8)) << 8) | (((__uint32_t)(centry
.flags)) << 24)) : __bswap32_var(centry.flags)) | (1<<
7)));
527 centry.ngroups = centry.nusers = htonl(20)(__builtin_constant_p(20) ? ((((__uint32_t)(20)) >> 24)
| ((((__uint32_t)(20)) & (0xff << 16)) >> 8)
| ((((__uint32_t)(20)) & (0xff << 8)) << 8) |
(((__uint32_t)(20)) << 24)) : __bswap32_var(20));
528 }
529
530 /* Admins don't get charged for creating a group.
531 * If in noAuth mode, you get changed for it but you
532 * are still allowed to create as many groups as you want.
533 */
534 admin = ((creator == SYSADMINID-204)
535 || IsAMemberOf(at, creator, SYSADMINID-204));
536 if (!admin) {
537 if (ntohl(centry.ngroups)(__builtin_constant_p(centry.ngroups) ? ((((__uint32_t)(centry
.ngroups)) >> 24) | ((((__uint32_t)(centry.ngroups)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(centry.ngroups
)) & (0xff << 8)) << 8) | (((__uint32_t)(centry
.ngroups)) << 24)) : __bswap32_var(centry.ngroups)) <= 0) {
538 if (!pr_noAuth)
539 return PRNOMORE(267274L);
540 } else {
541 centry.ngroups = htonl(ntohl(centry.ngroups) - 1)(__builtin_constant_p((__builtin_constant_p(centry.ngroups) ?
((((__uint32_t)(centry.ngroups)) >> 24) | ((((__uint32_t
)(centry.ngroups)) & (0xff << 16)) >> 8) | ((
((__uint32_t)(centry.ngroups)) & (0xff << 8)) <<
8) | (((__uint32_t)(centry.ngroups)) << 24)) : __bswap32_var
(centry.ngroups)) - 1) ? ((((__uint32_t)((__builtin_constant_p
(centry.ngroups) ? ((((__uint32_t)(centry.ngroups)) >> 24
) | ((((__uint32_t)(centry.ngroups)) & (0xff << 16)
) >> 8) | ((((__uint32_t)(centry.ngroups)) & (0xff <<
8)) << 8) | (((__uint32_t)(centry.ngroups)) << 24
)) : __bswap32_var(centry.ngroups)) - 1)) >> 24) | ((((
__uint32_t)((__builtin_constant_p(centry.ngroups) ? ((((__uint32_t
)(centry.ngroups)) >> 24) | ((((__uint32_t)(centry.ngroups
)) & (0xff << 16)) >> 8) | ((((__uint32_t)(centry
.ngroups)) & (0xff << 8)) << 8) | (((__uint32_t
)(centry.ngroups)) << 24)) : __bswap32_var(centry.ngroups
)) - 1)) & (0xff << 16)) >> 8) | ((((__uint32_t
)((__builtin_constant_p(centry.ngroups) ? ((((__uint32_t)(centry
.ngroups)) >> 24) | ((((__uint32_t)(centry.ngroups)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(centry.ngroups
)) & (0xff << 8)) << 8) | (((__uint32_t)(centry
.ngroups)) << 24)) : __bswap32_var(centry.ngroups)) - 1
)) & (0xff << 8)) << 8) | (((__uint32_t)((__builtin_constant_p
(centry.ngroups) ? ((((__uint32_t)(centry.ngroups)) >> 24
) | ((((__uint32_t)(centry.ngroups)) & (0xff << 16)
) >> 8) | ((((__uint32_t)(centry.ngroups)) & (0xff <<
8)) << 8) | (((__uint32_t)(centry.ngroups)) << 24
)) : __bswap32_var(centry.ngroups)) - 1)) << 24)) : __bswap32_var
((__builtin_constant_p(centry.ngroups) ? ((((__uint32_t)(centry
.ngroups)) >> 24) | ((((__uint32_t)(centry.ngroups)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(centry.ngroups
)) & (0xff << 8)) << 8) | (((__uint32_t)(centry
.ngroups)) << 24)) : __bswap32_var(centry.ngroups)) - 1
));
542 }
543 }
544
545 code = pr_Write(at, 0, loc, &centry, sizeof(centry));
546 if (code)
547 return code;
548 } /* if (loc) */
549 } else {
550 /* Initialize the quota for the user. Groups don't have their
551 * quota initialized.
552 */
553 tentry.flags |= PRQUOTA(1<<7);
554 tentry.ngroups = tentry.nusers = 20;
555 }
556
557 tentry.creator = creator;
558 *aid = tentry.id;
559 code = pr_WriteEntry(at, 0, newEntry, &tentry);
560 if (code)
561 return PRDBFAIL(267267L);
562 code = AddToIDHash(at, *aid, newEntry);
563 if (code != PRSUCCESS0)
564 return code;
565 code = AddToNameHash(at, aname, newEntry);
566 if (code != PRSUCCESS0)
567 return code;
568 if (tentry.flags & PRGRP2) {
569 code = AddToOwnerChain(at, tentry.id, oid);
570 if (code)
571 return code;
572 }
573 if (tentry.flags & PRGRP2) {
574 if (inc_header_word(at, groupcount, 1)pr_Write ((at), 0, ((char *)&(cheader.groupcount) - (char
*)&cheader), ((cheader.groupcount = ((__builtin_constant_p
((__builtin_constant_p(cheader.groupcount) ? ((((__uint32_t)(
cheader.groupcount)) >> 24) | ((((__uint32_t)(cheader.groupcount
)) & (0xff << 16)) >> 8) | ((((__uint32_t)(cheader
.groupcount)) & (0xff << 8)) << 8) | (((__uint32_t
)(cheader.groupcount)) << 24)) : __bswap32_var(cheader.
groupcount))+(1)) ? ((((__uint32_t)((__builtin_constant_p(cheader
.groupcount) ? ((((__uint32_t)(cheader.groupcount)) >> 24
) | ((((__uint32_t)(cheader.groupcount)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(cheader.groupcount)) &
(0xff << 8)) << 8) | (((__uint32_t)(cheader.groupcount
)) << 24)) : __bswap32_var(cheader.groupcount))+(1))) >>
24) | ((((__uint32_t)((__builtin_constant_p(cheader.groupcount
) ? ((((__uint32_t)(cheader.groupcount)) >> 24) | ((((__uint32_t
)(cheader.groupcount)) & (0xff << 16)) >> 8) |
((((__uint32_t)(cheader.groupcount)) & (0xff << 8)
) << 8) | (((__uint32_t)(cheader.groupcount)) << 24
)) : __bswap32_var(cheader.groupcount))+(1))) & (0xff <<
16)) >> 8) | ((((__uint32_t)((__builtin_constant_p(cheader
.groupcount) ? ((((__uint32_t)(cheader.groupcount)) >> 24
) | ((((__uint32_t)(cheader.groupcount)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(cheader.groupcount)) &
(0xff << 8)) << 8) | (((__uint32_t)(cheader.groupcount
)) << 24)) : __bswap32_var(cheader.groupcount))+(1))) &
(0xff << 8)) << 8) | (((__uint32_t)((__builtin_constant_p
(cheader.groupcount) ? ((((__uint32_t)(cheader.groupcount)) >>
24) | ((((__uint32_t)(cheader.groupcount)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(cheader.groupcount)) &
(0xff << 8)) << 8) | (((__uint32_t)(cheader.groupcount
)) << 24)) : __bswap32_var(cheader.groupcount))+(1))) <<
24)) : __bswap32_var((__builtin_constant_p(cheader.groupcount
) ? ((((__uint32_t)(cheader.groupcount)) >> 24) | ((((__uint32_t
)(cheader.groupcount)) & (0xff << 16)) >> 8) |
((((__uint32_t)(cheader.groupcount)) & (0xff << 8)
) << 8) | (((__uint32_t)(cheader.groupcount)) << 24
)) : __bswap32_var(cheader.groupcount))+(1))))), (char *)&
(cheader.groupcount)), sizeof(afs_int32)))
575 return PRDBFAIL(267267L);
576 } else if (tentry.flags & PRINST32) {
577 if (inc_header_word(at, instcount, 1)pr_Write ((at), 0, ((char *)&(cheader.instcount) - (char *
)&cheader), ((cheader.instcount = ((__builtin_constant_p(
(__builtin_constant_p(cheader.instcount) ? ((((__uint32_t)(cheader
.instcount)) >> 24) | ((((__uint32_t)(cheader.instcount
)) & (0xff << 16)) >> 8) | ((((__uint32_t)(cheader
.instcount)) & (0xff << 8)) << 8) | (((__uint32_t
)(cheader.instcount)) << 24)) : __bswap32_var(cheader.instcount
))+(1)) ? ((((__uint32_t)((__builtin_constant_p(cheader.instcount
) ? ((((__uint32_t)(cheader.instcount)) >> 24) | ((((__uint32_t
)(cheader.instcount)) & (0xff << 16)) >> 8) |
((((__uint32_t)(cheader.instcount)) & (0xff << 8))
<< 8) | (((__uint32_t)(cheader.instcount)) << 24
)) : __bswap32_var(cheader.instcount))+(1))) >> 24) | (
(((__uint32_t)((__builtin_constant_p(cheader.instcount) ? (((
(__uint32_t)(cheader.instcount)) >> 24) | ((((__uint32_t
)(cheader.instcount)) & (0xff << 16)) >> 8) |
((((__uint32_t)(cheader.instcount)) & (0xff << 8))
<< 8) | (((__uint32_t)(cheader.instcount)) << 24
)) : __bswap32_var(cheader.instcount))+(1))) & (0xff <<
16)) >> 8) | ((((__uint32_t)((__builtin_constant_p(cheader
.instcount) ? ((((__uint32_t)(cheader.instcount)) >> 24
) | ((((__uint32_t)(cheader.instcount)) & (0xff << 16
)) >> 8) | ((((__uint32_t)(cheader.instcount)) & (0xff
<< 8)) << 8) | (((__uint32_t)(cheader.instcount)
) << 24)) : __bswap32_var(cheader.instcount))+(1))) &
(0xff << 8)) << 8) | (((__uint32_t)((__builtin_constant_p
(cheader.instcount) ? ((((__uint32_t)(cheader.instcount)) >>
24) | ((((__uint32_t)(cheader.instcount)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(cheader.instcount)) &
(0xff << 8)) << 8) | (((__uint32_t)(cheader.instcount
)) << 24)) : __bswap32_var(cheader.instcount))+(1))) <<
24)) : __bswap32_var((__builtin_constant_p(cheader.instcount
) ? ((((__uint32_t)(cheader.instcount)) >> 24) | ((((__uint32_t
)(cheader.instcount)) & (0xff << 16)) >> 8) |
((((__uint32_t)(cheader.instcount)) & (0xff << 8))
<< 8) | (((__uint32_t)(cheader.instcount)) << 24
)) : __bswap32_var(cheader.instcount))+(1))))), (char *)&
(cheader.instcount)), sizeof(afs_int32)))
578 return PRDBFAIL(267267L);
579 } else {
580 if (inc_header_word(at, usercount, 1)pr_Write ((at), 0, ((char *)&(cheader.usercount) - (char *
)&cheader), ((cheader.usercount = ((__builtin_constant_p(
(__builtin_constant_p(cheader.usercount) ? ((((__uint32_t)(cheader
.usercount)) >> 24) | ((((__uint32_t)(cheader.usercount
)) & (0xff << 16)) >> 8) | ((((__uint32_t)(cheader
.usercount)) & (0xff << 8)) << 8) | (((__uint32_t
)(cheader.usercount)) << 24)) : __bswap32_var(cheader.usercount
))+(1)) ? ((((__uint32_t)((__builtin_constant_p(cheader.usercount
) ? ((((__uint32_t)(cheader.usercount)) >> 24) | ((((__uint32_t
)(cheader.usercount)) & (0xff << 16)) >> 8) |
((((__uint32_t)(cheader.usercount)) & (0xff << 8))
<< 8) | (((__uint32_t)(cheader.usercount)) << 24
)) : __bswap32_var(cheader.usercount))+(1))) >> 24) | (
(((__uint32_t)((__builtin_constant_p(cheader.usercount) ? (((
(__uint32_t)(cheader.usercount)) >> 24) | ((((__uint32_t
)(cheader.usercount)) & (0xff << 16)) >> 8) |
((((__uint32_t)(cheader.usercount)) & (0xff << 8))
<< 8) | (((__uint32_t)(cheader.usercount)) << 24
)) : __bswap32_var(cheader.usercount))+(1))) & (0xff <<
16)) >> 8) | ((((__uint32_t)((__builtin_constant_p(cheader
.usercount) ? ((((__uint32_t)(cheader.usercount)) >> 24
) | ((((__uint32_t)(cheader.usercount)) & (0xff << 16
)) >> 8) | ((((__uint32_t)(cheader.usercount)) & (0xff
<< 8)) << 8) | (((__uint32_t)(cheader.usercount)
) << 24)) : __bswap32_var(cheader.usercount))+(1))) &
(0xff << 8)) << 8) | (((__uint32_t)((__builtin_constant_p
(cheader.usercount) ? ((((__uint32_t)(cheader.usercount)) >>
24) | ((((__uint32_t)(cheader.usercount)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(cheader.usercount)) &
(0xff << 8)) << 8) | (((__uint32_t)(cheader.usercount
)) << 24)) : __bswap32_var(cheader.usercount))+(1))) <<
24)) : __bswap32_var((__builtin_constant_p(cheader.usercount
) ? ((((__uint32_t)(cheader.usercount)) >> 24) | ((((__uint32_t
)(cheader.usercount)) & (0xff << 16)) >> 8) |
((((__uint32_t)(cheader.usercount)) & (0xff << 8))
<< 8) | (((__uint32_t)(cheader.usercount)) << 24
)) : __bswap32_var(cheader.usercount))+(1))))), (char *)&
(cheader.usercount)), sizeof(afs_int32)))
581 return PRDBFAIL(267267L);
582 }
583 return PRSUCCESS0;
584}
585
586
587/* RemoveFromEntry - remove aid from bid's entries list, freeing a continuation
588 * entry if appropriate */
589
590afs_int32
591RemoveFromEntry(struct ubik_trans *at, afs_int32 aid, afs_int32 bid)
592{
593 afs_int32 code;
594 struct prentry tentry;
595 struct contentry centry;
596 struct contentry hentry;
597 afs_int32 temp;
598 afs_int32 i, j;
599 afs_int32 nptr;
600 afs_int32 hloc;
601
602 if (aid == bid)
603 return PRINCONSISTENT(267277L);
604 memset(&hentry, 0, sizeof(hentry));
605 temp = FindByID(at, bid);
606 if (temp == 0)
607 return PRNOENT(267268L);
608 code = pr_ReadEntry(at, 0, temp, &tentry);
609 if (code != 0)
610 return code;
611#ifdef PR_REMEMBER_TIMES1
612 tentry.removeTime = time(0);
613#endif
614 for (i = 0; i < PRSIZE10; i++) {
615 if (tentry.entries[i] == aid) {
616 tentry.entries[i] = PRBADID0x80000000;
617 tentry.count--;
618 code = pr_WriteEntry(at, 0, temp, &tentry);
619 if (code != 0)
620 return code;
621 return PRSUCCESS0;
622 }
623 if (tentry.entries[i] == 0) /* found end of list */
624 return PRNOENT(267268L);
625 }
626 hloc = 0;
627 nptr = tentry.next;
628 while (nptr != 0) {
629 code = pr_ReadCoEntry(at, 0, nptr, &centry);
630 if (code != 0)
631 return code;
632 if ((centry.id != bid) || !(centry.flags & PRCONT4))
633 return PRDBBAD(267275L);
634 for (i = 0; i < COSIZE39; i++) {
635 if (centry.entries[i] == aid) {
636 centry.entries[i] = PRBADID0x80000000;
637 for (j = 0; j < COSIZE39; j++)
638 if (centry.entries[j] != PRBADID0x80000000
639 && centry.entries[j] != 0)
640 break;
641 if (j == COSIZE39) { /* can free this block */
642 if (hloc == 0) {
643 tentry.next = centry.next;
644 } else {
645 hentry.next = centry.next;
646 code = pr_WriteCoEntry(at, 0, hloc, &hentry);
647 if (code != 0)
648 return code;
649 }
650 code = FreeBlock(at, nptr);
651 if (code)
652 return code;
653 } else { /* can't free it yet */
654 code = pr_WriteCoEntry(at, 0, nptr, &centry);
655 if (code != 0)
656 return code;
657 }
658 tentry.count--;
659 code = pr_WriteEntry(at, 0, temp, &tentry);
660 if (code)
661 return PRDBFAIL(267267L);
662 return 0;
663 }
664 if (centry.entries[i] == 0)
665 return PRNOENT(267268L);
666 } /* for all coentry slots */
667 hloc = nptr;
668 nptr = centry.next;
669 memcpy(&hentry, &centry, sizeof(centry));
670 } /* while there are coentries */
671 return PRNOENT(267268L);
672}
673
674#if defined(SUPERGROUPS1)
675/* ChangeIDEntry - remove aid from bid's entries list, freeing a continuation
676 * entry if appropriate */
677
678afs_int32
679ChangeIDEntry(struct ubik_trans *at, afs_int32 aid, afs_int32 newid, afs_int32 bid)
680{
681 afs_int32 code;
682 struct prentry tentry;
683 struct contentry centry;
684 afs_int32 temp;
685 afs_int32 i, j;
686 afs_int32 nptr;
687
688 if (aid == bid)
689 return PRINCONSISTENT(267277L);
690 temp = FindByID(at, bid);
691 if (temp == 0) {
692 return PRNOENT(267268L);
693 }
694 code = pr_ReadEntry(at, 0, temp, &tentry);
695 if (code != 0)
696 return code;
697 for (i = 0; i < PRSIZE10; i++) {
698 if (tentry.entries[i] == aid) {
699 tentry.entries[i] = newid;
700 code = pr_WriteEntry(at, 0, temp, &tentry);
701 if (code != 0)
702 return code;
703 return PRSUCCESS0;
704 }
705 if (tentry.entries[i] == 0) { /* found end of list */
706 return PRNOENT(267268L);
707 }
708 }
709
710 nptr = tentry.next;
711 while (nptr) {
712 code = pr_ReadCoEntry(at, 0, nptr, &centry);
713 if (code != 0)
714 return code;
715 if ((centry.id != bid) || !(centry.flags & PRCONT4)) {
716 fprintf(stderr__stderrp,
717 "ChangeIDEntry: bad database bid=%d centry.id=%d .flags=%d\n",
718 bid, centry.id, centry.flags);
719 return PRDBBAD(267275L);
720 }
721 for (i = 0; i < COSIZE39; i++) {
722 if (centry.entries[i] == aid) {
723 centry.entries[i] = newid;
724 for (j = 0; j < COSIZE39; j++)
725 if (centry.entries[j] != PRBADID0x80000000
726 && centry.entries[j] != 0)
727 break;
728 code = pr_WriteCoEntry(at, 0, nptr, &centry);
729 if (code != 0)
730 return code;
731 return 0;
732 }
733 if (centry.entries[i] == 0) {
734 return PRNOENT(267268L);
735 }
736 } /* for all coentry slots */
737 nptr = centry.next;
738 } /* while there are coentries */
739 return PRNOENT(267268L);
740}
741
742/* #ifdef SUPERGROUPS */
743/* RemoveFromSGEntry - remove aid from bid's supergroups list, freeing a
744 * continuation entry if appropriate */
745
746afs_int32
747RemoveFromSGEntry(struct ubik_trans *at, afs_int32 aid, afs_int32 bid)
748{
749 afs_int32 code;
750 struct prentry tentry;
751 struct prentryg *tentryg;
752 struct contentry centry;
753 struct contentry hentry;
754 afs_int32 temp;
755 afs_int32 i, j;
756 afs_int32 nptr;
757 afs_int32 hloc;
758
759 if (aid == bid)
760 return PRINCONSISTENT(267277L);
761 memset(&hentry, 0, sizeof(hentry));
762 temp = FindByID(at, bid);
763 if (temp == 0) {
764 return PRNOENT(267268L);
765 }
766 code = pr_ReadEntry(at, 0, temp, &tentry);
767 if (code != 0)
768 return code;
769#ifdef PR_REMEMBER_TIMES1
770 tentry.removeTime = time(NULL((void *)0));
771#endif
772 tentryg = (struct prentryg *)&tentry;
773 for (i = 0; i < SGSIZE2; i++) {
774 if (tentryg->supergroup[i] == aid) {
775 tentryg->supergroup[i] = PRBADID0x80000000;
776 tentryg->countsg--;
777 code = pr_WriteEntry(at, 0, temp, &tentry);
778 if (code != 0)
779 return code;
780 return PRSUCCESS0;
781 }
782 if (tentryg->supergroup[i] == 0) { /* found end of list */
783 return PRNOENT(267268L);
784 }
785 }
786 hloc = 0;
787 nptr = tentryg->nextsg;
788 while (nptr) {
789 code = pr_ReadCoEntry(at, 0, nptr, &centry);
790 if (code != 0)
791 return code;
792 if ((centry.id != bid) || !(centry.flags & PRCONT4)) {
793 fprintf(stderr__stderrp,
794 "ChangeIDEntry: bad database bid=%d centry.id=%d .flags=%d\n",
795 bid, centry.id, centry.flags);
796 return PRDBBAD(267275L);
797 }
798 for (i = 0; i < COSIZE39; i++) {
799 if (centry.entries[i] == aid) {
800 centry.entries[i] = PRBADID0x80000000;
801 for (j = 0; j < COSIZE39; j++)
802 if (centry.entries[j] != PRBADID0x80000000
803 && centry.entries[j] != 0)
804 break;
805 if (j == COSIZE39) { /* can free this block */
806 if (hloc == 0) {
807 tentryg->nextsg = centry.next;
808 } else {
809 hentry.next = centry.next;
810 code = pr_WriteCoEntry(at, 0, hloc, &hentry);
811 if (code != 0)
812 return code;
813 }
814 code = FreeBlock(at, nptr);
815 if (code)
816 return code;
817 } else { /* can't free it yet */
818 code = pr_WriteCoEntry(at, 0, nptr, &centry);
819 if (code != 0)
820 return code;
821 }
822 tentryg->countsg--;
823 code = pr_WriteEntry(at, 0, temp, &tentry);
824 if (code)
825 return PRDBFAIL(267267L);
826 return 0;
827 }
828 if (centry.entries[i] == 0) {
829 return PRNOENT(267268L);
830 }
831 } /* for all coentry slots */
832 hloc = nptr;
833 nptr = centry.next;
834 memcpy((char *)&centry, (char *)&hentry, sizeof(centry));
835 } /* while there are coentries */
836 return PRNOENT(267268L);
837}
838
839#endif /* SUPERGROUPS */
840
841/* DeleteEntry - delete the entry in tentry at loc, removing it from all
842 * groups, putting groups owned by it on orphan chain, and freeing the space */
843
844afs_int32
845DeleteEntry(struct ubik_trans *at, struct prentry *tentry, afs_int32 loc)
846{
847 afs_int32 code;
848 struct contentry centry;
849 afs_int32 i;
850 afs_int32 nptr;
851
852 if (strchr(tentry->name, '@')) {
853 if (tentry->flags & PRGRP2) {
854 /* If there are still foreign user accounts from that cell
855 * don't delete the group */
856 if (tentry->count)
857 return PRBADARG(267273L);
858 } else {
859 /* adjust quota */
860
861 afs_int32 loc = FindByID(at, tentry->cellid);
862 struct prentry centry;
863 if (loc) {
864 code = pr_Read(at, 0, loc, &centry, sizeof(centry));
865 if (code)
866 return code;
867 if (ntohl(centry.flags)(__builtin_constant_p(centry.flags) ? ((((__uint32_t)(centry.
flags)) >> 24) | ((((__uint32_t)(centry.flags)) & (
0xff << 16)) >> 8) | ((((__uint32_t)(centry.flags
)) & (0xff << 8)) << 8) | (((__uint32_t)(centry
.flags)) << 24)) : __bswap32_var(centry.flags)) & PRQUOTA(1<<7)) {
868 centry.ngroups = htonl(ntohl(centry.ngroups) + 1)(__builtin_constant_p((__builtin_constant_p(centry.ngroups) ?
((((__uint32_t)(centry.ngroups)) >> 24) | ((((__uint32_t
)(centry.ngroups)) & (0xff << 16)) >> 8) | ((
((__uint32_t)(centry.ngroups)) & (0xff << 8)) <<
8) | (((__uint32_t)(centry.ngroups)) << 24)) : __bswap32_var
(centry.ngroups)) + 1) ? ((((__uint32_t)((__builtin_constant_p
(centry.ngroups) ? ((((__uint32_t)(centry.ngroups)) >> 24
) | ((((__uint32_t)(centry.ngroups)) & (0xff << 16)
) >> 8) | ((((__uint32_t)(centry.ngroups)) & (0xff <<
8)) << 8) | (((__uint32_t)(centry.ngroups)) << 24
)) : __bswap32_var(centry.ngroups)) + 1)) >> 24) | ((((
__uint32_t)((__builtin_constant_p(centry.ngroups) ? ((((__uint32_t
)(centry.ngroups)) >> 24) | ((((__uint32_t)(centry.ngroups
)) & (0xff << 16)) >> 8) | ((((__uint32_t)(centry
.ngroups)) & (0xff << 8)) << 8) | (((__uint32_t
)(centry.ngroups)) << 24)) : __bswap32_var(centry.ngroups
)) + 1)) & (0xff << 16)) >> 8) | ((((__uint32_t
)((__builtin_constant_p(centry.ngroups) ? ((((__uint32_t)(centry
.ngroups)) >> 24) | ((((__uint32_t)(centry.ngroups)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(centry.ngroups
)) & (0xff << 8)) << 8) | (((__uint32_t)(centry
.ngroups)) << 24)) : __bswap32_var(centry.ngroups)) + 1
)) & (0xff << 8)) << 8) | (((__uint32_t)((__builtin_constant_p
(centry.ngroups) ? ((((__uint32_t)(centry.ngroups)) >> 24
) | ((((__uint32_t)(centry.ngroups)) & (0xff << 16)
) >> 8) | ((((__uint32_t)(centry.ngroups)) & (0xff <<
8)) << 8) | (((__uint32_t)(centry.ngroups)) << 24
)) : __bswap32_var(centry.ngroups)) + 1)) << 24)) : __bswap32_var
((__builtin_constant_p(centry.ngroups) ? ((((__uint32_t)(centry
.ngroups)) >> 24) | ((((__uint32_t)(centry.ngroups)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(centry.ngroups
)) & (0xff << 8)) << 8) | (((__uint32_t)(centry
.ngroups)) << 24)) : __bswap32_var(centry.ngroups)) + 1
));
869 }
870 code = pr_Write(at, 0, loc, &centry, sizeof(centry));
871 if (code)
872 return code;
873 }
874 }
875 }
876 /* First remove the entire membership list */
877 for (i = 0; i < PRSIZE10; i++) {
878 if (tentry->entries[i] == PRBADID0x80000000)
879 continue;
880 if (tentry->entries[i] == 0)
881 break;
882#if defined(SUPERGROUPS1)
883 if ((tentry->flags & PRGRP2) && tentry->entries[i] < 0) /* Supergroup */
884 code = RemoveFromSGEntry(at, tentry->id, tentry->entries[i]);
885 else
886#endif
887 code = RemoveFromEntry(at, tentry->id, tentry->entries[i]);
888 if (code)
889 return code;
890 }
891#if defined(SUPERGROUPS1)
892 {
893 struct prentryg *tentryg = (struct prentryg *)tentry;
894
895 /* Then remove the entire supergroup list */
896 for (i = 0; i < SGSIZE2; i++) {
897 if (tentryg->supergroup[i] == PRBADID0x80000000)
898 continue;
899 if (tentryg->supergroup[i] == 0)
900 break;
901 code = RemoveFromEntry(at, tentry->id, tentryg->supergroup[i]);
902 if (code)
903 return code;
904 }
905 }
906#endif /* SUPERGROUPS */
907 nptr = tentry->next;
908 while (nptr != 0) {
909 code = pr_ReadCoEntry(at, 0, nptr, &centry);
910 if (code != 0)
911 return PRDBFAIL(267267L);
912 for (i = 0; i < COSIZE39; i++) {
913 if (centry.entries[i] == PRBADID0x80000000)
914 continue;
915 if (centry.entries[i] == 0)
916 break;
917 code = RemoveFromEntry(at, tentry->id, centry.entries[i]);
918 if (code)
919 return code;
920 }
921 code = FreeBlock(at, nptr); /* free continuation block */
922 if (code)
923 return code;
924 nptr = centry.next;
925 }
926
927 /* Remove us from other's owned chain. Note that this will zero our owned
928 * field (on disk) so this step must follow the above step in case we are
929 * on our own owned list. */
930 if (tentry->flags & PRGRP2) {
931 if (tentry->owner) {
932 code = RemoveFromOwnerChain(at, tentry->id, tentry->owner);
933 if (code)
934 return code;
935 } else {
936 code = RemoveFromOrphan(at, tentry->id);
937 if (code)
938 return code;
939 }
940 }
941
942 code = RemoveFromIDHash(at, tentry->id, &loc);
943 if (code != PRSUCCESS0)
944 return code;
945 code = RemoveFromNameHash(at, tentry->name, &loc);
946 if (code != PRSUCCESS0)
947 return code;
948
949 if (tentry->flags & PRGRP2) {
950 afs_int32 loc = FindByID(at, tentry->creator);
951 struct prentry centry;
952 int admin;
953
954 if (loc) {
955 code = pr_Read(at, 0, loc, &centry, sizeof(centry));
956 if (code)
957 return code;
958 admin = ((tentry->creator == SYSADMINID-204)
959 || IsAMemberOf(at, tentry->creator, SYSADMINID-204));
960 if (ntohl(centry.flags)(__builtin_constant_p(centry.flags) ? ((((__uint32_t)(centry.
flags)) >> 24) | ((((__uint32_t)(centry.flags)) & (
0xff << 16)) >> 8) | ((((__uint32_t)(centry.flags
)) & (0xff << 8)) << 8) | (((__uint32_t)(centry
.flags)) << 24)) : __bswap32_var(centry.flags)) & PRQUOTA(1<<7)) {
961 if (!(admin && (ntohl(centry.ngroups)(__builtin_constant_p(centry.ngroups) ? ((((__uint32_t)(centry
.ngroups)) >> 24) | ((((__uint32_t)(centry.ngroups)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(centry.ngroups
)) & (0xff << 8)) << 8) | (((__uint32_t)(centry
.ngroups)) << 24)) : __bswap32_var(centry.ngroups)) >= 20))) {
962 centry.ngroups = htonl(ntohl(centry.ngroups) + 1)(__builtin_constant_p((__builtin_constant_p(centry.ngroups) ?
((((__uint32_t)(centry.ngroups)) >> 24) | ((((__uint32_t
)(centry.ngroups)) & (0xff << 16)) >> 8) | ((
((__uint32_t)(centry.ngroups)) & (0xff << 8)) <<
8) | (((__uint32_t)(centry.ngroups)) << 24)) : __bswap32_var
(centry.ngroups)) + 1) ? ((((__uint32_t)((__builtin_constant_p
(centry.ngroups) ? ((((__uint32_t)(centry.ngroups)) >> 24
) | ((((__uint32_t)(centry.ngroups)) & (0xff << 16)
) >> 8) | ((((__uint32_t)(centry.ngroups)) & (0xff <<
8)) << 8) | (((__uint32_t)(centry.ngroups)) << 24
)) : __bswap32_var(centry.ngroups)) + 1)) >> 24) | ((((
__uint32_t)((__builtin_constant_p(centry.ngroups) ? ((((__uint32_t
)(centry.ngroups)) >> 24) | ((((__uint32_t)(centry.ngroups
)) & (0xff << 16)) >> 8) | ((((__uint32_t)(centry
.ngroups)) & (0xff << 8)) << 8) | (((__uint32_t
)(centry.ngroups)) << 24)) : __bswap32_var(centry.ngroups
)) + 1)) & (0xff << 16)) >> 8) | ((((__uint32_t
)((__builtin_constant_p(centry.ngroups) ? ((((__uint32_t)(centry
.ngroups)) >> 24) | ((((__uint32_t)(centry.ngroups)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(centry.ngroups
)) & (0xff << 8)) << 8) | (((__uint32_t)(centry
.ngroups)) << 24)) : __bswap32_var(centry.ngroups)) + 1
)) & (0xff << 8)) << 8) | (((__uint32_t)((__builtin_constant_p
(centry.ngroups) ? ((((__uint32_t)(centry.ngroups)) >> 24
) | ((((__uint32_t)(centry.ngroups)) & (0xff << 16)
) >> 8) | ((((__uint32_t)(centry.ngroups)) & (0xff <<
8)) << 8) | (((__uint32_t)(centry.ngroups)) << 24
)) : __bswap32_var(centry.ngroups)) + 1)) << 24)) : __bswap32_var
((__builtin_constant_p(centry.ngroups) ? ((((__uint32_t)(centry
.ngroups)) >> 24) | ((((__uint32_t)(centry.ngroups)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(centry.ngroups
)) & (0xff << 8)) << 8) | (((__uint32_t)(centry
.ngroups)) << 24)) : __bswap32_var(centry.ngroups)) + 1
));
963 }
964 }
965 code = pr_Write(at, 0, loc, &centry, sizeof(centry));
966 if (code)
967 return code;
968 }
969 }
970
971 if (tentry->flags & PRGRP2) {
972 if (inc_header_word(at, groupcount, -1)pr_Write ((at), 0, ((char *)&(cheader.groupcount) - (char
*)&cheader), ((cheader.groupcount = ((__builtin_constant_p
((__builtin_constant_p(cheader.groupcount) ? ((((__uint32_t)(
cheader.groupcount)) >> 24) | ((((__uint32_t)(cheader.groupcount
)) & (0xff << 16)) >> 8) | ((((__uint32_t)(cheader
.groupcount)) & (0xff << 8)) << 8) | (((__uint32_t
)(cheader.groupcount)) << 24)) : __bswap32_var(cheader.
groupcount))+(-1)) ? ((((__uint32_t)((__builtin_constant_p(cheader
.groupcount) ? ((((__uint32_t)(cheader.groupcount)) >> 24
) | ((((__uint32_t)(cheader.groupcount)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(cheader.groupcount)) &
(0xff << 8)) << 8) | (((__uint32_t)(cheader.groupcount
)) << 24)) : __bswap32_var(cheader.groupcount))+(-1))) >>
24) | ((((__uint32_t)((__builtin_constant_p(cheader.groupcount
) ? ((((__uint32_t)(cheader.groupcount)) >> 24) | ((((__uint32_t
)(cheader.groupcount)) & (0xff << 16)) >> 8) |
((((__uint32_t)(cheader.groupcount)) & (0xff << 8)
) << 8) | (((__uint32_t)(cheader.groupcount)) << 24
)) : __bswap32_var(cheader.groupcount))+(-1))) & (0xff <<
16)) >> 8) | ((((__uint32_t)((__builtin_constant_p(cheader
.groupcount) ? ((((__uint32_t)(cheader.groupcount)) >> 24
) | ((((__uint32_t)(cheader.groupcount)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(cheader.groupcount)) &
(0xff << 8)) << 8) | (((__uint32_t)(cheader.groupcount
)) << 24)) : __bswap32_var(cheader.groupcount))+(-1))) &
(0xff << 8)) << 8) | (((__uint32_t)((__builtin_constant_p
(cheader.groupcount) ? ((((__uint32_t)(cheader.groupcount)) >>
24) | ((((__uint32_t)(cheader.groupcount)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(cheader.groupcount)) &
(0xff << 8)) << 8) | (((__uint32_t)(cheader.groupcount
)) << 24)) : __bswap32_var(cheader.groupcount))+(-1))) <<
24)) : __bswap32_var((__builtin_constant_p(cheader.groupcount
) ? ((((__uint32_t)(cheader.groupcount)) >> 24) | ((((__uint32_t
)(cheader.groupcount)) & (0xff << 16)) >> 8) |
((((__uint32_t)(cheader.groupcount)) & (0xff << 8)
) << 8) | (((__uint32_t)(cheader.groupcount)) << 24
)) : __bswap32_var(cheader.groupcount))+(-1))))), (char *)&
(cheader.groupcount)), sizeof(afs_int32)))
973 return PRDBFAIL(267267L);
974 } else if (tentry->flags & PRINST32) {
975 if (inc_header_word(at, instcount, -1)pr_Write ((at), 0, ((char *)&(cheader.instcount) - (char *
)&cheader), ((cheader.instcount = ((__builtin_constant_p(
(__builtin_constant_p(cheader.instcount) ? ((((__uint32_t)(cheader
.instcount)) >> 24) | ((((__uint32_t)(cheader.instcount
)) & (0xff << 16)) >> 8) | ((((__uint32_t)(cheader
.instcount)) & (0xff << 8)) << 8) | (((__uint32_t
)(cheader.instcount)) << 24)) : __bswap32_var(cheader.instcount
))+(-1)) ? ((((__uint32_t)((__builtin_constant_p(cheader.instcount
) ? ((((__uint32_t)(cheader.instcount)) >> 24) | ((((__uint32_t
)(cheader.instcount)) & (0xff << 16)) >> 8) |
((((__uint32_t)(cheader.instcount)) & (0xff << 8))
<< 8) | (((__uint32_t)(cheader.instcount)) << 24
)) : __bswap32_var(cheader.instcount))+(-1))) >> 24) | (
(((__uint32_t)((__builtin_constant_p(cheader.instcount) ? (((
(__uint32_t)(cheader.instcount)) >> 24) | ((((__uint32_t
)(cheader.instcount)) & (0xff << 16)) >> 8) |
((((__uint32_t)(cheader.instcount)) & (0xff << 8))
<< 8) | (((__uint32_t)(cheader.instcount)) << 24
)) : __bswap32_var(cheader.instcount))+(-1))) & (0xff <<
16)) >> 8) | ((((__uint32_t)((__builtin_constant_p(cheader
.instcount) ? ((((__uint32_t)(cheader.instcount)) >> 24
) | ((((__uint32_t)(cheader.instcount)) & (0xff << 16
)) >> 8) | ((((__uint32_t)(cheader.instcount)) & (0xff
<< 8)) << 8) | (((__uint32_t)(cheader.instcount)
) << 24)) : __bswap32_var(cheader.instcount))+(-1))) &
(0xff << 8)) << 8) | (((__uint32_t)((__builtin_constant_p
(cheader.instcount) ? ((((__uint32_t)(cheader.instcount)) >>
24) | ((((__uint32_t)(cheader.instcount)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(cheader.instcount)) &
(0xff << 8)) << 8) | (((__uint32_t)(cheader.instcount
)) << 24)) : __bswap32_var(cheader.instcount))+(-1))) <<
24)) : __bswap32_var((__builtin_constant_p(cheader.instcount
) ? ((((__uint32_t)(cheader.instcount)) >> 24) | ((((__uint32_t
)(cheader.instcount)) & (0xff << 16)) >> 8) |
((((__uint32_t)(cheader.instcount)) & (0xff << 8))
<< 8) | (((__uint32_t)(cheader.instcount)) << 24
)) : __bswap32_var(cheader.instcount))+(-1))))), (char *)&
(cheader.instcount)), sizeof(afs_int32)))
976 return PRDBFAIL(267267L);
977 } else {
978 if (strchr(tentry->name, '@')) {
979 if (inc_header_word(at, foreigncount, -1)pr_Write ((at), 0, ((char *)&(cheader.foreigncount) - (char
*)&cheader), ((cheader.foreigncount = ((__builtin_constant_p
((__builtin_constant_p(cheader.foreigncount) ? ((((__uint32_t
)(cheader.foreigncount)) >> 24) | ((((__uint32_t)(cheader
.foreigncount)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(cheader.foreigncount)) & (0xff << 8)) << 8)
| (((__uint32_t)(cheader.foreigncount)) << 24)) : __bswap32_var
(cheader.foreigncount))+(-1)) ? ((((__uint32_t)((__builtin_constant_p
(cheader.foreigncount) ? ((((__uint32_t)(cheader.foreigncount
)) >> 24) | ((((__uint32_t)(cheader.foreigncount)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(cheader.foreigncount
)) & (0xff << 8)) << 8) | (((__uint32_t)(cheader
.foreigncount)) << 24)) : __bswap32_var(cheader.foreigncount
))+(-1))) >> 24) | ((((__uint32_t)((__builtin_constant_p
(cheader.foreigncount) ? ((((__uint32_t)(cheader.foreigncount
)) >> 24) | ((((__uint32_t)(cheader.foreigncount)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(cheader.foreigncount
)) & (0xff << 8)) << 8) | (((__uint32_t)(cheader
.foreigncount)) << 24)) : __bswap32_var(cheader.foreigncount
))+(-1))) & (0xff << 16)) >> 8) | ((((__uint32_t
)((__builtin_constant_p(cheader.foreigncount) ? ((((__uint32_t
)(cheader.foreigncount)) >> 24) | ((((__uint32_t)(cheader
.foreigncount)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(cheader.foreigncount)) & (0xff << 8)) << 8)
| (((__uint32_t)(cheader.foreigncount)) << 24)) : __bswap32_var
(cheader.foreigncount))+(-1))) & (0xff << 8)) <<
8) | (((__uint32_t)((__builtin_constant_p(cheader.foreigncount
) ? ((((__uint32_t)(cheader.foreigncount)) >> 24) | (((
(__uint32_t)(cheader.foreigncount)) & (0xff << 16))
>> 8) | ((((__uint32_t)(cheader.foreigncount)) & (
0xff << 8)) << 8) | (((__uint32_t)(cheader.foreigncount
)) << 24)) : __bswap32_var(cheader.foreigncount))+(-1))
) << 24)) : __bswap32_var((__builtin_constant_p(cheader
.foreigncount) ? ((((__uint32_t)(cheader.foreigncount)) >>
24) | ((((__uint32_t)(cheader.foreigncount)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(cheader.foreigncount)) &
(0xff << 8)) << 8) | (((__uint32_t)(cheader.foreigncount
)) << 24)) : __bswap32_var(cheader.foreigncount))+(-1))
))), (char *)&(cheader.foreigncount)), sizeof(afs_int32)))
980 return PRDBFAIL(267267L);
981 } else {
982 if (inc_header_word(at, usercount, -1)pr_Write ((at), 0, ((char *)&(cheader.usercount) - (char *
)&cheader), ((cheader.usercount = ((__builtin_constant_p(
(__builtin_constant_p(cheader.usercount) ? ((((__uint32_t)(cheader
.usercount)) >> 24) | ((((__uint32_t)(cheader.usercount
)) & (0xff << 16)) >> 8) | ((((__uint32_t)(cheader
.usercount)) & (0xff << 8)) << 8) | (((__uint32_t
)(cheader.usercount)) << 24)) : __bswap32_var(cheader.usercount
))+(-1)) ? ((((__uint32_t)((__builtin_constant_p(cheader.usercount
) ? ((((__uint32_t)(cheader.usercount)) >> 24) | ((((__uint32_t
)(cheader.usercount)) & (0xff << 16)) >> 8) |
((((__uint32_t)(cheader.usercount)) & (0xff << 8))
<< 8) | (((__uint32_t)(cheader.usercount)) << 24
)) : __bswap32_var(cheader.usercount))+(-1))) >> 24) | (
(((__uint32_t)((__builtin_constant_p(cheader.usercount) ? (((
(__uint32_t)(cheader.usercount)) >> 24) | ((((__uint32_t
)(cheader.usercount)) & (0xff << 16)) >> 8) |
((((__uint32_t)(cheader.usercount)) & (0xff << 8))
<< 8) | (((__uint32_t)(cheader.usercount)) << 24
)) : __bswap32_var(cheader.usercount))+(-1))) & (0xff <<
16)) >> 8) | ((((__uint32_t)((__builtin_constant_p(cheader
.usercount) ? ((((__uint32_t)(cheader.usercount)) >> 24
) | ((((__uint32_t)(cheader.usercount)) & (0xff << 16
)) >> 8) | ((((__uint32_t)(cheader.usercount)) & (0xff
<< 8)) << 8) | (((__uint32_t)(cheader.usercount)
) << 24)) : __bswap32_var(cheader.usercount))+(-1))) &
(0xff << 8)) << 8) | (((__uint32_t)((__builtin_constant_p
(cheader.usercount) ? ((((__uint32_t)(cheader.usercount)) >>
24) | ((((__uint32_t)(cheader.usercount)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(cheader.usercount)) &
(0xff << 8)) << 8) | (((__uint32_t)(cheader.usercount
)) << 24)) : __bswap32_var(cheader.usercount))+(-1))) <<
24)) : __bswap32_var((__builtin_constant_p(cheader.usercount
) ? ((((__uint32_t)(cheader.usercount)) >> 24) | ((((__uint32_t
)(cheader.usercount)) & (0xff << 16)) >> 8) |
((((__uint32_t)(cheader.usercount)) & (0xff << 8))
<< 8) | (((__uint32_t)(cheader.usercount)) << 24
)) : __bswap32_var(cheader.usercount))+(-1))))), (char *)&
(cheader.usercount)), sizeof(afs_int32)))
983 return PRDBFAIL(267267L);
984 }
985 }
986 code = FreeBlock(at, loc);
987 return code;
988}
989
990/* AddToEntry - add aid to entry's entries list, alloc'ing a continuation block
991 * if needed.
992 *
993 * Note the entry is written out by this routine. */
994
995afs_int32
996AddToEntry(struct ubik_trans *tt, struct prentry *entry, afs_int32 loc, afs_int32 aid)
997{
998 afs_int32 code;
999 afs_int32 i;
1000 struct contentry nentry;
1001 struct contentry aentry;
1002 afs_int32 nptr;
1003 afs_int32 last; /* addr of last cont. block */
1004 afs_int32 first = 0;
1005 afs_int32 cloc = 0;
1006 afs_int32 slot = -1;
1007
1008 if (entry->id == aid)
1009 return PRINCONSISTENT(267277L);
1010#ifdef PR_REMEMBER_TIMES1
1011 entry->addTime = time(0);
1012#endif
1013 for (i = 0; i < PRSIZE10; i++) {
1014 if (entry->entries[i] == aid)
1015 return PRIDEXIST(267265L);
1016 if (entry->entries[i] == PRBADID0x80000000) { /* remember this spot */
1017 first = 1;
1018 slot = i;
1019 } else if (entry->entries[i] == 0) { /* end of the line */
1020 if (slot == -1) {
1021 first = 1;
1022 slot = i;
1023 }
1024 break;
1025 }
1026 }
1027 last = 0;
1028 nptr = entry->next;
1029 while (nptr != 0) {
1030 code = pr_ReadCoEntry(tt, 0, nptr, &nentry);
1031 if (code != 0)
1032 return code;
1033 last = nptr;
1034 if (!(nentry.flags & PRCONT4))
1035 return PRDBFAIL(267267L);
1036 for (i = 0; i < COSIZE39; i++) {
1037 if (nentry.entries[i] == aid)
1038 return PRIDEXIST(267265L);
1039 if (nentry.entries[i] == PRBADID0x80000000) {
1040 if (slot == -1) {
1041 slot = i;
1042 cloc = nptr;
1043 }
1044 } else if (nentry.entries[i] == 0) {
1045 if (slot == -1) {
1046 slot = i;
1047 cloc = nptr;
1048 }
1049 break;
1050 }
1051 }
1052 nptr = nentry.next;
1053 }
1054 if (slot != -1) { /* we found a place */
1055 entry->count++;
1056 if (first) { /* place is in first block */
1057 entry->entries[slot] = aid;
1058 code = pr_WriteEntry(tt, 0, loc, entry);
1059 if (code != 0)
1060 return code;
1061 return PRSUCCESS0;
1062 }
1063 code = pr_WriteEntry(tt, 0, loc, entry);
1064 if (code)
1065 return code;
1066 code = pr_ReadCoEntry(tt, 0, cloc, &aentry);
1067 if (code != 0)
1068 return code;
1069 aentry.entries[slot] = aid;
1070 code = pr_WriteCoEntry(tt, 0, cloc, &aentry);
1071 if (code != 0)
1072 return code;
1073 return PRSUCCESS0;
1074 }
1075 /* have to allocate a continuation block if we got here */
1076 nptr = AllocBlock(tt);
1077 if (last) {
1078 /* then we should tack new block after last block in cont. chain */
1079 nentry.next = nptr;
1080 code = pr_WriteCoEntry(tt, 0, last, &nentry);
1081 if (code != 0)
1082 return code;
1083 } else {
1084 entry->next = nptr;
1085 }
1086 memset(&aentry, 0, sizeof(aentry));
1087 aentry.flags |= PRCONT4;
1088 aentry.id = entry->id;
1089 aentry.next = 0;
1090 aentry.entries[0] = aid;
1091 code = pr_WriteCoEntry(tt, 0, nptr, &aentry);
1092 if (code != 0)
1093 return code;
1094 /* don't forget to update count, here! */
1095 entry->count++;
1096 code = pr_WriteEntry(tt, 0, loc, entry);
1097 return code;
1098
1099}
1100
1101#if defined(SUPERGROUPS1)
1102
1103/* AddToSGEntry - add aid to entry's supergroup list, alloc'ing a
1104 * continuation block if needed.
1105 *
1106 * Note the entry is written out by this routine. */
1107
1108afs_int32
1109AddToSGEntry(struct ubik_trans *tt, struct prentry *entry, afs_int32 loc, afs_int32 aid)
1110{
1111 afs_int32 code;
1112 afs_int32 i;
1113 struct contentry nentry;
1114 struct contentry aentry;
1115 struct prentryg *entryg;
1116 afs_int32 nptr;
1117 afs_int32 last; /* addr of last cont. block */
1118 afs_int32 first = 0;
1119 afs_int32 cloc = 0;
1120 afs_int32 slot = -1;
1121
1122 if (entry->id == aid)
1123 return PRINCONSISTENT(267277L);
1124#ifdef PR_REMEMBER_TIMES1
1125 entry->addTime = time(NULL((void *)0));
1126#endif
1127 entryg = (struct prentryg *)entry;
1128 for (i = 0; i < SGSIZE2; i++) {
1129 if (entryg->supergroup[i] == aid)
1130 return PRIDEXIST(267265L);
1131 if (entryg->supergroup[i] == PRBADID0x80000000) { /* remember this spot */
1132 first = 1;
1133 slot = i;
1134 } else if (entryg->supergroup[i] == 0) { /* end of the line */
1135 if (slot == -1) {
1136 first = 1;
1137 slot = i;
1138 }
1139 break;
1140 }
1141 }
1142 last = 0;
1143 nptr = entryg->nextsg;
1144 while (nptr) {
1145 code = pr_ReadCoEntry(tt, 0, nptr, &nentry);
1146 if (code != 0)
1147 return code;
1148 last = nptr;
1149 if (!(nentry.flags & PRCONT4))
1150 return PRDBFAIL(267267L);
1151 for (i = 0; i < COSIZE39; i++) {
1152 if (nentry.entries[i] == aid)
1153 return PRIDEXIST(267265L);
1154 if (nentry.entries[i] == PRBADID0x80000000) {
1155 if (slot == -1) {
1156 slot = i;
1157 cloc = nptr;
1158 }
1159 } else if (nentry.entries[i] == 0) {
1160 if (slot == -1) {
1161 slot = i;
1162 cloc = nptr;
1163 }
1164 break;
1165 }
1166 }
1167 nptr = nentry.next;
1168 }
1169 if (slot != -1) { /* we found a place */
1170 entryg->countsg++;
1171 if (first) { /* place is in first block */
1172 entryg->supergroup[slot] = aid;
1173 code = pr_WriteEntry(tt, 0, loc, entry);
1174 if (code != 0)
1175 return code;
1176 return PRSUCCESS0;
1177 }
1178 code = pr_WriteEntry(tt, 0, loc, entry);
1179 if (code)
1180 return code;
1181 code = pr_ReadCoEntry(tt, 0, cloc, &aentry);
1182 if (code != 0)
1183 return code;
1184 aentry.entries[slot] = aid;
1185 code = pr_WriteCoEntry(tt, 0, cloc, &aentry);
1186 if (code != 0)
1187 return code;
1188 return PRSUCCESS0;
1189 }
1190 /* have to allocate a continuation block if we got here */
1191 nptr = AllocBlock(tt);
1192 if (last) {
1193 /* then we should tack new block after last block in cont. chain */
1194 nentry.next = nptr;
1195 code = pr_WriteCoEntry(tt, 0, last, &nentry);
1196 if (code != 0)
1197 return code;
1198 } else {
1199 entryg->nextsg = nptr;
1200 }
1201 memset(&aentry, 0, sizeof(aentry));
1202 aentry.flags |= PRCONT4;
1203 aentry.id = entry->id;
1204 aentry.next = 0;
1205 aentry.entries[0] = aid;
1206 code = pr_WriteCoEntry(tt, 0, nptr, &aentry);
1207 if (code != 0)
1208 return code;
1209 /* don't forget to update count, here! */
1210 entryg->countsg++;
1211 code = pr_WriteEntry(tt, 0, loc, entry);
1212 return code;
1213
1214}
1215#endif /* SUPERGROUPS */
1216
1217afs_int32
1218AddToPRList(prlist *alist, int *sizeP, afs_int32 id)
1219{
1220 char *tmp;
1221 int count;
1222
1223 if (alist->prlist_len >= *sizeP) {
1224 count = alist->prlist_len + 100;
1225 if (alist->prlist_val) {
1226 tmp =
1227 (char *)realloc(alist->prlist_val, count * sizeof(afs_int32));
1228 } else {
1229 tmp = (char *)malloc(count * sizeof(afs_int32));
1230 }
1231 if (!tmp)
1232 return (PRNOMEM(267280L));
1233 alist->prlist_val = (afs_int32 *) tmp;
1234 *sizeP = count;
1235 }
1236 alist->prlist_val[alist->prlist_len++] = id;
1237 return 0;
1238}
1239
1240afs_int32
1241GetList(struct ubik_trans *at, struct prentry *tentry, prlist *alist, afs_int32 add)
1242{
1243 afs_int32 code;
1244 afs_int32 i;
1245 struct contentry centry;
1246 afs_int32 nptr;
1247 int size;
1248 int count = 0;
1249
1250 size = 0;
1251 alist->prlist_val = 0;
1252 alist->prlist_len = 0;
1253
1254 for (i = 0; i < PRSIZE10; i++) {
1255 if (tentry->entries[i] == PRBADID0x80000000)
1256 continue;
1257 if (tentry->entries[i] == 0)
1258 break;
1259 code = AddToPRList(alist, &size, tentry->entries[i]);
1260 if (code)
1261 return code;
1262#if defined(SUPERGROUPS1)
1263 if (!add)
1264 continue;
1265 code = GetListSG2(at, tentry->entries[i], alist, &size, depthsg);
1266 if (code)
1267 return code;
1268#endif
1269 }
1270
1271 for (nptr = tentry->next; nptr != 0; nptr = centry.next) {
1272 /* look through cont entries */
1273 code = pr_ReadCoEntry(at, 0, nptr, &centry);
1274 if (code != 0)
1275 return code;
1276 for (i = 0; i < COSIZE39; i++) {
1277 if (centry.entries[i] == PRBADID0x80000000)
1278 continue;
1279 if (centry.entries[i] == 0)
1280 break;
1281 code = AddToPRList(alist, &size, centry.entries[i]);
1282 if (code)
1283 return code;
1284#if defined(SUPERGROUPS1)
1285 if (!add)
1286 continue;
1287 code = GetListSG2(at, centry.entries[i], alist, &size, depthsg);
1288 if (code)
1289 return code;
1290#endif
1291 }
1292 if (count++ > 50) {
1293#ifndef AFS_PTHREAD_ENV
1294 IOMGR_Poll();
1295#endif
1296 count = 0;
1297 }
1298 }
1299
1300 if (add) { /* this is for a CPS, so tack on appropriate stuff */
1301 if (tentry->id != ANONYMOUSID32766 && tentry->id != ANYUSERID-101) {
1302 if ((code = AddToPRList(alist, &size, ANYUSERID-101))
1303 || (code = AddAuthGroup(tentry, alist, &size))
1304 || (code = AddToPRList(alist, &size, tentry->id)))
1305 return code;
1306 } else {
1307 if ((code = AddToPRList(alist, &size, ANYUSERID-101))
1308 || (code = AddToPRList(alist, &size, tentry->id)))
1309 return code;
1310 }
1311 }
1312#ifndef AFS_PTHREAD_ENV
1313 if (alist->prlist_len > 100)
1314 IOMGR_Poll();
1315#endif
1316 qsort(alist->prlist_val, alist->prlist_len, sizeof(afs_int32), IDCmp);
1317 return PRSUCCESS0;
1318}
1319
1320
1321afs_int32
1322GetList2(struct ubik_trans *at, struct prentry *tentry, struct prentry *tentry2, prlist *alist, afs_int32 add)
1323{
1324 afs_int32 code = 0;
1325 afs_int32 i;
1326 struct contentry centry;
1327 afs_int32 nptr;
1328 afs_int32 size;
1329 int count = 0;
1330
1331 size = 0;
1332 alist->prlist_val = 0;
1333 alist->prlist_len = 0;
1334 for (i = 0; i < PRSIZE10; i++) {
1335 if (tentry->entries[i] == PRBADID0x80000000)
1336 continue;
1337 if (tentry->entries[i] == 0)
1338 break;
1339 code = AddToPRList(alist, &size, tentry->entries[i]);
1340 if (code)
1341 return code;
1342#if defined(SUPERGROUPS1)
1343 if (!add)
1344 continue;
1345 code = GetListSG2(at, tentry->entries[i], alist, &size, depthsg);
1346 if (code)
1347 return code;
1348#endif
1349 }
1350
1351 nptr = tentry->next;
1352 while (nptr != 0) {
1353 /* look through cont entries */
1354 code = pr_ReadCoEntry(at, 0, nptr, &centry);
1355 if (code != 0)
1356 return code;
1357 for (i = 0; i < COSIZE39; i++) {
1358 if (centry.entries[i] == PRBADID0x80000000)
1359 continue;
1360 if (centry.entries[i] == 0)
1361 break;
1362 code = AddToPRList(alist, &size, centry.entries[i]);
1363 if (code)
1364 return code;
1365#if defined(SUPERGROUPS1)
1366 if (!add)
1367 continue;
1368 code = GetListSG2(at, centry.entries[i], alist, &size, depthsg);
1369 if (code)
1370 return code;
1371#endif
1372 }
1373 nptr = centry.next;
1374 if (count++ > 50) {
1375#ifndef AFS_PTHREAD_ENV
1376 IOMGR_Poll();
1377#endif
1378 count = 0;
1379 }
1380 }
1381
1382 for (i = 0; i < PRSIZE10; i++) {
1383 if (tentry2->entries[i] == PRBADID0x80000000)
1384 continue;
1385 if (tentry2->entries[i] == 0)
1386 break;
1387 code = AddToPRList(alist, &size, tentry2->entries[i]);
1388 if (code)
1389 break;
1390 }
1391
1392 if (!code) {
1393 nptr = tentry2->next;
1394 while (nptr != 0) {
1395 /* look through cont entries */
1396 code = pr_ReadCoEntry(at, 0, nptr, &centry);
1397 if (code != 0)
1398 break;
1399 for (i = 0; i < COSIZE39; i++) {
1400 if (centry.entries[i] == PRBADID0x80000000)
1401 continue;
1402 if (centry.entries[i] == 0)
1403 break;
1404 code = AddToPRList(alist, &size, centry.entries[i]);
1405 if (code)
1406 break;
1407 }
1408 nptr = centry.next;
1409 if (count++ > 50) {
1410#ifndef AFS_PTHREAD_ENV
1411 IOMGR_Poll();
1412#endif
1413 count = 0;
1414 }
1415 }
1416 }
1417 if (add) { /* this is for a CPS, so tack on appropriate stuff */
1418 if (tentry->id != ANONYMOUSID32766 && tentry->id != ANYUSERID-101) {
1419 if ((code = AddToPRList(alist, &size, ANYUSERID-101))
1420 || (code = AddToPRList(alist, &size, AUTHUSERID-102))
1421 || (code = AddToPRList(alist, &size, tentry->id)))
1422 return code;
1423 } else {
1424 if ((code = AddToPRList(alist, &size, ANYUSERID-101))
1425 || (code = AddToPRList(alist, &size, tentry->id)))
1426 return code;
1427 }
1428 }
1429#ifndef AFS_PTHREAD_ENV
1430 if (alist->prlist_len > 100)
1431 IOMGR_Poll();
1432#endif
1433 qsort(alist->prlist_val, alist->prlist_len, sizeof(afs_int32), IDCmp);
1434 return PRSUCCESS0;
1435}
1436
1437#if defined(SUPERGROUPS1)
1438
1439afs_int32
1440GetListSG2(struct ubik_trans *at, afs_int32 gid, prlist *alist, afs_int32 *sizeP, afs_int32 depth)
1441{
1442 afs_int32 code;
1443 struct prentry tentry;
1444 struct prentryg *tentryg = (struct prentryg *)&tentry;
1445 afs_int32 i;
1446 struct contentry centry;
1447 afs_int32 nptr;
1448 int count = 0;
1449 afs_int32 temp;
1450 int didsomething;
1451#if DEBUG_SG_MAP
1452 int predictfound, predictflagged;
1453#endif
1454
1455#if DEBUG_SG_MAP
1456 predictfound = 0;
1457 if (!in_map(sg_flagged, -gid)) {
1458 predictflagged = 0;
1459 fprintf(stderr__stderrp, "GetListSG2: I have not yet searched for gid=%d\n",
1460 gid);
1461 } else if (predictflagged = 1, in_map(sg_found, -gid)) {
1462 predictfound = 1;
1463 fprintf(stderr__stderrp,
1464 "GetListSG2: I have already searched for gid=%d, and predict success.\n",
1465 gid);
1466 }
1467#endif
1468
1469 if (in_map(sg_flagged, -gid) && !in_map(sg_found, -gid)) {
1470#if DEBUG_SG_MAP
1471 fprintf(stderr__stderrp,
1472 "GetListSG2: I have already searched for gid=%d, and predict failure.\n",
1473 gid);
1474#else
1475 return 0;
1476#endif
1477 }
1478
1479 if (depth < 1)
1480 return 0;
1481 temp = FindByID(at, gid);
1482 if (!temp) {
1483 code = PRNOENT(267268L);
1484 return code;
1485 }
1486 code = pr_ReadEntry(at, 0, temp, &tentry);
1487 if (code)
1488 return code;
1489#if DEBUG_SG_MAP
1490 fprintf(stderr__stderrp, "GetListSG2: lookup for gid=%d [\n", gid);
1491#endif
1492 didsomething = 0;
1493
1494 for (i = 0; i < SGSIZE2; i++) {
1495 if (tentryg->supergroup[i] == PRBADID0x80000000)
1496 continue;
1497 if (tentryg->supergroup[i] == 0)
1498 break;
1499 didsomething = 1;
1500#if DEBUG_SG_MAP
1501 fprintf(stderr__stderrp, "via gid=%d, added %d\n", gid,
1502 e.tentryg.supergroup[i]);
1503#endif
1504 code = AddToPRList(alist, sizeP, tentryg->supergroup[i]);
1505 if (code)
1506 return code;
1507 code =
1508 GetListSG2(at, tentryg->supergroup[i], alist, sizeP, depth - 1);
1509 if (code)
1510 return code;
1511 }
1512
1513 nptr = tentryg->nextsg;
1514 while (nptr) {
1515 didsomething = 1;
1516 /* look through cont entries */
1517 code = pr_ReadCoEntry(at, 0, nptr, &centry);
1518 if (code != 0)
1519 return code;
1520 for (i = 0; i < COSIZE39; i++) {
1521 if (centry.entries[i] == PRBADID0x80000000)
1522 continue;
1523 if (centry.entries[i] == 0)
1524 break;
1525#if DEBUG_SG_MAP
1526 fprintf(stderr__stderrp, "via gid=%d, added %d\n", gid,
1527 e.centry.entries[i]);
1528#endif
1529 code = AddToPRList(alist, sizeP, centry.entries[i]);
1530 if (code)
1531 return code;
1532 code = GetListSG2(at, centry.entries[i], alist, sizeP, depth - 1);
1533 if (code)
1534 return code;
1535 }
1536 nptr = centry.next;
1537 if (count++ > 50) {
1538#ifndef AFS_PTHREAD_ENV
1539 IOMGR_Poll();
1540#endif
1541 count = 0;
1542 }
1543 }
1544#if DEBUG_SG_MAP
1545 fprintf(stderr__stderrp, "] for gid %d, done [flag=%s]\n", gid,
1546 didsomething ? "TRUE" : "FALSE");
1547 if (predictflagged && didsomething != predictfound)
1548 fprintf(stderr__stderrp, "**** for gid=%d, didsomething=%d predictfound=%d\n",
1549 didsomething, predictfound);
1550#endif
1551 if (didsomething)
1552 sg_found = add_map(sg_found, -gid);
1553 else
1554 sg_found = bic_map(sg_found, add_map(NIL_MAP((struct map *) 0), -gid));
1555 sg_flagged = add_map(sg_flagged, -gid);
1556 return 0;
1557}
1558
1559afs_int32
1560GetSGList(struct ubik_trans *at, struct prentry *tentry, prlist *alist)
1561{
1562 afs_int32 code;
1563 afs_int32 i;
1564 struct contentry centry;
1565 struct prentryg *tentryg;
1566 afs_int32 nptr;
1567 int size;
1568 int count = 0;
1569
1570 size = 0;
1571 alist->prlist_val = 0;
1572 alist->prlist_len = 0;
1573
1574 tentryg = (struct prentryg *)tentry;
1575 for (i = 0; i < SGSIZE2; i++) {
1576 if (tentryg->supergroup[i] == PRBADID0x80000000)
1577 continue;
1578 if (tentryg->supergroup[i] == 0)
1579 break;
1580 code = AddToPRList(alist, &size, tentryg->supergroup[i]);
1581 if (code)
1582 return code;
1583 }
1584
1585 nptr = tentryg->nextsg;
1586 while (nptr) {
1587 /* look through cont entries */
1588 code = pr_ReadCoEntry(at, 0, nptr, &centry);
1589 if (code != 0)
1590 return code;
1591 for (i = 0; i < COSIZE39; i++) {
1592 if (centry.entries[i] == PRBADID0x80000000)
1593 continue;
1594 if (centry.entries[i] == 0)
1595 break;
1596 code = AddToPRList(alist, &size, centry.entries[i]);
1597 if (code)
1598 return code;
1599 }
1600 nptr = centry.next;
1601 if (count++ > 50) {
1602#ifndef AFS_PTHREAD_ENV
1603 IOMGR_Poll();
1604#endif
1605 count = 0;
1606 }
1607 }
1608
1609#ifndef AFS_PTHREAD_ENV
1610 if (alist->prlist_len > 100)
1611 IOMGR_Poll();
1612#endif
1613 qsort((char *)alist->prlist_val, (int)alist->prlist_len,
1614 sizeof(afs_int32), IDCmp);
1615 return PRSUCCESS0;
1616}
1617#endif /* SUPERGROUPS */
1618
1619afs_int32
1620GetOwnedChain(struct ubik_trans *ut, afs_int32 *next, prlist *alist)
1621{
1622 afs_int32 code;
1623 struct prentry tentry;
1624 int size;
1625 int count = 0;
1626
1627 size = 0;
1628 alist->prlist_val = 0;
1629 alist->prlist_len = 0;
1630
1631 for (; *next; *next = ntohl(tentry.nextOwned)(__builtin_constant_p(tentry.nextOwned) ? ((((__uint32_t)(tentry
.nextOwned)) >> 24) | ((((__uint32_t)(tentry.nextOwned)
) & (0xff << 16)) >> 8) | ((((__uint32_t)(tentry
.nextOwned)) & (0xff << 8)) << 8) | (((__uint32_t
)(tentry.nextOwned)) << 24)) : __bswap32_var(tentry.nextOwned
))) {
1632 code = pr_Read(ut, 0, *next, &tentry, sizeof(tentry));
1633 if (code)
1634 return code;
1635 code = AddToPRList(alist, &size, ntohl(tentry.id)(__builtin_constant_p(tentry.id) ? ((((__uint32_t)(tentry.id)
) >> 24) | ((((__uint32_t)(tentry.id)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(tentry.id)) & (0xff <<
8)) << 8) | (((__uint32_t)(tentry.id)) << 24)) :
__bswap32_var(tentry.id)));
1636 if (alist->prlist_len >= PR_MAXGROUPS5000) {
1637 return PRTOOMANY(267279L);
1638 }
1639 if (code)
1640 return code;
1641 if (count++ > 50) {
1642#ifndef AFS_PTHREAD_ENV
1643 IOMGR_Poll();
1644#endif
1645 count = 0;
1646 }
1647 }
1648#ifndef AFS_PTHREAD_ENV
1649 if (alist->prlist_len > 100)
1650 IOMGR_Poll();
1651#endif
1652 qsort(alist->prlist_val, alist->prlist_len, sizeof(afs_int32), IDCmp);
1653 return PRSUCCESS0;
1654}
1655
1656afs_int32
1657GetMax(struct ubik_trans *at, afs_int32 *uid, afs_int32 *gid)
1658{
1659 *uid = ntohl(cheader.maxID)(__builtin_constant_p(cheader.maxID) ? ((((__uint32_t)(cheader
.maxID)) >> 24) | ((((__uint32_t)(cheader.maxID)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(cheader.maxID
)) & (0xff << 8)) << 8) | (((__uint32_t)(cheader
.maxID)) << 24)) : __bswap32_var(cheader.maxID));
1660 *gid = ntohl(cheader.maxGroup)(__builtin_constant_p(cheader.maxGroup) ? ((((__uint32_t)(cheader
.maxGroup)) >> 24) | ((((__uint32_t)(cheader.maxGroup))
& (0xff << 16)) >> 8) | ((((__uint32_t)(cheader
.maxGroup)) & (0xff << 8)) << 8) | (((__uint32_t
)(cheader.maxGroup)) << 24)) : __bswap32_var(cheader.maxGroup
));
1661 return PRSUCCESS0;
1662}
1663
1664afs_int32
1665SetMax(struct ubik_trans *at, afs_int32 id, afs_int32 flag)
1666{
1667 afs_int32 code;
1668 if (flag & PRGRP2) {
1669 cheader.maxGroup = htonl(id)(__builtin_constant_p(id) ? ((((__uint32_t)(id)) >> 24)
| ((((__uint32_t)(id)) & (0xff << 16)) >> 8)
| ((((__uint32_t)(id)) & (0xff << 8)) << 8) |
(((__uint32_t)(id)) << 24)) : __bswap32_var(id));
1670 code =
1671 pr_Write(at, 0, 16, (char *)&cheader.maxGroup,
1672 sizeof(cheader.maxGroup));
1673 if (code != 0)
1674 return code;
1675 } else {
1676 cheader.maxID = htonl(id)(__builtin_constant_p(id) ? ((((__uint32_t)(id)) >> 24)
| ((((__uint32_t)(id)) & (0xff << 16)) >> 8)
| ((((__uint32_t)(id)) & (0xff << 8)) << 8) |
(((__uint32_t)(id)) << 24)) : __bswap32_var(id));
1677 code =
1678 pr_Write(at, 0, 20, (char *)&cheader.maxID,
1679 sizeof(cheader.maxID));
1680 if (code != 0)
1681 return code;
1682 }
1683 return PRSUCCESS0;
1684}
1685
1686static afs_int32
1687UpdateCache(struct ubik_trans *tt, void *rock)
1688{
1689 afs_int32 code;
1690
1691 code = pr_Read(tt, 0, 0, (char *)&cheader, sizeof(cheader));
1692 if (code != 0) {
1693 afs_com_err(whoami, code, "Couldn't read header");
1694 }
1695 return code;
1696}
1697
1698afs_int32
1699read_DbHeader(struct ubik_trans *tt)
1700{
1701 return ubik_CheckCache(tt, UpdateCache, NULL((void *)0));
1702}
1703
1704int pr_noAuth;
1705
1706/**
1707 * reads in db cache from ubik.
1708 *
1709 * @param[in] ut ubik transaction
1710 * @param[out] rock opaque pointer to an int*, which on success will be set
1711 * to 1 if we need to build the database, or 0 if we do not
1712 *
1713 * @return operation status
1714 * @retval 0 success
1715 */
1716static afs_int32
1717Initdb_check(struct ubik_trans *tt, void *rock)
1718{
1719 int *build_rock = rock;
1720 afs_int32 code;
1721 afs_int32 len;
1722
1723 len = sizeof(cheader);
1724 code = pr_Read(tt, 0, 0, (char *)&cheader, len);
1725 if (code != 0) {
1726 afs_com_err(whoami, code, "couldn't read header");
1727 return code;
1728 }
1729 if ((ntohl(cheader.version)(__builtin_constant_p(cheader.version) ? ((((__uint32_t)(cheader
.version)) >> 24) | ((((__uint32_t)(cheader.version)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(cheader.version
)) & (0xff << 8)) << 8) | (((__uint32_t)(cheader
.version)) << 24)) : __bswap32_var(cheader.version)) == PRDBVERSION0)
1730 && ntohl(cheader.headerSize)(__builtin_constant_p(cheader.headerSize) ? ((((__uint32_t)(cheader
.headerSize)) >> 24) | ((((__uint32_t)(cheader.headerSize
)) & (0xff << 16)) >> 8) | ((((__uint32_t)(cheader
.headerSize)) & (0xff << 8)) << 8) | (((__uint32_t
)(cheader.headerSize)) << 24)) : __bswap32_var(cheader.
headerSize)) == sizeof(cheader)
1731 && ntohl(cheader.eofPtr)(__builtin_constant_p(cheader.eofPtr) ? ((((__uint32_t)(cheader
.eofPtr)) >> 24) | ((((__uint32_t)(cheader.eofPtr)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(cheader.eofPtr
)) & (0xff << 8)) << 8) | (((__uint32_t)(cheader
.eofPtr)) << 24)) : __bswap32_var(cheader.eofPtr)) != 0
1732 && FindByID(tt, ANONYMOUSID32766) != 0) {
1733 /* database exists, so we don't have to build it */
1734 *build_rock = 0;
1735 return 0;
1736 }
1737
1738 /* else we need to build a database */
1739 *build_rock = 1;
1740 return 0;
1741}
1742
1743afs_int32
1744Initdb(void)
1745{
1746 struct ubik_trans *tt;
1747 int build = 0;
1748 afs_int32 code;
1749
1750 /* init the database. We'll try reading it, but if we're starting
1751 * from scratch, we'll have to do a write transaction. */
1752
1753 pr_noAuth = afsconf_GetNoAuthFlag(prdir);
1754
1755 code = ubik_BeginTransReadAny(dbase, UBIK_READTRANS0, &tt);
1756 if (code)
1757 return code;
1758 code = ubik_SetLock(tt, 1, 1, LOCKREAD1);
1759 if (code) {
1760 ubik_AbortTrans(tt);
1761 return code;
1762 }
1763
1764 code = ubik_CheckCache(tt, Initdb_check, &build);
1765 if (code) {
1766 ubik_AbortTrans(tt);
1767 return code;
1768 }
1769
1770 if (build) {
1771 /* Only rebuild database if the db was deleted (the header is zero) and we
1772 * are running noAuth. */
1773 char *bp = (char *)&cheader;
1774 int i;
1775 for (i = 0; i < sizeof(cheader); i++) {
1776 if (bp[i]) {
1777 code = PRDBBAD(267275L);
1778 afs_com_err(whoami, code,
1779 "Can't rebuild database because it is not empty");
1780 break;
1781 }
1782 }
1783 if (!pr_noAuth) {
1784 code = PRDBBAD(267275L);
1785 afs_com_err(whoami, code,
1786 "Can't rebuild database because not running NoAuth");
1787 }
1788 }
1789
1790 if (code) {
1791 ubik_EndTrans(tt);
1792 } else {
1793 code = ubik_EndTrans(tt);
1794 }
1795 if (code || !build) {
1796 /* either we encountered an error, or we don't need to build the db */
1797 return code;
1798 }
1799
1800 code = ubik_BeginTrans(dbase, UBIK_WRITETRANS1, &tt);
1801 if (code)
1802 return code;
1803
1804 code = ubik_SetLock(tt, 1, 1, LOCKWRITE2);
1805 if (code) {
1806 ubik_AbortTrans(tt);
1807 return code;
1808 }
1809
1810 /* before doing a rebuild, check again that the dbase looks bad, because
1811 * the previous check was only under a ReadAny transaction, and there could
1812 * actually have been a good database out there. Now that we have a
1813 * real write transaction, make sure things are still bad.
1814 */
1815 code = pr_Read(tt, 0, 0, (char *)&cheader, sizeof(cheader));
1816 if (code != 0) {
1817 afs_com_err(whoami, code, "couldn't read header");
1818 ubik_AbortTrans(tt);
1819 return code;
1820 }
1821 if ((ntohl(cheader.version)(__builtin_constant_p(cheader.version) ? ((((__uint32_t)(cheader
.version)) >> 24) | ((((__uint32_t)(cheader.version)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(cheader.version
)) & (0xff << 8)) << 8) | (((__uint32_t)(cheader
.version)) << 24)) : __bswap32_var(cheader.version)) == PRDBVERSION0)
1822 && ntohl(cheader.headerSize)(__builtin_constant_p(cheader.headerSize) ? ((((__uint32_t)(cheader
.headerSize)) >> 24) | ((((__uint32_t)(cheader.headerSize
)) & (0xff << 16)) >> 8) | ((((__uint32_t)(cheader
.headerSize)) & (0xff << 8)) << 8) | (((__uint32_t
)(cheader.headerSize)) << 24)) : __bswap32_var(cheader.
headerSize)) == sizeof(cheader)
1823 && ntohl(cheader.eofPtr)(__builtin_constant_p(cheader.eofPtr) ? ((((__uint32_t)(cheader
.eofPtr)) >> 24) | ((((__uint32_t)(cheader.eofPtr)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(cheader.eofPtr
)) & (0xff << 8)) << 8) | (((__uint32_t)(cheader
.eofPtr)) << 24)) : __bswap32_var(cheader.eofPtr)) != 0
1824 && FindByID(tt, ANONYMOUSID32766) != 0) {
1825 /* database exists, so we don't have to build it */
1826 code = ubik_EndTrans(tt);
1827 if (code)
1828 return code;
1829 return PRSUCCESS0;
1830 }
1831
1832 /* Initialize the database header */
1833 if ((code = set_header_word(tt, version, htonl(PRDBVERSION))pr_Write ((tt), 0, ((char *)&(cheader.version) - (char *)
&cheader), ((cheader.version = ((__builtin_constant_p(0) ?
((((__uint32_t)(0)) >> 24) | ((((__uint32_t)(0)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(0)) & (
0xff << 8)) << 8) | (((__uint32_t)(0)) << 24
)) : __bswap32_var(0)))), (char *)&(cheader.version)), sizeof
(afs_int32)))
1834 || (code = set_header_word(tt, headerSize, htonl(sizeof(cheader)))pr_Write ((tt), 0, ((char *)&(cheader.headerSize) - (char
*)&cheader), ((cheader.headerSize = ((__builtin_constant_p
(sizeof(cheader)) ? ((((__uint32_t)(sizeof(cheader))) >>
24) | ((((__uint32_t)(sizeof(cheader))) & (0xff <<
16)) >> 8) | ((((__uint32_t)(sizeof(cheader))) & (
0xff << 8)) << 8) | (((__uint32_t)(sizeof(cheader
))) << 24)) : __bswap32_var(sizeof(cheader))))), (char *
)&(cheader.headerSize)), sizeof(afs_int32)))
1835 || (code = set_header_word(tt, eofPtr, cheader.headerSize)pr_Write ((tt), 0, ((char *)&(cheader.eofPtr) - (char *)&
cheader), ((cheader.eofPtr = (cheader.headerSize)), (char *)&
(cheader.eofPtr)), sizeof(afs_int32)))) {
1836 afs_com_err(whoami, code, "couldn't write header words");
1837 ubik_AbortTrans(tt);
1838 return code;
1839 }
1840#define InitialGroup(id,name)do { afs_int32 temp = (id); afs_int32 flag = (id) < 0 ? 2 :
0; code = CreateEntry (tt, (name), &temp, 1, flag, -204,
-204); if (code) { afs_com_err (whoami, code, "couldn't create %s with id %di."
, (name), (id)); ubik_AbortTrans(tt); return code; } } while (
0) do { \
1841 afs_int32 temp = (id); \
1842 afs_int32 flag = (id) < 0 ? PRGRP2 : 0; \
1843 code = CreateEntry \
1844 (tt, (name), &temp, /*idflag*/1, flag, SYSADMINID-204, SYSADMINID-204); \
1845 if (code) { \
1846 afs_com_err (whoami, code, "couldn't create %s with id %di.", \
1847 (name), (id)); \
1848 ubik_AbortTrans(tt); \
1849 return code; \
1850 } \
1851} while (0)
1852
1853 InitialGroup(SYSADMINID, "system:administrators")do { afs_int32 temp = (-204); afs_int32 flag = (-204) < 0 ?
2 : 0; code = CreateEntry (tt, ("system:administrators"), &
temp, 1, flag, -204, -204); if (code) { afs_com_err (whoami, code
, "couldn't create %s with id %di.", ("system:administrators"
), (-204)); ubik_AbortTrans(tt); return code; } } while (0);
1854 InitialGroup(SYSBACKUPID, "system:backup")do { afs_int32 temp = (-205); afs_int32 flag = (-205) < 0 ?
2 : 0; code = CreateEntry (tt, ("system:backup"), &temp,
1, flag, -204, -204); if (code) { afs_com_err (whoami, code,
"couldn't create %s with id %di.", ("system:backup"), (-205)
); ubik_AbortTrans(tt); return code; } } while (0);
1855 InitialGroup(ANYUSERID, "system:anyuser")do { afs_int32 temp = (-101); afs_int32 flag = (-101) < 0 ?
2 : 0; code = CreateEntry (tt, ("system:anyuser"), &temp
, 1, flag, -204, -204); if (code) { afs_com_err (whoami, code
, "couldn't create %s with id %di.", ("system:anyuser"), (-101
)); ubik_AbortTrans(tt); return code; } } while (0);
1856 InitialGroup(AUTHUSERID, "system:authuser")do { afs_int32 temp = (-102); afs_int32 flag = (-102) < 0 ?
2 : 0; code = CreateEntry (tt, ("system:authuser"), &temp
, 1, flag, -204, -204); if (code) { afs_com_err (whoami, code
, "couldn't create %s with id %di.", ("system:authuser"), (-102
)); ubik_AbortTrans(tt); return code; } } while (0);
1857 InitialGroup(SYSVIEWERID, "system:ptsviewers")do { afs_int32 temp = (-203); afs_int32 flag = (-203) < 0 ?
2 : 0; code = CreateEntry (tt, ("system:ptsviewers"), &temp
, 1, flag, -204, -204); if (code) { afs_com_err (whoami, code
, "couldn't create %s with id %di.", ("system:ptsviewers"), (
-203)); ubik_AbortTrans(tt); return code; } } while (0);
1858 InitialGroup(ANONYMOUSID, "anonymous")do { afs_int32 temp = (32766); afs_int32 flag = (32766) < 0
? 2 : 0; code = CreateEntry (tt, ("anonymous"), &temp, 1
, flag, -204, -204); if (code) { afs_com_err (whoami, code, "couldn't create %s with id %di."
, ("anonymous"), (32766)); ubik_AbortTrans(tt); return code; }
} while (0);
1859
1860 /* Well, we don't really want the max id set to anonymousid, so we'll set
1861 * it back to 0 */
1862 code = set_header_word(tt, maxID, 0)pr_Write ((tt), 0, ((char *)&(cheader.maxID) - (char *)&
cheader), ((cheader.maxID = (0)), (char *)&(cheader.maxID
)), sizeof(afs_int32)); /* correct in any byte order */
1863 if (code) {
1864 afs_com_err(whoami, code, "couldn't reset max id");
1865 ubik_AbortTrans(tt);
1866 return code;
1867 }
1868
1869 code = ubik_EndTrans(tt);
1870 if (code)
1871 return code;
1872 return PRSUCCESS0;
1873}
1874
1875afs_int32
1876ChangeEntry(struct ubik_trans *at, afs_int32 aid, afs_int32 cid, char *name, afs_int32 oid, afs_int32 newid)
1877{
1878 afs_int32 code;
1879 afs_int32 i, pos;
1880#if defined(SUPERGROUPS1)
1881 afs_int32 nextpos;
1882#else
1883 afs_int32 nptr;
1884 struct contentry centry;
1885#endif
1886 struct prentry tentry, tent;
1887 afs_int32 loc;
1888 afs_int32 oldowner;
1889 char holder[PR_MAXNAMELEN64];
1890 char temp[PR_MAXNAMELEN64];
1891 char oldname[PR_MAXNAMELEN64];
1892 char *atsign;
1893
1894 memset(holder, 0, PR_MAXNAMELEN64);
1895 memset(temp, 0, PR_MAXNAMELEN64);
1896 loc = FindByID(at, aid);
1897 if (!loc)
1898 return PRNOENT(267268L);
1899 code = pr_ReadEntry(at, 0, loc, &tentry);
1900 if (code)
1901 return PRDBFAIL(267267L);
1902 if (restricted && !IsAMemberOf(at, cid, SYSADMINID-204))
1903 return PRPERM(267269L);
1904 if (tentry.owner != cid && !IsAMemberOf(at, cid, SYSADMINID-204)
1905 && !IsAMemberOf(at, cid, tentry.owner) && !pr_noAuth)
1906 return PRPERM(267269L);
1907#ifdef PR_REMEMBER_TIMES1
1908 tentry.changeTime = time(0);
1909#endif
1910
1911 /* we're actually trying to change the id */
1912 if (newid && (newid != aid)) {
1913 if (!IsAMemberOf(at, cid, SYSADMINID-204) && !pr_noAuth)
1914 return PRPERM(267269L);
1915
1916 pos = FindByID(at, newid);
1917 if (pos)
1918 return PRIDEXIST(267265L); /* new id already in use! */
1919 if ((aid < 0 && newid > 0) || (aid > 0 && newid < 0))
1920 return PRPERM(267269L);
1921
1922 /* Should check that foreign users id to change to is good: inRange() */
1923
1924 /* if new id is not in use, rehash things */
1925 code = RemoveFromIDHash(at, aid, &loc);
1926 if (code != PRSUCCESS0)
1927 return code;
1928 tentry.id = newid;
1929 code = pr_WriteEntry(at, 0, loc, &tentry);
1930 if (code)
1931 return code;
1932 code = AddToIDHash(at, tentry.id, loc);
1933 if (code)
1934 return code;
1935
1936 /* get current data */
1937 code = pr_ReadEntry(at, 0, loc, &tentry);
1938 if (code)
1939 return PRDBFAIL(267267L);
1940
1941#if defined(SUPERGROUPS1)
1942 if (tentry.id > (afs_int32) ntohl(cheader.maxID)(__builtin_constant_p(cheader.maxID) ? ((((__uint32_t)(cheader
.maxID)) >> 24) | ((((__uint32_t)(cheader.maxID)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(cheader.maxID
)) & (0xff << 8)) << 8) | (((__uint32_t)(cheader
.maxID)) << 24)) : __bswap32_var(cheader.maxID)))
1943 code = set_header_word(at, maxID, htonl(tentry.id))pr_Write ((at), 0, ((char *)&(cheader.maxID) - (char *)&
cheader), ((cheader.maxID = ((__builtin_constant_p(tentry.id)
? ((((__uint32_t)(tentry.id)) >> 24) | ((((__uint32_t)
(tentry.id)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(tentry.id)) & (0xff << 8)) << 8) | (((__uint32_t
)(tentry.id)) << 24)) : __bswap32_var(tentry.id)))), (char
*)&(cheader.maxID)), sizeof(afs_int32));
1944 if (code)
1945 return PRDBFAIL(267267L);
1946
1947 /* need to fix up: membership
1948 * (supergroups?)
1949 * ownership
1950 */
1951
1952 for (i = 0; i < PRSIZE10; i++) {
1953 if (tentry.entries[i] == PRBADID0x80000000)
1954 continue;
1955 if (tentry.entries[i] == 0)
1956 break;
1957 if ((tentry.flags & PRGRP2) && tentry.entries[i] < 0) { /* Supergroup */
1958 return 5; /* not yet, in short. */
1959 } else {
1960 code = ChangeIDEntry(at, aid, newid, tentry.entries[i]);
1961 }
1962 if (code)
1963 return code;
1964 }
1965 for (pos = ntohl(tentry.owned)(__builtin_constant_p(tentry.owned) ? ((((__uint32_t)(tentry.
owned)) >> 24) | ((((__uint32_t)(tentry.owned)) & (
0xff << 16)) >> 8) | ((((__uint32_t)(tentry.owned
)) & (0xff << 8)) << 8) | (((__uint32_t)(tentry
.owned)) << 24)) : __bswap32_var(tentry.owned)); pos; pos = nextpos) {
1966 code = pr_ReadEntry(at, 0, pos, &tent);
1967 if (code)
1968 break;
1969 tent.owner = newid;
1970 nextpos = tent.nextOwned;
1971 code = pr_WriteEntry(at, 0, pos, &tent);
1972 if (code)
1973 break;
1974 }
1975 pos = tentry.next;
1976 while (pos) {
1977#define centry (*(struct contentry*)&tent)
1978 code = pr_ReadCoEntry(at, 0, pos, &centry);
Value stored to 'code' is never read
1979 if ((centry.id != aid)
1980 || !(centry.flags & PRCONT4)) {
1981 fprintf(stderr__stderrp,
1982 "ChangeEntry: bad database aid=%d centry.id=%d .flags=%d\n",
1983 aid, centry.id, centry.flags);
1984 return PRDBBAD(267275L);
1985 }
1986 centry.id = newid;
1987 for (i = 0; i < COSIZE39; i++) {
1988 if (centry.entries[i] == PRBADID0x80000000)
1989 continue;
1990 if (centry.entries[i] == 0)
1991 break;
1992 if ((centry.flags & PRGRP2) && centry.entries[i] < 0) { /* Supergroup */
1993 return 5; /* not yet, in short. */
1994 } else {
1995 code = ChangeIDEntry(at, aid, newid, centry.entries[i]);
1996 }
1997 if (code)
1998 return code;
1999 }
2000 code = pr_WriteCoEntry(at, 0, pos, &centry);
2001 pos = centry.next;
2002#undef centry
2003 }
2004 if (code)
2005 return code;
2006
2007#else /* SUPERGROUPS */
2008
2009
2010 /* Also change the references from the membership list */
2011 for (i = 0; i < PRSIZE10; i++) {
2012 if (tentry.entries[i] == PRBADID0x80000000)
2013 continue;
2014 if (tentry.entries[i] == 0)
2015 break;
2016 pos = FindByID(at, tentry.entries[i]);
2017 if (!pos)
2018 return (PRDBFAIL(267267L));
2019 code = RemoveFromEntry(at, aid, tentry.entries[i]);
2020 if (code)
2021 return code;
2022 code = pr_ReadEntry(at, 0, pos, &tent);
2023 if (code)
2024 return code;
2025 code = AddToEntry(at, &tent, pos, newid);
2026 if (code)
2027 return code;
2028 }
2029 /* Look through cont entries too. This needs to be broken into
2030 * seperate transaction so that no one transaction becomes too
2031 * large to complete.
2032 */
2033 for (nptr = tentry.next; nptr; nptr = centry.next) {
2034 code = pr_ReadCoEntry(at, 0, nptr, &centry);
2035 if (code)
2036 return code;
2037 for (i = 0; i < COSIZE39; i++) {
2038 if (centry.entries[i] == PRBADID0x80000000)
2039 continue;
2040 if (centry.entries[i] == 0)
2041 break;
2042 pos = FindByID(at, centry.entries[i]);
2043 if (!pos)
2044 return (PRDBFAIL(267267L));
2045 code = RemoveFromEntry(at, aid, centry.entries[i]);
2046 if (code)
2047 return code;
2048 code = pr_ReadEntry(at, 0, pos, &tent);
2049 if (code)
2050 return code;
2051 code = AddToEntry(at, &tent, pos, newid);
2052 if (code)
2053 return code;
2054 }
2055 }
2056#endif /* SUPERGROUPS */
2057 }
2058
2059 atsign = strchr(tentry.name, '@'); /* check for foreign entry */
2060
2061 /* Change the owner */
2062 if (oid && (oid != tentry.owner)) {
2063 /* only groups can have their owner's changed */
2064 if (!(tentry.flags & PRGRP2))
2065 return PRPERM(267269L);
2066 if (atsign != NULL((void *)0))
2067 return PRPERM(267269L);
2068 oldowner = tentry.owner;
2069 tentry.owner = oid;
2070 /* The entry must be written through first so Remove and Add routines
2071 * can operate on disk data */
2072 code = pr_WriteEntry(at, 0, loc, &tentry);
2073 if (code)
2074 return PRDBFAIL(267267L);
2075
2076 /* switch owner chains */
2077 if (oldowner) /* if it has an owner */
2078 code = RemoveFromOwnerChain(at, tentry.id, oldowner);
2079 else /* must be an orphan */
2080 code = RemoveFromOrphan(at, tentry.id);
2081 if (code)
2082 return code;
2083 code = AddToOwnerChain(at, tentry.id, tentry.owner);
2084 if (code)
2085 return code;
2086
2087 /* fix up the name */
2088 if (strlen(name) == 0)
2089 name = tentry.name;
2090 /* get current data */
2091 code = pr_ReadEntry(at, 0, loc, &tentry);
2092 if (code)
2093 return PRDBFAIL(267267L);
2094 }
2095
2096 /* Change the name, if name is a ptr to tentry.name then this name change
2097 * is due to a chown, otherwise caller has specified a new name */
2098 if ((name == tentry.name) || (*name && (strcmp(tentry.name, name) != 0))) {
2099 strncpy(oldname, tentry.name, PR_MAXNAMELEN64);
2100 if (tentry.flags & PRGRP2) {
2101 /* don't let foreign cell groups change name */
2102 if (atsign != NULL((void *)0))
2103 return PRPERM(267269L);
2104 code = CorrectGroupName(at, name, cid, tentry.owner, tentry.name);
2105 if (code)
2106 return code;
2107
2108 if (name == tentry.name) { /* owner fixup */
2109 if (strcmp(oldname, tentry.name) == 0)
2110 goto nameOK;
2111 } else { /* new name, caller must be correct */
2112 if (strcmp(name, tentry.name) != 0)
2113 return PRBADNAM(267272L);
2114 }
2115 } else
2116 /* Allow a foreign name change only if the cellname part is
2117 * the same */
2118 {
2119 char *newatsign;
2120
2121 newatsign = strchr(name, '@');
2122 if (newatsign != atsign) { /* if they are the same no problem */
2123 /*if the pointers are not equal the strings better be */
2124 if ((atsign == NULL((void *)0)) || (newatsign == NULL((void *)0))
2125 || strcmp(atsign, newatsign))
2126 return PRPERM(267269L);
2127 }
2128 if (!CorrectUserName(name))
2129 return PRBADNAM(267272L);
2130 }
2131
2132 pos = FindByName(at, name, &tent);
2133 if (pos)
2134 return PREXIST(267264L);
2135 code = RemoveFromNameHash(at, oldname, &loc);
2136 if (code != PRSUCCESS0)
2137 return code;
2138 strncpy(tentry.name, name, PR_MAXNAMELEN64);
2139 code = pr_WriteEntry(at, 0, loc, &tentry);
2140 if (code)
2141 return PRDBFAIL(267267L);
2142 code = AddToNameHash(at, tentry.name, loc);
2143 if (code != PRSUCCESS0)
2144 return code;
2145 nameOK:;
2146 }
2147 return PRSUCCESS0;
2148}
2149
2150
2151static afs_int32
2152allocNextId(struct ubik_trans * at, struct prentry * cellEntry)
2153{
2154 /* Id's for foreign cell entries are constructed as follows:
2155 * The 16 low order bits are the group id of the cell and the
2156 * top 16 bits identify the particular users in that cell */
2157
2158 afs_int32 id;
2159 afs_int32 cellid = ((ntohl(cellEntry->id)(__builtin_constant_p(cellEntry->id) ? ((((__uint32_t)(cellEntry
->id)) >> 24) | ((((__uint32_t)(cellEntry->id)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(cellEntry->
id)) & (0xff << 8)) << 8) | (((__uint32_t)(cellEntry
->id)) << 24)) : __bswap32_var(cellEntry->id))) & 0x0000ffff);
2160
2161 id = (ntohl(cellEntry->nusers)(__builtin_constant_p(cellEntry->nusers) ? ((((__uint32_t)
(cellEntry->nusers)) >> 24) | ((((__uint32_t)(cellEntry
->nusers)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(cellEntry->nusers)) & (0xff << 8)) << 8)
| (((__uint32_t)(cellEntry->nusers)) << 24)) : __bswap32_var
(cellEntry->nusers)) + 1);
2162 while (FindByID(at, ((id << 16) | cellid))) {
2163 id++;
2164 if (id > 0xffff)
2165 return 0;
2166 }
2167
2168 cellEntry->nusers = htonl(id)(__builtin_constant_p(id) ? ((((__uint32_t)(id)) >> 24)
| ((((__uint32_t)(id)) & (0xff << 16)) >> 8)
| ((((__uint32_t)(id)) & (0xff << 8)) << 8) |
(((__uint32_t)(id)) << 24)) : __bswap32_var(id));
2169 /* use the field nusers to keep
2170 * the next available id in that
2171 * foreign cell's group. Note :
2172 * It would seem more appropriate
2173 * to use ngroup for that and nusers
2174 * to enforce the quota, however pts
2175 * does not have an option to change
2176 * foreign users quota yet */
2177
2178 id = (id << 16) | cellid;
2179 return id;
2180}
2181
2182static int
2183inRange(struct prentry *cellEntry, afs_int32 aid)
2184{
2185 afs_uint32 id, cellid, groupid;
2186
2187
2188 /*
2189 * The only thing that we want to make sure here is that
2190 * the id is in the legal range of this group. If it is
2191 * a duplicate we don't care since it will get caught
2192 * in a different check.
2193 */
2194
2195 cellid = aid & 0x0000ffff;
2196 groupid = (ntohl(cellEntry->id)(__builtin_constant_p(cellEntry->id) ? ((((__uint32_t)(cellEntry
->id)) >> 24) | ((((__uint32_t)(cellEntry->id)) &
(0xff << 16)) >> 8) | ((((__uint32_t)(cellEntry->
id)) & (0xff << 8)) << 8) | (((__uint32_t)(cellEntry
->id)) << 24)) : __bswap32_var(cellEntry->id))) & 0x0000ffff;
2197 if (cellid != groupid)
2198 return 0; /* not in range */
2199
2200 /*
2201 * if we got here we're ok but we need to update the nusers
2202 * field in order to get the id correct the next time that
2203 * we try to allocate it automatically
2204 */
2205
2206 id = aid >> 16;
2207 if (id > ntohl(cellEntry->nusers)(__builtin_constant_p(cellEntry->nusers) ? ((((__uint32_t)
(cellEntry->nusers)) >> 24) | ((((__uint32_t)(cellEntry
->nusers)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(cellEntry->nusers)) & (0xff << 8)) << 8)
| (((__uint32_t)(cellEntry->nusers)) << 24)) : __bswap32_var
(cellEntry->nusers)))
2208 cellEntry->nusers = htonl(id)(__builtin_constant_p(id) ? ((((__uint32_t)(id)) >> 24)
| ((((__uint32_t)(id)) & (0xff << 16)) >> 8)
| ((((__uint32_t)(id)) & (0xff << 8)) << 8) |
(((__uint32_t)(id)) << 24)) : __bswap32_var(id));
2209 return 1;
2210
2211}
2212
2213static int
2214AddAuthGroup(struct prentry *tentry, prlist *alist, afs_int32 *size)
2215{
2216 if (!(strchr(tentry->name, '@')))
2217 return (AddToPRList(alist, size, AUTHUSERID-102));
2218 else
2219 return PRSUCCESS0;
2220}