void *ds_hash_iter_next(ds_hash_iter_t *i)
{
void *result = NULL;
ds_hash_t *t;
CODA_ASSERT(DS_HASH_ITER_VALID(i));
if (i->curiter != NULL) {
result = ds_list_iter_next(i->curiter);
if (result == NULL) {
t = i->table;
CODA_ASSERT(DS_HASH_VALID(t));
ds_list_iter_destroy(i->curiter);
i->curiter = NULL;
i->curbucket++;
while (i->curbucket < t->nbuckets) {
if (ds_list_count((t->buckets)[i->curbucket]) > 0) {
i->curiter =
ds_list_iter_create((t->buckets)[i->curbucket]);
result = ds_list_iter_next(i->curiter);
break;
}
i->curbucket++;
}
}
}
return result;
}
void PDB_removeFromGroup(int32_t id, int32_t groupId)
{
PDB_HANDLE h;
PDB_profile r;
/* sanity check arguments (groupId must be < 0) */
CODA_ASSERT(PDB_ISGROUP(groupId) && (id != 0));
h = PDB_db_open(O_RDWR);
/* remove id from the group's member list */
PDB_readProfile(h, groupId, &r);
CODA_ASSERT(r.id != 0);
pdb_array_del(&(r.groups_or_members), id);
PDB_writeProfile(h, &r);
PDB_freeProfile(&r);
/* remove groupId from user's member_of list */
PDB_readProfile(h, id, &r);
CODA_ASSERT(r.id != 0);
pdb_array_del(&(r.member_of), groupId);
PDB_updateCps(h, &r);
PDB_freeProfile(&r);
PDB_db_close(h);
}
void
ds_list_iter_destroy(ds_list_iter_t *i) {
ds_list_iter_t *trail;
ds_list_iter_t *cur;
ds_list_t *l;
CODA_ASSERT(DS_LIST_ITER_VALID(i));
l = i->list;
CODA_ASSERT(DS_LIST_VALID(l));
trail = NULL;
cur = l->iter_list;
while (cur != NULL) {
if (cur == i) break;
trail = cur;
cur = cur->next_iter;
}
CODA_ASSERT(cur != NULL);
if (trail == NULL)
l->iter_list = cur->next_iter;
else
trail->next_iter = cur->next_iter;
i->magic = 0;
i->list = NULL;
i->next_elt = NULL;
i->next_iter = NULL;
FREE(i);
}
int
main(int argc, char **argv)
{
struct DiskPartition *dp;
Inode testcreate;
Device devno;
int fd, count;
char *buff="This is a test string";
Partent pe, pf;
FILE *vtab;
int rc;
char host[256];
/* write a vicetab file */
hostname(host);
/* set up a simple partition & ftree partition */
/* they must be on different diskpartions */
pe = Partent_create(host, "simpled", "simple","");
pf = Partent_create(host, "/tmp/f", "ftree","width=8,depth=5");
unlink("vicetab");
rc = creat("vicetab", 00600);
CODA_ASSERT( rc != -1 );
vtab = Partent_set("vicetab", "r+");
rc = Partent_add(vtab, pe);
CODA_ASSERT( rc == 0 );
rc = Partent_add(vtab, pf);
CODA_ASSERT( rc == 0 );
Partent_free(&pe);
Partent_free(&pf);
Partent_end(vtab);
printf("Make sure to run makeftree vicetab /tmp/f before continuing!\n");
return 0;
}
void *
ds_list_last(ds_list_t *l) {
CODA_ASSERT(DS_LIST_VALID(l));
if (l->tail) {
CODA_ASSERT(DS_LIST_ELT_VALID(l->tail));
return l->tail->contents;
} else {
return NULL;
}
}
void *
ds_list_first(ds_list_t *l) {
CODA_ASSERT(DS_LIST_VALID(l));
if (l->head) {
CODA_ASSERT(DS_LIST_ELT_VALID(l->head));
return l->head->contents;
} else {
return NULL;
}
}
void *
ds_list_member(ds_list_t *l, void *e) {
ds_list_elt_t *elt;
CODA_ASSERT(DS_LIST_VALID(l));
CODA_ASSERT(e != NULL);
elt = ds_list_find_member(l,e);
if (elt)
return elt->contents;
else
return NULL;
}
void *
ds_list_append(ds_list_t *l, void *i) {
ds_list_elt_t *result;
CODA_ASSERT(DS_LIST_VALID(l));
CODA_ASSERT(i != NULL);
/* test for duplicates */
if (!l->has_dups)
if (ds_list_find_member(l,i))
return NULL;
result = ds_list_elt_create(i);
/* Is the list empty? */
if (l->head == NULL) {
l->head = result;
l->tail = result;
} else {
/* Is the list unsorted? */
if (l->cmpfn == NULL) {
CODA_ASSERT(DS_LIST_ELT_VALID(l->tail));
result->p = l->tail;
l->tail->n = result;
l->tail = result;
} else {
/* Walk backwards, checking for the insertion point */
ds_list_elt_t *cur = l->tail;
while (cur != NULL
&& DS_LIST_ELT_VALID(cur)
&& l->cmpfn(result->contents,cur->contents) < 0)
{
cur = cur->p;
}
if (cur == NULL) { /* new element at beginning of list */
result->n = l->head;
l->head->p = result;
l->head = result;
} else {
CODA_ASSERT(DS_LIST_ELT_VALID(cur));
result->p = cur;
result->n = cur->n;
result->p->n = result;
if (result->n)
result->n->p = result;
else /* new element at end of list */
l->tail = result;
}
}
}
l->count++;
return i;
}
/* Initializes the access list package. Version should always be AL_VERSION.
This routine may be called many times -- it will perform reinitialization
each time. Synchronization code here guarantees that the .pdb and .pcf
files are mutually consistent, provided all updaters follow the locking
discipline. */
int AL_Initialize(IN const char *Version)
{
LogMsg(1,AL_DebugLevel,stdout,"AL_Initialize(%s)", Version);
LogMsg(4,AL_DebugLevel,stdout,
"Library version: '%s'\tHeader version: '%s'\t",
AL_VERSION,Version);
CODA_ASSERT(strcmp(Version, AL_VERSION) == 0);
CODA_ASSERT(PDB_db_exists());
return(0);
}
void PDB_deleteGroup(int32_t id)
{
PDB_HANDLE h;
PDB_profile r,p;
int32_t nextid;
pdb_array_off off;
h=PDB_db_open(O_RDWR);
PDB_readProfile(h, id, &r);
if(r.id == 0){
PDB_db_close(h);
return;
}
PDB_deleteProfile(h, &r);
/* remove from owner's list */
PDB_readProfile(h, r.owner_id, &p);
CODA_ASSERT(p.id != 0);
pdb_array_del(&(p.groups_or_members), id);
PDB_writeProfile(h, &p);
PDB_freeProfile(&p);
/* remove from groups if memberof */
nextid = pdb_array_head(&(r.member_of), &off);
while(nextid != 0){
PDB_readProfile(h, nextid, &p);
CODA_ASSERT(p.id == 0);
pdb_array_del(&(p.groups_or_members), id);
PDB_writeProfile(h, &p);
PDB_freeProfile(&p);
nextid = pdb_array_next(&(r.member_of), &off);
}
/* remove from members */
nextid = pdb_array_head(&(r.groups_or_members), &off);
while(nextid != 0){
PDB_readProfile(h, nextid, &p);
CODA_ASSERT(p.id != 0);
pdb_array_del(&(p.member_of), id);
PDB_updateCps(h, &p);
PDB_freeProfile(&p);
nextid = pdb_array_next(&(r.groups_or_members), &off);
}
/* Now fix the owner's cps */
PDB_readProfile(h, r.owner_id, &p);
CODA_ASSERT(p.id != 0);
PDB_updateCps(h, &p);
PDB_freeProfile(&p);
PDB_freeProfile(&r);
PDB_db_close(h);
}
void InitPW(int firsttime)
{
int fd, i;
struct stat stbuf;
char *fbuf;
char *admin = PRS_ADMINGROUP;
if (firsttime == PWFIRSTTIME) {
memcpy(FileKey, DefKey, RPC2_KEYSIZE);
/* moved from void main in auth2: */
PWLen = 100; /* length of PW array; this is an initial guess,
may increase below */
PWArray = (RPC2_EncryptionKey *)malloc(PWLen * RPC2_KEYSIZE);
CODA_ASSERT(PWArray != NULL);
}
/* now back to the old InitPW */
/* Reads in contents of PWFile and builds a sorted list of passwords
in PWArray. Frees existing storage coor to PWArray.
*/
if (PWFile == NULL)
PWFile = strdup(vice_config_path("db/auth2.pw"));
if ((fd = open(PWFile, O_RDONLY, 0)) < 0 ||
myflock(fd, MYFLOCK_SH, MYFLOCK_BL) < 0 /* locking is superstitious */
|| fstat(fd, &stbuf)) {
perror(PWFile);
abort();
}
/* make sure the auth2.pw file is not world readable */
if (stbuf.st_mode & 077)
chmod(PWFile, 0600);
CODA_ASSERT((fbuf = (char *)malloc(1 + stbuf.st_size)) != NULL);
CODA_ASSERT(stbuf.st_size ==
read(fd, fbuf, stbuf.st_size)); /* entirefile */
PWTime = stbuf.st_mtime; /* time on file to check for changes */
fbuf[stbuf.st_size] = 0; /* sentinel to stop sscanf() later */
/* and unlock the file */
myflock(fd, MYFLOCK_UN, MYFLOCK_BL);
close(fd);
CODA_ASSERT(AL_NameToId(admin, &AdminID) == 0);
for (i = 0; i < RPC2_KEYSIZE; i++)
DeleteKey[i] = 0xff;
BuildPWArray(fbuf);
free(fbuf);
}
void
ds_list_destroy(ds_list_t *l) {
CODA_ASSERT(DS_LIST_VALID(l));
/* Either the list must be unsafe, or there must be nothing in it. */
CODA_ASSERT(!(l->is_safe) || (l->count == 0));
l->magic = 0;
l->cmpfn = NULL;
l->head = l->tail = NULL;
l->count = 0;
FREE(l);
}
void ds_hash_print(ds_hash_t *t, void (*printer)(void *))
{
int i;
CODA_ASSERT(DS_HASH_VALID(t));
CODA_ASSERT(printer != NULL);
for (i = 0; i < t->nbuckets; i++) {
if (DS_HASH_DEBUG) {
fprintf(stderr, "**** bucket %d\n", i);
}
ds_list_print((t->buckets)[i], TRUE, printer);
}
}
static void BuildPWArray(char *fileBuf)
{
/* fileBuf: pointer to in-core contents of PWFile parses the file buffer
* and builds up PWArray; sets PWLen and PWCount */
char *nextline, *kk;
int thisid, i;
RPC2_EncryptionKey thiskey;
char holder[3];
PWCount = 0; /* no of valid entries in PWArray */
memset((char *)PWArray, 0, PWLen * RPC2_KEYSIZE);
nextline = fileBuf; /* index into start of next line in fbuf */
while (TRUE) {
if (strchr(nextline, '\t') == NULL)
break;
thisid = atoi(nextline);
if (thisid < 0)
goto nextline;
CODA_ASSERT((kk = strchr(nextline, '\t')) != NULL);
kk++;
for (i = 0; i < RPC2_KEYSIZE; i++) {
int x;
holder[0] = *(kk++);
holder[1] = *(kk++);
holder[2] = '\0';
CODA_ASSERT(1 == sscanf(holder, "%2x", &x));
thiskey[i] = x;
}
if (AuthDebugLevel) {
printf("%d\t", thisid);
for (i = 0; i < RPC2_KEYSIZE; i++)
printf("%02x", thiskey[i]);
printf("\n");
fflush(stdout);
}
if (thisid >= PWLen)
EnlargePW(2 * thisid);
/*factor of 2 to prevent frequent realloc() */
memcpy(PWArray[thisid], thiskey, RPC2_KEYSIZE);
PWCount++;
nextline:
CODA_ASSERT((nextline = strchr(nextline, '\n')) != NULL);
nextline++; /* safe, since fileBuf is NULL-terminated */
}
}
void PDB_cloneUser(char *name, int32_t cloneid, int32_t *newId)
{
PDB_HANDLE h;
int32_t nextid, maxId, minGroupId;
PDB_profile r, p;
pdb_array_off off;
/* sanity check arguments */
CODA_ASSERT(name && (name[0] != '\0') && newId && (cloneid != 0));
/* MAKE SURE NO USER WITH THAT NAME ALREADY EXISTS */
CODA_ASSERT(PDB_nameInUse(name) == 0);
h=PDB_db_open(O_RDWR);
/* Read the profile we are cloning */
PDB_readProfile(h, cloneid, &r);
CODA_ASSERT(r.id != 0);
/* add one to the highest user id -- that's our new user's id */
PDB_db_maxids(h, &maxId, &minGroupId);
r.id = maxId + 1;
PDB_db_update_maxids(h, r.id, minGroupId, PDB_MAXID_SET);
/* CREATE A NEW USER WITH SPECIFIED NAME, ALL OTHER FIELDS EMPTY */
/* create the new user's profile */
free(r.name);
r.name = strdup(name);
/* MAKE THE NEW USER A MEMBER OF THE SAME GROUPS AS THE OLD USER */
nextid = pdb_array_head(&(r.member_of), &off);
while(nextid != 0){
PDB_readProfile(h, nextid, &p);
CODA_ASSERT(r.id != 0);
pdb_array_add(&(p.groups_or_members), r.id);
PDB_writeProfile(h, &p);
PDB_freeProfile(&p);
nextid = pdb_array_next(&(r.member_of), &off);
}
/* updateCps also writes the new user's information to the databases */
PDB_updateCps(h, &r);
PDB_db_close(h);
*newId = r.id;
PDB_freeProfile(&r);
}
/* get boolean (starting with YyNn; loop forever */
int Parser_getbool(const char *prompt, int deft)
{
int result = 0;
char *line;
int size = strlen(prompt) + 8;
char *theprompt = malloc(size);
CODA_ASSERT(theprompt);
fflush(stdout);
if ( deft != 0 && deft != 1 ) {
fprintf(stderr, "Error: Parser_getbool given bad default (%d).\n",
deft);
CODA_ASSERT ( 0 );
}
sprintf(theprompt, "%s [%s]: ", prompt, (deft==0)? "N" : "Y");
do {
line = NULL;
line = readline(theprompt);
if ( line == NULL ) {
result = deft;
break;
}
if ( *line == '\0' ) {
result = deft;
break;
}
if ( *line == 'y' || *line == 'Y' ) {
result = 1;
break;
}
if ( *line == 'n' || *line == 'N' ) {
result = 0;
break;
}
if ( line )
free(line);
fprintf(stdout, "Invalid string. Must start with yY or nN\n");
fflush(stdout);
} while ( 1 );
if ( line )
free(line);
if ( theprompt )
free(theprompt);
return result;
}
void PDB_createGroup(char *name, int32_t owner, int32_t *newGroupId)
{
PDB_HANDLE h;
int32_t maxId, minGroupId;
PDB_profile r, p;
/* sanity check arguments */
CODA_ASSERT(name && (name[0] != '\0') && newGroupId
&& PDB_ISUSER(owner));
/* MAKE SURE NO GROUP WITH THAT NAME ALREADY EXISTS */
CODA_ASSERT(PDB_nameInUse(name) == 0);
h=PDB_db_open(O_RDWR);
PDB_readProfile(h, owner, &p);
CODA_ASSERT(p.id != 0);
/* subtract one from the lowest group id -- that's new group's id */
PDB_db_maxids(h, &maxId, &minGroupId);
r.id = minGroupId - 1;
*newGroupId = r.id;
PDB_db_update_maxids(h, maxId, r.id, PDB_MAXID_SET);
/* CREATE A NEW GROUP WITH SPECIFIED NAME AND OWNER */
/* create the new group's profile */
r.name = strdup(name);
r.owner_id = owner;
r.owner_name = strdup(p.name);
pdb_array_init(&(r.member_of));
pdb_array_init(&(r.cps));
pdb_array_add(&(r.cps),r.id);
pdb_array_init(&(r.groups_or_members));
pdb_array_add(&(r.groups_or_members),owner);
/* write the new group's information to the databases */
PDB_writeProfile(h, &r);
/* add the new group's id to owner's groups_or_members list */
pdb_array_add(&(p.groups_or_members), r.id);
pdb_array_add(&(p.member_of), r.id);
pdb_array_add(&(p.cps), r.id);
PDB_writeProfile(h, &p);
PDB_freeProfile(&r);
PDB_freeProfile(&p);
PDB_db_close(h);
}
void PDB_deleteProfile(PDB_HANDLE h, PDB_profile *r)
{
/* sanity check arguments */
CODA_ASSERT(r && h);
PDB_db_delete(h, r->id, r->name);
}
void PDB_deleteUser(int32_t id)
{
PDB_HANDLE h;
PDB_profile r,p;
int32_t nextid;
pdb_array_off off;
h=PDB_db_open(O_RDWR);
PDB_readProfile(h, id, &r);
if(r.id == 0){
PDB_db_close(h);
return;
}
PDB_deleteProfile(h, &r);
/* Remove from groups */
nextid = pdb_array_head(&(r.member_of), &off);
while(nextid != 0){
PDB_readProfile(h, nextid, &p);
CODA_ASSERT(p.id != 0);
pdb_array_del(&(p.groups_or_members), id);
PDB_writeProfile(h, &p);
PDB_freeProfile(&p);
nextid = pdb_array_next(&(r.member_of), &off);
}
PDB_freeProfile(&r);
PDB_db_close(h);
}
void FID_VFid2DFid(const struct ViceFid *vf, DirFid *df)
{
CODA_ASSERT( vf && df );
df->Vnode = vf->Vnode;
df->Unique = vf->Unique;
}
char *Parser_getstr(const char *prompt, const char *deft, char *res,
size_t len)
{
char *line = NULL;
int size = strlen(prompt) + strlen(deft) + 8;
char *theprompt;
theprompt = malloc(size);
CODA_ASSERT(theprompt);
sprintf(theprompt, "%s [%s]: ", prompt, deft);
line = readline(theprompt);
free(theprompt);
if ( line == NULL || *line == '\0' ) {
strncpy(res, deft, len);
} else {
strncpy(res, line, len);
}
if ( line ) {
free(line);
return res;
} else {
return NULL;
}
}
static ds_list_elt_t *
ds_list_find_member(ds_list_t *l, void *e) {
ds_list_elt_t *cur;
bool found = FALSE;
/* calling functions must test validity of l */
cur = l->head;
while (!found && cur != NULL) {
CODA_ASSERT(DS_LIST_ELT_VALID(cur));
/* test is different for sorted, unsorted lists */
if (l->cmpfn != NULL) {
if (l->cmpfn(e,cur->contents) == 0) {
found = TRUE;
} else {
cur = cur->n;
}
} else {
if (e == cur->contents) {
found = TRUE;
} else {
cur = cur->n;
}
}
}
return cur;
}
void *
ds_list_iter_next(ds_list_iter_t *i) {
ds_list_t *l;
void *result = NULL;
CODA_ASSERT(DS_LIST_ITER_VALID(i));
l = i->list;
CODA_ASSERT(DS_LIST_VALID(l));
if (i->next_elt) {
CODA_ASSERT(DS_LIST_ELT_VALID(i->next_elt));
result = i->next_elt->contents;
i->next_elt = i->next_elt->n;
}
return result;
}
void FID_Int2DFid(DirFid *fid, const int vnode, const int unique)
{
CODA_ASSERT(fid);
fid->Vnode = vnode;
fid->Unique = unique;
return;
}
static
void
ds_list_elt_destroy(ds_list_elt_t *e) {
CODA_ASSERT(DS_LIST_ELT_VALID(e));
e->p = e->n = NULL;
e->contents = NULL;
e->magic = 0;
FREE(e);
}
void *ds_hash_member(ds_hash_t *t, void *e)
{
int bucket;
ds_list_t *chain;
CODA_ASSERT(DS_HASH_VALID(t));
bucket = (t->hfn(e)) % t->nbuckets;
chain = (t->buckets)[bucket];
return (ds_list_member(chain, e));
}
void ds_hash_iter_destroy(ds_hash_iter_t *i)
{
CODA_ASSERT(DS_HASH_ITER_VALID(i));
if (i->curiter)
ds_list_iter_destroy(i->curiter);
i->magic = 0;
i->table = NULL;
i->curbucket = 0;
i->curiter = NULL;
FREE(i->curiter);
}
static void
ds_list_advance_iters(ds_list_elt_t *dropping,
ds_list_iter_t *iter) {
while (iter != NULL) {
CODA_ASSERT(DS_LIST_ITER_VALID(iter));
if (iter->next_elt == dropping)
iter->next_elt = iter->next_elt->n;
iter = iter->next_iter;
}
}
void PDB_readProfile_byname(PDB_HANDLE h, const char *name, PDB_profile *r)
{
void *data;
size_t size;
/* sanity check arguments */
CODA_ASSERT(r && h);
PDB_db_read(h, 0, name, &data, &size);
pdb_unpack(r, data, size);
}
void
ds_list_print(ds_list_t *l, bool forward, void (*printer)(void *)) {
ds_list_elt_t *cur;
CODA_ASSERT(DS_LIST_VALID(l));
CODA_ASSERT(printer != NULL);
if (forward) {
cur = l->head;
while (cur != NULL) {
printer(cur->contents);
cur = cur->n;
}
} else {
cur = l->tail;
while (cur != NULL) {
printer(cur->contents);
cur = cur->p;
}
}
}
