mirror of
https://github.com/samba-team/samba.git
synced 2025-01-12 09:18:10 +03:00
convert tdb from u32 to uint32_t to match the current Samba trees
(This used to be ctdb commit 0dc754b7e8b0985a252885ed043949dfb7ea1ae1)
This commit is contained in:
Andrew Tridgell
parent
c2f84d6f4e
commit
67d2b14d90
@ -48,7 +48,7 @@ static struct tdb_errname {
|
||||
/* Error string for the last tdb error */
|
||||
const char *tdb_errorstr(struct tdb_context *tdb)
|
||||
{
|
||||
u32 i;
|
||||
uint32_t i;
|
||||
for (i = 0; i < sizeof(emap) / sizeof(struct tdb_errname); i++)
|
||||
if (tdb->ecode == emap[i].ecode)
|
||||
return emap[i].estring;
|
||||
|
||||
@ -99,9 +99,9 @@ static int tdb_write(struct tdb_context *tdb, tdb_off_t off,
|
||||
}
|
||||
|
||||
/* Endian conversion: we only ever deal with 4 byte quantities */
|
||||
void *tdb_convert(void *buf, u32 size)
|
||||
void *tdb_convert(void *buf, uint32_t size)
|
||||
{
|
||||
u32 i, *p = (u32 *)buf;
|
||||
uint32_t i, *p = (uint32_t *)buf;
|
||||
for (i = 0; i < size / 4; i++)
|
||||
p[i] = TDB_BYTEREV(p[i]);
|
||||
return buf;
|
||||
@ -142,17 +142,17 @@ static int tdb_read(struct tdb_context *tdb, tdb_off_t off, void *buf,
|
||||
do an unlocked scan of the hash table heads to find the next non-zero head. The value
|
||||
will then be confirmed with the lock held
|
||||
*/
|
||||
static void tdb_next_hash_chain(struct tdb_context *tdb, u32 *chain)
|
||||
static void tdb_next_hash_chain(struct tdb_context *tdb, uint32_t *chain)
|
||||
{
|
||||
u32 h = *chain;
|
||||
uint32_t h = *chain;
|
||||
if (tdb->map_ptr) {
|
||||
for (;h < tdb->header.hash_size;h++) {
|
||||
if (0 != *(u32 *)(TDB_HASH_TOP(h) + (unsigned char *)tdb->map_ptr)) {
|
||||
if (0 != *(uint32_t *)(TDB_HASH_TOP(h) + (unsigned char *)tdb->map_ptr)) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
u32 off=0;
|
||||
uint32_t off=0;
|
||||
for (;h < tdb->header.hash_size;h++) {
|
||||
if (tdb_ofs_read(tdb, TDB_HASH_TOP(h), &off) != 0 || off != 0) {
|
||||
break;
|
||||
|
||||
@ -526,7 +526,7 @@ int tdb_write_unlock_record(struct tdb_context *tdb, tdb_off_t off)
|
||||
int tdb_unlock_record(struct tdb_context *tdb, tdb_off_t off)
|
||||
{
|
||||
struct tdb_traverse_lock *i;
|
||||
u32 count = 0;
|
||||
uint32_t count = 0;
|
||||
|
||||
if (tdb->global_lock.count) {
|
||||
return 0;
|
||||
|
||||
@ -34,8 +34,8 @@ static struct tdb_context *tdbs = NULL;
|
||||
/* This is based on the hash algorithm from gdbm */
|
||||
static unsigned int default_tdb_hash(TDB_DATA *key)
|
||||
{
|
||||
u32 value; /* Used to compute the hash value. */
|
||||
u32 i; /* Used to cycle through random values. */
|
||||
uint32_t value; /* Used to compute the hash value. */
|
||||
uint32_t i; /* Used to cycle through random values. */
|
||||
|
||||
/* Set the initial value from the key size. */
|
||||
for (value = 0x238F13AF * key->dsize, i=0; i < key->dsize; i++)
|
||||
@ -137,7 +137,7 @@ struct tdb_context *tdb_open_ex(const char *name, int hash_size, int tdb_flags,
|
||||
struct stat st;
|
||||
int rev = 0, locked = 0;
|
||||
unsigned char *vp;
|
||||
u32 vertest;
|
||||
uint32_t vertest;
|
||||
unsigned v;
|
||||
|
||||
if (!(tdb = (struct tdb_context *)calloc(1, sizeof *tdb))) {
|
||||
@ -233,8 +233,8 @@ struct tdb_context *tdb_open_ex(const char *name, int hash_size, int tdb_flags,
|
||||
rev = (tdb->flags & TDB_CONVERT);
|
||||
}
|
||||
vp = (unsigned char *)&tdb->header.version;
|
||||
vertest = (((u32)vp[0]) << 24) | (((u32)vp[1]) << 16) |
|
||||
(((u32)vp[2]) << 8) | (u32)vp[3];
|
||||
vertest = (((uint32_t)vp[0]) << 24) | (((uint32_t)vp[1]) << 16) |
|
||||
(((uint32_t)vp[2]) << 8) | (uint32_t)vp[3];
|
||||
tdb->flags |= (vertest==TDB_VERSION) ? TDB_BIGENDIAN : 0;
|
||||
if (!rev)
|
||||
tdb->flags &= ~TDB_CONVERT;
|
||||
|
||||
@ -75,7 +75,7 @@ static int tdb_key_compare(TDB_DATA key, TDB_DATA data, void *private_data)
|
||||
|
||||
/* Returns 0 on fail. On success, return offset of record, and fills
|
||||
in rec */
|
||||
static tdb_off_t tdb_find(struct tdb_context *tdb, TDB_DATA key, u32 hash,
|
||||
static tdb_off_t tdb_find(struct tdb_context *tdb, TDB_DATA key, uint32_t hash,
|
||||
struct list_struct *r)
|
||||
{
|
||||
tdb_off_t rec_ptr;
|
||||
@ -102,10 +102,10 @@ static tdb_off_t tdb_find(struct tdb_context *tdb, TDB_DATA key, u32 hash,
|
||||
}
|
||||
|
||||
/* As tdb_find, but if you succeed, keep the lock */
|
||||
tdb_off_t tdb_find_lock_hash(struct tdb_context *tdb, TDB_DATA key, u32 hash, int locktype,
|
||||
tdb_off_t tdb_find_lock_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash, int locktype,
|
||||
struct list_struct *rec)
|
||||
{
|
||||
u32 rec_ptr;
|
||||
uint32_t rec_ptr;
|
||||
|
||||
if (tdb_lock(tdb, BUCKET(hash), locktype) == -1)
|
||||
return 0;
|
||||
@ -119,7 +119,7 @@ tdb_off_t tdb_find_lock_hash(struct tdb_context *tdb, TDB_DATA key, u32 hash, in
|
||||
is <= the old data size and the key exists.
|
||||
on failure return -1.
|
||||
*/
|
||||
static int tdb_update_hash(struct tdb_context *tdb, TDB_DATA key, u32 hash, TDB_DATA dbuf)
|
||||
static int tdb_update_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash, TDB_DATA dbuf)
|
||||
{
|
||||
struct list_struct rec;
|
||||
tdb_off_t rec_ptr;
|
||||
@ -158,7 +158,7 @@ TDB_DATA tdb_fetch(struct tdb_context *tdb, TDB_DATA key)
|
||||
tdb_off_t rec_ptr;
|
||||
struct list_struct rec;
|
||||
TDB_DATA ret;
|
||||
u32 hash;
|
||||
uint32_t hash;
|
||||
|
||||
/* find which hash bucket it is in */
|
||||
hash = tdb->hash_fn(&key);
|
||||
@ -196,7 +196,7 @@ int tdb_parse_record(struct tdb_context *tdb, TDB_DATA key,
|
||||
tdb_off_t rec_ptr;
|
||||
struct list_struct rec;
|
||||
int ret;
|
||||
u32 hash;
|
||||
uint32_t hash;
|
||||
|
||||
/* find which hash bucket it is in */
|
||||
hash = tdb->hash_fn(&key);
|
||||
@ -219,7 +219,7 @@ int tdb_parse_record(struct tdb_context *tdb, TDB_DATA key,
|
||||
this doesn't match the conventions in the rest of this module, but is
|
||||
compatible with gdbm
|
||||
*/
|
||||
static int tdb_exists_hash(struct tdb_context *tdb, TDB_DATA key, u32 hash)
|
||||
static int tdb_exists_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash)
|
||||
{
|
||||
struct list_struct rec;
|
||||
|
||||
@ -231,7 +231,7 @@ static int tdb_exists_hash(struct tdb_context *tdb, TDB_DATA key, u32 hash)
|
||||
|
||||
int tdb_exists(struct tdb_context *tdb, TDB_DATA key)
|
||||
{
|
||||
u32 hash = tdb->hash_fn(&key);
|
||||
uint32_t hash = tdb->hash_fn(&key);
|
||||
return tdb_exists_hash(tdb, key, hash);
|
||||
}
|
||||
|
||||
@ -271,7 +271,7 @@ int tdb_do_delete(struct tdb_context *tdb, tdb_off_t rec_ptr, struct list_struct
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int tdb_count_dead(struct tdb_context *tdb, u32 hash)
|
||||
static int tdb_count_dead(struct tdb_context *tdb, uint32_t hash)
|
||||
{
|
||||
int res = 0;
|
||||
tdb_off_t rec_ptr;
|
||||
@ -296,7 +296,7 @@ static int tdb_count_dead(struct tdb_context *tdb, u32 hash)
|
||||
/*
|
||||
* Purge all DEAD records from a hash chain
|
||||
*/
|
||||
static int tdb_purge_dead(struct tdb_context *tdb, u32 hash)
|
||||
static int tdb_purge_dead(struct tdb_context *tdb, uint32_t hash)
|
||||
{
|
||||
int res = -1;
|
||||
struct list_struct rec;
|
||||
@ -332,7 +332,7 @@ static int tdb_purge_dead(struct tdb_context *tdb, u32 hash)
|
||||
}
|
||||
|
||||
/* delete an entry in the database given a key */
|
||||
static int tdb_delete_hash(struct tdb_context *tdb, TDB_DATA key, u32 hash)
|
||||
static int tdb_delete_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash)
|
||||
{
|
||||
tdb_off_t rec_ptr;
|
||||
struct list_struct rec;
|
||||
@ -386,14 +386,14 @@ static int tdb_delete_hash(struct tdb_context *tdb, TDB_DATA key, u32 hash)
|
||||
|
||||
int tdb_delete(struct tdb_context *tdb, TDB_DATA key)
|
||||
{
|
||||
u32 hash = tdb->hash_fn(&key);
|
||||
uint32_t hash = tdb->hash_fn(&key);
|
||||
return tdb_delete_hash(tdb, key, hash);
|
||||
}
|
||||
|
||||
/*
|
||||
* See if we have a dead record around with enough space
|
||||
*/
|
||||
static tdb_off_t tdb_find_dead(struct tdb_context *tdb, u32 hash,
|
||||
static tdb_off_t tdb_find_dead(struct tdb_context *tdb, uint32_t hash,
|
||||
struct list_struct *r, tdb_len_t length)
|
||||
{
|
||||
tdb_off_t rec_ptr;
|
||||
@ -427,7 +427,7 @@ static tdb_off_t tdb_find_dead(struct tdb_context *tdb, u32 hash,
|
||||
int tdb_store(struct tdb_context *tdb, TDB_DATA key, TDB_DATA dbuf, int flag)
|
||||
{
|
||||
struct list_struct rec;
|
||||
u32 hash;
|
||||
uint32_t hash;
|
||||
tdb_off_t rec_ptr;
|
||||
char *p = NULL;
|
||||
int ret = -1;
|
||||
@ -565,7 +565,7 @@ int tdb_store(struct tdb_context *tdb, TDB_DATA key, TDB_DATA dbuf, int flag)
|
||||
/* Append to an entry. Create if not exist. */
|
||||
int tdb_append(struct tdb_context *tdb, TDB_DATA key, TDB_DATA new_dbuf)
|
||||
{
|
||||
u32 hash;
|
||||
uint32_t hash;
|
||||
TDB_DATA dbuf;
|
||||
int ret = -1;
|
||||
|
||||
|
||||
@ -30,16 +30,12 @@
|
||||
#include "system/select.h"
|
||||
#include "tdb.h"
|
||||
|
||||
#ifndef u32
|
||||
#define u32 unsigned
|
||||
#endif
|
||||
|
||||
#ifndef HAVE_GETPAGESIZE
|
||||
#define getpagesize() 0x2000
|
||||
#endif
|
||||
|
||||
typedef u32 tdb_len_t;
|
||||
typedef u32 tdb_off_t;
|
||||
typedef uint32_t tdb_len_t;
|
||||
typedef uint32_t tdb_off_t;
|
||||
|
||||
#ifndef offsetof
|
||||
#define offsetof(t,f) ((unsigned int)&((t *)0)->f)
|
||||
@ -65,7 +61,7 @@ typedef u32 tdb_off_t;
|
||||
#define TDB_RECOVERY_HEAD offsetof(struct tdb_header, recovery_start)
|
||||
#define TDB_SEQNUM_OFS offsetof(struct tdb_header, sequence_number)
|
||||
#define TDB_PAD_BYTE 0x42
|
||||
#define TDB_PAD_U32 0x42424242
|
||||
#define TDB_PAD_UINT32_T 0x42424242
|
||||
|
||||
/* NB assumes there is a local variable called "tdb" that is the
|
||||
* current context, also takes doubly-parenthesized print-style
|
||||
@ -95,8 +91,8 @@ struct list_struct {
|
||||
tdb_len_t rec_len; /* total byte length of record */
|
||||
tdb_len_t key_len; /* byte length of key */
|
||||
tdb_len_t data_len; /* byte length of data */
|
||||
u32 full_hash; /* the full 32 bit hash of the key */
|
||||
u32 magic; /* try to catch errors */
|
||||
uint32_t full_hash; /* the full 32 bit hash of the key */
|
||||
uint32_t magic; /* try to catch errors */
|
||||
/* the following union is implied:
|
||||
union {
|
||||
char record[rec_len];
|
||||
@ -104,7 +100,7 @@ struct list_struct {
|
||||
char key[key_len];
|
||||
char data[data_len];
|
||||
}
|
||||
u32 totalsize; (tailer)
|
||||
uint32_t totalsize; (tailer)
|
||||
}
|
||||
*/
|
||||
};
|
||||
@ -113,8 +109,8 @@ struct list_struct {
|
||||
/* this is stored at the front of every database */
|
||||
struct tdb_header {
|
||||
char magic_food[32]; /* for /etc/magic */
|
||||
u32 version; /* version of the code */
|
||||
u32 hash_size; /* number of hash entries */
|
||||
uint32_t version; /* version of the code */
|
||||
uint32_t hash_size; /* number of hash entries */
|
||||
tdb_off_t rwlocks; /* obsolete - kept to detect old formats */
|
||||
tdb_off_t recovery_start; /* offset of transaction recovery region */
|
||||
tdb_off_t sequence_number; /* used when TDB_SEQNUM is set */
|
||||
@ -123,14 +119,14 @@ struct tdb_header {
|
||||
|
||||
struct tdb_lock_type {
|
||||
int list;
|
||||
u32 count;
|
||||
u32 ltype;
|
||||
uint32_t count;
|
||||
uint32_t ltype;
|
||||
};
|
||||
|
||||
struct tdb_traverse_lock {
|
||||
struct tdb_traverse_lock *next;
|
||||
u32 off;
|
||||
u32 hash;
|
||||
uint32_t off;
|
||||
uint32_t hash;
|
||||
int lock_rw;
|
||||
};
|
||||
|
||||
@ -138,7 +134,7 @@ struct tdb_traverse_lock {
|
||||
struct tdb_methods {
|
||||
int (*tdb_read)(struct tdb_context *, tdb_off_t , void *, tdb_len_t , int );
|
||||
int (*tdb_write)(struct tdb_context *, tdb_off_t, const void *, tdb_len_t);
|
||||
void (*next_hash_chain)(struct tdb_context *, u32 *);
|
||||
void (*next_hash_chain)(struct tdb_context *, uint32_t *);
|
||||
int (*tdb_oob)(struct tdb_context *, tdb_off_t , int );
|
||||
int (*tdb_expand_file)(struct tdb_context *, tdb_off_t , tdb_off_t );
|
||||
int (*tdb_brlock)(struct tdb_context *, tdb_off_t , int, int, int, size_t);
|
||||
@ -157,7 +153,7 @@ struct tdb_context {
|
||||
struct tdb_lock_type *lockrecs; /* only real locks, all with count>0 */
|
||||
enum TDB_ERROR ecode; /* error code for last tdb error */
|
||||
struct tdb_header header; /* a cached copy of the header */
|
||||
u32 flags; /* the flags passed to tdb_open */
|
||||
uint32_t flags; /* the flags passed to tdb_open */
|
||||
struct tdb_traverse_lock travlocks; /* current traversal locks */
|
||||
struct tdb_context *next; /* all tdbs to avoid multiple opens */
|
||||
dev_t device; /* uniquely identifies this tdb */
|
||||
@ -189,7 +185,7 @@ int tdb_write_lock_record(struct tdb_context *tdb, tdb_off_t off);
|
||||
int tdb_write_unlock_record(struct tdb_context *tdb, tdb_off_t off);
|
||||
int tdb_ofs_read(struct tdb_context *tdb, tdb_off_t offset, tdb_off_t *d);
|
||||
int tdb_ofs_write(struct tdb_context *tdb, tdb_off_t offset, tdb_off_t *d);
|
||||
void *tdb_convert(void *buf, u32 size);
|
||||
void *tdb_convert(void *buf, uint32_t size);
|
||||
int tdb_free(struct tdb_context *tdb, tdb_off_t offset, struct list_struct *rec);
|
||||
tdb_off_t tdb_allocate(struct tdb_context *tdb, tdb_len_t length, struct list_struct *rec);
|
||||
int tdb_ofs_read(struct tdb_context *tdb, tdb_off_t offset, tdb_off_t *d);
|
||||
@ -205,7 +201,7 @@ int tdb_parse_data(struct tdb_context *tdb, TDB_DATA key,
|
||||
int (*parser)(TDB_DATA key, TDB_DATA data,
|
||||
void *private_data),
|
||||
void *private_data);
|
||||
tdb_off_t tdb_find_lock_hash(struct tdb_context *tdb, TDB_DATA key, u32 hash, int locktype,
|
||||
tdb_off_t tdb_find_lock_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash, int locktype,
|
||||
struct list_struct *rec);
|
||||
void tdb_io_init(struct tdb_context *tdb);
|
||||
int tdb_expand(struct tdb_context *tdb, tdb_off_t size);
|
||||
|
||||
@ -273,7 +273,7 @@ TDB_DATA tdb_firstkey(struct tdb_context *tdb)
|
||||
/* find the next entry in the database, returning its key */
|
||||
TDB_DATA tdb_nextkey(struct tdb_context *tdb, TDB_DATA oldkey)
|
||||
{
|
||||
u32 oldhash;
|
||||
uint32_t oldhash;
|
||||
TDB_DATA key = tdb_null;
|
||||
struct list_struct rec;
|
||||
unsigned char *k = NULL;
|
||||
|
||||
Loading…
Reference in New Issue
Block a user