[moira.git] / afssync / utils.c

/* $Header$ */
/* $Source$ */


/*
 * P_R_P_Q_# (C) COPYRIGHT IBM CORPORATION 1988
 * LICENSED MATERIALS - PROPERTY OF IBM
 * REFER TO COPYRIGHT INSTRUCTIONS FORM NUMBER G120-2083
 */

/*	
       Sherri Nichols
       Information Technology Center
       November, 1988

       Modified May, 1989 by Jeff Schiller to keep disk file in
       network byte order

*/


#include <sys/types.h>
#include <lock.h>
#include <ubik.h>
#include <stdio.h>
#include <netinet/in.h>
#include <netdb.h>
#include <rx/xdr.h>
#include <rx/rx.h>
#include <rx/rx_vab.h>
#include "print.h"
#include "prserver.h"
#include "prerror.h"

#define USERSMS	14487

extern struct prheader cheader;
extern struct ubik_dbase *dbase;

long IDHash(x)
long x;
{
    /* returns hash bucket for x */
    return ((abs(x)) % HASHSIZE);
}

long NameHash(aname)
register unsigned char *aname;
{
    /* returns hash bucket for aname */
    register unsigned int hash=0;
    register int i;
/* stolen directly from the HashString function in the vol package */
    for (i=strlen(aname),aname += i-1;i--;aname--)
	hash = (hash*31) + (*aname-31);
    return(hash % HASHSIZE);
}


long pr_Write(tt,afd,pos,buff,len)
struct ubik_trans *tt;
long afd;
long pos;
char *buff;
long len;
{
    /* package up seek and write into one procedure for ease of use */
    long code;
    code = ubik_Seek(tt,afd,pos);
    if (code) return code;
    code = ubik_Write(tt,buff,len);
    return code;
}

long pr_Read(tt,afd,pos,buff,len)
struct ubik_trans *tt;
long afd;
long pos;
char *buff;
long len;
{
    /* same thing for read */
    long code;
    code = ubik_Seek(tt,afd,pos);
    if (code) return code;
    code = ubik_Read(tt,buff,len);
    return code;
}

pr_WriteEntry(tt, afd, pos, tentry)
struct ubik_trans *tt;
long afd;
long pos;
struct prentry *tentry;
{
    long code;
    register long i;
    struct prentry nentry;
    if (ntohl(1) != 1) {	/* Need to swap bytes. */
      nentry.flags = htonl(tentry->flags);
      nentry.id = htonl(tentry->id);
      nentry.cellid = htonl(tentry->cellid);
      nentry.next = htonl(tentry->next);
      nentry.nextID = htonl(tentry->nextID);
      nentry.nextName = htonl(tentry->nextName);
      nentry.owner = htonl(tentry->owner);
      nentry.creator = htonl(tentry->creator);
      nentry.ngroups = htonl(tentry->ngroups);
      nentry.nusers = htonl(tentry->nusers);
      nentry.count = htonl(tentry->count);
      nentry.instance = htonl(tentry->instance);
      nentry.owned = htonl(tentry->owned);
      nentry.nextOwned = htonl(tentry->nextOwned);
      nentry.parent = htonl(tentry->parent);
      nentry.sibling = htonl(tentry->sibling);
      nentry.child = htonl(tentry->child);
      strncpy(nentry.name, tentry->name, PR_MAXNAMELEN);
      for (i = 0; i < PRSIZE; i++)
	nentry.entries[i] = htonl(tentry->entries[i]);
      code = ubik_Seek(tt, afd, pos);
      if (code) return (code);
      code = ubik_Write(tt, (char *) &nentry, sizeof(struct prentry));
      return(code);
    } else {
      code = ubik_Seek(tt, afd, pos);
      if (code) return (code);
      code = ubik_Write(tt, (char *) tentry, sizeof(struct prentry));
      return(code);
    }
}

pr_ReadEntry(tt, afd, pos, tentry)
struct ubik_trans *tt;
long afd;
long pos;
struct prentry *tentry;
{
    long code;
    register long i;
    struct prentry nentry;
    code = ubik_Seek(tt, afd, pos);
    if (code) return (code);
    if (ntohl(1) == 1) {	/* no swapping needed */
      code = ubik_Read(tt, (char *) tentry, sizeof(struct prentry));
      return(code);
    }
    code = ubik_Read(tt, (char *) &nentry, sizeof(struct prentry));
    if (code) return (code);
    tentry->flags = ntohl(nentry.flags);
    tentry->id = ntohl(nentry.id);
    tentry->cellid = ntohl(nentry.cellid);
    tentry->next = ntohl(nentry.next);
    tentry->nextID = ntohl(nentry.nextID);
    tentry->nextName = ntohl(nentry.nextName);
    tentry->owner = ntohl(nentry.owner);
    tentry->creator = ntohl(nentry.creator);
    tentry->ngroups = ntohl(nentry.ngroups);
    tentry->nusers = ntohl(nentry.nusers);
    tentry->count = ntohl(nentry.count);
    tentry->instance = ntohl(nentry.instance);
    tentry->owned = ntohl(nentry.owned);
    tentry->nextOwned = ntohl(nentry.nextOwned);
    tentry->parent = ntohl(nentry.parent);
    tentry->sibling = ntohl(nentry.sibling);
    tentry->child = ntohl(nentry.child);
    strncpy(tentry->name, nentry.name, PR_MAXNAMELEN);
    for (i = 0; i < PRSIZE; i++)
      tentry->entries[i] = ntohl(nentry.entries[i]);
    return(code);
}

pr_WriteCoEntry(tt, afd, pos, tentry)
struct ubik_trans *tt;
long afd;
long pos;
struct contentry *tentry;
{
    long code;
    register long i;
    struct contentry nentry;
    if (ntohl(1) == 1) {	/* No need to swap */
      code = ubik_Seek(tt, afd, pos);
      if (code) return(code);
      code = ubik_Write(tt, (char *) tentry, sizeof(struct contentry));
      return(code);
    }
    nentry.flags = htonl(tentry->flags);
    nentry.id = htonl(tentry->id);
    nentry.cellid = htonl(tentry->cellid);
    nentry.next = htonl(tentry->next);
    for (i = 0; i < COSIZE; i++)
      nentry.entries[i] = htonl(tentry->entries[i]);
    code = ubik_Seek(tt, afd, pos);
    if (code) return (code);
    code = ubik_Write(tt, (char *) &nentry, sizeof(struct contentry));
    return(code);
}

pr_ReadCoEntry(tt, afd, pos, tentry)
struct ubik_trans *tt;
long afd;
long pos;
struct contentry *tentry;
{
    long code;
    register long i;
    struct contentry nentry;
    code = ubik_Seek(tt, afd, pos);
    if (code) return (code);
    if (ntohl(1) == 1) {	/* No swapping needed. */
      code = ubik_Read(tt, (char *) tentry, sizeof(struct contentry));
      return(code);
    }
    code = ubik_Read(tt, (char *) &nentry, sizeof(struct contentry));
    if (code) return (code);
    tentry->flags = ntohl(nentry.flags);
    tentry->id = ntohl(nentry.id);
    tentry->cellid = ntohl(nentry.cellid);
    tentry->next = ntohl(nentry.next);
    for (i = 0; i < COSIZE; i++)
      tentry->entries[i] = ntohl(nentry.entries[i]);
    return(code);
}

long AllocBlock(at)
register struct ubik_trans *at;
{
    /* allocate a free block of storage for entry, returning address of new entry  */
    register long code;
    long temp;
    struct prentry tentry;

    if (cheader.freePtr) {
	/* allocate this dude */
	temp = ntohl(cheader.freePtr);      
	code = pr_ReadEntry(at, 0, temp, &tentry);
	if (code) return 0;
	cheader.freePtr = htonl(tentry.next);
	code = pr_Write(at, 0, 8, (char *)&cheader.freePtr, sizeof(cheader.freePtr));
	if (code != 0) return 0;
	return temp;
    }
    else {
	/* hosed, nothing on free list, grow file */
	temp = ntohl(cheader.eofPtr);	/* remember this guy */
	cheader.eofPtr = htonl(temp + ENTRYSIZE);
	code = pr_Write(at, 0, 12,(char *) &cheader.eofPtr, sizeof(cheader.eofPtr));
	if (code != 0) return 0;
	return temp;
    }
}

long FreeBlock(at, pos)
register struct ubik_trans *at;
long pos;
{
    /* add a block of storage to the free list */
    register long code;
    struct prentry tentry;

    bzero(&tentry,sizeof(tentry));
    tentry.next = ntohl(cheader.freePtr);
    tentry.flags |= PRFREE;
    cheader.freePtr = htonl(pos);
    code = pr_Write(at,0,8, (char *) &cheader.freePtr,sizeof(cheader.freePtr));
    if (code != 0) return code;
    code = pr_WriteEntry(at,0,pos,&tentry);
    if (code != 0) return code;
    return PRSUCCESS;
}

long FindByID(at,aid)
register struct ubik_trans *at;
long aid;
{
    /* returns address of entry if found, 0 otherwise */
    register long code;
    long i;
    struct prentry tentry;
    long entry;

    i = IDHash(aid);
    entry = ntohl(cheader.idHash[i]);
    if (entry == 0) return entry;
    bzero(&tentry,sizeof(tentry));
    code = pr_ReadEntry(at, 0, entry, &tentry);
    if (code != 0) return 0;
    if (aid == tentry.id) return entry;
    entry = tentry.nextID;
    while (entry != NULL) {
	bzero(&tentry,sizeof(tentry));
	code = pr_ReadEntry(at,0,entry,&tentry);
	if (code != 0) return 0;
	if (aid == tentry.id) return entry;
	entry = tentry.nextID;
    }
    return 0;
}
 

long FindByName(at,aname)    
register struct ubik_trans *at;
char aname[PR_MAXNAMELEN];
{
    /* ditto */
    register long code;
    long i;
    struct prentry tentry;
    long entry;

    i = NameHash(aname);
    entry = ntohl(cheader.nameHash[i]);
    if (entry == 0) return entry;
    bzero(&tentry,sizeof(tentry));
    code = pr_ReadEntry(at, 0, entry,&tentry);
    if (code != 0) return 0;
    if ((strncmp(aname,tentry.name,PR_MAXNAMELEN)) == 0) return entry;
    entry = tentry.nextName;
    while (entry != NULL) {
	bzero(&tentry,sizeof(tentry));
	code = pr_ReadEntry(at,0,entry,&tentry);
	if (code != 0) return 0;
	if ((strncmp(aname,tentry.name,PR_MAXNAMELEN)) == 0) return entry;
	entry = tentry.nextName;
    }
    return 0;
}

long AllocID(at,flag,aid)
register struct ubik_trans *at;
long flag;
long *aid;
{
    /* allocs an id from the proper area of address space, based on flag */
    register long code = 1;
    register long i = 0;
    register maxcount = 50;  /* to prevent infinite loops */
    
    if (flag & PRGRP) {
	*aid = ntohl(cheader.maxGroup);
	while (code && i<maxcount) {
	    --(*aid);
	    code = FindByID(at,*aid);
	    i++;
	}
	if (code) return PRNOIDS;
	cheader.maxGroup = htonl(*aid);
	code = pr_Write(at,0,16,(char *)&cheader.maxGroup,sizeof(cheader.maxGroup));
	if (code) return PRDBFAIL;
	return PRSUCCESS;
    }
    else if (flag & PRFOREIGN) {
	*aid = ntohl(cheader.maxForeign);
	while (code && i<maxcount) {
	    ++(*aid);
	    code = FindByID(at,*aid);
	    i++;
	}
	if (code) return PRNOIDS;
	cheader.maxForeign = htonl(*aid);
	code = pr_Write(at,0,24,(char *)&cheader.maxForeign,sizeof(cheader.maxForeign));
	if (code) return PRDBFAIL;
	return PRSUCCESS;
    }
    else {
	*aid = ntohl(cheader.maxID);
	while (code && i<maxcount) {
	    ++(*aid);
	    code = FindByID(at,*aid);
	    i++;
	}
	if (code) return PRNOIDS;
	cheader.maxID = htonl(*aid);
	code = pr_Write(at,0,20,(char *)&cheader.maxID,sizeof(cheader.maxID));
	if (code) return PRDBFAIL;
	return PRSUCCESS;
    }
}

long IDCmp(a,b)
long *a;
long *b;
{
    /* used to sort CPS's so that comparison with acl's is easier */
    if (*a > *b) return 1;
    if (*a == *b) return 0;
    if (*a < *b) return -1;
}

long RemoveFromIDHash(tt,aid,loc)
struct ubik_trans *tt;
long aid;
long *loc;
{
    /* remove entry designated by aid from id hash table */
    register long code;
    long current, trail, i;
    struct prentry tentry;
    struct prentry bentry;

    i = IDHash(aid);
    current = ntohl(cheader.idHash[i]);
    bzero(&tentry,sizeof(tentry));
    bzero(&bentry,sizeof(bentry));
    trail = 0;
    if (current == NULL) return PRNOENT;
    code = pr_ReadEntry(tt,0,current,&tentry);
    if (code) return PRDBFAIL;
    while (aid != tentry.id) {
	trail = current;
	current = tentry.nextID;
	if (current == NULL) break;
	code = pr_ReadEntry(tt,0,current,&tentry);
	if (code) return PRDBFAIL;
    }
    if (current == NULL) return PRNOENT;  /* we didn't find him */
    if (trail == NULL) {
	/* it's the first entry! */
	cheader.idHash[i] = htonl(tentry.nextID);
	code = pr_Write(tt,0,72+HASHSIZE*4+i*4,(char *)&cheader.idHash[i],sizeof(cheader.idHash[i]));
	if (code) return PRDBFAIL;
    }
    else {
	code = pr_ReadEntry(tt,0,trail, &bentry);
	if (code) return PRDBFAIL;
	bentry.nextID = tentry.nextID;
	code = pr_WriteEntry(tt,0,trail,&bentry);
    }
    *loc = current;
    return PRSUCCESS;
}

long AddToIDHash(tt, aid, loc)
struct ubik_trans *tt;
long aid;
long loc;
{
    /* add entry at loc designated by aid to id hash table */
    register long code;
    long i;
    struct prentry tentry;

    i = IDHash(aid);
    bzero(&tentry,sizeof(tentry));
    code = pr_ReadEntry(tt,0,loc,&tentry);
    if (code) return PRDBFAIL;
    tentry.nextID = ntohl(cheader.idHash[i]);
    cheader.idHash[i] = htonl(loc);
    code = pr_WriteEntry(tt,0,loc,&tentry);
    if (code) return PRDBFAIL;
    code = pr_Write(tt,0,72+HASHSIZE*4+i*4,(char *)&cheader.idHash[i],sizeof(cheader.idHash[i]));
    if (code) return PRDBFAIL;
    return PRSUCCESS;
}

long RemoveFromNameHash(tt,aname,loc)
struct ubik_trans *tt;
char *aname;
long *loc;
{
    /* remove from name hash */
    register long code;
    long current, trail, i;
    struct prentry tentry;
    struct prentry bentry;

    i = NameHash(aname);
    current = ntohl(cheader.nameHash[i]);
    bzero(&tentry,sizeof(tentry));
    bzero(&bentry,sizeof(bentry));
    trail = 0;
    if (current == NULL) return PRNOENT;
    code = pr_ReadEntry(tt,0,current,&tentry);
    if (code) return PRDBFAIL;
    while (strcmp(aname,tentry.name)) {
	trail = current;
	current = tentry.nextName;
	if (current == NULL) break;
	code = pr_ReadEntry(tt,0,current,&tentry);
	if (code) return PRDBFAIL;
    }
    if (current == NULL) return PRNOENT;  /* we dnamen't find him */
    if (trail == NULL) {
	/* it's the first entry! */
	cheader.nameHash[i] = htonl(tentry.nextName);
	code = pr_Write(tt,0,72+i*4,(char *)&cheader.nameHash[i],sizeof(cheader.nameHash[i]));
	if (code) return PRDBFAIL;
    }
    else {
	code = pr_ReadEntry(tt,0,trail, &bentry);
	if (code) return PRDBFAIL;
	bentry.nextName = tentry.nextName;
	code = pr_WriteEntry(tt,0,trail,&bentry);
    }
    *loc = current;
    return PRSUCCESS;
}

long AddToNameHash(tt, aname, loc)
struct ubik_trans *tt;
char *aname;
long loc;
{
    /* add to name hash */
    register long code;
    long i;
    struct prentry tentry;

    i = NameHash(aname);
    bzero(&tentry,sizeof(tentry));
    code = pr_ReadEntry(tt,0,loc,&tentry);
    if (code) return PRDBFAIL;
    tentry.nextName = ntohl(cheader.nameHash[i]);
    cheader.nameHash[i] = htonl(loc);
    code = pr_WriteEntry(tt,0,loc,&tentry);
    if (code) return PRDBFAIL;
    code = pr_Write(tt,0,72+i*4,(char *)&cheader.nameHash[i],sizeof(cheader.nameHash[i]));
    if (code) return PRDBFAIL;
    return PRSUCCESS;
}

long AddToOwnerChain(at,gid,oid)
struct ubik_trans *at;
long gid;
long oid;
{
    /* add entry designated by gid to owner chain of entry designated by oid */
    register long code;
    long loc;
    long gloc;
    struct prentry tentry;
    struct prentry gentry;

    loc = FindByID(at,oid);
    if (!loc) return PRNOENT;
    code = pr_ReadEntry(at,0,loc,&tentry);
    if (code != 0) return PRDBFAIL;
    gloc = FindByID(at,gid);
    code = pr_ReadEntry(at,0,gloc,&gentry);
    if (code != 0) return PRDBFAIL;
    gentry.nextOwned = tentry.owned;
    tentry.owned = gloc;
    code = pr_WriteEntry(at,0,loc,&tentry);
    if (code != 0) return PRDBFAIL;
    code = pr_WriteEntry(at,0,gloc,&gentry);
    if (code != 0) return PRDBFAIL;
    return PRSUCCESS;
}

long RemoveFromOwnerChain(at,gid,oid)
struct ubik_trans *at;
long gid;
long oid;
{
    /* remove gid from owner chain for oid */
    register long code;
    long nptr;
    struct prentry tentry;
    struct prentry bentry;
    long loc;

    loc = FindByID(at,oid);
    if (!loc) return PRNOENT;
    code = pr_ReadEntry(at,0,loc,&tentry);
    if (code != 0) return PRDBFAIL;
    if (!tentry.owned) return PRNOENT;
    nptr = tentry.owned;
    bcopy(&tentry,&bentry,sizeof(tentry));
    while (nptr != NULL) {
	code = pr_ReadEntry(at,0,nptr,&tentry);
	if (code != 0) return PRDBFAIL;
	if (tentry.id == gid) {
	    /* found it */
	    if (nptr == bentry.owned) /* modifying first of chain */
		bentry.owned = tentry.nextOwned;
	    else bentry.nextOwned = tentry.nextOwned;
	    tentry.nextOwned = 0;
	    code = pr_WriteEntry(at,0,loc,&bentry);
	    if (code != 0) return PRDBFAIL;
	    code = pr_WriteEntry(at,0,nptr,&tentry);
	    if (code != 0) return PRDBFAIL;
	    return PRSUCCESS;
	}
	loc = nptr;
	nptr = tentry.nextOwned;
	bcopy(&tentry,&bentry,sizeof(tentry));
    }
    return PRNOENT;
}

long AddToOrphan(at,gid)
struct ubik_trans *at;
long gid;
{
    /* add gid to orphan list, as it's owner has died */
    register long code;
    long loc;
    struct prentry tentry;

    loc = FindByID(at,gid);
    if (!loc) return PRNOENT;
    code = pr_ReadEntry(at,0,loc,&tentry);
    if (code != 0) return PRDBFAIL;
    tentry.nextOwned = ntohl(cheader.orphan);
    cheader.orphan = htonl(loc);
    code = pr_WriteEntry(at,0,loc,&tentry);
    if (code != 0) return PRDBFAIL;
    code = pr_Write(at,0,32,(char *)&cheader.orphan,sizeof(cheader.orphan));
    if (code != 0) return PRDBFAIL;
    return PRSUCCESS;
}

long RemoveFromOrphan(at,gid)
struct ubik_trans *at;
long gid;
{
    /* remove gid from the orphan list */
    register long code;
    long loc;
    long nptr;
    struct prentry tentry;
    struct prentry bentry;

    loc = FindByID(at,gid);
    if (!loc) return PRNOENT;
    code = pr_ReadEntry(at,0,loc,&tentry);
    if (code != 0) return PRDBFAIL;
    if (cheader.orphan == htonl(loc)) {
	cheader.orphan = htonl(tentry.nextOwned);
	tentry.nextOwned = 0;
	code = pr_Write(at,0,32,(char *)&cheader.orphan,sizeof(cheader.orphan));
	if (code != 0) return PRDBFAIL;
	code = pr_WriteEntry(at,0,loc,&tentry);
	if (code != 0) return PRDBFAIL;
	return PRSUCCESS;
    }
    nptr = ntohl(cheader.orphan);
    bzero(&bentry,sizeof(bentry));
    loc = 0;
    while (nptr != NULL) {
	code = pr_ReadEntry(at,0,nptr,&tentry);
	if (code != 0) return PRDBFAIL;
	if (gid == tentry.id) {
	    /* found it */
	    bentry.nextOwned = tentry.nextOwned;
	    tentry.nextOwned = 0;
	    code = pr_WriteEntry(at,0,loc,&bentry);
	    if (code != 0) return PRDBFAIL;
	    code = pr_WriteEntry(at,0,nptr,&tentry);
	    if (code != 0) return PRDBFAIL;
	    return PRSUCCESS;
	}
	loc = nptr;
	nptr = tentry.nextOwned;
	bcopy(&tentry,&bentry,sizeof(tentry));
    }
    return PRNOENT;
}

long IsOwnerOf(at,aid,gid)
struct ubik_trans *at;
long aid;
long gid;
{
    /* returns 1 if aid is the owner of gid, 0 otherwise */
    register long code;
    struct prentry tentry;
    long loc;

    loc = FindByID(at,gid);
    if (!loc) return 0;
    code = pr_ReadEntry(at,0,loc,&tentry);
    if (code != 0) return 0;
    if (tentry.owner == aid) return 1;
    return 0;
}

long OwnerOf(at,gid)
struct ubik_trans *at;
long gid;
{
    /* returns the owner of gid */
    register long code;
    long loc;
    struct prentry tentry;

    loc = FindByID(at,gid);
    if (!loc) return 0;
    code = pr_ReadEntry(at,0,loc,&tentry);
    if (code != 0) return 0;
    return tentry.owner;
}
    

long WhoIsThis(acall, at, aid)
struct rx_call *acall;
struct ubik_trans *at;
long *aid;
{
    *aid = USERSMS;
    return 0;
}

long IsAMemberOf(at,aid,gid)
struct ubik_trans *at;
long aid;
long gid;
{
    /* returns true if aid is a member of gid */
    struct prentry tentry;
    struct contentry centry;
    register long code;
    long i;
    long loc;

    loc = FindByID(at,gid);
    if (!loc) return 0;
    bzero(&tentry,sizeof(tentry));
    code = pr_ReadEntry(at, 0, loc,&tentry);
    if (code) return 0;
    if (!(tentry.flags & PRGRP)) return 0;
    for (i= 0;i<PRSIZE;i++) {
	if (tentry.entries[i] == aid) return 1;
	if (tentry.entries[i] == 0) return 0;
    }
    if (tentry.next) {
	loc = tentry.next;
	while (loc) {
	    bzero(&centry,sizeof(centry));
	    code = pr_ReadCoEntry(at,0,loc,&centry);
	    if (code) return 0;
	    for (i=0;i<COSIZE;i++) {
		if (centry.entries[i] == aid) return 1;
		if (centry.entries[i] == 0) return 0;
	    }
	    loc = centry.next;
	}
    }
    return 0;  /* actually, should never get here */
}
Commit	Line	Data
e1f001e5	1	/* $Header$ */
	2	/* $Source$ */
	3
	4
	5	/*
	6	* P_R_P_Q_# (C) COPYRIGHT IBM CORPORATION 1988
	7	* LICENSED MATERIALS - PROPERTY OF IBM
	8	* REFER TO COPYRIGHT INSTRUCTIONS FORM NUMBER G120-2083
	9	*/
	10
	11	/*
	12	Sherri Nichols
	13	Information Technology Center
	14	November, 1988
	15
	16	Modified May, 1989 by Jeff Schiller to keep disk file in
	17	network byte order
	18
	19	*/
	20
	21
	22	#include <sys/types.h>
	23	#include <lock.h>
	24	#include <ubik.h>
	25	#include <stdio.h>
	26	#include <netinet/in.h>
	27	#include <netdb.h>
	28	#include <rx/xdr.h>
	29	#include <rx/rx.h>
	30	#include <rx/rx_vab.h>
e1f001e5	31	#include "print.h"
	32	#include "prserver.h"
	33	#include "prerror.h"
	34
11711105	35	#define USERSMS 14487
11711105	36
e1f001e5	37	extern struct prheader cheader;
	38	extern struct ubik_dbase *dbase;
	39
	40	long IDHash(x)
	41	long x;
	42	{
	43	/* returns hash bucket for x */
	44	return ((abs(x)) % HASHSIZE);
	45	}
	46
	47	long NameHash(aname)
	48	register unsigned char *aname;
	49	{
	50	/* returns hash bucket for aname */
	51	register unsigned int hash=0;
	52	register int i;
	53	/* stolen directly from the HashString function in the vol package */
	54	for (i=strlen(aname),aname += i-1;i--;aname--)
	55	hash = (hash31) + (aname-31);
	56	return(hash % HASHSIZE);
	57	}
	58
	59
	60	long pr_Write(tt,afd,pos,buff,len)
	61	struct ubik_trans *tt;
	62	long afd;
	63	long pos;
	64	char *buff;
	65	long len;
	66	{
	67	/* package up seek and write into one procedure for ease of use */
	68	long code;
	69	code = ubik_Seek(tt,afd,pos);
	70	if (code) return code;
	71	code = ubik_Write(tt,buff,len);
	72	return code;
	73	}
	74
	75	long pr_Read(tt,afd,pos,buff,len)
	76	struct ubik_trans *tt;
	77	long afd;
	78	long pos;
	79	char *buff;
	80	long len;
	81	{
	82	/* same thing for read */
	83	long code;
	84	code = ubik_Seek(tt,afd,pos);
	85	if (code) return code;
	86	code = ubik_Read(tt,buff,len);
	87	return code;
	88	}
	89
	90	pr_WriteEntry(tt, afd, pos, tentry)
	91	struct ubik_trans *tt;
	92	long afd;
	93	long pos;
	94	struct prentry *tentry;
	95	{
	96	long code;
	97	register long i;
	98	struct prentry nentry;
	99	if (ntohl(1) != 1) { /* Need to swap bytes. */
	100	nentry.flags = htonl(tentry->flags);
101	nentry.id = htonl(tentry->id);
102	nentry.cellid = htonl(tentry->cellid);
103	nentry.next = htonl(tentry->next);
104	nentry.nextID = htonl(tentry->nextID);
105	nentry.nextName = htonl(tentry->nextName);
106	nentry.owner = htonl(tentry->owner);
107	nentry.creator = htonl(tentry->creator);
108	nentry.ngroups = htonl(tentry->ngroups);
109	nentry.nusers = htonl(tentry->nusers);
110	nentry.count = htonl(tentry->count);
111	nentry.instance = htonl(tentry->instance);
112	nentry.owned = htonl(tentry->owned);
113	nentry.nextOwned = htonl(tentry->nextOwned);
114	nentry.parent = htonl(tentry->parent);
115	nentry.sibling = htonl(tentry->sibling);
116	nentry.child = htonl(tentry->child);
117	strncpy(nentry.name, tentry->name, PR_MAXNAMELEN);
118	for (i = 0; i < PRSIZE; i++)
119	nentry.entries[i] = htonl(tentry->entries[i]);
120	code = ubik_Seek(tt, afd, pos);
121	if (code) return (code);
122	code = ubik_Write(tt, (char *) &nentry, sizeof(struct prentry));
123	return(code);
124	} else {
125	code = ubik_Seek(tt, afd, pos);
126	if (code) return (code);
127	code = ubik_Write(tt, (char *) tentry, sizeof(struct prentry));
128	return(code);
129	}
130	}
131
132	pr_ReadEntry(tt, afd, pos, tentry)
133	struct ubik_trans *tt;
134	long afd;
135	long pos;
136	struct prentry *tentry;
137	{
138	long code;
139	register long i;
140	struct prentry nentry;
141	code = ubik_Seek(tt, afd, pos);
142	if (code) return (code);
143	if (ntohl(1) == 1) { /* no swapping needed */
144	code = ubik_Read(tt, (char *) tentry, sizeof(struct prentry));
145	return(code);
146	}
147	code = ubik_Read(tt, (char *) &nentry, sizeof(struct prentry));
148	if (code) return (code);
149	tentry->flags = ntohl(nentry.flags);
150	tentry->id = ntohl(nentry.id);
151	tentry->cellid = ntohl(nentry.cellid);
152	tentry->next = ntohl(nentry.next);
153	tentry->nextID = ntohl(nentry.nextID);
154	tentry->nextName = ntohl(nentry.nextName);
155	tentry->owner = ntohl(nentry.owner);
156	tentry->creator = ntohl(nentry.creator);
157	tentry->ngroups = ntohl(nentry.ngroups);
158	tentry->nusers = ntohl(nentry.nusers);
159	tentry->count = ntohl(nentry.count);
160	tentry->instance = ntohl(nentry.instance);
161	tentry->owned = ntohl(nentry.owned);
162	tentry->nextOwned = ntohl(nentry.nextOwned);
163	tentry->parent = ntohl(nentry.parent);
164	tentry->sibling = ntohl(nentry.sibling);
165	tentry->child = ntohl(nentry.child);
166	strncpy(tentry->name, nentry.name, PR_MAXNAMELEN);
167	for (i = 0; i < PRSIZE; i++)
168	tentry->entries[i] = ntohl(nentry.entries[i]);
169	return(code);
170	}
171
172	pr_WriteCoEntry(tt, afd, pos, tentry)
173	struct ubik_trans *tt;
174	long afd;
175	long pos;
176	struct contentry *tentry;
177	{
178	long code;
179	register long i;
180	struct contentry nentry;
181	if (ntohl(1) == 1) { /* No need to swap */
182	code = ubik_Seek(tt, afd, pos);
183	if (code) return(code);
184	code = ubik_Write(tt, (char *) tentry, sizeof(struct contentry));
185	return(code);
186	}
187	nentry.flags = htonl(tentry->flags);
188	nentry.id = htonl(tentry->id);
189	nentry.cellid = htonl(tentry->cellid);
190	nentry.next = htonl(tentry->next);
191	for (i = 0; i < COSIZE; i++)
192	nentry.entries[i] = htonl(tentry->entries[i]);
193	code = ubik_Seek(tt, afd, pos);
194	if (code) return (code);
195	code = ubik_Write(tt, (char *) &nentry, sizeof(struct contentry));
196	return(code);
197	}
198
199	pr_ReadCoEntry(tt, afd, pos, tentry)
200	struct ubik_trans *tt;
201	long afd;
202	long pos;
203	struct contentry *tentry;
204	{
205	long code;
206	register long i;
207	struct contentry nentry;
208	code = ubik_Seek(tt, afd, pos);
209	if (code) return (code);
210	if (ntohl(1) == 1) { /* No swapping needed. */
211	code = ubik_Read(tt, (char *) tentry, sizeof(struct contentry));
212	return(code);
213	}
214	code = ubik_Read(tt, (char *) &nentry, sizeof(struct contentry));
215	if (code) return (code);
216	tentry->flags = ntohl(nentry.flags);
217	tentry->id = ntohl(nentry.id);
218	tentry->cellid = ntohl(nentry.cellid);
219	tentry->next = ntohl(nentry.next);
220	for (i = 0; i < COSIZE; i++)
221	tentry->entries[i] = ntohl(nentry.entries[i]);
222	return(code);
223	}
224
225	long AllocBlock(at)
226	register struct ubik_trans *at;
227	{
228	/* allocate a free block of storage for entry, returning address of new entry */
229	register long code;
230	long temp;
231	struct prentry tentry;
232
233	if (cheader.freePtr) {
234	/* allocate this dude */
235	temp = ntohl(cheader.freePtr);
236	code = pr_ReadEntry(at, 0, temp, &tentry);
237	if (code) return 0;
238	cheader.freePtr = htonl(tentry.next);
239	code = pr_Write(at, 0, 8, (char *)&cheader.freePtr, sizeof(cheader.freePtr));
240	if (code != 0) return 0;
241	return temp;
242	}
243	else {
244	/* hosed, nothing on free list, grow file */
245	temp = ntohl(cheader.eofPtr); /* remember this guy */
246	cheader.eofPtr = htonl(temp + ENTRYSIZE);
247	code = pr_Write(at, 0, 12,(char *) &cheader.eofPtr, sizeof(cheader.eofPtr));
248	if (code != 0) return 0;
249	return temp;
250	}
251	}
252
253	long FreeBlock(at, pos)
254	register struct ubik_trans *at;
255	long pos;
256	{
257	/* add a block of storage to the free list */
258	register long code;
259	struct prentry tentry;
260
261	bzero(&tentry,sizeof(tentry));
262	tentry.next = ntohl(cheader.freePtr);
263	tentry.flags \|= PRFREE;
264	cheader.freePtr = htonl(pos);
265	code = pr_Write(at,0,8, (char *) &cheader.freePtr,sizeof(cheader.freePtr));
266	if (code != 0) return code;
267	code = pr_WriteEntry(at,0,pos,&tentry);
268	if (code != 0) return code;
269	return PRSUCCESS;
270	}
271
272	long FindByID(at,aid)
273	register struct ubik_trans *at;
274	long aid;
275	{
276	/* returns address of entry if found, 0 otherwise */
277	register long code;
278	long i;
279	struct prentry tentry;
280	long entry;
281
282	i = IDHash(aid);
283	entry = ntohl(cheader.idHash[i]);
284	if (entry == 0) return entry;
285	bzero(&tentry,sizeof(tentry));
286	code = pr_ReadEntry(at, 0, entry, &tentry);
287	if (code != 0) return 0;
288	if (aid == tentry.id) return entry;
289	entry = tentry.nextID;
290	while (entry != NULL) {
291	bzero(&tentry,sizeof(tentry));
292	code = pr_ReadEntry(at,0,entry,&tentry);
293	if (code != 0) return 0;
294	if (aid == tentry.id) return entry;
295	entry = tentry.nextID;
296	}
297	return 0;
298	}
299
300
301
302	long FindByName(at,aname)
303	register struct ubik_trans *at;
304	char aname[PR_MAXNAMELEN];
305	{
306	/* ditto */
307	register long code;
308	long i;
309	struct prentry tentry;
310	long entry;
311
312	i = NameHash(aname);
313	entry = ntohl(cheader.nameHash[i]);
314	if (entry == 0) return entry;
315	bzero(&tentry,sizeof(tentry));
316	code = pr_ReadEntry(at, 0, entry,&tentry);
317	if (code != 0) return 0;
318	if ((strncmp(aname,tentry.name,PR_MAXNAMELEN)) == 0) return entry;
319	entry = tentry.nextName;
320	while (entry != NULL) {
321	bzero(&tentry,sizeof(tentry));
322	code = pr_ReadEntry(at,0,entry,&tentry);
323	if (code != 0) return 0;
324	if ((strncmp(aname,tentry.name,PR_MAXNAMELEN)) == 0) return entry;
325	entry = tentry.nextName;
326	}
327	return 0;
328	}
329
330	long AllocID(at,flag,aid)
331	register struct ubik_trans *at;
332	long flag;
333	long *aid;
334	{
335	/* allocs an id from the proper area of address space, based on flag */
336	register long code = 1;
337	register long i = 0;
338	register maxcount = 50; /* to prevent infinite loops */
339
340	if (flag & PRGRP) {
341	*aid = ntohl(cheader.maxGroup);
342	while (code && i<maxcount) {
343	--(*aid);
344	code = FindByID(at,*aid);
345	i++;
346	}
347	if (code) return PRNOIDS;
348	cheader.maxGroup = htonl(*aid);
349	code = pr_Write(at,0,16,(char *)&cheader.maxGroup,sizeof(cheader.maxGroup));
350	if (code) return PRDBFAIL;
351	return PRSUCCESS;
352	}
353	else if (flag & PRFOREIGN) {
354	*aid = ntohl(cheader.maxForeign);
355	while (code && i<maxcount) {
356	++(*aid);
357	code = FindByID(at,*aid);
358	i++;
359	}
360	if (code) return PRNOIDS;
361	cheader.maxForeign = htonl(*aid);
362	code = pr_Write(at,0,24,(char *)&cheader.maxForeign,sizeof(cheader.maxForeign));
363	if (code) return PRDBFAIL;
364	return PRSUCCESS;
365	}
366	else {
367	*aid = ntohl(cheader.maxID);
368	while (code && i<maxcount) {
369	++(*aid);
370	code = FindByID(at,*aid);
371	i++;
372	}
373	if (code) return PRNOIDS;
374	cheader.maxID = htonl(*aid);
375	code = pr_Write(at,0,20,(char *)&cheader.maxID,sizeof(cheader.maxID));
376	if (code) return PRDBFAIL;
377	return PRSUCCESS;
378	}
379	}
380
381	long IDCmp(a,b)
382	long *a;
383	long *b;
384	{
385	/* used to sort CPS's so that comparison with acl's is easier */
386	if (a > b) return 1;
387	if (a == b) return 0;
388	if (a < b) return -1;
389	}
390
391	long RemoveFromIDHash(tt,aid,loc)
392	struct ubik_trans *tt;
393	long aid;
394	long *loc;
395	{
396	/* remove entry designated by aid from id hash table */
397	register long code;
398	long current, trail, i;
399	struct prentry tentry;
400	struct prentry bentry;
401
402	i = IDHash(aid);
403	current = ntohl(cheader.idHash[i]);
404	bzero(&tentry,sizeof(tentry));
405	bzero(&bentry,sizeof(bentry));
406	trail = 0;
407	if (current == NULL) return PRNOENT;
408	code = pr_ReadEntry(tt,0,current,&tentry);
409	if (code) return PRDBFAIL;
410	while (aid != tentry.id) {
411	trail = current;
412	current = tentry.nextID;
413	if (current == NULL) break;
414	code = pr_ReadEntry(tt,0,current,&tentry);
415	if (code) return PRDBFAIL;
416	}
417	if (current == NULL) return PRNOENT; /* we didn't find him */
418	if (trail == NULL) {
419	/* it's the first entry! */
420	cheader.idHash[i] = htonl(tentry.nextID);
421	code = pr_Write(tt,0,72+HASHSIZE4+i4,(char *)&cheader.idHash[i],sizeof(cheader.idHash[i]));
422	if (code) return PRDBFAIL;
423	}
424	else {
425	code = pr_ReadEntry(tt,0,trail, &bentry);
426	if (code) return PRDBFAIL;
427	bentry.nextID = tentry.nextID;
428	code = pr_WriteEntry(tt,0,trail,&bentry);
429	}
430	*loc = current;
431	return PRSUCCESS;
432	}
433
434	long AddToIDHash(tt, aid, loc)
435	struct ubik_trans *tt;
436	long aid;
437	long loc;
438	{
439	/* add entry at loc designated by aid to id hash table */
440	register long code;
441	long i;
442	struct prentry tentry;
443
444	i = IDHash(aid);
445	bzero(&tentry,sizeof(tentry));
446	code = pr_ReadEntry(tt,0,loc,&tentry);
447	if (code) return PRDBFAIL;
448	tentry.nextID = ntohl(cheader.idHash[i]);
449	cheader.idHash[i] = htonl(loc);
450	code = pr_WriteEntry(tt,0,loc,&tentry);
451	if (code) return PRDBFAIL;
452	code = pr_Write(tt,0,72+HASHSIZE4+i4,(char *)&cheader.idHash[i],sizeof(cheader.idHash[i]));
453	if (code) return PRDBFAIL;
454	return PRSUCCESS;
455	}
456
457	long RemoveFromNameHash(tt,aname,loc)
458	struct ubik_trans *tt;
459	char *aname;
460	long *loc;
461	{
462	/* remove from name hash */
463	register long code;
464	long current, trail, i;
465	struct prentry tentry;
466	struct prentry bentry;
467
468	i = NameHash(aname);
469	current = ntohl(cheader.nameHash[i]);
470	bzero(&tentry,sizeof(tentry));
471	bzero(&bentry,sizeof(bentry));
472	trail = 0;
473	if (current == NULL) return PRNOENT;
474	code = pr_ReadEntry(tt,0,current,&tentry);
475	if (code) return PRDBFAIL;
476	while (strcmp(aname,tentry.name)) {
477	trail = current;
478	current = tentry.nextName;
479	if (current == NULL) break;
480	code = pr_ReadEntry(tt,0,current,&tentry);
481	if (code) return PRDBFAIL;
482	}
483	if (current == NULL) return PRNOENT; /* we dnamen't find him */
484	if (trail == NULL) {
485	/* it's the first entry! */
486	cheader.nameHash[i] = htonl(tentry.nextName);
487	code = pr_Write(tt,0,72+i4,(char )&cheader.nameHash[i],sizeof(cheader.nameHash[i]));
488	if (code) return PRDBFAIL;
489	}
490	else {
491	code = pr_ReadEntry(tt,0,trail, &bentry);
492	if (code) return PRDBFAIL;
493	bentry.nextName = tentry.nextName;
494	code = pr_WriteEntry(tt,0,trail,&bentry);
495	}
496	*loc = current;
497	return PRSUCCESS;
498	}
499
500	long AddToNameHash(tt, aname, loc)
501	struct ubik_trans *tt;
502	char *aname;
503	long loc;
504	{
505	/* add to name hash */
506	register long code;
507	long i;
508	struct prentry tentry;
509
510	i = NameHash(aname);
511	bzero(&tentry,sizeof(tentry));
512	code = pr_ReadEntry(tt,0,loc,&tentry);
513	if (code) return PRDBFAIL;
514	tentry.nextName = ntohl(cheader.nameHash[i]);
515	cheader.nameHash[i] = htonl(loc);
516	code = pr_WriteEntry(tt,0,loc,&tentry);
517	if (code) return PRDBFAIL;
518	code = pr_Write(tt,0,72+i4,(char )&cheader.nameHash[i],sizeof(cheader.nameHash[i]));
519	if (code) return PRDBFAIL;
520	return PRSUCCESS;
521	}
522
523	long AddToOwnerChain(at,gid,oid)
524	struct ubik_trans *at;
525	long gid;
526	long oid;
527	{
528	/* add entry designated by gid to owner chain of entry designated by oid */
529	register long code;
530	long loc;
531	long gloc;
532	struct prentry tentry;
533	struct prentry gentry;
534
535	loc = FindByID(at,oid);
536	if (!loc) return PRNOENT;
537	code = pr_ReadEntry(at,0,loc,&tentry);
538	if (code != 0) return PRDBFAIL;
539	gloc = FindByID(at,gid);
540	code = pr_ReadEntry(at,0,gloc,&gentry);
541	if (code != 0) return PRDBFAIL;
542	gentry.nextOwned = tentry.owned;
543	tentry.owned = gloc;
544	code = pr_WriteEntry(at,0,loc,&tentry);
545	if (code != 0) return PRDBFAIL;
546	code = pr_WriteEntry(at,0,gloc,&gentry);
547	if (code != 0) return PRDBFAIL;
548	return PRSUCCESS;
549	}
550
551	long RemoveFromOwnerChain(at,gid,oid)
552	struct ubik_trans *at;
553	long gid;
554	long oid;
555	{
556	/* remove gid from owner chain for oid */
557	register long code;
558	long nptr;
559	struct prentry tentry;
560	struct prentry bentry;
561	long loc;
562
563	loc = FindByID(at,oid);
564	if (!loc) return PRNOENT;
565	code = pr_ReadEntry(at,0,loc,&tentry);
566	if (code != 0) return PRDBFAIL;
567	if (!tentry.owned) return PRNOENT;
568	nptr = tentry.owned;
569	bcopy(&tentry,&bentry,sizeof(tentry));
570	while (nptr != NULL) {
571	code = pr_ReadEntry(at,0,nptr,&tentry);
572	if (code != 0) return PRDBFAIL;
573	if (tentry.id == gid) {
574	/* found it */
575	if (nptr == bentry.owned) /* modifying first of chain */
576	bentry.owned = tentry.nextOwned;
577	else bentry.nextOwned = tentry.nextOwned;
578	tentry.nextOwned = 0;
579	code = pr_WriteEntry(at,0,loc,&bentry);
580	if (code != 0) return PRDBFAIL;
581	code = pr_WriteEntry(at,0,nptr,&tentry);
582	if (code != 0) return PRDBFAIL;
583	return PRSUCCESS;
584	}
585	loc = nptr;
586	nptr = tentry.nextOwned;
587	bcopy(&tentry,&bentry,sizeof(tentry));
588	}
589	return PRNOENT;
590	}
591
592	long AddToOrphan(at,gid)
593	struct ubik_trans *at;
594	long gid;
595	{
596	/* add gid to orphan list, as it's owner has died */
597	register long code;
598	long loc;
599	struct prentry tentry;
600
601	loc = FindByID(at,gid);
602	if (!loc) return PRNOENT;
603	code = pr_ReadEntry(at,0,loc,&tentry);
604	if (code != 0) return PRDBFAIL;
605	tentry.nextOwned = ntohl(cheader.orphan);
606	cheader.orphan = htonl(loc);
607	code = pr_WriteEntry(at,0,loc,&tentry);
608	if (code != 0) return PRDBFAIL;
609	code = pr_Write(at,0,32,(char *)&cheader.orphan,sizeof(cheader.orphan));
610	if (code != 0) return PRDBFAIL;
611	return PRSUCCESS;
612	}
613
614	long RemoveFromOrphan(at,gid)
615	struct ubik_trans *at;
616	long gid;
617	{
618	/* remove gid from the orphan list */
619	register long code;
620	long loc;
621	long nptr;
622	struct prentry tentry;
623	struct prentry bentry;
624
625	loc = FindByID(at,gid);
626	if (!loc) return PRNOENT;
627	code = pr_ReadEntry(at,0,loc,&tentry);
628	if (code != 0) return PRDBFAIL;
629	if (cheader.orphan == htonl(loc)) {
630	cheader.orphan = htonl(tentry.nextOwned);
631	tentry.nextOwned = 0;
632	code = pr_Write(at,0,32,(char *)&cheader.orphan,sizeof(cheader.orphan));
633	if (code != 0) return PRDBFAIL;
634	code = pr_WriteEntry(at,0,loc,&tentry);
635	if (code != 0) return PRDBFAIL;
636	return PRSUCCESS;
637	}
638	nptr = ntohl(cheader.orphan);
639	bzero(&bentry,sizeof(bentry));
640	loc = 0;
641	while (nptr != NULL) {
642	code = pr_ReadEntry(at,0,nptr,&tentry);
643	if (code != 0) return PRDBFAIL;
644	if (gid == tentry.id) {
645	/* found it */
646	bentry.nextOwned = tentry.nextOwned;
647	tentry.nextOwned = 0;
648	code = pr_WriteEntry(at,0,loc,&bentry);
649	if (code != 0) return PRDBFAIL;
650	code = pr_WriteEntry(at,0,nptr,&tentry);
651	if (code != 0) return PRDBFAIL;
652	return PRSUCCESS;
653	}
654	loc = nptr;
655	nptr = tentry.nextOwned;
656	bcopy(&tentry,&bentry,sizeof(tentry));
657	}
658	return PRNOENT;
659	}
660
661	long IsOwnerOf(at,aid,gid)
662	struct ubik_trans *at;
663	long aid;
664	long gid;
665	{
666	/* returns 1 if aid is the owner of gid, 0 otherwise */
667	register long code;
668	struct prentry tentry;
669	long loc;
670
671	loc = FindByID(at,gid);
672	if (!loc) return 0;
673	code = pr_ReadEntry(at,0,loc,&tentry);
674	if (code != 0) return 0;
675	if (tentry.owner == aid) return 1;
676	return 0;
677	}
678
679	long OwnerOf(at,gid)
680	struct ubik_trans *at;
681	long gid;
682	{
683	/* returns the owner of gid */
684	register long code;
685	long loc;
686	struct prentry tentry;
687
688	loc = FindByID(at,gid);
689	if (!loc) return 0;
690	code = pr_ReadEntry(at,0,loc,&tentry);
691	if (code != 0) return 0;
692	return tentry.owner;
693	}
694
695
696	long WhoIsThis(acall, at, aid)
697	struct rx_call *acall;
698	struct ubik_trans *at;
699	long *aid;
700	{
11711105	701	*aid = USERSMS;
e1f001e5	702	return 0;
	703	}
	704
	705	long IsAMemberOf(at,aid,gid)
	706	struct ubik_trans *at;
	707	long aid;
	708	long gid;
	709	{
	710	/* returns true if aid is a member of gid */
	711	struct prentry tentry;
	712	struct contentry centry;
	713	register long code;
	714	long i;
	715	long loc;
	716
	717	loc = FindByID(at,gid);
	718	if (!loc) return 0;
	719	bzero(&tentry,sizeof(tentry));
	720	code = pr_ReadEntry(at, 0, loc,&tentry);
	721	if (code) return 0;
	722	if (!(tentry.flags & PRGRP)) return 0;
	723	for (i= 0;i<PRSIZE;i++) {
	724	if (tentry.entries[i] == aid) return 1;
	725	if (tentry.entries[i] == 0) return 0;
	726	}
	727	if (tentry.next) {
	728	loc = tentry.next;
	729	while (loc) {
	730	bzero(&centry,sizeof(centry));
	731	code = pr_ReadCoEntry(at,0,loc,&centry);
	732	if (code) return 0;
	733	for (i=0;i<COSIZE;i++) {
	734	if (centry.entries[i] == aid) return 1;
	735	if (centry.entries[i] == 0) return 0;
	736	}
	737	loc = centry.next;
	738	}
	739	}
	740	return 0; /* actually, should never get here */
	741	}