/*
* Copyright 2000, International Business Machines Corporation and others.
* All Rights Reserved.
- *
+ *
* This software has been released under the terms of the IBM Public
* License. For details, see the LICENSE file in the top-level source
* directory or online at http://www.openafs.org/dl/license10.html
#include <afsconfig.h>
#include <afs/param.h>
-RCSID
- ("$Header$");
+#include <roken.h>
-#include <sys/types.h>
-#ifdef AFS_NT40_ENV
-#include <winsock2.h>
-#else
-#include <netinet/in.h>
-#endif
-#include <string.h>
#include <ubik.h>
#include <rx/xdr.h>
#include <rx/rx.h>
#include <afs/afsutil.h>
+
#include "kauth.h"
#include "kautils.h"
#include "kaserver.h"
+#if !defined(offsetof)
+#include <stddef.h> /* for definition of offsetof() */
+#endif
+
extern Date cheaderReadTime; /* time cheader last read in */
-#define set_header_word(tt,field,value) kawrite ((tt), ((char *)&(cheader.field) - (char *)&cheader), ((cheader.field = (value)), (char *)&(cheader.field)), sizeof(afs_int32))
+#define set_header_word(tt,field,value) \
+ ( \
+ (cheader.field) = (value), \
+ kawrite((tt), ((char *)&(cheader.field) - (char *)&cheader), \
+ (char *)&(cheader.field), sizeof(afs_int32)) \
+ )
-#define inc_header_word(tt,field) kawrite ((tt), ((char *)&(cheader.field) - (char *)&cheader), ((cheader.field = (htonl(ntohl(cheader.field)+1))), (char *)&(cheader.field)), sizeof(afs_int32))
+#define inc_header_word(tt,field) kawrite ((tt), (offsetof(struct kaheader, field)), ((cheader.field = (htonl(ntohl(cheader.field)+1))), (char *)&(cheader.field)), sizeof(afs_int32))
-static int index_OK();
+static int index_OK(afs_int32);
afs_int32
-NameHash(aname, ainstance)
- register char *aname;
- register char *ainstance;
+NameHash(char *aname, char *ainstance)
{
- register unsigned int hash;
- register int i;
+ unsigned int hash;
+ int i;
/* stolen directly from the HashString function in the vol package */
hash = 0;
/* package up seek and write into one procedure for ease of use */
afs_int32
-kawrite(tt, pos, buff, len)
- struct ubik_trans *tt;
- afs_int32 pos;
- char *buff;
- afs_int32 len;
+kawrite(struct ubik_trans *tt, afs_int32 pos, char *buff, afs_int32 len)
{
afs_int32 code;
/* same thing for read */
afs_int32
-karead(tt, pos, buff, len)
- struct ubik_trans *tt;
- afs_int32 pos;
- char *buff;
- afs_int32 len;
+karead(struct ubik_trans *tt, afs_int32 pos, char *buff, afs_int32 len)
{
afs_int32 code;
return code;
}
-static struct Lock cheader_lock;
static struct Lock keycache_lock;
static int maxCachedKeys;
static afs_int32 maxKeyLifetime;
static int dbfixup = 0;
-init_kadatabase(initFlags)
- int initFlags; /* same as init_kaprocs (see which) */
+void
+init_kadatabase(int initFlags)
{
- Lock_Init(&cheader_lock);
Lock_Init(&keycache_lock);
maxCachedKeys = 10;
- keyCache =
- (struct cachedKey *)malloc(maxCachedKeys * sizeof(struct cachedKey));
+ keyCache = malloc(maxCachedKeys * sizeof(struct cachedKey));
keyCacheVersion = 0;
if (initFlags & 4) {
maxKeyLifetime = 90;
/* check that the database has been initialized. Be careful to fail in a safe
manner, to avoid bogusly reinitializing the db. */
-
-afs_int32
-CheckInit(at, db_init)
- struct ubik_trans *at;
- int (*db_init) (); /* procedure to call if rebuilding DB */
+/**
+ * reads in db cache from ubik.
+ *
+ * @param[in] ut ubik transaction
+ * @param[in] rock opaque pointer to an int (*) (struct ubik_trans *), which
+ * will be called on rebuilding the database (or NULL to not
+ * rebuild the db)
+ *
+ * @return operation status
+ * @retval 0 success
+ */
+static afs_int32
+UpdateCache(struct ubik_trans *at, void *rock)
{
- register afs_int32 code;
+ int (*db_init) (struct ubik_trans *) = rock;
+ afs_int32 code;
afs_int32 iversion;
afs_int32 tversion;
- /* Don't read header if not necessary */
- if (!ubik_CacheUpdate(at))
- return 0;
-
- ObtainWriteLock(&cheader_lock);
if ((code = karead(at, 0, (char *)&iversion, sizeof(iversion)))
|| (code =
karead(at, sizeof(cheader) - sizeof(afs_int32), (char *)&tversion,
code = KAIO;
}
}
- ReleaseWriteLock(&cheader_lock);
if (code == 0)
return 0;
return db_init(at); /* initialize the db */
}
+afs_int32
+CheckInit(struct ubik_trans *at,
+ int (*db_init) (struct ubik_trans *)) /* procedure to call if rebuilding DB */
+{
+ return ubik_CheckCache(at, UpdateCache, db_init);
+}
+
/* Allocate a free block of storage for entry, returning address of a new
zeroed entry. If zero is returned, a Ubik I/O error can be assumed. */
afs_int32
-AllocBlock(at, tentry)
- register struct ubik_trans *at;
- struct kaentry *tentry;
+AllocBlock(struct ubik_trans *at, struct kaentry *tentry)
{
- register afs_int32 code;
+ afs_int32 code;
afs_int32 temp;
if (cheader.freePtr) {
Returns zero for success or an error code on failure. */
afs_int32
-FreeBlock(at, index)
- struct ubik_trans *at;
- afs_int32 index;
+FreeBlock(struct ubik_trans *at, afs_int32 index)
{
struct kaentry tentry;
int code;
returned. */
afs_int32
-FindBlock(at, aname, ainstance, toP, tentry)
- struct ubik_trans *at;
- char *aname;
- char *ainstance;
- afs_int32 *toP;
- struct kaentry *tentry;
+FindBlock(struct ubik_trans *at, char *aname, char *ainstance, afs_int32 *toP,
+ struct kaentry *tentry)
{
- register afs_int32 i, code;
- register afs_int32 to;
+ afs_int32 i, code;
+ afs_int32 to;
*toP = 0;
i = NameHash(aname, ainstance);
returns zero if there were no errors. */
afs_int32
-ThreadBlock(at, index, tentry)
- struct ubik_trans *at;
- afs_int32 index;
- struct kaentry *tentry;
+ThreadBlock(struct ubik_trans *at, afs_int32 index,
+ struct kaentry *tentry)
{
int code;
int hi; /* hash index */
error code. */
afs_int32
-UnthreadBlock(at, aentry)
- struct ubik_trans *at;
- struct kaentry *aentry;
+UnthreadBlock(struct ubik_trans *at, struct kaentry *aentry)
{
- register afs_int32 i, code;
- register afs_int32 to;
+ afs_int32 i, code;
+ afs_int32 to;
afs_int32 lo;
struct kaentry tentry;
remaining count is negative. */
afs_int32
-NextBlock(at, index, tentry, remaining)
- struct ubik_trans *at;
- afs_int32 index;
- struct kaentry *tentry;
- afs_int32 *remaining;
+NextBlock(struct ubik_trans *at, afs_int32 index, struct kaentry *tentry,
+ afs_int32 *remaining)
{
int code;
afs_int32 last;
and pointer to the user entry. */
afs_int32
-ka_NewKey(tt, tentryaddr, tentry, key)
- struct ubik_trans *tt;
- afs_int32 tentryaddr;
- struct kaentry *tentry;
- struct ktc_encryptionKey *key;
+ka_NewKey(struct ubik_trans *tt, afs_int32 tentryaddr,
+ struct kaentry *tentry, struct ktc_encryptionKey *key)
{
struct kaOldKeys okeys; /* old keys block */
afs_int32 okeysaddr, nextaddr; /* offset of old keys block */
Date now = time(0);
afs_int32 newkeyver; /* new key version number */
afs_int32 newtotalkeyentries = 0, oldtotalkeyentries = 0, keyentries;
- int foundcurrentkey = 0, addednewkey = 0, modified;
+ int addednewkey = 0, modified;
+#ifdef AUTH_DBM_LOG
+ int foundcurrentkey = 0;
+#endif
es_Report("Newkey for %s.%s\n", tentry->userID.name,
tentry->userID.instance);
("Warning: Entry %s.%s contains more than one valid key: fixing\n",
tentry->userID.name, tentry->userID.instance));
}
-#endif
foundcurrentkey = 1;
+#endif
}
/* If we find an oldkey of the same version or
}
afs_int32
-ka_DelKey(tt, tentryaddr, tentry)
- struct ubik_trans *tt;
- afs_int32 tentryaddr;
- struct kaentry *tentry;
+ka_DelKey(struct ubik_trans *tt, afs_int32 tentryaddr,
+ struct kaentry *tentry)
{
int code;
struct kaOldKeys okeys; /* old keys block */
afs_int32 okeysaddr, nextaddr; /* offset of old keys block */
afs_int32 prevptr = 0;
- Date now = time(0);
es_Report("DelKey for %s.%s\n", tentry->userID.name,
tentry->userID.instance);
}
void
-ka_debugKeyCache(info)
- struct ka_debugInfo *info;
+ka_debugKeyCache(struct ka_debugInfo *info)
{
int i;
- memcpy(&info->cheader_lock, &cheader_lock, sizeof(info->cheader_lock));
+ /* cheader_lock no longer exists */
+ memset(&info->cheader_lock, 0, sizeof(info->cheader_lock));
memcpy(&info->keycache_lock, &keycache_lock, sizeof(info->keycache_lock));
info->kcVersion = keyCacheVersion;
/* Add a key to the key cache, expanding it if necessary. */
void
-ka_Encache(name, inst, kvno, key, superseded)
- char *name;
- char *inst;
- afs_int32 kvno;
- struct ktc_encryptionKey *key;
- Date superseded;
+ka_Encache(char *name, char *inst, afs_int32 kvno,
+ struct ktc_encryptionKey *key, Date superseded)
{
int i;
return;
}
/* i == maxCachedKeys */
- keyCache =
- (struct cachedKey *)realloc(keyCache,
- (maxCachedKeys *=
- 2) * sizeof(struct cachedKey));
+ keyCache = realloc(keyCache, (maxCachedKeys *=2)
+ * sizeof(struct cachedKey));
if (keyCache == 0) {
es_Report("Can't realloc keyCache! out of memory?");
exit(123);
with tt==0, since Rx can't call Ubik. */
afs_int32
-ka_LookupKvno(tt, name, inst, kvno, key)
- struct ubik_trans *tt;
- char *name;
- char *inst;
- afs_int32 kvno;
- struct ktc_encryptionKey *key;
+ka_LookupKvno(struct ubik_trans *tt, char *name, char *inst, afs_int32 kvno,
+ struct ktc_encryptionKey *key)
{
int i;
int code = 0;
/* Look up the primary key and key version for a principal. */
afs_int32
-ka_LookupKey(tt, name, inst, kvno, key)
- struct ubik_trans *tt;
- char *name;
- char *inst;
- afs_int32 *kvno; /* returned */
- struct ktc_encryptionKey *key; /* copied out */
+ka_LookupKey(struct ubik_trans *tt,
+ char *name,
+ char *inst,
+ afs_int32 *kvno, /* returned */
+ struct ktc_encryptionKey *key) /* copied out */
{
int i;
afs_int32 to;
Ubik needs to use Rx. */
afs_int32
-ka_FillKeyCache(tt)
- struct ubik_trans *tt;
+ka_FillKeyCache(struct ubik_trans *tt)
{
int nfound;
afs_int32 ko;
}
afs_int32
-update_admin_count(tt, delta)
- struct ubik_trans *tt;
- int delta;
+update_admin_count(struct ubik_trans *tt, int delta)
{
afs_int32 to;
afs_int32 code;
}
static int
-index_OK(index)
- afs_int32 index;
+index_OK(afs_int32 index)
{
if ((index < sizeof(cheader)) || (index >= ntohl(cheader.eofPtr))
|| ((index - sizeof(cheader)) % sizeof(kaentry) != 0))
#define LEGALCHARS ".ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"
int
-name_instance_legal(name, instance)
- char *name;
- char *instance;
+name_instance_legal(char *name, char *instance)
{
int code;
return code;
}
+#if 0
static int
-string_legal(str, map)
- char *str;
- char *map;
+string_legal(char *str, char *map)
{
int slen;
return 0; /* with trailing null must fit in data base */
return (slen == strspn(str, map)); /* strspn returns length(str) if all chars in map */
}
+#endif
+
git://git.openafs.org / openafs.git / blobdiff