static
char *_XGetAtomName(
Display *dpy,
Atom atom)
{
xResourceReq *req;
char *name;
register Entry *table;
register int idx;
register Entry e;
if (dpy->atoms) {
table = dpy->atoms->table;
for (idx = TABLESIZE; --idx >= 0; ) {
if ((e = *table++) && (e->atom == atom)) {
idx = strlen(EntryName(e)) + 1;
if ((name = (char *)Xmalloc(idx)))
strcpy(name, EntryName(e));
return name;
}
}
}
GetResReq(GetAtomName, atom, req);
return (char *)NULL;
}
void
badEntry(afs_int32 e, afs_int32 i)
{
int offset;
struct kaentry entry;
offset = i * sizeof(struct kaentry) + sizeof(struct kaheader);
readDB(offset, &entry, sizeof(entry));
fprintf(stderr, "Entry %d, %s, hash index %d, is bad: [", i,
EntryName(&entry), NameHash(&entry));
if (e & 0x1)
fprintf(stderr, " UserEntry");
if (e & 0x2)
fprintf(stderr, " FreeEntry");
if (e & 0x4)
fprintf(stderr, " OldkeysEntry");
if (e & 0x8)
fprintf(stderr, " PastEOF");
if (!(e & 0xf))
fprintf(stderr, " <NULL>");
fprintf(stderr, " ] [");
if (e & 0x10)
fprintf(stderr, " UserChain");
if (e & 0x20)
fprintf(stderr, " FreeChain");
if (e & 0x40)
fprintf(stderr, " OldkeysChain");
if (!(e & 0xf0))
fprintf(stderr, " <NULL>");
fprintf(stderr, " ]\n");
}
void
RebuildEntry(struct kaentry *entryp)
{
char key[33];
char flags[128];
char Time[50];
/* Special entries are not rebuilt */
if (entryp->flags & KAFSPECIAL)
return;
fprintf(out, "create -name %s", EntryName(entryp));
ka_ConvertBytes(key, sizeof(key), (char *)&entryp->key,
sizeof(entryp->key));
fprintf(out, " -initial_password foo\n");
strcpy(flags, "");
if (entryp->flags & KAFADMIN)
strcat(flags, "+ADMIN");
if (entryp->flags & KAFNOTGS)
strcat(flags, "+NOTGS");
if (entryp->flags & KAFNOSEAL)
strcat(flags, "+NOSEAL");
if (entryp->flags & KAFNOCPW)
strcat(flags, "+NOCPW");
fprintf(out, "setfields -name %s", principal);
if (strcmp(flags, "") != 0)
fprintf(out, " -flags %s", &flags[1]);
if (entryp->user_expiration != 0xffffffff) {
time_t tt = entryp->user_expiration;
strftime(Time, 50, "%m/%d/%Y %H:%M",localtime(&tt));
fprintf(out, " -expiration '%s'", Time);
}
fprintf(out, " -lifetime %u", entryp->max_ticket_lifetime);
if (entryp->misc_auth_bytes[EXPIRES])
fprintf(out, " -pwexpires %u", entryp->misc_auth_bytes[EXPIRES]);
if (entryp->pwsums[0] || entryp->pwsums[1])
fprintf(out, " -reuse no");
if (entryp->misc_auth_bytes[ATTEMPTS])
fprintf(out, " -attempts %u", entryp->misc_auth_bytes[ATTEMPTS]);
if (entryp->misc_auth_bytes[LOCKTIME])
fprintf(out, " -locktime %d",
(int)(entryp->misc_auth_bytes[LOCKTIME] * 8.5));
fprintf(out, "\n");
fprintf(out, "setkey -name %s -new_key %s -kvno %d\n", principal, key,
ntohl(entryp->key_version));
}
static int
WorkerBee(struct cmd_syndesc *as, void *arock)
{
afs_int32 code;
char *dbFile;
char *outFile;
afs_int32 index;
struct stat info;
struct kaheader header;
int nentries, i, j, count;
int *entrys;
struct kaentry entry;
dbFile = as->parms[0].items->data; /* -database */
listuheader = (as->parms[1].items ? 1 : 0); /* -uheader */
listkheader = (as->parms[2].items ? 1 : 0); /* -kheader */
listentries = (as->parms[3].items ? 1 : 0); /* -entries */
verbose = (as->parms[4].items ? 1 : 0); /* -verbose */
outFile = (as->parms[5].items ? as->parms[5].items->data : NULL); /* -rebuild */
if (outFile) {
out = fopen(outFile, "w");
if (!out) {
afs_com_err(whoami, errno, "opening output file %s", outFile);
exit(7);
}
} else
out = 0;
fd = open(dbFile, O_RDONLY, 0);
if (fd < 0) {
afs_com_err(whoami, errno, "opening database file %s", dbFile);
exit(6);
}
code = fstat(fd, &info);
if (code) {
afs_com_err(whoami, errno, "stat'ing file %s", dbFile);
exit(6);
}
if ((info.st_size - UBIK_HEADERSIZE) % UBIK_BUFFERSIZE)
fprintf(stderr,
"DATABASE SIZE INCONSISTENT: was %d, should be (n*%d + %d), for integral n\n",
(int) info.st_size, UBIK_BUFFERSIZE, UBIK_HEADERSIZE);
readUbikHeader();
readDB(0, &header, sizeof(header));
code = CheckHeader(&header);
if (listkheader)
PrintHeader(&header);
nentries =
(info.st_size -
(UBIK_HEADERSIZE + header.headerSize)) / sizeof(struct kaentry);
entrys = calloc(nentries, sizeof(int));
for (i = 0, index = sizeof(header); i < nentries;
i++, index += sizeof(struct kaentry)) {
readDB(index, &entry, sizeof(entry));
if (index >= header.eofPtr) {
entrys[i] |= 0x8;
} else if (listentries) {
PrintEntry(index, &entry);
}
if (entry.flags & KAFNORMAL) {
entrys[i] |= 0x1; /* user entry */
if (strlen(entry.userID.name) == 0) {
if (verbose)
printf("Entry %d has zero length name\n", i);
continue;
}
if (!DES_check_key_parity(ktc_to_cblock(&entry.key))
|| DES_is_weak_key(ktc_to_cblock(&entry.key))) {
fprintf(stderr, "Entry %d, %s, has bad key\n", i,
EntryName(&entry));
continue;
}
if (out) {
RebuildEntry(&entry);
}
} else if (entry.flags & KAFFREE) {
entrys[i] |= 0x2; /* free entry */
} else if (entry.flags & KAFOLDKEYS) {
entrys[i] |= 0x4; /* old keys block */
/* Should check the structure of the oldkeys block? */
} else {
if (index < header.eofPtr) {
fprintf(stderr, "Entry %d is unrecognizable\n", i);
}
}
}
/* Follow the hash chains */
for (j = 0; j < HASHSIZE; j++) {
for (index = header.nameHash[j]; index; index = entry.next) {
readDB(index, &entry, sizeof(entry));
/* check to see if the name is hashed correctly */
i = NameHash(&entry);
if (i != j) {
fprintf(stderr,
"Entry %" AFS_SIZET_FMT ", %s, found in hash chain %d (should be %d)\n",
((index -
sizeof(struct kaheader)) / sizeof(struct kaentry)),
EntryName(&entry), j, i);
}
/* Is it on another hash chain or circular hash chain */
i = (index - header.headerSize) / sizeof(entry);
if (entrys[i] & 0x10) {
fprintf(stderr,
"Entry %d, %s, hash index %d, was found on another hash chain\n",
i, EntryName(&entry), j);
if (entry.next)
fprintf(stderr, "Skipping rest of hash chain %d\n", j);
else
fprintf(stderr, "No next entry in hash chain %d\n", j);
code++;
break;
}
entrys[i] |= 0x10; /* On hash chain */
}
}
/* Follow the free pointers */
count = 0;
for (index = header.freePtr; index; index = entry.next) {
readDB(index, &entry, sizeof(entry));
/* Is it on another chain or circular free chain */
i = (index - header.headerSize) / sizeof(entry);
if (entrys[i] & 0x20) {
fprintf(stderr, "Entry %d, %s, already found on free chain\n", i,
EntryName(&entry));
fprintf(stderr, "Skipping rest of free chain\n");
code++;
break;
}
entrys[i] |= 0x20; /* On free chain */
count++;
}
if (verbose)
printf("Found %d free entries\n", count);
/* Follow the oldkey blocks */
count = 0;
for (index = header.kvnoPtr; index; index = entry.next) {
readDB(index, &entry, sizeof(entry));
/* Is it on another chain or circular free chain */
i = (index - header.headerSize) / sizeof(entry);
if (entrys[i] & 0x40) {
fprintf(stderr, "Entry %d, %s, already found on olkeys chain\n",
i, EntryName(&entry));
fprintf(stderr, "Skipping rest of oldkeys chain\n");
code++;
break;
}
entrys[i] |= 0x40; /* On free chain */
count++;
}
if (verbose)
printf("Found %d oldkey blocks\n", count);
/* Now recheck all the blocks and see if they are allocated correctly
* 0x1 --> User Entry 0x10 --> On hash chain
* 0x2 --> Free Entry 0x20 --> On Free chain
* 0x4 --> OldKeys Entry 0x40 --> On Oldkeys chain
* 0x8 --> Past EOF
*/
for (i = 0; i < nentries; i++) {
j = entrys[i];
if (j & 0x1) { /* user entry */
if (!(j & 0x10))
badEntry(j, i); /* on hash chain? */
else if (j & 0xee)
badEntry(j, i); /* anything else? */
} else if (j & 0x2) { /* free entry */
if (!(j & 0x20))
badEntry(j, i); /* on free chain? */
else if (j & 0xdd)
badEntry(j, i); /* anything else? */
} else if (j & 0x4) { /* oldkeys entry */
if (!(j & 0x40))
badEntry(j, i); /* on oldkeys chain? */
else if (j & 0xbb)
badEntry(j, i); /* anything else? */
} else if (j & 0x8) { /* past eof */
if (j & 0xf7)
badEntry(j, i); /* anything else? */
} else
badEntry(j, i); /* anything else? */
}
exit(code != 0);
}
