mirror of
https://gitlab.com/openconnect/ocserv.git
synced 2026-02-10 08:46:58 +08:00
Use CCAN hashes and lists.
This commit is contained in:
Nikos Mavrogiannopoulos
@@ -1,15 +1,23 @@
|
||||
AM_CPPFLAGS = -I$(srcdir)/../gl/ -I$(builddir)/../gl/ \
|
||||
-I$(srcdir)/ -I$(builddir)/../ -I$(srcdir)/../libopts
|
||||
|
||||
EXTRA_DIST = ocserv.1 sample.config
|
||||
EXTRA_DIST = ocserv.1 sample.config ccan/licenses/BSD-MIT \
|
||||
ccan/licenses/CC0 ccan/licenses/LGPL-2.1
|
||||
|
||||
|
||||
bin_PROGRAMS = ocserv
|
||||
|
||||
CCAN_SOURCES = ccan/build_assert/build_assert.h ccan/check_type/check_type.h \
|
||||
ccan/container_of/container_of.h ccan/hash/hash.c ccan/hash/hash.h \
|
||||
ccan/htable/htable.c ccan/htable/htable.h ccan/htable/htable_type.h \
|
||||
ccan/list/list.c ccan/list/list.h
|
||||
|
||||
|
||||
ocserv_SOURCES = main.c main-auth.c worker-vpn.c worker-auth.c tlslib.c \
|
||||
cookies.c http-parser/http_parser.c list.h ipc.h \
|
||||
cookies.c http-parser/http_parser.c ipc.h \
|
||||
vpn.h cookies.h tlslib.h http-parser/http_parser.h log.c tun.c tun.h \
|
||||
config.c pam.c pam.h worker-resume.c worker.h hash.h \
|
||||
hashtable.h main-resume.c main.h main-script.c
|
||||
config.c pam.c pam.h worker-resume.c worker.h main-resume.c main.h \
|
||||
main-script.c $(CCAN_SOURCES)
|
||||
|
||||
ocserv_SOURCES += ocserv-args.def ocserv-args.c ocserv-args.h
|
||||
|
||||
|
||||
40
src/ccan/build_assert/build_assert.h
Normal file
40
src/ccan/build_assert/build_assert.h
Normal file
@@ -0,0 +1,40 @@
|
||||
/* CC0 (Public domain) - see LICENSE file for details */
|
||||
#ifndef CCAN_BUILD_ASSERT_H
|
||||
#define CCAN_BUILD_ASSERT_H
|
||||
|
||||
/**
|
||||
* BUILD_ASSERT - assert a build-time dependency.
|
||||
* @cond: the compile-time condition which must be true.
|
||||
*
|
||||
* Your compile will fail if the condition isn't true, or can't be evaluated
|
||||
* by the compiler. This can only be used within a function.
|
||||
*
|
||||
* Example:
|
||||
* #include <stddef.h>
|
||||
* ...
|
||||
* static char *foo_to_char(struct foo *foo)
|
||||
* {
|
||||
* // This code needs string to be at start of foo.
|
||||
* BUILD_ASSERT(offsetof(struct foo, string) == 0);
|
||||
* return (char *)foo;
|
||||
* }
|
||||
*/
|
||||
#define BUILD_ASSERT(cond) \
|
||||
do { (void) sizeof(char [1 - 2*!(cond)]); } while(0)
|
||||
|
||||
/**
|
||||
* BUILD_ASSERT_OR_ZERO - assert a build-time dependency, as an expression.
|
||||
* @cond: the compile-time condition which must be true.
|
||||
*
|
||||
* Your compile will fail if the condition isn't true, or can't be evaluated
|
||||
* by the compiler. This can be used in an expression: its value is "0".
|
||||
*
|
||||
* Example:
|
||||
* #define foo_to_char(foo) \
|
||||
* ((char *)(foo) \
|
||||
* + BUILD_ASSERT_OR_ZERO(offsetof(struct foo, string) == 0))
|
||||
*/
|
||||
#define BUILD_ASSERT_OR_ZERO(cond) \
|
||||
(sizeof(char [1 - 2*!(cond)]) - 1)
|
||||
|
||||
#endif /* CCAN_BUILD_ASSERT_H */
|
||||
64
src/ccan/check_type/check_type.h
Normal file
64
src/ccan/check_type/check_type.h
Normal file
@@ -0,0 +1,64 @@
|
||||
/* CC0 (Public domain) - see LICENSE file for details */
|
||||
#ifndef CCAN_CHECK_TYPE_H
|
||||
#define CCAN_CHECK_TYPE_H
|
||||
#include "config.h"
|
||||
|
||||
/**
|
||||
* check_type - issue a warning or build failure if type is not correct.
|
||||
* @expr: the expression whose type we should check (not evaluated).
|
||||
* @type: the exact type we expect the expression to be.
|
||||
*
|
||||
* This macro is usually used within other macros to try to ensure that a macro
|
||||
* argument is of the expected type. No type promotion of the expression is
|
||||
* done: an unsigned int is not the same as an int!
|
||||
*
|
||||
* check_type() always evaluates to 0.
|
||||
*
|
||||
* If your compiler does not support typeof, then the best we can do is fail
|
||||
* to compile if the sizes of the types are unequal (a less complete check).
|
||||
*
|
||||
* Example:
|
||||
* // They should always pass a 64-bit value to _set_some_value!
|
||||
* #define set_some_value(expr) \
|
||||
* _set_some_value((check_type((expr), uint64_t), (expr)))
|
||||
*/
|
||||
|
||||
/**
|
||||
* check_types_match - issue a warning or build failure if types are not same.
|
||||
* @expr1: the first expression (not evaluated).
|
||||
* @expr2: the second expression (not evaluated).
|
||||
*
|
||||
* This macro is usually used within other macros to try to ensure that
|
||||
* arguments are of identical types. No type promotion of the expressions is
|
||||
* done: an unsigned int is not the same as an int!
|
||||
*
|
||||
* check_types_match() always evaluates to 0.
|
||||
*
|
||||
* If your compiler does not support typeof, then the best we can do is fail
|
||||
* to compile if the sizes of the types are unequal (a less complete check).
|
||||
*
|
||||
* Example:
|
||||
* // Do subtraction to get to enclosing type, but make sure that
|
||||
* // pointer is of correct type for that member.
|
||||
* #define container_of(mbr_ptr, encl_type, mbr) \
|
||||
* (check_types_match((mbr_ptr), &((encl_type *)0)->mbr), \
|
||||
* ((encl_type *) \
|
||||
* ((char *)(mbr_ptr) - offsetof(enclosing_type, mbr))))
|
||||
*/
|
||||
#if HAVE_TYPEOF
|
||||
#define check_type(expr, type) \
|
||||
((typeof(expr) *)0 != (type *)0)
|
||||
|
||||
#define check_types_match(expr1, expr2) \
|
||||
((typeof(expr1) *)0 != (typeof(expr2) *)0)
|
||||
#else
|
||||
#include <ccan/build_assert/build_assert.h>
|
||||
/* Without typeof, we can only test the sizes. */
|
||||
#define check_type(expr, type) \
|
||||
BUILD_ASSERT_OR_ZERO(sizeof(expr) == sizeof(type))
|
||||
|
||||
#define check_types_match(expr1, expr2) \
|
||||
BUILD_ASSERT_OR_ZERO(sizeof(expr1) == sizeof(expr2))
|
||||
#endif /* HAVE_TYPEOF */
|
||||
|
||||
#endif /* CCAN_CHECK_TYPE_H */
|
||||
109
src/ccan/container_of/container_of.h
Normal file
109
src/ccan/container_of/container_of.h
Normal file
@@ -0,0 +1,109 @@
|
||||
/* CC0 (Public domain) - see LICENSE file for details */
|
||||
#ifndef CCAN_CONTAINER_OF_H
|
||||
#define CCAN_CONTAINER_OF_H
|
||||
#include <stddef.h>
|
||||
|
||||
#include "config.h"
|
||||
#include <ccan/check_type/check_type.h>
|
||||
|
||||
/**
|
||||
* container_of - get pointer to enclosing structure
|
||||
* @member_ptr: pointer to the structure member
|
||||
* @containing_type: the type this member is within
|
||||
* @member: the name of this member within the structure.
|
||||
*
|
||||
* Given a pointer to a member of a structure, this macro does pointer
|
||||
* subtraction to return the pointer to the enclosing type.
|
||||
*
|
||||
* Example:
|
||||
* struct foo {
|
||||
* int fielda, fieldb;
|
||||
* // ...
|
||||
* };
|
||||
* struct info {
|
||||
* int some_other_field;
|
||||
* struct foo my_foo;
|
||||
* };
|
||||
*
|
||||
* static struct info *foo_to_info(struct foo *foo)
|
||||
* {
|
||||
* return container_of(foo, struct info, my_foo);
|
||||
* }
|
||||
*/
|
||||
#define container_of(member_ptr, containing_type, member) \
|
||||
((containing_type *) \
|
||||
((char *)(member_ptr) \
|
||||
- container_off(containing_type, member)) \
|
||||
+ check_types_match(*(member_ptr), ((containing_type *)0)->member))
|
||||
|
||||
/**
|
||||
* container_off - get offset to enclosing structure
|
||||
* @containing_type: the type this member is within
|
||||
* @member: the name of this member within the structure.
|
||||
*
|
||||
* Given a pointer to a member of a structure, this macro does
|
||||
* typechecking and figures out the offset to the enclosing type.
|
||||
*
|
||||
* Example:
|
||||
* struct foo {
|
||||
* int fielda, fieldb;
|
||||
* // ...
|
||||
* };
|
||||
* struct info {
|
||||
* int some_other_field;
|
||||
* struct foo my_foo;
|
||||
* };
|
||||
*
|
||||
* static struct info *foo_to_info(struct foo *foo)
|
||||
* {
|
||||
* size_t off = container_off(struct info, my_foo);
|
||||
* return (void *)((char *)foo - off);
|
||||
* }
|
||||
*/
|
||||
#define container_off(containing_type, member) \
|
||||
offsetof(containing_type, member)
|
||||
|
||||
/**
|
||||
* container_of_var - get pointer to enclosing structure using a variable
|
||||
* @member_ptr: pointer to the structure member
|
||||
* @container_var: a pointer of same type as this member's container
|
||||
* @member: the name of this member within the structure.
|
||||
*
|
||||
* Given a pointer to a member of a structure, this macro does pointer
|
||||
* subtraction to return the pointer to the enclosing type.
|
||||
*
|
||||
* Example:
|
||||
* static struct info *foo_to_i(struct foo *foo)
|
||||
* {
|
||||
* struct info *i = container_of_var(foo, i, my_foo);
|
||||
* return i;
|
||||
* }
|
||||
*/
|
||||
#if HAVE_TYPEOF
|
||||
#define container_of_var(member_ptr, container_var, member) \
|
||||
container_of(member_ptr, typeof(*container_var), member)
|
||||
#else
|
||||
#define container_of_var(member_ptr, container_var, member) \
|
||||
((void *)((char *)(member_ptr) - \
|
||||
container_off_var(container_var, member)))
|
||||
#endif
|
||||
|
||||
/**
|
||||
* container_off_var - get offset of a field in enclosing structure
|
||||
* @container_var: a pointer to a container structure
|
||||
* @member: the name of a member within the structure.
|
||||
*
|
||||
* Given (any) pointer to a structure and a its member name, this
|
||||
* macro does pointer subtraction to return offset of member in a
|
||||
* structure memory layout.
|
||||
*
|
||||
*/
|
||||
#if HAVE_TYPEOF
|
||||
#define container_off_var(var, member) \
|
||||
container_off(typeof(*var), member)
|
||||
#else
|
||||
#define container_off_var(var, member) \
|
||||
((char *)&(var)->member - (char *)(var))
|
||||
#endif
|
||||
|
||||
#endif /* CCAN_CONTAINER_OF_H */
|
||||
925
src/ccan/hash/hash.c
Normal file
925
src/ccan/hash/hash.c
Normal file
@@ -0,0 +1,925 @@
|
||||
/* CC0 (Public domain) - see LICENSE file for details */
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
lookup3.c, by Bob Jenkins, May 2006, Public Domain.
|
||||
|
||||
These are functions for producing 32-bit hashes for hash table lookup.
|
||||
hash_word(), hashlittle(), hashlittle2(), hashbig(), mix(), and final()
|
||||
are externally useful functions. Routines to test the hash are included
|
||||
if SELF_TEST is defined. You can use this free for any purpose. It's in
|
||||
the public domain. It has no warranty.
|
||||
|
||||
You probably want to use hashlittle(). hashlittle() and hashbig()
|
||||
hash byte arrays. hashlittle() is is faster than hashbig() on
|
||||
little-endian machines. Intel and AMD are little-endian machines.
|
||||
On second thought, you probably want hashlittle2(), which is identical to
|
||||
hashlittle() except it returns two 32-bit hashes for the price of one.
|
||||
You could implement hashbig2() if you wanted but I haven't bothered here.
|
||||
|
||||
If you want to find a hash of, say, exactly 7 integers, do
|
||||
a = i1; b = i2; c = i3;
|
||||
mix(a,b,c);
|
||||
a += i4; b += i5; c += i6;
|
||||
mix(a,b,c);
|
||||
a += i7;
|
||||
final(a,b,c);
|
||||
then use c as the hash value. If you have a variable length array of
|
||||
4-byte integers to hash, use hash_word(). If you have a byte array (like
|
||||
a character string), use hashlittle(). If you have several byte arrays, or
|
||||
a mix of things, see the comments above hashlittle().
|
||||
|
||||
Why is this so big? I read 12 bytes at a time into 3 4-byte integers,
|
||||
then mix those integers. This is fast (you can do a lot more thorough
|
||||
mixing with 12*3 instructions on 3 integers than you can with 3 instructions
|
||||
on 1 byte), but shoehorning those bytes into integers efficiently is messy.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
//#define SELF_TEST 1
|
||||
|
||||
#if 0
|
||||
#include <stdio.h> /* defines printf for tests */
|
||||
#include <time.h> /* defines time_t for timings in the test */
|
||||
#include <stdint.h> /* defines uint32_t etc */
|
||||
#include <sys/param.h> /* attempt to define endianness */
|
||||
|
||||
#ifdef linux
|
||||
# include <endian.h> /* attempt to define endianness */
|
||||
#endif
|
||||
|
||||
/*
|
||||
* My best guess at if you are big-endian or little-endian. This may
|
||||
* need adjustment.
|
||||
*/
|
||||
#if (defined(__BYTE_ORDER) && defined(__LITTLE_ENDIAN) && \
|
||||
__BYTE_ORDER == __LITTLE_ENDIAN) || \
|
||||
(defined(i386) || defined(__i386__) || defined(__i486__) || \
|
||||
defined(__i586__) || defined(__i686__) || defined(__x86_64) || \
|
||||
defined(vax) || defined(MIPSEL))
|
||||
# define HASH_LITTLE_ENDIAN 1
|
||||
# define HASH_BIG_ENDIAN 0
|
||||
#elif (defined(__BYTE_ORDER) && defined(__BIG_ENDIAN) && \
|
||||
__BYTE_ORDER == __BIG_ENDIAN) || \
|
||||
(defined(sparc) || defined(POWERPC) || defined(mc68000) || defined(sel))
|
||||
# define HASH_LITTLE_ENDIAN 0
|
||||
# define HASH_BIG_ENDIAN 1
|
||||
#else
|
||||
# error Unknown endian
|
||||
#endif
|
||||
#endif /* old hash.c headers. */
|
||||
|
||||
#include <config.h>
|
||||
#include "hash.h"
|
||||
|
||||
#ifdef WORDS_BIGENDIAN
|
||||
#define HASH_LITTLE_ENDIAN 0
|
||||
#define HASH_BIG_ENDIAN 1
|
||||
#else
|
||||
#define HASH_LITTLE_ENDIAN 1
|
||||
#define HASH_BIG_ENDIAN 0
|
||||
#endif
|
||||
|
||||
#define hashsize(n) ((uint32_t)1<<(n))
|
||||
#define hashmask(n) (hashsize(n)-1)
|
||||
#define rot(x,k) (((x)<<(k)) | ((x)>>(32-(k))))
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
mix -- mix 3 32-bit values reversibly.
|
||||
|
||||
This is reversible, so any information in (a,b,c) before mix() is
|
||||
still in (a,b,c) after mix().
|
||||
|
||||
If four pairs of (a,b,c) inputs are run through mix(), or through
|
||||
mix() in reverse, there are at least 32 bits of the output that
|
||||
are sometimes the same for one pair and different for another pair.
|
||||
This was tested for:
|
||||
* pairs that differed by one bit, by two bits, in any combination
|
||||
of top bits of (a,b,c), or in any combination of bottom bits of
|
||||
(a,b,c).
|
||||
* "differ" is defined as +, -, ^, or ~^. For + and -, I transformed
|
||||
the output delta to a Gray code (a^(a>>1)) so a string of 1's (as
|
||||
is commonly produced by subtraction) look like a single 1-bit
|
||||
difference.
|
||||
* the base values were pseudorandom, all zero but one bit set, or
|
||||
all zero plus a counter that starts at zero.
|
||||
|
||||
Some k values for my "a-=c; a^=rot(c,k); c+=b;" arrangement that
|
||||
satisfy this are
|
||||
4 6 8 16 19 4
|
||||
9 15 3 18 27 15
|
||||
14 9 3 7 17 3
|
||||
Well, "9 15 3 18 27 15" didn't quite get 32 bits diffing
|
||||
for "differ" defined as + with a one-bit base and a two-bit delta. I
|
||||
used http://burtleburtle.net/bob/hash/avalanche.html to choose
|
||||
the operations, constants, and arrangements of the variables.
|
||||
|
||||
This does not achieve avalanche. There are input bits of (a,b,c)
|
||||
that fail to affect some output bits of (a,b,c), especially of a. The
|
||||
most thoroughly mixed value is c, but it doesn't really even achieve
|
||||
avalanche in c.
|
||||
|
||||
This allows some parallelism. Read-after-writes are good at doubling
|
||||
the number of bits affected, so the goal of mixing pulls in the opposite
|
||||
direction as the goal of parallelism. I did what I could. Rotates
|
||||
seem to cost as much as shifts on every machine I could lay my hands
|
||||
on, and rotates are much kinder to the top and bottom bits, so I used
|
||||
rotates.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
#define mix(a,b,c) \
|
||||
{ \
|
||||
a -= c; a ^= rot(c, 4); c += b; \
|
||||
b -= a; b ^= rot(a, 6); a += c; \
|
||||
c -= b; c ^= rot(b, 8); b += a; \
|
||||
a -= c; a ^= rot(c,16); c += b; \
|
||||
b -= a; b ^= rot(a,19); a += c; \
|
||||
c -= b; c ^= rot(b, 4); b += a; \
|
||||
}
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
final -- final mixing of 3 32-bit values (a,b,c) into c
|
||||
|
||||
Pairs of (a,b,c) values differing in only a few bits will usually
|
||||
produce values of c that look totally different. This was tested for
|
||||
* pairs that differed by one bit, by two bits, in any combination
|
||||
of top bits of (a,b,c), or in any combination of bottom bits of
|
||||
(a,b,c).
|
||||
* "differ" is defined as +, -, ^, or ~^. For + and -, I transformed
|
||||
the output delta to a Gray code (a^(a>>1)) so a string of 1's (as
|
||||
is commonly produced by subtraction) look like a single 1-bit
|
||||
difference.
|
||||
* the base values were pseudorandom, all zero but one bit set, or
|
||||
all zero plus a counter that starts at zero.
|
||||
|
||||
These constants passed:
|
||||
14 11 25 16 4 14 24
|
||||
12 14 25 16 4 14 24
|
||||
and these came close:
|
||||
4 8 15 26 3 22 24
|
||||
10 8 15 26 3 22 24
|
||||
11 8 15 26 3 22 24
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
#define final(a,b,c) \
|
||||
{ \
|
||||
c ^= b; c -= rot(b,14); \
|
||||
a ^= c; a -= rot(c,11); \
|
||||
b ^= a; b -= rot(a,25); \
|
||||
c ^= b; c -= rot(b,16); \
|
||||
a ^= c; a -= rot(c,4); \
|
||||
b ^= a; b -= rot(a,14); \
|
||||
c ^= b; c -= rot(b,24); \
|
||||
}
|
||||
|
||||
/*
|
||||
--------------------------------------------------------------------
|
||||
This works on all machines. To be useful, it requires
|
||||
-- that the key be an array of uint32_t's, and
|
||||
-- that the length be the number of uint32_t's in the key
|
||||
|
||||
The function hash_word() is identical to hashlittle() on little-endian
|
||||
machines, and identical to hashbig() on big-endian machines,
|
||||
except that the length has to be measured in uint32_ts rather than in
|
||||
bytes. hashlittle() is more complicated than hash_word() only because
|
||||
hashlittle() has to dance around fitting the key bytes into registers.
|
||||
--------------------------------------------------------------------
|
||||
*/
|
||||
uint32_t hash_u32(
|
||||
const uint32_t *k, /* the key, an array of uint32_t values */
|
||||
size_t length, /* the length of the key, in uint32_ts */
|
||||
uint32_t initval) /* the previous hash, or an arbitrary value */
|
||||
{
|
||||
uint32_t a,b,c;
|
||||
|
||||
/* Set up the internal state */
|
||||
a = b = c = 0xdeadbeef + (((uint32_t)length)<<2) + initval;
|
||||
|
||||
/*------------------------------------------------- handle most of the key */
|
||||
while (length > 3)
|
||||
{
|
||||
a += k[0];
|
||||
b += k[1];
|
||||
c += k[2];
|
||||
mix(a,b,c);
|
||||
length -= 3;
|
||||
k += 3;
|
||||
}
|
||||
|
||||
/*------------------------------------------- handle the last 3 uint32_t's */
|
||||
switch(length) /* all the case statements fall through */
|
||||
{
|
||||
case 3 : c+=k[2];
|
||||
case 2 : b+=k[1];
|
||||
case 1 : a+=k[0];
|
||||
final(a,b,c);
|
||||
case 0: /* case 0: nothing left to add */
|
||||
break;
|
||||
}
|
||||
/*------------------------------------------------------ report the result */
|
||||
return c;
|
||||
}
|
||||
|
||||
/*
|
||||
-------------------------------------------------------------------------------
|
||||
hashlittle() -- hash a variable-length key into a 32-bit value
|
||||
k : the key (the unaligned variable-length array of bytes)
|
||||
length : the length of the key, counting by bytes
|
||||
val2 : IN: can be any 4-byte value OUT: second 32 bit hash.
|
||||
Returns a 32-bit value. Every bit of the key affects every bit of
|
||||
the return value. Two keys differing by one or two bits will have
|
||||
totally different hash values. Note that the return value is better
|
||||
mixed than val2, so use that first.
|
||||
|
||||
The best hash table sizes are powers of 2. There is no need to do
|
||||
mod a prime (mod is sooo slow!). If you need less than 32 bits,
|
||||
use a bitmask. For example, if you need only 10 bits, do
|
||||
h = (h & hashmask(10));
|
||||
In which case, the hash table should have hashsize(10) elements.
|
||||
|
||||
If you are hashing n strings (uint8_t **)k, do it like this:
|
||||
for (i=0, h=0; i<n; ++i) h = hashlittle( k[i], len[i], h);
|
||||
|
||||
By Bob Jenkins, 2006. bob_jenkins@burtleburtle.net. You may use this
|
||||
code any way you wish, private, educational, or commercial. It's free.
|
||||
|
||||
Use for hash table lookup, or anything where one collision in 2^^32 is
|
||||
acceptable. Do NOT use for cryptographic purposes.
|
||||
-------------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
static uint32_t hashlittle( const void *key, size_t length, uint32_t *val2 )
|
||||
{
|
||||
uint32_t a,b,c; /* internal state */
|
||||
union { const void *ptr; size_t i; } u; /* needed for Mac Powerbook G4 */
|
||||
|
||||
/* Set up the internal state */
|
||||
a = b = c = 0xdeadbeef + ((uint32_t)length) + *val2;
|
||||
|
||||
u.ptr = key;
|
||||
if (HASH_LITTLE_ENDIAN && ((u.i & 0x3) == 0)) {
|
||||
const uint32_t *k = (const uint32_t *)key; /* read 32-bit chunks */
|
||||
const uint8_t *k8;
|
||||
|
||||
/*------ all but last block: aligned reads and affect 32 bits of (a,b,c) */
|
||||
while (length > 12)
|
||||
{
|
||||
a += k[0];
|
||||
b += k[1];
|
||||
c += k[2];
|
||||
mix(a,b,c);
|
||||
length -= 12;
|
||||
k += 3;
|
||||
}
|
||||
|
||||
/*----------------------------- handle the last (probably partial) block */
|
||||
/*
|
||||
* "k[2]&0xffffff" actually reads beyond the end of the string, but
|
||||
* then masks off the part it's not allowed to read. Because the
|
||||
* string is aligned, the masked-off tail is in the same word as the
|
||||
* rest of the string. Every machine with memory protection I've seen
|
||||
* does it on word boundaries, so is OK with this. But VALGRIND will
|
||||
* still catch it and complain. The masking trick does make the hash
|
||||
* noticably faster for short strings (like English words).
|
||||
*
|
||||
* Not on my testing with gcc 4.5 on an intel i5 CPU, at least --RR.
|
||||
*/
|
||||
#if 0
|
||||
switch(length)
|
||||
{
|
||||
case 12: c+=k[2]; b+=k[1]; a+=k[0]; break;
|
||||
case 11: c+=k[2]&0xffffff; b+=k[1]; a+=k[0]; break;
|
||||
case 10: c+=k[2]&0xffff; b+=k[1]; a+=k[0]; break;
|
||||
case 9 : c+=k[2]&0xff; b+=k[1]; a+=k[0]; break;
|
||||
case 8 : b+=k[1]; a+=k[0]; break;
|
||||
case 7 : b+=k[1]&0xffffff; a+=k[0]; break;
|
||||
case 6 : b+=k[1]&0xffff; a+=k[0]; break;
|
||||
case 5 : b+=k[1]&0xff; a+=k[0]; break;
|
||||
case 4 : a+=k[0]; break;
|
||||
case 3 : a+=k[0]&0xffffff; break;
|
||||
case 2 : a+=k[0]&0xffff; break;
|
||||
case 1 : a+=k[0]&0xff; break;
|
||||
case 0 : return c; /* zero length strings require no mixing */
|
||||
}
|
||||
|
||||
#else /* make valgrind happy */
|
||||
|
||||
k8 = (const uint8_t *)k;
|
||||
switch(length)
|
||||
{
|
||||
case 12: c+=k[2]; b+=k[1]; a+=k[0]; break;
|
||||
case 11: c+=((uint32_t)k8[10])<<16; /* fall through */
|
||||
case 10: c+=((uint32_t)k8[9])<<8; /* fall through */
|
||||
case 9 : c+=k8[8]; /* fall through */
|
||||
case 8 : b+=k[1]; a+=k[0]; break;
|
||||
case 7 : b+=((uint32_t)k8[6])<<16; /* fall through */
|
||||
case 6 : b+=((uint32_t)k8[5])<<8; /* fall through */
|
||||
case 5 : b+=k8[4]; /* fall through */
|
||||
case 4 : a+=k[0]; break;
|
||||
case 3 : a+=((uint32_t)k8[2])<<16; /* fall through */
|
||||
case 2 : a+=((uint32_t)k8[1])<<8; /* fall through */
|
||||
case 1 : a+=k8[0]; break;
|
||||
case 0 : return c;
|
||||
}
|
||||
|
||||
#endif /* !valgrind */
|
||||
|
||||
} else if (HASH_LITTLE_ENDIAN && ((u.i & 0x1) == 0)) {
|
||||
const uint16_t *k = (const uint16_t *)key; /* read 16-bit chunks */
|
||||
const uint8_t *k8;
|
||||
|
||||
/*--------------- all but last block: aligned reads and different mixing */
|
||||
while (length > 12)
|
||||
{
|
||||
a += k[0] + (((uint32_t)k[1])<<16);
|
||||
b += k[2] + (((uint32_t)k[3])<<16);
|
||||
c += k[4] + (((uint32_t)k[5])<<16);
|
||||
mix(a,b,c);
|
||||
length -= 12;
|
||||
k += 6;
|
||||
}
|
||||
|
||||
/*----------------------------- handle the last (probably partial) block */
|
||||
k8 = (const uint8_t *)k;
|
||||
switch(length)
|
||||
{
|
||||
case 12: c+=k[4]+(((uint32_t)k[5])<<16);
|
||||
b+=k[2]+(((uint32_t)k[3])<<16);
|
||||
a+=k[0]+(((uint32_t)k[1])<<16);
|
||||
break;
|
||||
case 11: c+=((uint32_t)k8[10])<<16; /* fall through */
|
||||
case 10: c+=k[4];
|
||||
b+=k[2]+(((uint32_t)k[3])<<16);
|
||||
a+=k[0]+(((uint32_t)k[1])<<16);
|
||||
break;
|
||||
case 9 : c+=k8[8]; /* fall through */
|
||||
case 8 : b+=k[2]+(((uint32_t)k[3])<<16);
|
||||
a+=k[0]+(((uint32_t)k[1])<<16);
|
||||
break;
|
||||
case 7 : b+=((uint32_t)k8[6])<<16; /* fall through */
|
||||
case 6 : b+=k[2];
|
||||
a+=k[0]+(((uint32_t)k[1])<<16);
|
||||
break;
|
||||
case 5 : b+=k8[4]; /* fall through */
|
||||
case 4 : a+=k[0]+(((uint32_t)k[1])<<16);
|
||||
break;
|
||||
case 3 : a+=((uint32_t)k8[2])<<16; /* fall through */
|
||||
case 2 : a+=k[0];
|
||||
break;
|
||||
case 1 : a+=k8[0];
|
||||
break;
|
||||
case 0 : return c; /* zero length requires no mixing */
|
||||
}
|
||||
|
||||
} else { /* need to read the key one byte at a time */
|
||||
const uint8_t *k = (const uint8_t *)key;
|
||||
|
||||
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
|
||||
while (length > 12)
|
||||
{
|
||||
a += k[0];
|
||||
a += ((uint32_t)k[1])<<8;
|
||||
a += ((uint32_t)k[2])<<16;
|
||||
a += ((uint32_t)k[3])<<24;
|
||||
b += k[4];
|
||||
b += ((uint32_t)k[5])<<8;
|
||||
b += ((uint32_t)k[6])<<16;
|
||||
b += ((uint32_t)k[7])<<24;
|
||||
c += k[8];
|
||||
c += ((uint32_t)k[9])<<8;
|
||||
c += ((uint32_t)k[10])<<16;
|
||||
c += ((uint32_t)k[11])<<24;
|
||||
mix(a,b,c);
|
||||
length -= 12;
|
||||
k += 12;
|
||||
}
|
||||
|
||||
/*-------------------------------- last block: affect all 32 bits of (c) */
|
||||
switch(length) /* all the case statements fall through */
|
||||
{
|
||||
case 12: c+=((uint32_t)k[11])<<24;
|
||||
case 11: c+=((uint32_t)k[10])<<16;
|
||||
case 10: c+=((uint32_t)k[9])<<8;
|
||||
case 9 : c+=k[8];
|
||||
case 8 : b+=((uint32_t)k[7])<<24;
|
||||
case 7 : b+=((uint32_t)k[6])<<16;
|
||||
case 6 : b+=((uint32_t)k[5])<<8;
|
||||
case 5 : b+=k[4];
|
||||
case 4 : a+=((uint32_t)k[3])<<24;
|
||||
case 3 : a+=((uint32_t)k[2])<<16;
|
||||
case 2 : a+=((uint32_t)k[1])<<8;
|
||||
case 1 : a+=k[0];
|
||||
break;
|
||||
case 0 : return c;
|
||||
}
|
||||
}
|
||||
|
||||
final(a,b,c);
|
||||
*val2 = b;
|
||||
return c;
|
||||
}
|
||||
|
||||
/*
|
||||
* hashbig():
|
||||
* This is the same as hash_word() on big-endian machines. It is different
|
||||
* from hashlittle() on all machines. hashbig() takes advantage of
|
||||
* big-endian byte ordering.
|
||||
*/
|
||||
static uint32_t hashbig( const void *key, size_t length, uint32_t *val2)
|
||||
{
|
||||
uint32_t a,b,c;
|
||||
union { const void *ptr; size_t i; } u; /* to cast key to (size_t) happily */
|
||||
|
||||
/* Set up the internal state */
|
||||
a = b = c = 0xdeadbeef + ((uint32_t)length) + *val2;
|
||||
|
||||
u.ptr = key;
|
||||
if (HASH_BIG_ENDIAN && ((u.i & 0x3) == 0)) {
|
||||
const uint32_t *k = (const uint32_t *)key; /* read 32-bit chunks */
|
||||
const uint8_t *k8;
|
||||
|
||||
/*------ all but last block: aligned reads and affect 32 bits of (a,b,c) */
|
||||
while (length > 12)
|
||||
{
|
||||
a += k[0];
|
||||
b += k[1];
|
||||
c += k[2];
|
||||
mix(a,b,c);
|
||||
length -= 12;
|
||||
k += 3;
|
||||
}
|
||||
|
||||
/*----------------------------- handle the last (probably partial) block */
|
||||
/*
|
||||
* "k[2]<<8" actually reads beyond the end of the string, but
|
||||
* then shifts out the part it's not allowed to read. Because the
|
||||
* string is aligned, the illegal read is in the same word as the
|
||||
* rest of the string. Every machine with memory protection I've seen
|
||||
* does it on word boundaries, so is OK with this. But VALGRIND will
|
||||
* still catch it and complain. The masking trick does make the hash
|
||||
* noticably faster for short strings (like English words).
|
||||
*
|
||||
* Not on my testing with gcc 4.5 on an intel i5 CPU, at least --RR.
|
||||
*/
|
||||
#if 0
|
||||
switch(length)
|
||||
{
|
||||
case 12: c+=k[2]; b+=k[1]; a+=k[0]; break;
|
||||
case 11: c+=k[2]&0xffffff00; b+=k[1]; a+=k[0]; break;
|
||||
case 10: c+=k[2]&0xffff0000; b+=k[1]; a+=k[0]; break;
|
||||
case 9 : c+=k[2]&0xff000000; b+=k[1]; a+=k[0]; break;
|
||||
case 8 : b+=k[1]; a+=k[0]; break;
|
||||
case 7 : b+=k[1]&0xffffff00; a+=k[0]; break;
|
||||
case 6 : b+=k[1]&0xffff0000; a+=k[0]; break;
|
||||
case 5 : b+=k[1]&0xff000000; a+=k[0]; break;
|
||||
case 4 : a+=k[0]; break;
|
||||
case 3 : a+=k[0]&0xffffff00; break;
|
||||
case 2 : a+=k[0]&0xffff0000; break;
|
||||
case 1 : a+=k[0]&0xff000000; break;
|
||||
case 0 : return c; /* zero length strings require no mixing */
|
||||
}
|
||||
|
||||
#else /* make valgrind happy */
|
||||
|
||||
k8 = (const uint8_t *)k;
|
||||
switch(length) /* all the case statements fall through */
|
||||
{
|
||||
case 12: c+=k[2]; b+=k[1]; a+=k[0]; break;
|
||||
case 11: c+=((uint32_t)k8[10])<<8; /* fall through */
|
||||
case 10: c+=((uint32_t)k8[9])<<16; /* fall through */
|
||||
case 9 : c+=((uint32_t)k8[8])<<24; /* fall through */
|
||||
case 8 : b+=k[1]; a+=k[0]; break;
|
||||
case 7 : b+=((uint32_t)k8[6])<<8; /* fall through */
|
||||
case 6 : b+=((uint32_t)k8[5])<<16; /* fall through */
|
||||
case 5 : b+=((uint32_t)k8[4])<<24; /* fall through */
|
||||
case 4 : a+=k[0]; break;
|
||||
case 3 : a+=((uint32_t)k8[2])<<8; /* fall through */
|
||||
case 2 : a+=((uint32_t)k8[1])<<16; /* fall through */
|
||||
case 1 : a+=((uint32_t)k8[0])<<24; break;
|
||||
case 0 : return c;
|
||||
}
|
||||
|
||||
#endif /* !VALGRIND */
|
||||
|
||||
} else { /* need to read the key one byte at a time */
|
||||
const uint8_t *k = (const uint8_t *)key;
|
||||
|
||||
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
|
||||
while (length > 12)
|
||||
{
|
||||
a += ((uint32_t)k[0])<<24;
|
||||
a += ((uint32_t)k[1])<<16;
|
||||
a += ((uint32_t)k[2])<<8;
|
||||
a += ((uint32_t)k[3]);
|
||||
b += ((uint32_t)k[4])<<24;
|
||||
b += ((uint32_t)k[5])<<16;
|
||||
b += ((uint32_t)k[6])<<8;
|
||||
b += ((uint32_t)k[7]);
|
||||
c += ((uint32_t)k[8])<<24;
|
||||
c += ((uint32_t)k[9])<<16;
|
||||
c += ((uint32_t)k[10])<<8;
|
||||
c += ((uint32_t)k[11]);
|
||||
mix(a,b,c);
|
||||
length -= 12;
|
||||
k += 12;
|
||||
}
|
||||
|
||||
/*-------------------------------- last block: affect all 32 bits of (c) */
|
||||
switch(length) /* all the case statements fall through */
|
||||
{
|
||||
case 12: c+=k[11];
|
||||
case 11: c+=((uint32_t)k[10])<<8;
|
||||
case 10: c+=((uint32_t)k[9])<<16;
|
||||
case 9 : c+=((uint32_t)k[8])<<24;
|
||||
case 8 : b+=k[7];
|
||||
case 7 : b+=((uint32_t)k[6])<<8;
|
||||
case 6 : b+=((uint32_t)k[5])<<16;
|
||||
case 5 : b+=((uint32_t)k[4])<<24;
|
||||
case 4 : a+=k[3];
|
||||
case 3 : a+=((uint32_t)k[2])<<8;
|
||||
case 2 : a+=((uint32_t)k[1])<<16;
|
||||
case 1 : a+=((uint32_t)k[0])<<24;
|
||||
break;
|
||||
case 0 : return c;
|
||||
}
|
||||
}
|
||||
|
||||
final(a,b,c);
|
||||
*val2 = b;
|
||||
return c;
|
||||
}
|
||||
|
||||
/* I basically use hashlittle here, but use native endian within each
|
||||
* element. This delivers least-surprise: hash such as "int arr[] = {
|
||||
* 1, 2 }; hash_stable(arr, 2, 0);" will be the same on big and little
|
||||
* endian machines, even though a bytewise hash wouldn't be. */
|
||||
uint64_t hash64_stable_64(const void *key, size_t n, uint64_t base)
|
||||
{
|
||||
const uint64_t *k = key;
|
||||
uint32_t a,b,c;
|
||||
|
||||
/* Set up the internal state */
|
||||
a = b = c = 0xdeadbeef + ((uint32_t)n*8) + (base >> 32) + base;
|
||||
|
||||
while (n > 3) {
|
||||
a += (uint32_t)k[0];
|
||||
b += (uint32_t)(k[0] >> 32);
|
||||
c += (uint32_t)k[1];
|
||||
mix(a,b,c);
|
||||
a += (uint32_t)(k[1] >> 32);
|
||||
b += (uint32_t)k[2];
|
||||
c += (uint32_t)(k[2] >> 32);
|
||||
mix(a,b,c);
|
||||
n -= 3;
|
||||
k += 3;
|
||||
}
|
||||
switch (n) {
|
||||
case 2:
|
||||
a += (uint32_t)k[0];
|
||||
b += (uint32_t)(k[0] >> 32);
|
||||
c += (uint32_t)k[1];
|
||||
mix(a,b,c);
|
||||
a += (uint32_t)(k[1] >> 32);
|
||||
break;
|
||||
case 1:
|
||||
a += (uint32_t)k[0];
|
||||
b += (uint32_t)(k[0] >> 32);
|
||||
break;
|
||||
case 0:
|
||||
return c;
|
||||
}
|
||||
final(a,b,c);
|
||||
return ((uint64_t)b << 32) | c;
|
||||
}
|
||||
|
||||
uint64_t hash64_stable_32(const void *key, size_t n, uint64_t base)
|
||||
{
|
||||
const uint32_t *k = key;
|
||||
uint32_t a,b,c;
|
||||
|
||||
/* Set up the internal state */
|
||||
a = b = c = 0xdeadbeef + ((uint32_t)n*4) + (base >> 32) + base;
|
||||
|
||||
while (n > 3) {
|
||||
a += k[0];
|
||||
b += k[1];
|
||||
c += k[2];
|
||||
mix(a,b,c);
|
||||
|
||||
n -= 3;
|
||||
k += 3;
|
||||
}
|
||||
switch (n) {
|
||||
case 2:
|
||||
b += (uint32_t)k[1];
|
||||
case 1:
|
||||
a += (uint32_t)k[0];
|
||||
break;
|
||||
case 0:
|
||||
return c;
|
||||
}
|
||||
final(a,b,c);
|
||||
return ((uint64_t)b << 32) | c;
|
||||
}
|
||||
|
||||
uint64_t hash64_stable_16(const void *key, size_t n, uint64_t base)
|
||||
{
|
||||
const uint16_t *k = key;
|
||||
uint32_t a,b,c;
|
||||
|
||||
/* Set up the internal state */
|
||||
a = b = c = 0xdeadbeef + ((uint32_t)n*2) + (base >> 32) + base;
|
||||
|
||||
while (n > 6) {
|
||||
a += (uint32_t)k[0] + ((uint32_t)k[1] << 16);
|
||||
b += (uint32_t)k[2] + ((uint32_t)k[3] << 16);
|
||||
c += (uint32_t)k[4] + ((uint32_t)k[5] << 16);
|
||||
mix(a,b,c);
|
||||
|
||||
n -= 6;
|
||||
k += 6;
|
||||
}
|
||||
|
||||
switch (n) {
|
||||
case 5:
|
||||
c += (uint32_t)k[4];
|
||||
case 4:
|
||||
b += ((uint32_t)k[3] << 16);
|
||||
case 3:
|
||||
b += (uint32_t)k[2];
|
||||
case 2:
|
||||
a += ((uint32_t)k[1] << 16);
|
||||
case 1:
|
||||
a += (uint32_t)k[0];
|
||||
break;
|
||||
case 0:
|
||||
return c;
|
||||
}
|
||||
final(a,b,c);
|
||||
return ((uint64_t)b << 32) | c;
|
||||
}
|
||||
|
||||
uint64_t hash64_stable_8(const void *key, size_t n, uint64_t base)
|
||||
{
|
||||
uint32_t b32 = base + (base >> 32);
|
||||
uint32_t lower = hashlittle(key, n, &b32);
|
||||
|
||||
return ((uint64_t)b32 << 32) | lower;
|
||||
}
|
||||
|
||||
uint32_t hash_any(const void *key, size_t length, uint32_t base)
|
||||
{
|
||||
if (HASH_BIG_ENDIAN)
|
||||
return hashbig(key, length, &base);
|
||||
else
|
||||
return hashlittle(key, length, &base);
|
||||
}
|
||||
|
||||
uint32_t hash_stable_64(const void *key, size_t n, uint32_t base)
|
||||
{
|
||||
return hash64_stable_64(key, n, base);
|
||||
}
|
||||
|
||||
uint32_t hash_stable_32(const void *key, size_t n, uint32_t base)
|
||||
{
|
||||
return hash64_stable_32(key, n, base);
|
||||
}
|
||||
|
||||
uint32_t hash_stable_16(const void *key, size_t n, uint32_t base)
|
||||
{
|
||||
return hash64_stable_16(key, n, base);
|
||||
}
|
||||
|
||||
uint32_t hash_stable_8(const void *key, size_t n, uint32_t base)
|
||||
{
|
||||
return hashlittle(key, n, &base);
|
||||
}
|
||||
|
||||
/* Jenkins' lookup8 is a 64 bit hash, but he says it's obsolete. Use
|
||||
* the plain one and recombine into 64 bits. */
|
||||
uint64_t hash64_any(const void *key, size_t length, uint64_t base)
|
||||
{
|
||||
uint32_t b32 = base + (base >> 32);
|
||||
uint32_t lower;
|
||||
|
||||
if (HASH_BIG_ENDIAN)
|
||||
lower = hashbig(key, length, &b32);
|
||||
else
|
||||
lower = hashlittle(key, length, &b32);
|
||||
|
||||
return ((uint64_t)b32 << 32) | lower;
|
||||
}
|
||||
|
||||
#ifdef SELF_TEST
|
||||
|
||||
/* used for timings */
|
||||
void driver1()
|
||||
{
|
||||
uint8_t buf[256];
|
||||
uint32_t i;
|
||||
uint32_t h=0;
|
||||
time_t a,z;
|
||||
|
||||
time(&a);
|
||||
for (i=0; i<256; ++i) buf[i] = 'x';
|
||||
for (i=0; i<1; ++i)
|
||||
{
|
||||
h = hashlittle(&buf[0],1,h);
|
||||
}
|
||||
time(&z);
|
||||
if (z-a > 0) printf("time %d %.8x\n", z-a, h);
|
||||
}
|
||||
|
||||
/* check that every input bit changes every output bit half the time */
|
||||
#define HASHSTATE 1
|
||||
#define HASHLEN 1
|
||||
#define MAXPAIR 60
|
||||
#define MAXLEN 70
|
||||
void driver2()
|
||||
{
|
||||
uint8_t qa[MAXLEN+1], qb[MAXLEN+2], *a = &qa[0], *b = &qb[1];
|
||||
uint32_t c[HASHSTATE], d[HASHSTATE], i=0, j=0, k, l, m=0, z;
|
||||
uint32_t e[HASHSTATE],f[HASHSTATE],g[HASHSTATE],h[HASHSTATE];
|
||||
uint32_t x[HASHSTATE],y[HASHSTATE];
|
||||
uint32_t hlen;
|
||||
|
||||
printf("No more than %d trials should ever be needed \n",MAXPAIR/2);
|
||||
for (hlen=0; hlen < MAXLEN; ++hlen)
|
||||
{
|
||||
z=0;
|
||||
for (i=0; i<hlen; ++i) /*----------------------- for each input byte, */
|
||||
{
|
||||
for (j=0; j<8; ++j) /*------------------------ for each input bit, */
|
||||
{
|
||||
for (m=1; m<8; ++m) /*------------ for several possible initvals, */
|
||||
{
|
||||
for (l=0; l<HASHSTATE; ++l)
|
||||
e[l]=f[l]=g[l]=h[l]=x[l]=y[l]=~((uint32_t)0);
|
||||
|
||||
/*---- check that every output bit is affected by that input bit */
|
||||
for (k=0; k<MAXPAIR; k+=2)
|
||||
{
|
||||
uint32_t finished=1;
|
||||
/* keys have one bit different */
|
||||
for (l=0; l<hlen+1; ++l) {a[l] = b[l] = (uint8_t)0;}
|
||||
/* have a and b be two keys differing in only one bit */
|
||||
a[i] ^= (k<<j);
|
||||
a[i] ^= (k>>(8-j));
|
||||
c[0] = hashlittle(a, hlen, m);
|
||||
b[i] ^= ((k+1)<<j);
|
||||
b[i] ^= ((k+1)>>(8-j));
|
||||
d[0] = hashlittle(b, hlen, m);
|
||||
/* check every bit is 1, 0, set, and not set at least once */
|
||||
for (l=0; l<HASHSTATE; ++l)
|
||||
{
|
||||
e[l] &= (c[l]^d[l]);
|
||||
f[l] &= ~(c[l]^d[l]);
|
||||
g[l] &= c[l];
|
||||
h[l] &= ~c[l];
|
||||
x[l] &= d[l];
|
||||
y[l] &= ~d[l];
|
||||
if (e[l]|f[l]|g[l]|h[l]|x[l]|y[l]) finished=0;
|
||||
}
|
||||
if (finished) break;
|
||||
}
|
||||
if (k>z) z=k;
|
||||
if (k==MAXPAIR)
|
||||
{
|
||||
printf("Some bit didn't change: ");
|
||||
printf("%.8x %.8x %.8x %.8x %.8x %.8x ",
|
||||
e[0],f[0],g[0],h[0],x[0],y[0]);
|
||||
printf("i %d j %d m %d len %d\n", i, j, m, hlen);
|
||||
}
|
||||
if (z==MAXPAIR) goto done;
|
||||
}
|
||||
}
|
||||
}
|
||||
done:
|
||||
if (z < MAXPAIR)
|
||||
{
|
||||
printf("Mix success %2d bytes %2d initvals ",i,m);
|
||||
printf("required %d trials\n", z/2);
|
||||
}
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
/* Check for reading beyond the end of the buffer and alignment problems */
|
||||
void driver3()
|
||||
{
|
||||
uint8_t buf[MAXLEN+20], *b;
|
||||
uint32_t len;
|
||||
uint8_t q[] = "This is the time for all good men to come to the aid of their country...";
|
||||
uint32_t h;
|
||||
uint8_t qq[] = "xThis is the time for all good men to come to the aid of their country...";
|
||||
uint32_t i;
|
||||
uint8_t qqq[] = "xxThis is the time for all good men to come to the aid of their country...";
|
||||
uint32_t j;
|
||||
uint8_t qqqq[] = "xxxThis is the time for all good men to come to the aid of their country...";
|
||||
uint32_t ref,x,y;
|
||||
uint8_t *p;
|
||||
|
||||
printf("Endianness. These lines should all be the same (for values filled in):\n");
|
||||
printf("%.8x %.8x %.8x\n",
|
||||
hash_word((const uint32_t *)q, (sizeof(q)-1)/4, 13),
|
||||
hash_word((const uint32_t *)q, (sizeof(q)-5)/4, 13),
|
||||
hash_word((const uint32_t *)q, (sizeof(q)-9)/4, 13));
|
||||
p = q;
|
||||
printf("%.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x\n",
|
||||
hashlittle(p, sizeof(q)-1, 13), hashlittle(p, sizeof(q)-2, 13),
|
||||
hashlittle(p, sizeof(q)-3, 13), hashlittle(p, sizeof(q)-4, 13),
|
||||
hashlittle(p, sizeof(q)-5, 13), hashlittle(p, sizeof(q)-6, 13),
|
||||
hashlittle(p, sizeof(q)-7, 13), hashlittle(p, sizeof(q)-8, 13),
|
||||
hashlittle(p, sizeof(q)-9, 13), hashlittle(p, sizeof(q)-10, 13),
|
||||
hashlittle(p, sizeof(q)-11, 13), hashlittle(p, sizeof(q)-12, 13));
|
||||
p = &qq[1];
|
||||
printf("%.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x\n",
|
||||
hashlittle(p, sizeof(q)-1, 13), hashlittle(p, sizeof(q)-2, 13),
|
||||
hashlittle(p, sizeof(q)-3, 13), hashlittle(p, sizeof(q)-4, 13),
|
||||
hashlittle(p, sizeof(q)-5, 13), hashlittle(p, sizeof(q)-6, 13),
|
||||
hashlittle(p, sizeof(q)-7, 13), hashlittle(p, sizeof(q)-8, 13),
|
||||
hashlittle(p, sizeof(q)-9, 13), hashlittle(p, sizeof(q)-10, 13),
|
||||
hashlittle(p, sizeof(q)-11, 13), hashlittle(p, sizeof(q)-12, 13));
|
||||
p = &qqq[2];
|
||||
printf("%.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x\n",
|
||||
hashlittle(p, sizeof(q)-1, 13), hashlittle(p, sizeof(q)-2, 13),
|
||||
hashlittle(p, sizeof(q)-3, 13), hashlittle(p, sizeof(q)-4, 13),
|
||||
hashlittle(p, sizeof(q)-5, 13), hashlittle(p, sizeof(q)-6, 13),
|
||||
hashlittle(p, sizeof(q)-7, 13), hashlittle(p, sizeof(q)-8, 13),
|
||||
hashlittle(p, sizeof(q)-9, 13), hashlittle(p, sizeof(q)-10, 13),
|
||||
hashlittle(p, sizeof(q)-11, 13), hashlittle(p, sizeof(q)-12, 13));
|
||||
p = &qqqq[3];
|
||||
printf("%.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x %.8x\n",
|
||||
hashlittle(p, sizeof(q)-1, 13), hashlittle(p, sizeof(q)-2, 13),
|
||||
hashlittle(p, sizeof(q)-3, 13), hashlittle(p, sizeof(q)-4, 13),
|
||||
hashlittle(p, sizeof(q)-5, 13), hashlittle(p, sizeof(q)-6, 13),
|
||||
hashlittle(p, sizeof(q)-7, 13), hashlittle(p, sizeof(q)-8, 13),
|
||||
hashlittle(p, sizeof(q)-9, 13), hashlittle(p, sizeof(q)-10, 13),
|
||||
hashlittle(p, sizeof(q)-11, 13), hashlittle(p, sizeof(q)-12, 13));
|
||||
printf("\n");
|
||||
|
||||
/* check that hashlittle2 and hashlittle produce the same results */
|
||||
i=47; j=0;
|
||||
hashlittle2(q, sizeof(q), &i, &j);
|
||||
if (hashlittle(q, sizeof(q), 47) != i)
|
||||
printf("hashlittle2 and hashlittle mismatch\n");
|
||||
|
||||
/* check that hash_word2 and hash_word produce the same results */
|
||||
len = 0xdeadbeef;
|
||||
i=47, j=0;
|
||||
hash_word2(&len, 1, &i, &j);
|
||||
if (hash_word(&len, 1, 47) != i)
|
||||
printf("hash_word2 and hash_word mismatch %x %x\n",
|
||||
i, hash_word(&len, 1, 47));
|
||||
|
||||
/* check hashlittle doesn't read before or after the ends of the string */
|
||||
for (h=0, b=buf+1; h<8; ++h, ++b)
|
||||
{
|
||||
for (i=0; i<MAXLEN; ++i)
|
||||
{
|
||||
len = i;
|
||||
for (j=0; j<i; ++j) *(b+j)=0;
|
||||
|
||||
/* these should all be equal */
|
||||
ref = hashlittle(b, len, (uint32_t)1);
|
||||
*(b+i)=(uint8_t)~0;
|
||||
*(b-1)=(uint8_t)~0;
|
||||
x = hashlittle(b, len, (uint32_t)1);
|
||||
y = hashlittle(b, len, (uint32_t)1);
|
||||
if ((ref != x) || (ref != y))
|
||||
{
|
||||
printf("alignment error: %.8x %.8x %.8x %d %d\n",ref,x,y,
|
||||
h, i);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* check for problems with nulls */
|
||||
void driver4()
|
||||
{
|
||||
uint8_t buf[1];
|
||||
uint32_t h,i,state[HASHSTATE];
|
||||
|
||||
|
||||
buf[0] = ~0;
|
||||
for (i=0; i<HASHSTATE; ++i) state[i] = 1;
|
||||
printf("These should all be different\n");
|
||||
for (i=0, h=0; i<8; ++i)
|
||||
{
|
||||
h = hashlittle(buf, 0, h);
|
||||
printf("%2ld 0-byte strings, hash is %.8x\n", i, h);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
int main()
|
||||
{
|
||||
driver1(); /* test that the key is hashed: used for timings */
|
||||
driver2(); /* test that whole key is hashed thoroughly */
|
||||
driver3(); /* test that nothing but the key is hashed */
|
||||
driver4(); /* test hashing multiple buffers (all buffers are null) */
|
||||
return 1;
|
||||
}
|
||||
|
||||
#endif /* SELF_TEST */
|
||||
313
src/ccan/hash/hash.h
Normal file
313
src/ccan/hash/hash.h
Normal file
@@ -0,0 +1,313 @@
|
||||
/* CC0 (Public domain) - see LICENSE file for details */
|
||||
#ifndef CCAN_HASH_H
|
||||
#define CCAN_HASH_H
|
||||
#include "config.h"
|
||||
#include <stdint.h>
|
||||
#include <stdlib.h>
|
||||
#include <ccan/build_assert/build_assert.h>
|
||||
|
||||
/* Stolen mostly from: lookup3.c, by Bob Jenkins, May 2006, Public Domain.
|
||||
*
|
||||
* http://burtleburtle.net/bob/c/lookup3.c
|
||||
*/
|
||||
|
||||
/**
|
||||
* hash - fast hash of an array for internal use
|
||||
* @p: the array or pointer to first element
|
||||
* @num: the number of elements to hash
|
||||
* @base: the base number to roll into the hash (usually 0)
|
||||
*
|
||||
* The memory region pointed to by p is combined with the base to form
|
||||
* a 32-bit hash.
|
||||
*
|
||||
* This hash will have different results on different machines, so is
|
||||
* only useful for internal hashes (ie. not hashes sent across the
|
||||
* network or saved to disk).
|
||||
*
|
||||
* It may also change with future versions: it could even detect at runtime
|
||||
* what the fastest hash to use is.
|
||||
*
|
||||
* See also: hash64, hash_stable.
|
||||
*
|
||||
* Example:
|
||||
* #include <ccan/hash/hash.h>
|
||||
* #include <err.h>
|
||||
* #include <stdio.h>
|
||||
* #include <string.h>
|
||||
*
|
||||
* // Simple demonstration: idential strings will have the same hash, but
|
||||
* // two different strings will probably not.
|
||||
* int main(int argc, char *argv[])
|
||||
* {
|
||||
* uint32_t hash1, hash2;
|
||||
*
|
||||
* if (argc != 3)
|
||||
* err(1, "Usage: %s <string1> <string2>", argv[0]);
|
||||
*
|
||||
* hash1 = hash(argv[1], strlen(argv[1]), 0);
|
||||
* hash2 = hash(argv[2], strlen(argv[2]), 0);
|
||||
* printf("Hash is %s\n", hash1 == hash2 ? "same" : "different");
|
||||
* return 0;
|
||||
* }
|
||||
*/
|
||||
#define hash(p, num, base) hash_any((p), (num)*sizeof(*(p)), (base))
|
||||
|
||||
/**
|
||||
* hash_stable - hash of an array for external use
|
||||
* @p: the array or pointer to first element
|
||||
* @num: the number of elements to hash
|
||||
* @base: the base number to roll into the hash (usually 0)
|
||||
*
|
||||
* The array of simple integer types pointed to by p is combined with
|
||||
* the base to form a 32-bit hash.
|
||||
*
|
||||
* This hash will have the same results on different machines, so can
|
||||
* be used for external hashes (ie. hashes sent across the network or
|
||||
* saved to disk). The results will not change in future versions of
|
||||
* this module.
|
||||
*
|
||||
* Note that it is only legal to hand an array of simple integer types
|
||||
* to this hash (ie. char, uint16_t, int64_t, etc). In these cases,
|
||||
* the same values will have the same hash result, even though the
|
||||
* memory representations of integers depend on the machine
|
||||
* endianness.
|
||||
*
|
||||
* See also:
|
||||
* hash64_stable
|
||||
*
|
||||
* Example:
|
||||
* #include <ccan/hash/hash.h>
|
||||
* #include <err.h>
|
||||
* #include <stdio.h>
|
||||
* #include <string.h>
|
||||
*
|
||||
* int main(int argc, char *argv[])
|
||||
* {
|
||||
* if (argc != 2)
|
||||
* err(1, "Usage: %s <string-to-hash>", argv[0]);
|
||||
*
|
||||
* printf("Hash stable result is %u\n",
|
||||
* hash_stable(argv[1], strlen(argv[1]), 0));
|
||||
* return 0;
|
||||
* }
|
||||
*/
|
||||
#define hash_stable(p, num, base) \
|
||||
(BUILD_ASSERT_OR_ZERO(sizeof(*(p)) == 8 || sizeof(*(p)) == 4 \
|
||||
|| sizeof(*(p)) == 2 || sizeof(*(p)) == 1) + \
|
||||
sizeof(*(p)) == 8 ? hash_stable_64((p), (num), (base)) \
|
||||
: sizeof(*(p)) == 4 ? hash_stable_32((p), (num), (base)) \
|
||||
: sizeof(*(p)) == 2 ? hash_stable_16((p), (num), (base)) \
|
||||
: hash_stable_8((p), (num), (base)))
|
||||
|
||||
/**
|
||||
* hash_u32 - fast hash an array of 32-bit values for internal use
|
||||
* @key: the array of uint32_t
|
||||
* @num: the number of elements to hash
|
||||
* @base: the base number to roll into the hash (usually 0)
|
||||
*
|
||||
* The array of uint32_t pointed to by @key is combined with the base
|
||||
* to form a 32-bit hash. This is 2-3 times faster than hash() on small
|
||||
* arrays, but the advantage vanishes over large hashes.
|
||||
*
|
||||
* This hash will have different results on different machines, so is
|
||||
* only useful for internal hashes (ie. not hashes sent across the
|
||||
* network or saved to disk).
|
||||
*/
|
||||
uint32_t hash_u32(const uint32_t *key, size_t num, uint32_t base);
|
||||
|
||||
/**
|
||||
* hash_string - very fast hash of an ascii string
|
||||
* @str: the nul-terminated string
|
||||
*
|
||||
* The string is hashed, using a hash function optimized for ASCII and
|
||||
* similar strings. It's weaker than the other hash functions.
|
||||
*
|
||||
* This hash may have different results on different machines, so is
|
||||
* only useful for internal hashes (ie. not hashes sent across the
|
||||
* network or saved to disk). The results will be different from the
|
||||
* other hash functions in this module, too.
|
||||
*/
|
||||
static inline uint32_t hash_string(const char *string)
|
||||
{
|
||||
/* This is Karl Nelson <kenelson@ece.ucdavis.edu>'s X31 hash.
|
||||
* It's a little faster than the (much better) lookup3 hash(): 56ns vs
|
||||
* 84ns on my 2GHz Intel Core Duo 2 laptop for a 10 char string. */
|
||||
uint32_t ret;
|
||||
|
||||
for (ret = 0; *string; string++)
|
||||
ret = (ret << 5) - ret + *string;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* hash64 - fast 64-bit hash of an array for internal use
|
||||
* @p: the array or pointer to first element
|
||||
* @num: the number of elements to hash
|
||||
* @base: the 64-bit base number to roll into the hash (usually 0)
|
||||
*
|
||||
* The memory region pointed to by p is combined with the base to form
|
||||
* a 64-bit hash.
|
||||
*
|
||||
* This hash will have different results on different machines, so is
|
||||
* only useful for internal hashes (ie. not hashes sent across the
|
||||
* network or saved to disk).
|
||||
*
|
||||
* It may also change with future versions: it could even detect at runtime
|
||||
* what the fastest hash to use is.
|
||||
*
|
||||
* See also: hash.
|
||||
*
|
||||
* Example:
|
||||
* #include <ccan/hash/hash.h>
|
||||
* #include <err.h>
|
||||
* #include <stdio.h>
|
||||
* #include <string.h>
|
||||
*
|
||||
* // Simple demonstration: idential strings will have the same hash, but
|
||||
* // two different strings will probably not.
|
||||
* int main(int argc, char *argv[])
|
||||
* {
|
||||
* uint64_t hash1, hash2;
|
||||
*
|
||||
* if (argc != 3)
|
||||
* err(1, "Usage: %s <string1> <string2>", argv[0]);
|
||||
*
|
||||
* hash1 = hash64(argv[1], strlen(argv[1]), 0);
|
||||
* hash2 = hash64(argv[2], strlen(argv[2]), 0);
|
||||
* printf("Hash is %s\n", hash1 == hash2 ? "same" : "different");
|
||||
* return 0;
|
||||
* }
|
||||
*/
|
||||
#define hash64(p, num, base) hash64_any((p), (num)*sizeof(*(p)), (base))
|
||||
|
||||
/**
|
||||
* hash64_stable - 64 bit hash of an array for external use
|
||||
* @p: the array or pointer to first element
|
||||
* @num: the number of elements to hash
|
||||
* @base: the base number to roll into the hash (usually 0)
|
||||
*
|
||||
* The array of simple integer types pointed to by p is combined with
|
||||
* the base to form a 64-bit hash.
|
||||
*
|
||||
* This hash will have the same results on different machines, so can
|
||||
* be used for external hashes (ie. hashes sent across the network or
|
||||
* saved to disk). The results will not change in future versions of
|
||||
* this module.
|
||||
*
|
||||
* Note that it is only legal to hand an array of simple integer types
|
||||
* to this hash (ie. char, uint16_t, int64_t, etc). In these cases,
|
||||
* the same values will have the same hash result, even though the
|
||||
* memory representations of integers depend on the machine
|
||||
* endianness.
|
||||
*
|
||||
* See also:
|
||||
* hash_stable
|
||||
*
|
||||
* Example:
|
||||
* #include <ccan/hash/hash.h>
|
||||
* #include <err.h>
|
||||
* #include <stdio.h>
|
||||
* #include <string.h>
|
||||
*
|
||||
* int main(int argc, char *argv[])
|
||||
* {
|
||||
* if (argc != 2)
|
||||
* err(1, "Usage: %s <string-to-hash>", argv[0]);
|
||||
*
|
||||
* printf("Hash stable result is %llu\n",
|
||||
* (long long)hash64_stable(argv[1], strlen(argv[1]), 0));
|
||||
* return 0;
|
||||
* }
|
||||
*/
|
||||
#define hash64_stable(p, num, base) \
|
||||
(BUILD_ASSERT_OR_ZERO(sizeof(*(p)) == 8 || sizeof(*(p)) == 4 \
|
||||
|| sizeof(*(p)) == 2 || sizeof(*(p)) == 1) + \
|
||||
sizeof(*(p)) == 8 ? hash64_stable_64((p), (num), (base)) \
|
||||
: sizeof(*(p)) == 4 ? hash64_stable_32((p), (num), (base)) \
|
||||
: sizeof(*(p)) == 2 ? hash64_stable_16((p), (num), (base)) \
|
||||
: hash64_stable_8((p), (num), (base)))
|
||||
|
||||
|
||||
/**
|
||||
* hashl - fast 32/64-bit hash of an array for internal use
|
||||
* @p: the array or pointer to first element
|
||||
* @num: the number of elements to hash
|
||||
* @base: the base number to roll into the hash (usually 0)
|
||||
*
|
||||
* This is either hash() or hash64(), on 32/64 bit long machines.
|
||||
*/
|
||||
#define hashl(p, num, base) \
|
||||
(BUILD_ASSERT_OR_ZERO(sizeof(long) == sizeof(uint32_t) \
|
||||
|| sizeof(long) == sizeof(uint64_t)) + \
|
||||
(sizeof(long) == sizeof(uint64_t) \
|
||||
? hash64((p), (num), (base)) : hash((p), (num), (base))))
|
||||
|
||||
/* Our underlying operations. */
|
||||
uint32_t hash_any(const void *key, size_t length, uint32_t base);
|
||||
uint32_t hash_stable_64(const void *key, size_t n, uint32_t base);
|
||||
uint32_t hash_stable_32(const void *key, size_t n, uint32_t base);
|
||||
uint32_t hash_stable_16(const void *key, size_t n, uint32_t base);
|
||||
uint32_t hash_stable_8(const void *key, size_t n, uint32_t base);
|
||||
uint64_t hash64_any(const void *key, size_t length, uint64_t base);
|
||||
uint64_t hash64_stable_64(const void *key, size_t n, uint64_t base);
|
||||
uint64_t hash64_stable_32(const void *key, size_t n, uint64_t base);
|
||||
uint64_t hash64_stable_16(const void *key, size_t n, uint64_t base);
|
||||
uint64_t hash64_stable_8(const void *key, size_t n, uint64_t base);
|
||||
|
||||
/**
|
||||
* hash_pointer - hash a pointer for internal use
|
||||
* @p: the pointer value to hash
|
||||
* @base: the base number to roll into the hash (usually 0)
|
||||
*
|
||||
* The pointer p (not what p points to!) is combined with the base to form
|
||||
* a 32-bit hash.
|
||||
*
|
||||
* This hash will have different results on different machines, so is
|
||||
* only useful for internal hashes (ie. not hashes sent across the
|
||||
* network or saved to disk).
|
||||
*
|
||||
* Example:
|
||||
* #include <ccan/hash/hash.h>
|
||||
*
|
||||
* // Code to keep track of memory regions.
|
||||
* struct region {
|
||||
* struct region *chain;
|
||||
* void *start;
|
||||
* unsigned int size;
|
||||
* };
|
||||
* // We keep a simple hash table.
|
||||
* static struct region *region_hash[128];
|
||||
*
|
||||
* static void add_region(struct region *r)
|
||||
* {
|
||||
* unsigned int h = hash_pointer(r->start, 0);
|
||||
*
|
||||
* r->chain = region_hash[h];
|
||||
* region_hash[h] = r->chain;
|
||||
* }
|
||||
*
|
||||
* static struct region *find_region(const void *start)
|
||||
* {
|
||||
* struct region *r;
|
||||
*
|
||||
* for (r = region_hash[hash_pointer(start, 0)]; r; r = r->chain)
|
||||
* if (r->start == start)
|
||||
* return r;
|
||||
* return NULL;
|
||||
* }
|
||||
*/
|
||||
static inline uint32_t hash_pointer(const void *p, uint32_t base)
|
||||
{
|
||||
if (sizeof(p) % sizeof(uint32_t) == 0) {
|
||||
/* This convoluted union is the right way of aliasing. */
|
||||
union {
|
||||
uint32_t a[sizeof(p) / sizeof(uint32_t)];
|
||||
const void *p;
|
||||
} u;
|
||||
u.p = p;
|
||||
return hash_u32(u.a, sizeof(p) / sizeof(uint32_t), base);
|
||||
} else
|
||||
return hash(&p, 1, base);
|
||||
}
|
||||
#endif /* HASH_H */
|
||||
275
src/ccan/htable/htable.c
Normal file
275
src/ccan/htable/htable.c
Normal file
@@ -0,0 +1,275 @@
|
||||
/* Licensed under LGPLv2+ - see LICENSE file for details */
|
||||
#include <config.h>
|
||||
#include <ccan/htable/htable.h>
|
||||
#include <stdlib.h>
|
||||
#include <limits.h>
|
||||
#include <stdbool.h>
|
||||
#include <assert.h>
|
||||
|
||||
#define COLD
|
||||
|
||||
/* We use 0x1 as deleted marker. */
|
||||
#define HTABLE_DELETED (0x1)
|
||||
|
||||
/* We clear out the bits which are always the same, and put metadata there. */
|
||||
static inline uintptr_t get_extra_ptr_bits(const struct htable *ht,
|
||||
uintptr_t e)
|
||||
{
|
||||
return e & ht->common_mask;
|
||||
}
|
||||
|
||||
static inline void *get_raw_ptr(const struct htable *ht, uintptr_t e)
|
||||
{
|
||||
return (void *)((e & ~ht->common_mask) | ht->common_bits);
|
||||
}
|
||||
|
||||
static inline uintptr_t make_hval(const struct htable *ht,
|
||||
const void *p, uintptr_t bits)
|
||||
{
|
||||
return ((uintptr_t)p & ~ht->common_mask) | bits;
|
||||
}
|
||||
|
||||
static inline bool entry_is_valid(uintptr_t e)
|
||||
{
|
||||
return e > HTABLE_DELETED;
|
||||
}
|
||||
|
||||
static inline uintptr_t get_hash_ptr_bits(const struct htable *ht,
|
||||
size_t hash)
|
||||
{
|
||||
/* Shuffling the extra bits (as specified in mask) down the
|
||||
* end is quite expensive. But the lower bits are redundant, so
|
||||
* we fold the value first. */
|
||||
return (hash ^ (hash >> ht->bits))
|
||||
& ht->common_mask & ~ht->perfect_bit;
|
||||
}
|
||||
|
||||
void htable_init(struct htable *ht,
|
||||
size_t (*rehash)(const void *elem, void *priv), void *priv)
|
||||
{
|
||||
struct htable empty = HTABLE_INITIALIZER(empty, NULL, NULL);
|
||||
*ht = empty;
|
||||
ht->rehash = rehash;
|
||||
ht->priv = priv;
|
||||
ht->table = &ht->perfect_bit;
|
||||
}
|
||||
|
||||
void htable_clear(struct htable *ht)
|
||||
{
|
||||
if (ht->table != &ht->perfect_bit)
|
||||
free((void *)ht->table);
|
||||
htable_init(ht, ht->rehash, ht->priv);
|
||||
}
|
||||
|
||||
static size_t hash_bucket(const struct htable *ht, size_t h)
|
||||
{
|
||||
return h & ((1 << ht->bits)-1);
|
||||
}
|
||||
|
||||
static void *htable_val(const struct htable *ht,
|
||||
struct htable_iter *i, size_t hash, uintptr_t perfect)
|
||||
{
|
||||
uintptr_t h2 = get_hash_ptr_bits(ht, hash) | perfect;
|
||||
|
||||
while (ht->table[i->off]) {
|
||||
if (ht->table[i->off] != HTABLE_DELETED) {
|
||||
if (get_extra_ptr_bits(ht, ht->table[i->off]) == h2)
|
||||
return get_raw_ptr(ht, ht->table[i->off]);
|
||||
}
|
||||
i->off = (i->off + 1) & ((1 << ht->bits)-1);
|
||||
h2 &= ~perfect;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void *htable_firstval(const struct htable *ht,
|
||||
struct htable_iter *i, size_t hash)
|
||||
{
|
||||
i->off = hash_bucket(ht, hash);
|
||||
return htable_val(ht, i, hash, ht->perfect_bit);
|
||||
}
|
||||
|
||||
void *htable_nextval(const struct htable *ht,
|
||||
struct htable_iter *i, size_t hash)
|
||||
{
|
||||
i->off = (i->off + 1) & ((1 << ht->bits)-1);
|
||||
return htable_val(ht, i, hash, 0);
|
||||
}
|
||||
|
||||
void *htable_first(const struct htable *ht, struct htable_iter *i)
|
||||
{
|
||||
for (i->off = 0; i->off < (size_t)1 << ht->bits; i->off++) {
|
||||
if (entry_is_valid(ht->table[i->off]))
|
||||
return get_raw_ptr(ht, ht->table[i->off]);
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void *htable_next(const struct htable *ht, struct htable_iter *i)
|
||||
{
|
||||
for (i->off++; i->off < (size_t)1 << ht->bits; i->off++) {
|
||||
if (entry_is_valid(ht->table[i->off]))
|
||||
return get_raw_ptr(ht, ht->table[i->off]);
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* This does not expand the hash table, that's up to caller. */
|
||||
static void ht_add(struct htable *ht, const void *new, size_t h)
|
||||
{
|
||||
size_t i;
|
||||
uintptr_t perfect = ht->perfect_bit;
|
||||
|
||||
i = hash_bucket(ht, h);
|
||||
|
||||
while (entry_is_valid(ht->table[i])) {
|
||||
perfect = 0;
|
||||
i = (i + 1) & ((1 << ht->bits)-1);
|
||||
}
|
||||
ht->table[i] = make_hval(ht, new, get_hash_ptr_bits(ht, h)|perfect);
|
||||
}
|
||||
|
||||
static COLD bool double_table(struct htable *ht)
|
||||
{
|
||||
unsigned int i;
|
||||
size_t oldnum = (size_t)1 << ht->bits;
|
||||
uintptr_t *oldtable, e;
|
||||
|
||||
oldtable = ht->table;
|
||||
ht->table = calloc(1 << (ht->bits+1), sizeof(size_t));
|
||||
if (!ht->table) {
|
||||
ht->table = oldtable;
|
||||
return false;
|
||||
}
|
||||
ht->bits++;
|
||||
ht->max = ((size_t)3 << ht->bits) / 4;
|
||||
ht->max_with_deleted = ((size_t)9 << ht->bits) / 10;
|
||||
|
||||
/* If we lost our "perfect bit", get it back now. */
|
||||
if (!ht->perfect_bit && ht->common_mask) {
|
||||
for (i = 0; i < sizeof(ht->common_mask) * CHAR_BIT; i++) {
|
||||
if (ht->common_mask & ((size_t)1 << i)) {
|
||||
ht->perfect_bit = (size_t)1 << i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (oldtable != &ht->perfect_bit) {
|
||||
for (i = 0; i < oldnum; i++) {
|
||||
if (entry_is_valid(e = oldtable[i])) {
|
||||
void *p = get_raw_ptr(ht, e);
|
||||
ht_add(ht, p, ht->rehash(p, ht->priv));
|
||||
}
|
||||
}
|
||||
free(oldtable);
|
||||
}
|
||||
ht->deleted = 0;
|
||||
return true;
|
||||
}
|
||||
|
||||
static COLD void rehash_table(struct htable *ht)
|
||||
{
|
||||
size_t start, i;
|
||||
uintptr_t e;
|
||||
|
||||
/* Beware wrap cases: we need to start from first empty bucket. */
|
||||
for (start = 0; ht->table[start]; start++);
|
||||
|
||||
for (i = 0; i < (size_t)1 << ht->bits; i++) {
|
||||
size_t h = (i + start) & ((1 << ht->bits)-1);
|
||||
e = ht->table[h];
|
||||
if (!e)
|
||||
continue;
|
||||
if (e == HTABLE_DELETED)
|
||||
ht->table[h] = 0;
|
||||
else if (!(e & ht->perfect_bit)) {
|
||||
void *p = get_raw_ptr(ht, e);
|
||||
ht->table[h] = 0;
|
||||
ht_add(ht, p, ht->rehash(p, ht->priv));
|
||||
}
|
||||
}
|
||||
ht->deleted = 0;
|
||||
}
|
||||
|
||||
/* We stole some bits, now we need to put them back... */
|
||||
static COLD void update_common(struct htable *ht, const void *p)
|
||||
{
|
||||
unsigned int i;
|
||||
uintptr_t maskdiff, bitsdiff;
|
||||
|
||||
if (ht->elems == 0) {
|
||||
/* Always reveal one bit of the pointer in the bucket,
|
||||
* so it's not zero or HTABLE_DELETED (1), even if
|
||||
* hash happens to be 0. Assumes (void *)1 is not a
|
||||
* valid pointer. */
|
||||
for (i = sizeof(uintptr_t)*CHAR_BIT - 1; i > 0; i--) {
|
||||
if ((uintptr_t)p & ((uintptr_t)1 << i))
|
||||
break;
|
||||
}
|
||||
|
||||
ht->common_mask = ~((uintptr_t)1 << i);
|
||||
ht->common_bits = ((uintptr_t)p & ht->common_mask);
|
||||
ht->perfect_bit = 1;
|
||||
return;
|
||||
}
|
||||
|
||||
/* Find bits which are unequal to old common set. */
|
||||
maskdiff = ht->common_bits ^ ((uintptr_t)p & ht->common_mask);
|
||||
|
||||
/* These are the bits which go there in existing entries. */
|
||||
bitsdiff = ht->common_bits & maskdiff;
|
||||
|
||||
for (i = 0; i < (size_t)1 << ht->bits; i++) {
|
||||
if (!entry_is_valid(ht->table[i]))
|
||||
continue;
|
||||
/* Clear the bits no longer in the mask, set them as
|
||||
* expected. */
|
||||
ht->table[i] &= ~maskdiff;
|
||||
ht->table[i] |= bitsdiff;
|
||||
}
|
||||
|
||||
/* Take away those bits from our mask, bits and perfect bit. */
|
||||
ht->common_mask &= ~maskdiff;
|
||||
ht->common_bits &= ~maskdiff;
|
||||
ht->perfect_bit &= ~maskdiff;
|
||||
}
|
||||
|
||||
bool htable_add(struct htable *ht, size_t hash, const void *p)
|
||||
{
|
||||
if (ht->elems+1 > ht->max && !double_table(ht))
|
||||
return false;
|
||||
if (ht->elems+1 + ht->deleted > ht->max_with_deleted)
|
||||
rehash_table(ht);
|
||||
assert(p);
|
||||
if (((uintptr_t)p & ht->common_mask) != ht->common_bits)
|
||||
update_common(ht, p);
|
||||
|
||||
ht_add(ht, p, hash);
|
||||
ht->elems++;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool htable_del(struct htable *ht, size_t h, const void *p)
|
||||
{
|
||||
struct htable_iter i;
|
||||
void *c;
|
||||
|
||||
for (c = htable_firstval(ht,&i,h); c; c = htable_nextval(ht,&i,h)) {
|
||||
if (c == p) {
|
||||
htable_delval(ht, &i);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
void htable_delval(struct htable *ht, struct htable_iter *i)
|
||||
{
|
||||
assert(i->off < (size_t)1 << ht->bits);
|
||||
assert(entry_is_valid(ht->table[i->off]));
|
||||
|
||||
ht->elems--;
|
||||
ht->table[i->off] = HTABLE_DELETED;
|
||||
ht->deleted++;
|
||||
}
|
||||
176
src/ccan/htable/htable.h
Normal file
176
src/ccan/htable/htable.h
Normal file
@@ -0,0 +1,176 @@
|
||||
/* Licensed under LGPLv2+ - see LICENSE file for details */
|
||||
#ifndef CCAN_HTABLE_H
|
||||
#define CCAN_HTABLE_H
|
||||
#include <config.h>
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
/**
|
||||
* struct htable - private definition of a htable.
|
||||
*
|
||||
* It's exposed here so you can put it in your structures and so we can
|
||||
* supply inline functions.
|
||||
*/
|
||||
struct htable {
|
||||
size_t (*rehash)(const void *elem, void *priv);
|
||||
void *priv;
|
||||
unsigned int bits;
|
||||
size_t elems, deleted, max, max_with_deleted;
|
||||
/* These are the bits which are the same in all pointers. */
|
||||
uintptr_t common_mask, common_bits;
|
||||
uintptr_t perfect_bit;
|
||||
uintptr_t *table;
|
||||
};
|
||||
|
||||
/**
|
||||
* HTABLE_INITIALIZER - static initialization for a hash table.
|
||||
* @name: name of this htable.
|
||||
* @rehash: hash function to use for rehashing.
|
||||
* @priv: private argument to @rehash function.
|
||||
*
|
||||
* This is useful for setting up static and global hash tables.
|
||||
*
|
||||
* Example:
|
||||
* // For simplicity's sake, say hash value is contents of elem.
|
||||
* static size_t rehash(const void *elem, void *unused)
|
||||
* {
|
||||
* return *(size_t *)elem;
|
||||
* }
|
||||
* static struct htable ht = HTABLE_INITIALIZER(ht, rehash, NULL);
|
||||
*/
|
||||
#define HTABLE_INITIALIZER(name, rehash, priv) \
|
||||
{ rehash, priv, 0, 0, 0, 0, 0, -1, 0, 0, &name.perfect_bit }
|
||||
|
||||
/**
|
||||
* htable_init - initialize an empty hash table.
|
||||
* @ht: the hash table to initialize
|
||||
* @rehash: hash function to use for rehashing.
|
||||
* @priv: private argument to @rehash function.
|
||||
*/
|
||||
void htable_init(struct htable *ht,
|
||||
size_t (*rehash)(const void *elem, void *priv), void *priv);
|
||||
|
||||
/**
|
||||
* htable_clear - empty a hash table.
|
||||
* @ht: the hash table to clear
|
||||
*
|
||||
* This doesn't do anything to any pointers left in it.
|
||||
*/
|
||||
void htable_clear(struct htable *ht);
|
||||
|
||||
/**
|
||||
* htable_rehash - use a hashtree's rehash function
|
||||
* @elem: the argument to rehash()
|
||||
*
|
||||
*/
|
||||
size_t htable_rehash(const void *elem);
|
||||
|
||||
/**
|
||||
* htable_add - add a pointer into a hash table.
|
||||
* @ht: the htable
|
||||
* @hash: the hash value of the object
|
||||
* @p: the non-NULL pointer
|
||||
*
|
||||
* Also note that this can only fail due to allocation failure. Otherwise, it
|
||||
* returns true.
|
||||
*/
|
||||
bool htable_add(struct htable *ht, size_t hash, const void *p);
|
||||
|
||||
/**
|
||||
* htable_del - remove a pointer from a hash table
|
||||
* @ht: the htable
|
||||
* @hash: the hash value of the object
|
||||
* @p: the pointer
|
||||
*
|
||||
* Returns true if the pointer was found (and deleted).
|
||||
*/
|
||||
bool htable_del(struct htable *ht, size_t hash, const void *p);
|
||||
|
||||
/**
|
||||
* struct htable_iter - iterator or htable_first or htable_firstval etc.
|
||||
*
|
||||
* This refers to a location inside the hashtable.
|
||||
*/
|
||||
struct htable_iter {
|
||||
size_t off;
|
||||
};
|
||||
|
||||
/**
|
||||
* htable_firstval - find a candidate for a given hash value
|
||||
* @htable: the hashtable
|
||||
* @i: the struct htable_iter to initialize
|
||||
* @hash: the hash value
|
||||
*
|
||||
* You'll need to check the value is what you want; returns NULL if none.
|
||||
* See Also:
|
||||
* htable_delval()
|
||||
*/
|
||||
void *htable_firstval(const struct htable *htable,
|
||||
struct htable_iter *i, size_t hash);
|
||||
|
||||
/**
|
||||
* htable_nextval - find another candidate for a given hash value
|
||||
* @htable: the hashtable
|
||||
* @i: the struct htable_iter to initialize
|
||||
* @hash: the hash value
|
||||
*
|
||||
* You'll need to check the value is what you want; returns NULL if no more.
|
||||
*/
|
||||
void *htable_nextval(const struct htable *htable,
|
||||
struct htable_iter *i, size_t hash);
|
||||
|
||||
/**
|
||||
* htable_get - find an entry in the hash table
|
||||
* @ht: the hashtable
|
||||
* @h: the hash value of the entry
|
||||
* @cmp: the comparison function
|
||||
* @ptr: the pointer to hand to the comparison function.
|
||||
*
|
||||
* Convenient inline wrapper for htable_firstval/htable_nextval loop.
|
||||
*/
|
||||
static inline void *htable_get(const struct htable *ht,
|
||||
size_t h,
|
||||
bool (*cmp)(const void *candidate, void *ptr),
|
||||
const void *ptr)
|
||||
{
|
||||
struct htable_iter i;
|
||||
void *c;
|
||||
|
||||
for (c = htable_firstval(ht,&i,h); c; c = htable_nextval(ht,&i,h)) {
|
||||
if (cmp(c, (void *)ptr))
|
||||
return c;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/**
|
||||
* htable_first - find an entry in the hash table
|
||||
* @ht: the hashtable
|
||||
* @i: the struct htable_iter to initialize
|
||||
*
|
||||
* Get an entry in the hashtable; NULL if empty.
|
||||
*/
|
||||
void *htable_first(const struct htable *htable, struct htable_iter *i);
|
||||
|
||||
/**
|
||||
* htable_next - find another entry in the hash table
|
||||
* @ht: the hashtable
|
||||
* @i: the struct htable_iter to use
|
||||
*
|
||||
* Get another entry in the hashtable; NULL if all done.
|
||||
* This is usually used after htable_first or prior non-NULL htable_next.
|
||||
*/
|
||||
void *htable_next(const struct htable *htable, struct htable_iter *i);
|
||||
|
||||
/**
|
||||
* htable_delval - remove an iterated pointer from a hash table
|
||||
* @ht: the htable
|
||||
* @i: the htable_iter
|
||||
*
|
||||
* Usually used to delete a hash entry after it has been found with
|
||||
* htable_firstval etc.
|
||||
*/
|
||||
void htable_delval(struct htable *ht, struct htable_iter *i);
|
||||
|
||||
#endif /* CCAN_HTABLE_H */
|
||||
103
src/ccan/htable/htable_type.h
Normal file
103
src/ccan/htable/htable_type.h
Normal file
@@ -0,0 +1,103 @@
|
||||
/* Licensed under LGPLv2+ - see LICENSE file for details */
|
||||
#ifndef CCAN_HTABLE_TYPE_H
|
||||
#define CCAN_HTABLE_TYPE_H
|
||||
#include <ccan/htable/htable.h>
|
||||
#include "config.h"
|
||||
|
||||
/**
|
||||
* HTABLE_DEFINE_TYPE - create a set of htable ops for a type
|
||||
* @type: a type whose pointers will be values in the hash.
|
||||
* @keyof: a function/macro to extract a key: <keytype> @keyof(const type *elem)
|
||||
* @hashfn: a hash function for a @key: size_t @hashfn(const <keytype> *)
|
||||
* @eqfn: an equality function keys: bool @eqfn(const type *, const <keytype> *)
|
||||
* @prefix: a prefix for all the functions to define (of form <name>_*)
|
||||
*
|
||||
* NULL values may not be placed into the hash table.
|
||||
*
|
||||
* This defines the type hashtable type and an iterator type:
|
||||
* struct <name>;
|
||||
* struct <name>_iter;
|
||||
*
|
||||
* It also defines initialization and freeing functions:
|
||||
* void <name>_init(struct <name> *);
|
||||
* void <name>_clear(struct <name> *);
|
||||
*
|
||||
* Add function only fails if we run out of memory:
|
||||
* bool <name>_add(struct <name> *ht, const <type> *e);
|
||||
*
|
||||
* Delete and delete-by key return true if it was in the set:
|
||||
* bool <name>_del(struct <name> *ht, const <type> *e);
|
||||
* bool <name>_delkey(struct <name> *ht, const <keytype> *k);
|
||||
*
|
||||
* Find function return the matching element, or NULL:
|
||||
* type *<name>_get(const struct @name *ht, const <keytype> *k);
|
||||
*
|
||||
* Iteration over hashtable is also supported:
|
||||
* type *<name>_first(const struct <name> *ht, struct <name>_iter *i);
|
||||
* type *<name>_next(const struct <name> *ht, struct <name>_iter *i);
|
||||
*
|
||||
* It's currently safe to iterate over a changing hashtable, but you might
|
||||
* miss an element. Iteration isn't very efficient, either.
|
||||
*
|
||||
* You can use HTABLE_INITIALIZER like so:
|
||||
* struct <name> ht = { HTABLE_INITIALIZER(ht.raw, <name>_hash, NULL) };
|
||||
*/
|
||||
#define HTABLE_DEFINE_TYPE(type, keyof, hashfn, eqfn, name) \
|
||||
struct name { struct htable raw; }; \
|
||||
struct name##_iter { struct htable_iter i; }; \
|
||||
static inline size_t name##_hash(const void *elem, void *priv) \
|
||||
{ \
|
||||
return hashfn(keyof((const type *)elem)); \
|
||||
} \
|
||||
static inline void name##_init(struct name *ht) \
|
||||
{ \
|
||||
htable_init(&ht->raw, name##_hash, NULL); \
|
||||
} \
|
||||
static inline void name##_clear(struct name *ht) \
|
||||
{ \
|
||||
htable_clear(&ht->raw); \
|
||||
} \
|
||||
static inline bool name##_add(struct name *ht, const type *elem) \
|
||||
{ \
|
||||
return htable_add(&ht->raw, hashfn(keyof(elem)), elem); \
|
||||
} \
|
||||
static inline bool name##_del(struct name *ht, const type *elem) \
|
||||
{ \
|
||||
return htable_del(&ht->raw, hashfn(keyof(elem)), elem); \
|
||||
} \
|
||||
static inline type *name##_get(const struct name *ht, \
|
||||
const HTABLE_KTYPE(keyof) k) \
|
||||
{ \
|
||||
/* Typecheck for eqfn */ \
|
||||
(void)sizeof(eqfn((const type *)NULL, \
|
||||
keyof((const type *)NULL))); \
|
||||
return htable_get(&ht->raw, \
|
||||
hashfn(k), \
|
||||
(bool (*)(const void *, void *))(eqfn), \
|
||||
k); \
|
||||
} \
|
||||
static inline bool name##_delkey(struct name *ht, \
|
||||
const HTABLE_KTYPE(keyof) k) \
|
||||
{ \
|
||||
type *elem = name##_get(ht, k); \
|
||||
if (elem) \
|
||||
return name##_del(ht, elem); \
|
||||
return false; \
|
||||
} \
|
||||
static inline type *name##_first(const struct name *ht, \
|
||||
struct name##_iter *iter) \
|
||||
{ \
|
||||
return htable_first(&ht->raw, &iter->i); \
|
||||
} \
|
||||
static inline type *name##_next(const struct name *ht, \
|
||||
struct name##_iter *iter) \
|
||||
{ \
|
||||
return htable_next(&ht->raw, &iter->i); \
|
||||
}
|
||||
|
||||
#if HAVE_TYPEOF
|
||||
#define HTABLE_KTYPE(keyof) typeof(keyof(NULL))
|
||||
#else
|
||||
#define HTABLE_KTYPE(keyof) void *
|
||||
#endif
|
||||
#endif /* CCAN_HTABLE_TYPE_H */
|
||||
17
src/ccan/licenses/BSD-MIT
Normal file
17
src/ccan/licenses/BSD-MIT
Normal file
@@ -0,0 +1,17 @@
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
THE SOFTWARE.
|
||||
28
src/ccan/licenses/CC0
Normal file
28
src/ccan/licenses/CC0
Normal file
@@ -0,0 +1,28 @@
|
||||
Statement of Purpose
|
||||
|
||||
The laws of most jurisdictions throughout the world automatically confer exclusive Copyright and Related Rights (defined below) upon the creator and subsequent owner(s) (each and all, an "owner") of an original work of authorship and/or a database (each, a "Work").
|
||||
|
||||
Certain owners wish to permanently relinquish those rights to a Work for the purpose of contributing to a commons of creative, cultural and scientific works ("Commons") that the public can reliably and without fear of later claims of infringement build upon, modify, incorporate in other works, reuse and redistribute as freely as possible in any form whatsoever and for any purposes, including without limitation commercial purposes. These owners may contribute to the Commons to promote the ideal of a free culture and the further production of creative, cultural and scientific works, or to gain reputation or greater distribution for their Work in part through the use and efforts of others.
|
||||
|
||||
For these and/or other purposes and motivations, and without any expectation of additional consideration or compensation, the person associating CC0 with a Work (the "Affirmer"), to the extent that he or she is an owner of Copyright and Related Rights in the Work, voluntarily elects to apply CC0 to the Work and publicly distribute the Work under its terms, with knowledge of his or her Copyright and Related Rights in the Work and the meaning and intended legal effect of CC0 on those rights.
|
||||
|
||||
1. Copyright and Related Rights. A Work made available under CC0 may be protected by copyright and related or neighboring rights ("Copyright and Related Rights"). Copyright and Related Rights include, but are not limited to, the following:
|
||||
|
||||
the right to reproduce, adapt, distribute, perform, display, communicate, and translate a Work;
|
||||
moral rights retained by the original author(s) and/or performer(s);
|
||||
publicity and privacy rights pertaining to a person's image or likeness depicted in a Work;
|
||||
rights protecting against unfair competition in regards to a Work, subject to the limitations in paragraph 4(a), below;
|
||||
rights protecting the extraction, dissemination, use and reuse of data in a Work;
|
||||
database rights (such as those arising under Directive 96/9/EC of the European Parliament and of the Council of 11 March 1996 on the legal protection of databases, and under any national implementation thereof, including any amended or successor version of such directive); and
|
||||
other similar, equivalent or corresponding rights throughout the world based on applicable law or treaty, and any national implementations thereof.
|
||||
|
||||
2. Waiver. To the greatest extent permitted by, but not in contravention of, applicable law, Affirmer hereby overtly, fully, permanently, irrevocably and unconditionally waives, abandons, and surrenders all of Affirmer's Copyright and Related Rights and associated claims and causes of action, whether now known or unknown (including existing as well as future claims and causes of action), in the Work (i) in all territories worldwide, (ii) for the maximum duration provided by applicable law or treaty (including future time extensions), (iii) in any current or future medium and for any number of copies, and (iv) for any purpose whatsoever, including without limitation commercial, advertising or promotional purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each member of the public at large and to the detriment of Affirmer's heirs and successors, fully intending that such Waiver shall not be subject to revocation, rescission, cancellation, termination, or any other legal or equitable action to disrupt the quiet enjoyment of the Work by the public as contemplated by Affirmer's express Statement of Purpose.
|
||||
|
||||
3. Public License Fallback. Should any part of the Waiver for any reason be judged legally invalid or ineffective under applicable law, then the Waiver shall be preserved to the maximum extent permitted taking into account Affirmer's express Statement of Purpose. In addition, to the extent the Waiver is so judged Affirmer hereby grants to each affected person a royalty-free, non transferable, non sublicensable, non exclusive, irrevocable and unconditional license to exercise Affirmer's Copyright and Related Rights in the Work (i) in all territories worldwide, (ii) for the maximum duration provided by applicable law or treaty (including future time extensions), (iii) in any current or future medium and for any number of copies, and (iv) for any purpose whatsoever, including without limitation commercial, advertising or promotional purposes (the "License"). The License shall be deemed effective as of the date CC0 was applied by Affirmer to the Work. Should any part of the License for any reason be judged legally invalid or ineffective under applicable law, such partial invalidity or ineffectiveness shall not invalidate the remainder of the License, and in such case Affirmer hereby affirms that he or she will not (i) exercise any of his or her remaining Copyright and Related Rights in the Work or (ii) assert any associated claims and causes of action with respect to the Work, in either case contrary to Affirmer's express Statement of Purpose.
|
||||
|
||||
4. Limitations and Disclaimers.
|
||||
|
||||
No trademark or patent rights held by Affirmer are waived, abandoned, surrendered, licensed or otherwise affected by this document.
|
||||
Affirmer offers the Work as-is and makes no representations or warranties of any kind concerning the Work, express, implied, statutory or otherwise, including without limitation warranties of title, merchantability, fitness for a particular purpose, non infringement, or the absence of latent or other defects, accuracy, or the present or absence of errors, whether or not discoverable, all to the greatest extent permissible under applicable law.
|
||||
Affirmer disclaims responsibility for clearing rights of other persons that may apply to the Work or any use thereof, including without limitation any person's Copyright and Related Rights in the Work. Further, Affirmer disclaims responsibility for obtaining any necessary consents, permissions or other rights required for any use of the Work.
|
||||
Affirmer understands and acknowledges that Creative Commons is not a party to this document and has no duty or obligation with respect to this CC0 or use of the Work.
|
||||
510
src/ccan/licenses/LGPL-2.1
Normal file
510
src/ccan/licenses/LGPL-2.1
Normal file
@@ -0,0 +1,510 @@
|
||||
|
||||
GNU LESSER GENERAL PUBLIC LICENSE
|
||||
Version 2.1, February 1999
|
||||
|
||||
Copyright (C) 1991, 1999 Free Software Foundation, Inc.
|
||||
51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
Everyone is permitted to copy and distribute verbatim copies
|
||||
of this license document, but changing it is not allowed.
|
||||
|
||||
[This is the first released version of the Lesser GPL. It also counts
|
||||
as the successor of the GNU Library Public License, version 2, hence
|
||||
the version number 2.1.]
|
||||
|
||||
Preamble
|
||||
|
||||
The licenses for most software are designed to take away your
|
||||
freedom to share and change it. By contrast, the GNU General Public
|
||||
Licenses are intended to guarantee your freedom to share and change
|
||||
free software--to make sure the software is free for all its users.
|
||||
|
||||
This license, the Lesser General Public License, applies to some
|
||||
specially designated software packages--typically libraries--of the
|
||||
Free Software Foundation and other authors who decide to use it. You
|
||||
can use it too, but we suggest you first think carefully about whether
|
||||
this license or the ordinary General Public License is the better
|
||||
strategy to use in any particular case, based on the explanations
|
||||
below.
|
||||
|
||||
When we speak of free software, we are referring to freedom of use,
|
||||
not price. Our General Public Licenses are designed to make sure that
|
||||
you have the freedom to distribute copies of free software (and charge
|
||||
for this service if you wish); that you receive source code or can get
|
||||
it if you want it; that you can change the software and use pieces of
|
||||
it in new free programs; and that you are informed that you can do
|
||||
these things.
|
||||
|
||||
To protect your rights, we need to make restrictions that forbid
|
||||
distributors to deny you these rights or to ask you to surrender these
|
||||
rights. These restrictions translate to certain responsibilities for
|
||||
you if you distribute copies of the library or if you modify it.
|
||||
|
||||
For example, if you distribute copies of the library, whether gratis
|
||||
or for a fee, you must give the recipients all the rights that we gave
|
||||
you. You must make sure that they, too, receive or can get the source
|
||||
code. If you link other code with the library, you must provide
|
||||
complete object files to the recipients, so that they can relink them
|
||||
with the library after making changes to the library and recompiling
|
||||
it. And you must show them these terms so they know their rights.
|
||||
|
||||
We protect your rights with a two-step method: (1) we copyright the
|
||||
library, and (2) we offer you this license, which gives you legal
|
||||
permission to copy, distribute and/or modify the library.
|
||||
|
||||
To protect each distributor, we want to make it very clear that
|
||||
there is no warranty for the free library. Also, if the library is
|
||||
modified by someone else and passed on, the recipients should know
|
||||
that what they have is not the original version, so that the original
|
||||
author's reputation will not be affected by problems that might be
|
||||
introduced by others.
|
||||
|
||||
Finally, software patents pose a constant threat to the existence of
|
||||
any free program. We wish to make sure that a company cannot
|
||||
effectively restrict the users of a free program by obtaining a
|
||||
restrictive license from a patent holder. Therefore, we insist that
|
||||
any patent license obtained for a version of the library must be
|
||||
consistent with the full freedom of use specified in this license.
|
||||
|
||||
Most GNU software, including some libraries, is covered by the
|
||||
ordinary GNU General Public License. This license, the GNU Lesser
|
||||
General Public License, applies to certain designated libraries, and
|
||||
is quite different from the ordinary General Public License. We use
|
||||
this license for certain libraries in order to permit linking those
|
||||
libraries into non-free programs.
|
||||
|
||||
When a program is linked with a library, whether statically or using
|
||||
a shared library, the combination of the two is legally speaking a
|
||||
combined work, a derivative of the original library. The ordinary
|
||||
General Public License therefore permits such linking only if the
|
||||
entire combination fits its criteria of freedom. The Lesser General
|
||||
Public License permits more lax criteria for linking other code with
|
||||
the library.
|
||||
|
||||
We call this license the "Lesser" General Public License because it
|
||||
does Less to protect the user's freedom than the ordinary General
|
||||
Public License. It also provides other free software developers Less
|
||||
of an advantage over competing non-free programs. These disadvantages
|
||||
are the reason we use the ordinary General Public License for many
|
||||
libraries. However, the Lesser license provides advantages in certain
|
||||
special circumstances.
|
||||
|
||||
For example, on rare occasions, there may be a special need to
|
||||
encourage the widest possible use of a certain library, so that it
|
||||
becomes a de-facto standard. To achieve this, non-free programs must
|
||||
be allowed to use the library. A more frequent case is that a free
|
||||
library does the same job as widely used non-free libraries. In this
|
||||
case, there is little to gain by limiting the free library to free
|
||||
software only, so we use the Lesser General Public License.
|
||||
|
||||
In other cases, permission to use a particular library in non-free
|
||||
programs enables a greater number of people to use a large body of
|
||||
free software. For example, permission to use the GNU C Library in
|
||||
non-free programs enables many more people to use the whole GNU
|
||||
operating system, as well as its variant, the GNU/Linux operating
|
||||
system.
|
||||
|
||||
Although the Lesser General Public License is Less protective of the
|
||||
users' freedom, it does ensure that the user of a program that is
|
||||
linked with the Library has the freedom and the wherewithal to run
|
||||
that program using a modified version of the Library.
|
||||
|
||||
The precise terms and conditions for copying, distribution and
|
||||
modification follow. Pay close attention to the difference between a
|
||||
"work based on the library" and a "work that uses the library". The
|
||||
former contains code derived from the library, whereas the latter must
|
||||
be combined with the library in order to run.
|
||||
|
||||
GNU LESSER GENERAL PUBLIC LICENSE
|
||||
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
|
||||
|
||||
0. This License Agreement applies to any software library or other
|
||||
program which contains a notice placed by the copyright holder or
|
||||
other authorized party saying it may be distributed under the terms of
|
||||
this Lesser General Public License (also called "this License").
|
||||
Each licensee is addressed as "you".
|
||||
|
||||
A "library" means a collection of software functions and/or data
|
||||
prepared so as to be conveniently linked with application programs
|
||||
(which use some of those functions and data) to form executables.
|
||||
|
||||
The "Library", below, refers to any such software library or work
|
||||
which has been distributed under these terms. A "work based on the
|
||||
Library" means either the Library or any derivative work under
|
||||
copyright law: that is to say, a work containing the Library or a
|
||||
portion of it, either verbatim or with modifications and/or translated
|
||||
straightforwardly into another language. (Hereinafter, translation is
|
||||
included without limitation in the term "modification".)
|
||||
|
||||
"Source code" for a work means the preferred form of the work for
|
||||
making modifications to it. For a library, complete source code means
|
||||
all the source code for all modules it contains, plus any associated
|
||||
interface definition files, plus the scripts used to control
|
||||
compilation and installation of the library.
|
||||
|
||||
Activities other than copying, distribution and modification are not
|
||||
covered by this License; they are outside its scope. The act of
|
||||
running a program using the Library is not restricted, and output from
|
||||
such a program is covered only if its contents constitute a work based
|
||||
on the Library (independent of the use of the Library in a tool for
|
||||
writing it). Whether that is true depends on what the Library does
|
||||
and what the program that uses the Library does.
|
||||
|
||||
1. You may copy and distribute verbatim copies of the Library's
|
||||
complete source code as you receive it, in any medium, provided that
|
||||
you conspicuously and appropriately publish on each copy an
|
||||
appropriate copyright notice and disclaimer of warranty; keep intact
|
||||
all the notices that refer to this License and to the absence of any
|
||||
warranty; and distribute a copy of this License along with the
|
||||
Library.
|
||||
|
||||
You may charge a fee for the physical act of transferring a copy,
|
||||
and you may at your option offer warranty protection in exchange for a
|
||||
fee.
|
||||
|
||||
2. You may modify your copy or copies of the Library or any portion
|
||||
of it, thus forming a work based on the Library, and copy and
|
||||
distribute such modifications or work under the terms of Section 1
|
||||
above, provided that you also meet all of these conditions:
|
||||
|
||||
a) The modified work must itself be a software library.
|
||||
|
||||
b) You must cause the files modified to carry prominent notices
|
||||
stating that you changed the files and the date of any change.
|
||||
|
||||
c) You must cause the whole of the work to be licensed at no
|
||||
charge to all third parties under the terms of this License.
|
||||
|
||||
d) If a facility in the modified Library refers to a function or a
|
||||
table of data to be supplied by an application program that uses
|
||||
the facility, other than as an argument passed when the facility
|
||||
is invoked, then you must make a good faith effort to ensure that,
|
||||
in the event an application does not supply such function or
|
||||
table, the facility still operates, and performs whatever part of
|
||||
its purpose remains meaningful.
|
||||
|
||||
(For example, a function in a library to compute square roots has
|
||||
a purpose that is entirely well-defined independent of the
|
||||
application. Therefore, Subsection 2d requires that any
|
||||
application-supplied function or table used by this function must
|
||||
be optional: if the application does not supply it, the square
|
||||
root function must still compute square roots.)
|
||||
|
||||
These requirements apply to the modified work as a whole. If
|
||||
identifiable sections of that work are not derived from the Library,
|
||||
and can be reasonably considered independent and separate works in
|
||||
themselves, then this License, and its terms, do not apply to those
|
||||
sections when you distribute them as separate works. But when you
|
||||
distribute the same sections as part of a whole which is a work based
|
||||
on the Library, the distribution of the whole must be on the terms of
|
||||
this License, whose permissions for other licensees extend to the
|
||||
entire whole, and thus to each and every part regardless of who wrote
|
||||
it.
|
||||
|
||||
Thus, it is not the intent of this section to claim rights or contest
|
||||
your rights to work written entirely by you; rather, the intent is to
|
||||
exercise the right to control the distribution of derivative or
|
||||
collective works based on the Library.
|
||||
|
||||
In addition, mere aggregation of another work not based on the Library
|
||||
with the Library (or with a work based on the Library) on a volume of
|
||||
a storage or distribution medium does not bring the other work under
|
||||
the scope of this License.
|
||||
|
||||
3. You may opt to apply the terms of the ordinary GNU General Public
|
||||
License instead of this License to a given copy of the Library. To do
|
||||
this, you must alter all the notices that refer to this License, so
|
||||
that they refer to the ordinary GNU General Public License, version 2,
|
||||
instead of to this License. (If a newer version than version 2 of the
|
||||
ordinary GNU General Public License has appeared, then you can specify
|
||||
that version instead if you wish.) Do not make any other change in
|
||||
these notices.
|
||||
|
||||
Once this change is made in a given copy, it is irreversible for
|
||||
that copy, so the ordinary GNU General Public License applies to all
|
||||
subsequent copies and derivative works made from that copy.
|
||||
|
||||
This option is useful when you wish to copy part of the code of
|
||||
the Library into a program that is not a library.
|
||||
|
||||
4. You may copy and distribute the Library (or a portion or
|
||||
derivative of it, under Section 2) in object code or executable form
|
||||
under the terms of Sections 1 and 2 above provided that you accompany
|
||||
it with the complete corresponding machine-readable source code, which
|
||||
must be distributed under the terms of Sections 1 and 2 above on a
|
||||
medium customarily used for software interchange.
|
||||
|
||||
If distribution of object code is made by offering access to copy
|
||||
from a designated place, then offering equivalent access to copy the
|
||||
source code from the same place satisfies the requirement to
|
||||
distribute the source code, even though third parties are not
|
||||
compelled to copy the source along with the object code.
|
||||
|
||||
5. A program that contains no derivative of any portion of the
|
||||
Library, but is designed to work with the Library by being compiled or
|
||||
linked with it, is called a "work that uses the Library". Such a
|
||||
work, in isolation, is not a derivative work of the Library, and
|
||||
therefore falls outside the scope of this License.
|
||||
|
||||
However, linking a "work that uses the Library" with the Library
|
||||
creates an executable that is a derivative of the Library (because it
|
||||
contains portions of the Library), rather than a "work that uses the
|
||||
library". The executable is therefore covered by this License.
|
||||
Section 6 states terms for distribution of such executables.
|
||||
|
||||
When a "work that uses the Library" uses material from a header file
|
||||
that is part of the Library, the object code for the work may be a
|
||||
derivative work of the Library even though the source code is not.
|
||||
Whether this is true is especially significant if the work can be
|
||||
linked without the Library, or if the work is itself a library. The
|
||||
threshold for this to be true is not precisely defined by law.
|
||||
|
||||
If such an object file uses only numerical parameters, data
|
||||
structure layouts and accessors, and small macros and small inline
|
||||
functions (ten lines or less in length), then the use of the object
|
||||
file is unrestricted, regardless of whether it is legally a derivative
|
||||
work. (Executables containing this object code plus portions of the
|
||||
Library will still fall under Section 6.)
|
||||
|
||||
Otherwise, if the work is a derivative of the Library, you may
|
||||
distribute the object code for the work under the terms of Section 6.
|
||||
Any executables containing that work also fall under Section 6,
|
||||
whether or not they are linked directly with the Library itself.
|
||||
|
||||
6. As an exception to the Sections above, you may also combine or
|
||||
link a "work that uses the Library" with the Library to produce a
|
||||
work containing portions of the Library, and distribute that work
|
||||
under terms of your choice, provided that the terms permit
|
||||
modification of the work for the customer's own use and reverse
|
||||
engineering for debugging such modifications.
|
||||
|
||||
You must give prominent notice with each copy of the work that the
|
||||
Library is used in it and that the Library and its use are covered by
|
||||
this License. You must supply a copy of this License. If the work
|
||||
during execution displays copyright notices, you must include the
|
||||
copyright notice for the Library among them, as well as a reference
|
||||
directing the user to the copy of this License. Also, you must do one
|
||||
of these things:
|
||||
|
||||
a) Accompany the work with the complete corresponding
|
||||
machine-readable source code for the Library including whatever
|
||||
changes were used in the work (which must be distributed under
|
||||
Sections 1 and 2 above); and, if the work is an executable linked
|
||||
with the Library, with the complete machine-readable "work that
|
||||
uses the Library", as object code and/or source code, so that the
|
||||
user can modify the Library and then relink to produce a modified
|
||||
executable containing the modified Library. (It is understood
|
||||
that the user who changes the contents of definitions files in the
|
||||
Library will not necessarily be able to recompile the application
|
||||
to use the modified definitions.)
|
||||
|
||||
b) Use a suitable shared library mechanism for linking with the
|
||||
Library. A suitable mechanism is one that (1) uses at run time a
|
||||
copy of the library already present on the user's computer system,
|
||||
rather than copying library functions into the executable, and (2)
|
||||
will operate properly with a modified version of the library, if
|
||||
the user installs one, as long as the modified version is
|
||||
interface-compatible with the version that the work was made with.
|
||||
|
||||
c) Accompany the work with a written offer, valid for at least
|
||||
three years, to give the same user the materials specified in
|
||||
Subsection 6a, above, for a charge no more than the cost of
|
||||
performing this distribution.
|
||||
|
||||
d) If distribution of the work is made by offering access to copy
|
||||
from a designated place, offer equivalent access to copy the above
|
||||
specified materials from the same place.
|
||||
|
||||
e) Verify that the user has already received a copy of these
|
||||
materials or that you have already sent this user a copy.
|
||||
|
||||
For an executable, the required form of the "work that uses the
|
||||
Library" must include any data and utility programs needed for
|
||||
reproducing the executable from it. However, as a special exception,
|
||||
the materials to be distributed need not include anything that is
|
||||
normally distributed (in either source or binary form) with the major
|
||||
components (compiler, kernel, and so on) of the operating system on
|
||||
which the executable runs, unless that component itself accompanies
|
||||
the executable.
|
||||
|
||||
It may happen that this requirement contradicts the license
|
||||
restrictions of other proprietary libraries that do not normally
|
||||
accompany the operating system. Such a contradiction means you cannot
|
||||
use both them and the Library together in an executable that you
|
||||
distribute.
|
||||
|
||||
7. You may place library facilities that are a work based on the
|
||||
Library side-by-side in a single library together with other library
|
||||
facilities not covered by this License, and distribute such a combined
|
||||
library, provided that the separate distribution of the work based on
|
||||
the Library and of the other library facilities is otherwise
|
||||
permitted, and provided that you do these two things:
|
||||
|
||||
a) Accompany the combined library with a copy of the same work
|
||||
based on the Library, uncombined with any other library
|
||||
facilities. This must be distributed under the terms of the
|
||||
Sections above.
|
||||
|
||||
b) Give prominent notice with the combined library of the fact
|
||||
that part of it is a work based on the Library, and explaining
|
||||
where to find the accompanying uncombined form of the same work.
|
||||
|
||||
8. You may not copy, modify, sublicense, link with, or distribute
|
||||
the Library except as expressly provided under this License. Any
|
||||
attempt otherwise to copy, modify, sublicense, link with, or
|
||||
distribute the Library is void, and will automatically terminate your
|
||||
rights under this License. However, parties who have received copies,
|
||||
or rights, from you under this License will not have their licenses
|
||||
terminated so long as such parties remain in full compliance.
|
||||
|
||||
9. You are not required to accept this License, since you have not
|
||||
signed it. However, nothing else grants you permission to modify or
|
||||
distribute the Library or its derivative works. These actions are
|
||||
prohibited by law if you do not accept this License. Therefore, by
|
||||
modifying or distributing the Library (or any work based on the
|
||||
Library), you indicate your acceptance of this License to do so, and
|
||||
all its terms and conditions for copying, distributing or modifying
|
||||
the Library or works based on it.
|
||||
|
||||
10. Each time you redistribute the Library (or any work based on the
|
||||
Library), the recipient automatically receives a license from the
|
||||
original licensor to copy, distribute, link with or modify the Library
|
||||
subject to these terms and conditions. You may not impose any further
|
||||
restrictions on the recipients' exercise of the rights granted herein.
|
||||
You are not responsible for enforcing compliance by third parties with
|
||||
this License.
|
||||
|
||||
11. If, as a consequence of a court judgment or allegation of patent
|
||||
infringement or for any other reason (not limited to patent issues),
|
||||
conditions are imposed on you (whether by court order, agreement or
|
||||
otherwise) that contradict the conditions of this License, they do not
|
||||
excuse you from the conditions of this License. If you cannot
|
||||
distribute so as to satisfy simultaneously your obligations under this
|
||||
License and any other pertinent obligations, then as a consequence you
|
||||
may not distribute the Library at all. For example, if a patent
|
||||
license would not permit royalty-free redistribution of the Library by
|
||||
all those who receive copies directly or indirectly through you, then
|
||||
the only way you could satisfy both it and this License would be to
|
||||
refrain entirely from distribution of the Library.
|
||||
|
||||
If any portion of this section is held invalid or unenforceable under
|
||||
any particular circumstance, the balance of the section is intended to
|
||||
apply, and the section as a whole is intended to apply in other
|
||||
circumstances.
|
||||
|
||||
It is not the purpose of this section to induce you to infringe any
|
||||
patents or other property right claims or to contest validity of any
|
||||
such claims; this section has the sole purpose of protecting the
|
||||
integrity of the free software distribution system which is
|
||||
implemented by public license practices. Many people have made
|
||||
generous contributions to the wide range of software distributed
|
||||
through that system in reliance on consistent application of that
|
||||
system; it is up to the author/donor to decide if he or she is willing
|
||||
to distribute software through any other system and a licensee cannot
|
||||
impose that choice.
|
||||
|
||||
This section is intended to make thoroughly clear what is believed to
|
||||
be a consequence of the rest of this License.
|
||||
|
||||
12. If the distribution and/or use of the Library is restricted in
|
||||
certain countries either by patents or by copyrighted interfaces, the
|
||||
original copyright holder who places the Library under this License
|
||||
may add an explicit geographical distribution limitation excluding those
|
||||
countries, so that distribution is permitted only in or among
|
||||
countries not thus excluded. In such case, this License incorporates
|
||||
the limitation as if written in the body of this License.
|
||||
|
||||
13. The Free Software Foundation may publish revised and/or new
|
||||
versions of the Lesser General Public License from time to time.
|
||||
Such new versions will be similar in spirit to the present version,
|
||||
but may differ in detail to address new problems or concerns.
|
||||
|
||||
Each version is given a distinguishing version number. If the Library
|
||||
specifies a version number of this License which applies to it and
|
||||
"any later version", you have the option of following the terms and
|
||||
conditions either of that version or of any later version published by
|
||||
the Free Software Foundation. If the Library does not specify a
|
||||
license version number, you may choose any version ever published by
|
||||
the Free Software Foundation.
|
||||
|
||||
14. If you wish to incorporate parts of the Library into other free
|
||||
programs whose distribution conditions are incompatible with these,
|
||||
write to the author to ask for permission. For software which is
|
||||
copyrighted by the Free Software Foundation, write to the Free
|
||||
Software Foundation; we sometimes make exceptions for this. Our
|
||||
decision will be guided by the two goals of preserving the free status
|
||||
of all derivatives of our free software and of promoting the sharing
|
||||
and reuse of software generally.
|
||||
|
||||
NO WARRANTY
|
||||
|
||||
15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
|
||||
WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
|
||||
EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
|
||||
OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
|
||||
KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
|
||||
LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
|
||||
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
|
||||
|
||||
16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
|
||||
WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
|
||||
AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
|
||||
FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
|
||||
CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
|
||||
LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
|
||||
RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
|
||||
FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
|
||||
SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
|
||||
DAMAGES.
|
||||
|
||||
END OF TERMS AND CONDITIONS
|
||||
|
||||
How to Apply These Terms to Your New Libraries
|
||||
|
||||
If you develop a new library, and you want it to be of the greatest
|
||||
possible use to the public, we recommend making it free software that
|
||||
everyone can redistribute and change. You can do so by permitting
|
||||
redistribution under these terms (or, alternatively, under the terms
|
||||
of the ordinary General Public License).
|
||||
|
||||
To apply these terms, attach the following notices to the library.
|
||||
It is safest to attach them to the start of each source file to most
|
||||
effectively convey the exclusion of warranty; and each file should
|
||||
have at least the "copyright" line and a pointer to where the full
|
||||
notice is found.
|
||||
|
||||
|
||||
<one line to give the library's name and a brief idea of what it does.>
|
||||
Copyright (C) <year> <name of author>
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
|
||||
Also add information on how to contact you by electronic and paper mail.
|
||||
|
||||
You should also get your employer (if you work as a programmer) or
|
||||
your school, if any, to sign a "copyright disclaimer" for the library,
|
||||
if necessary. Here is a sample; alter the names:
|
||||
|
||||
Yoyodyne, Inc., hereby disclaims all copyright interest in the
|
||||
library `Frob' (a library for tweaking knobs) written by James
|
||||
Random Hacker.
|
||||
|
||||
<signature of Ty Coon>, 1 April 1990
|
||||
Ty Coon, President of Vice
|
||||
|
||||
That's all there is to it!
|
||||
|
||||
|
||||
43
src/ccan/list/list.c
Normal file
43
src/ccan/list/list.c
Normal file
@@ -0,0 +1,43 @@
|
||||
/* Licensed under BSD-MIT - see LICENSE file for details */
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include "list.h"
|
||||
|
||||
static void *corrupt(const char *abortstr,
|
||||
const struct list_node *head,
|
||||
const struct list_node *node,
|
||||
unsigned int count)
|
||||
{
|
||||
if (abortstr) {
|
||||
fprintf(stderr,
|
||||
"%s: prev corrupt in node %p (%u) of %p\n",
|
||||
abortstr, node, count, head);
|
||||
abort();
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
struct list_node *list_check_node(const struct list_node *node,
|
||||
const char *abortstr)
|
||||
{
|
||||
const struct list_node *p, *n;
|
||||
int count = 0;
|
||||
|
||||
for (p = node, n = node->next; n != node; p = n, n = n->next) {
|
||||
count++;
|
||||
if (n->prev != p)
|
||||
return corrupt(abortstr, node, n, count);
|
||||
}
|
||||
/* Check prev on head node. */
|
||||
if (node->prev != p)
|
||||
return corrupt(abortstr, node, node, 0);
|
||||
|
||||
return (struct list_node *)node;
|
||||
}
|
||||
|
||||
struct list_head *list_check(const struct list_head *h, const char *abortstr)
|
||||
{
|
||||
if (!list_check_node(&h->n, abortstr))
|
||||
return NULL;
|
||||
return (struct list_head *)h;
|
||||
}
|
||||
473
src/ccan/list/list.h
Normal file
473
src/ccan/list/list.h
Normal file
@@ -0,0 +1,473 @@
|
||||
/* Licensed under BSD-MIT - see LICENSE file for details */
|
||||
#ifndef CCAN_LIST_H
|
||||
#define CCAN_LIST_H
|
||||
#include <stdbool.h>
|
||||
#include <assert.h>
|
||||
#include <ccan/container_of/container_of.h>
|
||||
#include <ccan/check_type/check_type.h>
|
||||
|
||||
/**
|
||||
* struct list_node - an entry in a doubly-linked list
|
||||
* @next: next entry (self if empty)
|
||||
* @prev: previous entry (self if empty)
|
||||
*
|
||||
* This is used as an entry in a linked list.
|
||||
* Example:
|
||||
* struct child {
|
||||
* const char *name;
|
||||
* // Linked list of all us children.
|
||||
* struct list_node list;
|
||||
* };
|
||||
*/
|
||||
struct list_node
|
||||
{
|
||||
struct list_node *next, *prev;
|
||||
};
|
||||
|
||||
/**
|
||||
* struct list_head - the head of a doubly-linked list
|
||||
* @h: the list_head (containing next and prev pointers)
|
||||
*
|
||||
* This is used as the head of a linked list.
|
||||
* Example:
|
||||
* struct parent {
|
||||
* const char *name;
|
||||
* struct list_head children;
|
||||
* unsigned int num_children;
|
||||
* };
|
||||
*/
|
||||
struct list_head
|
||||
{
|
||||
struct list_node n;
|
||||
};
|
||||
|
||||
/**
|
||||
* list_check - check head of a list for consistency
|
||||
* @h: the list_head
|
||||
* @abortstr: the location to print on aborting, or NULL.
|
||||
*
|
||||
* Because list_nodes have redundant information, consistency checking between
|
||||
* the back and forward links can be done. This is useful as a debugging check.
|
||||
* If @abortstr is non-NULL, that will be printed in a diagnostic if the list
|
||||
* is inconsistent, and the function will abort.
|
||||
*
|
||||
* Returns the list head if the list is consistent, NULL if not (it
|
||||
* can never return NULL if @abortstr is set).
|
||||
*
|
||||
* See also: list_check_node()
|
||||
*
|
||||
* Example:
|
||||
* static void dump_parent(struct parent *p)
|
||||
* {
|
||||
* struct child *c;
|
||||
*
|
||||
* printf("%s (%u children):\n", p->name, p->num_children);
|
||||
* list_check(&p->children, "bad child list");
|
||||
* list_for_each(&p->children, c, list)
|
||||
* printf(" -> %s\n", c->name);
|
||||
* }
|
||||
*/
|
||||
struct list_head *list_check(const struct list_head *h, const char *abortstr);
|
||||
|
||||
/**
|
||||
* list_check_node - check node of a list for consistency
|
||||
* @n: the list_node
|
||||
* @abortstr: the location to print on aborting, or NULL.
|
||||
*
|
||||
* Check consistency of the list node is in (it must be in one).
|
||||
*
|
||||
* See also: list_check()
|
||||
*
|
||||
* Example:
|
||||
* static void dump_child(const struct child *c)
|
||||
* {
|
||||
* list_check_node(&c->list, "bad child list");
|
||||
* printf("%s\n", c->name);
|
||||
* }
|
||||
*/
|
||||
struct list_node *list_check_node(const struct list_node *n,
|
||||
const char *abortstr);
|
||||
|
||||
#ifdef CCAN_LIST_DEBUG
|
||||
#define list_debug(h) list_check((h), __func__)
|
||||
#define list_debug_node(n) list_check_node((n), __func__)
|
||||
#else
|
||||
#define list_debug(h) (h)
|
||||
#define list_debug_node(n) (n)
|
||||
#endif
|
||||
|
||||
/**
|
||||
* LIST_HEAD_INIT - initializer for an empty list_head
|
||||
* @name: the name of the list.
|
||||
*
|
||||
* Explicit initializer for an empty list.
|
||||
*
|
||||
* See also:
|
||||
* LIST_HEAD, list_head_init()
|
||||
*
|
||||
* Example:
|
||||
* static struct list_head my_list = LIST_HEAD_INIT(my_list);
|
||||
*/
|
||||
#define LIST_HEAD_INIT(name) { { &name.n, &name.n } }
|
||||
|
||||
/**
|
||||
* LIST_HEAD - define and initialize an empty list_head
|
||||
* @name: the name of the list.
|
||||
*
|
||||
* The LIST_HEAD macro defines a list_head and initializes it to an empty
|
||||
* list. It can be prepended by "static" to define a static list_head.
|
||||
*
|
||||
* See also:
|
||||
* LIST_HEAD_INIT, list_head_init()
|
||||
*
|
||||
* Example:
|
||||
* static LIST_HEAD(my_global_list);
|
||||
*/
|
||||
#define LIST_HEAD(name) \
|
||||
struct list_head name = LIST_HEAD_INIT(name)
|
||||
|
||||
/**
|
||||
* list_head_init - initialize a list_head
|
||||
* @h: the list_head to set to the empty list
|
||||
*
|
||||
* Example:
|
||||
* ...
|
||||
* struct parent *parent = malloc(sizeof(*parent));
|
||||
*
|
||||
* list_head_init(&parent->children);
|
||||
* parent->num_children = 0;
|
||||
*/
|
||||
static inline void list_head_init(struct list_head *h)
|
||||
{
|
||||
h->n.next = h->n.prev = &h->n;
|
||||
}
|
||||
|
||||
/**
|
||||
* list_add - add an entry at the start of a linked list.
|
||||
* @h: the list_head to add the node to
|
||||
* @n: the list_node to add to the list.
|
||||
*
|
||||
* The list_node does not need to be initialized; it will be overwritten.
|
||||
* Example:
|
||||
* struct child *child = malloc(sizeof(*child));
|
||||
*
|
||||
* child->name = "marvin";
|
||||
* list_add(&parent->children, &child->list);
|
||||
* parent->num_children++;
|
||||
*/
|
||||
static inline void list_add(struct list_head *h, struct list_node *n)
|
||||
{
|
||||
n->next = h->n.next;
|
||||
n->prev = &h->n;
|
||||
h->n.next->prev = n;
|
||||
h->n.next = n;
|
||||
(void)list_debug(h);
|
||||
}
|
||||
|
||||
/**
|
||||
* list_add_tail - add an entry at the end of a linked list.
|
||||
* @h: the list_head to add the node to
|
||||
* @n: the list_node to add to the list.
|
||||
*
|
||||
* The list_node does not need to be initialized; it will be overwritten.
|
||||
* Example:
|
||||
* list_add_tail(&parent->children, &child->list);
|
||||
* parent->num_children++;
|
||||
*/
|
||||
static inline void list_add_tail(struct list_head *h, struct list_node *n)
|
||||
{
|
||||
n->next = &h->n;
|
||||
n->prev = h->n.prev;
|
||||
h->n.prev->next = n;
|
||||
h->n.prev = n;
|
||||
(void)list_debug(h);
|
||||
}
|
||||
|
||||
/**
|
||||
* list_empty - is a list empty?
|
||||
* @h: the list_head
|
||||
*
|
||||
* If the list is empty, returns true.
|
||||
*
|
||||
* Example:
|
||||
* assert(list_empty(&parent->children) == (parent->num_children == 0));
|
||||
*/
|
||||
static inline bool list_empty(const struct list_head *h)
|
||||
{
|
||||
(void)list_debug(h);
|
||||
return h->n.next == &h->n;
|
||||
}
|
||||
|
||||
/**
|
||||
* list_del - delete an entry from an (unknown) linked list.
|
||||
* @n: the list_node to delete from the list.
|
||||
*
|
||||
* Note that this leaves @n in an undefined state; it can be added to
|
||||
* another list, but not deleted again.
|
||||
*
|
||||
* See also:
|
||||
* list_del_from()
|
||||
*
|
||||
* Example:
|
||||
* list_del(&child->list);
|
||||
* parent->num_children--;
|
||||
*/
|
||||
static inline void list_del(struct list_node *n)
|
||||
{
|
||||
(void)list_debug_node(n);
|
||||
n->next->prev = n->prev;
|
||||
n->prev->next = n->next;
|
||||
#ifdef CCAN_LIST_DEBUG
|
||||
/* Catch use-after-del. */
|
||||
n->next = n->prev = NULL;
|
||||
#endif
|
||||
}
|
||||
|
||||
/**
|
||||
* list_del_from - delete an entry from a known linked list.
|
||||
* @h: the list_head the node is in.
|
||||
* @n: the list_node to delete from the list.
|
||||
*
|
||||
* This explicitly indicates which list a node is expected to be in,
|
||||
* which is better documentation and can catch more bugs.
|
||||
*
|
||||
* See also: list_del()
|
||||
*
|
||||
* Example:
|
||||
* list_del_from(&parent->children, &child->list);
|
||||
* parent->num_children--;
|
||||
*/
|
||||
static inline void list_del_from(struct list_head *h, struct list_node *n)
|
||||
{
|
||||
#ifdef CCAN_LIST_DEBUG
|
||||
{
|
||||
/* Thorough check: make sure it was in list! */
|
||||
struct list_node *i;
|
||||
for (i = h->n.next; i != n; i = i->next)
|
||||
assert(i != &h->n);
|
||||
}
|
||||
#endif /* CCAN_LIST_DEBUG */
|
||||
|
||||
/* Quick test that catches a surprising number of bugs. */
|
||||
assert(!list_empty(h));
|
||||
list_del(n);
|
||||
}
|
||||
|
||||
/**
|
||||
* list_entry - convert a list_node back into the structure containing it.
|
||||
* @n: the list_node
|
||||
* @type: the type of the entry
|
||||
* @member: the list_node member of the type
|
||||
*
|
||||
* Example:
|
||||
* // First list entry is children.next; convert back to child.
|
||||
* child = list_entry(parent->children.n.next, struct child, list);
|
||||
*
|
||||
* See Also:
|
||||
* list_top(), list_for_each()
|
||||
*/
|
||||
#define list_entry(n, type, member) container_of(n, type, member)
|
||||
|
||||
/**
|
||||
* list_top - get the first entry in a list
|
||||
* @h: the list_head
|
||||
* @type: the type of the entry
|
||||
* @member: the list_node member of the type
|
||||
*
|
||||
* If the list is empty, returns NULL.
|
||||
*
|
||||
* Example:
|
||||
* struct child *first;
|
||||
* first = list_top(&parent->children, struct child, list);
|
||||
* if (!first)
|
||||
* printf("Empty list!\n");
|
||||
*/
|
||||
#define list_top(h, type, member) \
|
||||
((type *)list_top_((h), list_off_(type, member)))
|
||||
|
||||
static inline const void *list_top_(const struct list_head *h, size_t off)
|
||||
{
|
||||
if (list_empty(h))
|
||||
return NULL;
|
||||
return (const char *)h->n.next - off;
|
||||
}
|
||||
|
||||
/**
|
||||
* list_tail - get the last entry in a list
|
||||
* @h: the list_head
|
||||
* @type: the type of the entry
|
||||
* @member: the list_node member of the type
|
||||
*
|
||||
* If the list is empty, returns NULL.
|
||||
*
|
||||
* Example:
|
||||
* struct child *last;
|
||||
* last = list_tail(&parent->children, struct child, list);
|
||||
* if (!last)
|
||||
* printf("Empty list!\n");
|
||||
*/
|
||||
#define list_tail(h, type, member) \
|
||||
((type *)list_tail_((h), list_off_(type, member)))
|
||||
|
||||
static inline const void *list_tail_(const struct list_head *h, size_t off)
|
||||
{
|
||||
if (list_empty(h))
|
||||
return NULL;
|
||||
return (const char *)h->n.prev - off;
|
||||
}
|
||||
|
||||
/**
|
||||
* list_for_each - iterate through a list.
|
||||
* @h: the list_head (warning: evaluated multiple times!)
|
||||
* @i: the structure containing the list_node
|
||||
* @member: the list_node member of the structure
|
||||
*
|
||||
* This is a convenient wrapper to iterate @i over the entire list. It's
|
||||
* a for loop, so you can break and continue as normal.
|
||||
*
|
||||
* Example:
|
||||
* list_for_each(&parent->children, child, list)
|
||||
* printf("Name: %s\n", child->name);
|
||||
*/
|
||||
#define list_for_each(h, i, member) \
|
||||
list_for_each_off(h, i, list_off_var_(i, member))
|
||||
|
||||
/**
|
||||
* list_for_each_rev - iterate through a list backwards.
|
||||
* @h: the list_head
|
||||
* @i: the structure containing the list_node
|
||||
* @member: the list_node member of the structure
|
||||
*
|
||||
* This is a convenient wrapper to iterate @i over the entire list. It's
|
||||
* a for loop, so you can break and continue as normal.
|
||||
*
|
||||
* Example:
|
||||
* list_for_each_rev(&parent->children, child, list)
|
||||
* printf("Name: %s\n", child->name);
|
||||
*/
|
||||
#define list_for_each_rev(h, i, member) \
|
||||
for (i = container_of_var(list_debug(h)->n.prev, i, member); \
|
||||
&i->member != &(h)->n; \
|
||||
i = container_of_var(i->member.prev, i, member))
|
||||
|
||||
/**
|
||||
* list_for_each_safe - iterate through a list, maybe during deletion
|
||||
* @h: the list_head
|
||||
* @i: the structure containing the list_node
|
||||
* @nxt: the structure containing the list_node
|
||||
* @member: the list_node member of the structure
|
||||
*
|
||||
* This is a convenient wrapper to iterate @i over the entire list. It's
|
||||
* a for loop, so you can break and continue as normal. The extra variable
|
||||
* @nxt is used to hold the next element, so you can delete @i from the list.
|
||||
*
|
||||
* Example:
|
||||
* struct child *next;
|
||||
* list_for_each_safe(&parent->children, child, next, list) {
|
||||
* list_del(&child->list);
|
||||
* parent->num_children--;
|
||||
* }
|
||||
*/
|
||||
#define list_for_each_safe(h, i, nxt, member) \
|
||||
list_for_each_safe_off(h, i, nxt, list_off_var_(i, member))
|
||||
|
||||
/**
|
||||
* list_for_each_off - iterate through a list of memory regions.
|
||||
* @h: the list_head
|
||||
* @i: the pointer to a memory region wich contains list node data.
|
||||
* @off: offset(relative to @i) at which list node data resides.
|
||||
*
|
||||
* This is a low-level wrapper to iterate @i over the entire list, used to
|
||||
* implement all oher, more high-level, for-each constructs. It's a for loop,
|
||||
* so you can break and continue as normal.
|
||||
*
|
||||
* WARNING! Being the low-level macro that it is, this wrapper doesn't know
|
||||
* nor care about the type of @i. The only assumtion made is that @i points
|
||||
* to a chunk of memory that at some @offset, relative to @i, contains a
|
||||
* properly filled `struct node_list' which in turn contains pointers to
|
||||
* memory chunks and it's turtles all the way down. Whith all that in mind
|
||||
* remember that given the wrong pointer/offset couple this macro will
|
||||
* happilly churn all you memory untill SEGFAULT stops it, in other words
|
||||
* caveat emptor.
|
||||
*
|
||||
* It is worth mentioning that one of legitimate use-cases for that wrapper
|
||||
* is operation on opaque types with known offset for `struct list_node'
|
||||
* member(preferably 0), because it allows you not to disclose the type of
|
||||
* @i.
|
||||
*
|
||||
* Example:
|
||||
* list_for_each_off(&parent->children, child,
|
||||
* offsetof(struct child, list))
|
||||
* printf("Name: %s\n", child->name);
|
||||
*/
|
||||
#define list_for_each_off(h, i, off) \
|
||||
for (i = list_node_to_off_(list_debug(h)->n.next, (off)); \
|
||||
list_node_from_off_((void *)i, (off)) != &(h)->n; \
|
||||
i = list_node_to_off_(list_node_from_off_((void *)i, (off))->next, \
|
||||
(off)))
|
||||
|
||||
/**
|
||||
* list_for_each_safe_off - iterate through a list of memory regions, maybe
|
||||
* during deletion
|
||||
* @h: the list_head
|
||||
* @i: the pointer to a memory region wich contains list node data.
|
||||
* @nxt: the structure containing the list_node
|
||||
* @off: offset(relative to @i) at which list node data resides.
|
||||
*
|
||||
* For details see `list_for_each_off' and `list_for_each_safe'
|
||||
* descriptions.
|
||||
*
|
||||
* Example:
|
||||
* list_for_each_safe_off(&parent->children, child,
|
||||
* next, offsetof(struct child, list))
|
||||
* printf("Name: %s\n", child->name);
|
||||
*/
|
||||
#define list_for_each_safe_off(h, i, nxt, off) \
|
||||
for (i = list_node_to_off_(list_debug(h)->n.next, (off)), \
|
||||
nxt = list_node_to_off_(list_node_from_off_(i, (off))->next, \
|
||||
(off)); \
|
||||
list_node_from_off_(i, (off)) != &(h)->n; \
|
||||
i = nxt, \
|
||||
nxt = list_node_to_off_(list_node_from_off_(i, (off))->next, \
|
||||
(off)))
|
||||
|
||||
|
||||
/* Other -off variants. */
|
||||
#define list_entry_off(n, type, off) \
|
||||
((type *)list_node_from_off_((n), (off)))
|
||||
|
||||
#define list_head_off(h, type, off) \
|
||||
((type *)list_head_off((h), (off)))
|
||||
|
||||
#define list_tail_off(h, type, off) \
|
||||
((type *)list_tail_((h), (off)))
|
||||
|
||||
#define list_add_off(h, n, off) \
|
||||
list_add((h), list_node_from_off_((n), (off)))
|
||||
|
||||
#define list_del_off(n, off) \
|
||||
list_del(list_node_from_off_((n), (off)))
|
||||
|
||||
#define list_del_from_off(h, n, off) \
|
||||
list_del_from(h, list_node_from_off_((n), (off)))
|
||||
|
||||
/* Offset helper functions so we only single-evaluate. */
|
||||
static inline void *list_node_to_off_(struct list_node *node, size_t off)
|
||||
{
|
||||
return (void *)((char *)node - off);
|
||||
}
|
||||
static inline struct list_node *list_node_from_off_(void *ptr, size_t off)
|
||||
{
|
||||
return (struct list_node *)((char *)ptr + off);
|
||||
}
|
||||
|
||||
/* Get the offset of the member, but make sure it's a list_node. */
|
||||
#define list_off_(type, member) \
|
||||
(container_off(type, member) + \
|
||||
check_type(((type *)0)->member, struct list_node))
|
||||
|
||||
#define list_off_var_(var, member) \
|
||||
(container_off_var(var, member) + \
|
||||
check_type(var->member, struct list_node))
|
||||
|
||||
#endif /* CCAN_LIST_H */
|
||||
80
src/hash.h
80
src/hash.h
@@ -1,80 +0,0 @@
|
||||
#ifndef _LINUX_HASH_H
|
||||
#define _LINUX_HASH_H
|
||||
/* Fast hashing routine for ints, longs and pointers.
|
||||
(C) 2002 Nadia Yvette Chambers, IBM */
|
||||
|
||||
/*
|
||||
* Knuth recommends primes in approximately golden ratio to the maximum
|
||||
* integer representable by a machine word for multiplicative hashing.
|
||||
* Chuck Lever verified the effectiveness of this technique:
|
||||
* http://www.citi.umich.edu/techreports/reports/citi-tr-00-1.pdf
|
||||
*
|
||||
* These primes are chosen to be bit-sparse, that is operations on
|
||||
* them can use shifts and additions instead of multiplications for
|
||||
* machines where multiplications are slow.
|
||||
*/
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
/* 2^31 + 2^29 - 2^25 + 2^22 - 2^19 - 2^16 + 1 */
|
||||
#define GOLDEN_RATIO_PRIME_32 0x9e370001UL
|
||||
/* 2^63 + 2^61 - 2^57 + 2^54 - 2^51 - 2^18 + 1 */
|
||||
#define GOLDEN_RATIO_PRIME_64 0x9e37fffffffc0001UL
|
||||
|
||||
#if SIZEOF_UNSIGNED_LONG == 4
|
||||
#define GOLDEN_RATIO_PRIME GOLDEN_RATIO_PRIME_32
|
||||
#define hash_long(val, bits) hash_32(val, bits)
|
||||
#elif SIZEOF_UNSIGNED_LONG == 8
|
||||
#define hash_long(val, bits) hash_64(val, bits)
|
||||
#define GOLDEN_RATIO_PRIME GOLDEN_RATIO_PRIME_64
|
||||
#else
|
||||
#error Wordsize not 32 or 64
|
||||
#endif
|
||||
|
||||
static inline uint64_t hash_64(uint64_t val, unsigned int bits)
|
||||
{
|
||||
uint64_t hash = val;
|
||||
|
||||
/* Sigh, gcc can't optimise this alone like it does for 32 bits. */
|
||||
uint64_t n = hash;
|
||||
n <<= 18;
|
||||
hash -= n;
|
||||
n <<= 33;
|
||||
hash -= n;
|
||||
n <<= 3;
|
||||
hash += n;
|
||||
n <<= 3;
|
||||
hash -= n;
|
||||
n <<= 4;
|
||||
hash += n;
|
||||
n <<= 2;
|
||||
hash += n;
|
||||
|
||||
/* High bits are more random, so use them. */
|
||||
return hash >> (64 - bits);
|
||||
}
|
||||
|
||||
static inline uint32_t hash_32(uint32_t val, unsigned int bits)
|
||||
{
|
||||
/* On some cpus multiply is faster, on others gcc will do shifts */
|
||||
uint32_t hash = val * GOLDEN_RATIO_PRIME_32;
|
||||
|
||||
/* High bits are more random, so use them. */
|
||||
return hash >> (32 - bits);
|
||||
}
|
||||
|
||||
static inline unsigned long hash_ptr(const void *ptr, unsigned int bits)
|
||||
{
|
||||
return hash_long((unsigned long)ptr, bits);
|
||||
}
|
||||
|
||||
static inline uint32_t hash32_ptr(const void *ptr)
|
||||
{
|
||||
unsigned long val = (unsigned long)ptr;
|
||||
|
||||
#if SIZEOF_UNSIGNED_LONG == 8
|
||||
val ^= (val >> 32);
|
||||
#endif
|
||||
return (uint32_t)val;
|
||||
}
|
||||
#endif /* _LINUX_HASH_H */
|
||||
231
src/hashtable.h
231
src/hashtable.h
@@ -1,231 +0,0 @@
|
||||
/*
|
||||
* Statically sized hash table implementation
|
||||
* (C) 2012 Sasha Levin <levinsasha928@gmail.com>
|
||||
*/
|
||||
|
||||
#ifndef _LINUX_HASHTABLE_H
|
||||
#define _LINUX_HASHTABLE_H
|
||||
|
||||
#include <list.h>
|
||||
#include <stdint.h>
|
||||
|
||||
/**
|
||||
* ilog2 - log of base 2 of 32-bit or a 64-bit unsigned value
|
||||
* @n - parameter
|
||||
*
|
||||
* constant-capable log of base 2 calculation
|
||||
* - this can be used to initialise global variables from constant data, hence
|
||||
* the massive ternary operator construction
|
||||
*
|
||||
* selects the appropriately-sized optimised version depending on sizeof(n)
|
||||
*/
|
||||
#define hash_ilog2(n) \
|
||||
( \
|
||||
__builtin_constant_p(n) ? ( \
|
||||
(n) < 1 ? -1 : \
|
||||
(n) & (1ULL << 63) ? 63 : \
|
||||
(n) & (1ULL << 62) ? 62 : \
|
||||
(n) & (1ULL << 61) ? 61 : \
|
||||
(n) & (1ULL << 60) ? 60 : \
|
||||
(n) & (1ULL << 59) ? 59 : \
|
||||
(n) & (1ULL << 58) ? 58 : \
|
||||
(n) & (1ULL << 57) ? 57 : \
|
||||
(n) & (1ULL << 56) ? 56 : \
|
||||
(n) & (1ULL << 55) ? 55 : \
|
||||
(n) & (1ULL << 54) ? 54 : \
|
||||
(n) & (1ULL << 53) ? 53 : \
|
||||
(n) & (1ULL << 52) ? 52 : \
|
||||
(n) & (1ULL << 51) ? 51 : \
|
||||
(n) & (1ULL << 50) ? 50 : \
|
||||
(n) & (1ULL << 49) ? 49 : \
|
||||
(n) & (1ULL << 48) ? 48 : \
|
||||
(n) & (1ULL << 47) ? 47 : \
|
||||
(n) & (1ULL << 46) ? 46 : \
|
||||
(n) & (1ULL << 45) ? 45 : \
|
||||
(n) & (1ULL << 44) ? 44 : \
|
||||
(n) & (1ULL << 43) ? 43 : \
|
||||
(n) & (1ULL << 42) ? 42 : \
|
||||
(n) & (1ULL << 41) ? 41 : \
|
||||
(n) & (1ULL << 40) ? 40 : \
|
||||
(n) & (1ULL << 39) ? 39 : \
|
||||
(n) & (1ULL << 38) ? 38 : \
|
||||
(n) & (1ULL << 37) ? 37 : \
|
||||
(n) & (1ULL << 36) ? 36 : \
|
||||
(n) & (1ULL << 35) ? 35 : \
|
||||
(n) & (1ULL << 34) ? 34 : \
|
||||
(n) & (1ULL << 33) ? 33 : \
|
||||
(n) & (1ULL << 32) ? 32 : \
|
||||
(n) & (1ULL << 31) ? 31 : \
|
||||
(n) & (1ULL << 30) ? 30 : \
|
||||
(n) & (1ULL << 29) ? 29 : \
|
||||
(n) & (1ULL << 28) ? 28 : \
|
||||
(n) & (1ULL << 27) ? 27 : \
|
||||
(n) & (1ULL << 26) ? 26 : \
|
||||
(n) & (1ULL << 25) ? 25 : \
|
||||
(n) & (1ULL << 24) ? 24 : \
|
||||
(n) & (1ULL << 23) ? 23 : \
|
||||
(n) & (1ULL << 22) ? 22 : \
|
||||
(n) & (1ULL << 21) ? 21 : \
|
||||
(n) & (1ULL << 20) ? 20 : \
|
||||
(n) & (1ULL << 19) ? 19 : \
|
||||
(n) & (1ULL << 18) ? 18 : \
|
||||
(n) & (1ULL << 17) ? 17 : \
|
||||
(n) & (1ULL << 16) ? 16 : \
|
||||
(n) & (1ULL << 15) ? 15 : \
|
||||
(n) & (1ULL << 14) ? 14 : \
|
||||
(n) & (1ULL << 13) ? 13 : \
|
||||
(n) & (1ULL << 12) ? 12 : \
|
||||
(n) & (1ULL << 11) ? 11 : \
|
||||
(n) & (1ULL << 10) ? 10 : \
|
||||
(n) & (1ULL << 9) ? 9 : \
|
||||
(n) & (1ULL << 8) ? 8 : \
|
||||
(n) & (1ULL << 7) ? 7 : \
|
||||
(n) & (1ULL << 6) ? 6 : \
|
||||
(n) & (1ULL << 5) ? 5 : \
|
||||
(n) & (1ULL << 4) ? 4 : \
|
||||
(n) & (1ULL << 3) ? 3 : \
|
||||
(n) & (1ULL << 2) ? 2 : \
|
||||
(n) & (1ULL << 1) ? 1 : \
|
||||
(n) & (1ULL << 0) ? 0 : \
|
||||
-1 \
|
||||
) : \
|
||||
-1 \
|
||||
)
|
||||
|
||||
#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
|
||||
|
||||
#define DEFINE_HASHTABLE(name, bits) \
|
||||
struct hlist_head name[1 << (bits)] = \
|
||||
{ [0 ... ((1 << (bits)) - 1)] = HLIST_HEAD_INIT }
|
||||
|
||||
#define DECLARE_HASHTABLE(name, bits) \
|
||||
struct hlist_head name[1 << (bits)]
|
||||
|
||||
#define HASH_SIZE(name) (ARRAY_SIZE(name))
|
||||
#define HASH_BITS(name) hash_ilog2(HASH_SIZE(name))
|
||||
|
||||
/* Use hash_32 when possible to allow for fast 32bit hashing in 64bit kernels. */
|
||||
#define hash_min(val, bits) \
|
||||
(sizeof(val) <= 4 ? hash_32(val, bits) : hash_long(val, bits))
|
||||
|
||||
static inline void __hash_init(struct hlist_head *ht, unsigned int sz)
|
||||
{
|
||||
unsigned int i;
|
||||
|
||||
for (i = 0; i < sz; i++)
|
||||
INIT_HLIST_HEAD(&ht[i]);
|
||||
}
|
||||
|
||||
/**
|
||||
* hash_init - initialize a hash table
|
||||
* @hashtable: hashtable to be initialized
|
||||
*
|
||||
* Calculates the size of the hashtable from the given parameter, otherwise
|
||||
* same as hash_init_size.
|
||||
*
|
||||
* This has to be a macro since HASH_BITS() will not work on pointers since
|
||||
* it calculates the size during preprocessing.
|
||||
*/
|
||||
#define hash_init(hashtable) __hash_init(hashtable, HASH_SIZE(hashtable))
|
||||
|
||||
/**
|
||||
* hash_add - add an object to a hashtable
|
||||
* @hashtable: hashtable to add to
|
||||
* @node: the &struct hlist_node of the object to be added
|
||||
* @key: the key of the object to be added
|
||||
*/
|
||||
#define hash_add(hashtable, node, key) \
|
||||
hlist_add_head(node, &hashtable[hash_min(key, HASH_BITS(hashtable))])
|
||||
|
||||
/**
|
||||
* hash_hashed - check whether an object is in any hashtable
|
||||
* @node: the &struct hlist_node of the object to be checked
|
||||
*/
|
||||
static inline unsigned hash_hashed(struct hlist_node *node)
|
||||
{
|
||||
return !hlist_unhashed(node);
|
||||
}
|
||||
|
||||
static inline unsigned __hash_empty(struct hlist_head *ht, unsigned int sz)
|
||||
{
|
||||
unsigned int i;
|
||||
|
||||
for (i = 0; i < sz; i++)
|
||||
if (!hlist_empty(&ht[i]))
|
||||
return 0;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
/**
|
||||
* hash_empty - check whether a hashtable is empty
|
||||
* @hashtable: hashtable to check
|
||||
*
|
||||
* This has to be a macro since HASH_BITS() will not work on pointers since
|
||||
* it calculates the size during preprocessing.
|
||||
*/
|
||||
#define hash_empty(hashtable) __hash_empty(hashtable, HASH_SIZE(hashtable))
|
||||
|
||||
/**
|
||||
* hash_del - remove an object from a hashtable
|
||||
* @node: &struct hlist_node of the object to remove
|
||||
*/
|
||||
static inline void hash_del(struct hlist_node *node)
|
||||
{
|
||||
hlist_del_init(node);
|
||||
}
|
||||
|
||||
/**
|
||||
* hash_for_each - iterate over a hashtable
|
||||
* @name: hashtable to iterate
|
||||
* @bkt: integer to use as bucket loop cursor
|
||||
* @node: the &struct list_head to use as a loop cursor for each entry
|
||||
* @obj: the type * to use as a loop cursor for each entry
|
||||
* @member: the name of the hlist_node within the struct
|
||||
*/
|
||||
#define hash_for_each(name, bkt, node, obj, member) \
|
||||
for ((bkt) = 0, node = NULL; node == NULL && (bkt) < HASH_SIZE(name); (bkt)++)\
|
||||
hlist_for_each_entry(obj, node, &name[bkt], member)
|
||||
|
||||
/**
|
||||
* hash_for_each_safe - iterate over a hashtable safe against removal of
|
||||
* hash entry
|
||||
* @name: hashtable to iterate
|
||||
* @bkt: integer to use as bucket loop cursor
|
||||
* @node: the &struct list_head to use as a loop cursor for each entry
|
||||
* @tmp: a &struct used for temporary storage
|
||||
* @obj: the type * to use as a loop cursor for each entry
|
||||
* @member: the name of the hlist_node within the struct
|
||||
*/
|
||||
#define hash_for_each_safe(name, bkt, node, tmp, obj, member) \
|
||||
for ((bkt) = 0, node = NULL; node == NULL && (bkt) < HASH_SIZE(name); (bkt)++)\
|
||||
hlist_for_each_entry_safe(obj, node, tmp, &name[bkt], member)
|
||||
|
||||
/**
|
||||
* hash_for_each_possible - iterate over all possible objects hashing to the
|
||||
* same bucket
|
||||
* @name: hashtable to iterate
|
||||
* @obj: the type * to use as a loop cursor for each entry
|
||||
* @node: the &struct list_head to use as a loop cursor for each entry
|
||||
* @member: the name of the hlist_node within the struct
|
||||
* @key: the key of the objects to iterate over
|
||||
*/
|
||||
#define hash_for_each_possible(name, obj, node, member, key) \
|
||||
hlist_for_each_entry(obj, node, &name[hash_min(key, HASH_BITS(name))], member)
|
||||
|
||||
/**
|
||||
* hash_for_each_possible_safe - iterate over all possible objects hashing to the
|
||||
* same bucket safe against removals
|
||||
* @name: hashtable to iterate
|
||||
* @obj: the type * to use as a loop cursor for each entry
|
||||
* @node: the &struct list_head to use as a loop cursor for each entry
|
||||
* @tmp: a &struct used for temporary storage
|
||||
* @member: the name of the hlist_node within the struct
|
||||
* @key: the key of the objects to iterate over
|
||||
*/
|
||||
#define hash_for_each_possible_safe(name, obj, node, tmp, member, key) \
|
||||
hlist_for_each_entry_safe(obj, node, tmp, \
|
||||
&name[hash_min(key, HASH_BITS(name))], member)
|
||||
|
||||
|
||||
#endif
|
||||
749
src/list.h
749
src/list.h
@@ -1,749 +0,0 @@
|
||||
#ifndef _LINUX_LIST_H
|
||||
#define _LINUX_LIST_H
|
||||
|
||||
#undef offsetof
|
||||
#ifdef __compiler_offsetof
|
||||
#define offsetof(TYPE,MEMBER) __compiler_offsetof(TYPE,MEMBER)
|
||||
#else
|
||||
#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
|
||||
#endif
|
||||
|
||||
/**
|
||||
* container_of - cast a member of a structure out to the containing structure
|
||||
* @ptr: the pointer to the member.
|
||||
* @type: the type of the container struct this is embedded in.
|
||||
* @member: the name of the member within the struct.
|
||||
*
|
||||
*/
|
||||
#define container_of(ptr, type, member) ({ \
|
||||
const typeof( ((type *)0)->member ) *__mptr = (ptr); \
|
||||
(type *)( (char *)__mptr - offsetof(type,member) );})
|
||||
|
||||
struct list_head {
|
||||
struct list_head *next, *prev;
|
||||
};
|
||||
|
||||
/*
|
||||
* Simple doubly linked list implementation.
|
||||
*
|
||||
* Some of the internal functions ("__xxx") are useful when
|
||||
* manipulating whole lists rather than single entries, as
|
||||
* sometimes we already know the next/prev entries and we can
|
||||
* generate better code by using them directly rather than
|
||||
* using the generic single-entry routines.
|
||||
*/
|
||||
|
||||
#define LIST_HEAD_INIT(name) { &(name), &(name) }
|
||||
|
||||
#define LIST_HEAD(name) \
|
||||
struct list_head name = LIST_HEAD_INIT(name)
|
||||
|
||||
static inline void INIT_LIST_HEAD(struct list_head *list)
|
||||
{
|
||||
list->next = list;
|
||||
list->prev = list;
|
||||
}
|
||||
|
||||
/*
|
||||
* Insert a new entry between two known consecutive entries.
|
||||
*
|
||||
* This is only for internal list manipulation where we know
|
||||
* the prev/next entries already!
|
||||
*/
|
||||
#ifndef CONFIG_DEBUG_LIST
|
||||
static inline void __list_add(struct list_head *new,
|
||||
struct list_head *prev,
|
||||
struct list_head *next)
|
||||
{
|
||||
next->prev = new;
|
||||
new->next = next;
|
||||
new->prev = prev;
|
||||
prev->next = new;
|
||||
}
|
||||
#else
|
||||
extern void __list_add(struct list_head *new,
|
||||
struct list_head *prev,
|
||||
struct list_head *next);
|
||||
#endif
|
||||
|
||||
/**
|
||||
* list_add - add a new entry
|
||||
* @new: new entry to be added
|
||||
* @head: list head to add it after
|
||||
*
|
||||
* Insert a new entry after the specified head.
|
||||
* This is good for implementing stacks.
|
||||
*/
|
||||
static inline void list_add(struct list_head *new, struct list_head *head)
|
||||
{
|
||||
__list_add(new, head, head->next);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* list_add_tail - add a new entry
|
||||
* @new: new entry to be added
|
||||
* @head: list head to add it before
|
||||
*
|
||||
* Insert a new entry before the specified head.
|
||||
* This is useful for implementing queues.
|
||||
*/
|
||||
static inline void list_add_tail(struct list_head *new, struct list_head *head)
|
||||
{
|
||||
__list_add(new, head->prev, head);
|
||||
}
|
||||
|
||||
/*
|
||||
* Delete a list entry by making the prev/next entries
|
||||
* point to each other.
|
||||
*
|
||||
* This is only for internal list manipulation where we know
|
||||
* the prev/next entries already!
|
||||
*/
|
||||
static inline void __list_del(struct list_head * prev, struct list_head * next)
|
||||
{
|
||||
next->prev = prev;
|
||||
prev->next = next;
|
||||
}
|
||||
|
||||
/**
|
||||
* list_del - deletes entry from list.
|
||||
* @entry: the element to delete from the list.
|
||||
* Note: list_empty() on entry does not return true after this, the entry is
|
||||
* in an undefined state.
|
||||
*/
|
||||
#ifndef CONFIG_DEBUG_LIST
|
||||
static inline void __list_del_entry(struct list_head *entry)
|
||||
{
|
||||
__list_del(entry->prev, entry->next);
|
||||
}
|
||||
|
||||
static inline void list_del(struct list_head *entry)
|
||||
{
|
||||
__list_del(entry->prev, entry->next);
|
||||
entry->next = NULL;
|
||||
entry->prev = NULL;
|
||||
}
|
||||
#else
|
||||
extern void __list_del_entry(struct list_head *entry);
|
||||
extern void list_del(struct list_head *entry);
|
||||
#endif
|
||||
|
||||
/**
|
||||
* list_replace - replace old entry by new one
|
||||
* @old : the element to be replaced
|
||||
* @new : the new element to insert
|
||||
*
|
||||
* If @old was empty, it will be overwritten.
|
||||
*/
|
||||
static inline void list_replace(struct list_head *old,
|
||||
struct list_head *new)
|
||||
{
|
||||
new->next = old->next;
|
||||
new->next->prev = new;
|
||||
new->prev = old->prev;
|
||||
new->prev->next = new;
|
||||
}
|
||||
|
||||
static inline void list_replace_init(struct list_head *old,
|
||||
struct list_head *new)
|
||||
{
|
||||
list_replace(old, new);
|
||||
INIT_LIST_HEAD(old);
|
||||
}
|
||||
|
||||
/**
|
||||
* list_del_init - deletes entry from list and reinitialize it.
|
||||
* @entry: the element to delete from the list.
|
||||
*/
|
||||
static inline void list_del_init(struct list_head *entry)
|
||||
{
|
||||
__list_del_entry(entry);
|
||||
INIT_LIST_HEAD(entry);
|
||||
}
|
||||
|
||||
/**
|
||||
* list_move - delete from one list and add as another's head
|
||||
* @list: the entry to move
|
||||
* @head: the head that will precede our entry
|
||||
*/
|
||||
static inline void list_move(struct list_head *list, struct list_head *head)
|
||||
{
|
||||
__list_del_entry(list);
|
||||
list_add(list, head);
|
||||
}
|
||||
|
||||
/**
|
||||
* list_move_tail - delete from one list and add as another's tail
|
||||
* @list: the entry to move
|
||||
* @head: the head that will follow our entry
|
||||
*/
|
||||
static inline void list_move_tail(struct list_head *list,
|
||||
struct list_head *head)
|
||||
{
|
||||
__list_del_entry(list);
|
||||
list_add_tail(list, head);
|
||||
}
|
||||
|
||||
/**
|
||||
* list_is_last - tests whether @list is the last entry in list @head
|
||||
* @list: the entry to test
|
||||
* @head: the head of the list
|
||||
*/
|
||||
static inline int list_is_last(const struct list_head *list,
|
||||
const struct list_head *head)
|
||||
{
|
||||
return list->next == head;
|
||||
}
|
||||
|
||||
/**
|
||||
* list_empty - tests whether a list is empty
|
||||
* @head: the list to test.
|
||||
*/
|
||||
static inline int list_empty(const struct list_head *head)
|
||||
{
|
||||
return head->next == head;
|
||||
}
|
||||
|
||||
/**
|
||||
* list_empty_careful - tests whether a list is empty and not being modified
|
||||
* @head: the list to test
|
||||
*
|
||||
* Description:
|
||||
* tests whether a list is empty _and_ checks that no other CPU might be
|
||||
* in the process of modifying either member (next or prev)
|
||||
*
|
||||
* NOTE: using list_empty_careful() without synchronization
|
||||
* can only be safe if the only activity that can happen
|
||||
* to the list entry is list_del_init(). Eg. it cannot be used
|
||||
* if another CPU could re-list_add() it.
|
||||
*/
|
||||
static inline int list_empty_careful(const struct list_head *head)
|
||||
{
|
||||
struct list_head *next = head->next;
|
||||
return (next == head) && (next == head->prev);
|
||||
}
|
||||
|
||||
/**
|
||||
* list_rotate_left - rotate the list to the left
|
||||
* @head: the head of the list
|
||||
*/
|
||||
static inline void list_rotate_left(struct list_head *head)
|
||||
{
|
||||
struct list_head *first;
|
||||
|
||||
if (!list_empty(head)) {
|
||||
first = head->next;
|
||||
list_move_tail(first, head);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* list_is_singular - tests whether a list has just one entry.
|
||||
* @head: the list to test.
|
||||
*/
|
||||
static inline int list_is_singular(const struct list_head *head)
|
||||
{
|
||||
return !list_empty(head) && (head->next == head->prev);
|
||||
}
|
||||
|
||||
static inline void __list_cut_position(struct list_head *list,
|
||||
struct list_head *head, struct list_head *entry)
|
||||
{
|
||||
struct list_head *new_first = entry->next;
|
||||
list->next = head->next;
|
||||
list->next->prev = list;
|
||||
list->prev = entry;
|
||||
entry->next = list;
|
||||
head->next = new_first;
|
||||
new_first->prev = head;
|
||||
}
|
||||
|
||||
/**
|
||||
* list_cut_position - cut a list into two
|
||||
* @list: a new list to add all removed entries
|
||||
* @head: a list with entries
|
||||
* @entry: an entry within head, could be the head itself
|
||||
* and if so we won't cut the list
|
||||
*
|
||||
* This helper moves the initial part of @head, up to and
|
||||
* including @entry, from @head to @list. You should
|
||||
* pass on @entry an element you know is on @head. @list
|
||||
* should be an empty list or a list you do not care about
|
||||
* losing its data.
|
||||
*
|
||||
*/
|
||||
static inline void list_cut_position(struct list_head *list,
|
||||
struct list_head *head, struct list_head *entry)
|
||||
{
|
||||
if (list_empty(head))
|
||||
return;
|
||||
if (list_is_singular(head) &&
|
||||
(head->next != entry && head != entry))
|
||||
return;
|
||||
if (entry == head)
|
||||
INIT_LIST_HEAD(list);
|
||||
else
|
||||
__list_cut_position(list, head, entry);
|
||||
}
|
||||
|
||||
static inline void __list_splice(const struct list_head *list,
|
||||
struct list_head *prev,
|
||||
struct list_head *next)
|
||||
{
|
||||
struct list_head *first = list->next;
|
||||
struct list_head *last = list->prev;
|
||||
|
||||
first->prev = prev;
|
||||
prev->next = first;
|
||||
|
||||
last->next = next;
|
||||
next->prev = last;
|
||||
}
|
||||
|
||||
/**
|
||||
* list_splice - join two lists, this is designed for stacks
|
||||
* @list: the new list to add.
|
||||
* @head: the place to add it in the first list.
|
||||
*/
|
||||
static inline void list_splice(const struct list_head *list,
|
||||
struct list_head *head)
|
||||
{
|
||||
if (!list_empty(list))
|
||||
__list_splice(list, head, head->next);
|
||||
}
|
||||
|
||||
/**
|
||||
* list_splice_tail - join two lists, each list being a queue
|
||||
* @list: the new list to add.
|
||||
* @head: the place to add it in the first list.
|
||||
*/
|
||||
static inline void list_splice_tail(struct list_head *list,
|
||||
struct list_head *head)
|
||||
{
|
||||
if (!list_empty(list))
|
||||
__list_splice(list, head->prev, head);
|
||||
}
|
||||
|
||||
/**
|
||||
* list_splice_init - join two lists and reinitialise the emptied list.
|
||||
* @list: the new list to add.
|
||||
* @head: the place to add it in the first list.
|
||||
*
|
||||
* The list at @list is reinitialised
|
||||
*/
|
||||
static inline void list_splice_init(struct list_head *list,
|
||||
struct list_head *head)
|
||||
{
|
||||
if (!list_empty(list)) {
|
||||
__list_splice(list, head, head->next);
|
||||
INIT_LIST_HEAD(list);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* list_splice_tail_init - join two lists and reinitialise the emptied list
|
||||
* @list: the new list to add.
|
||||
* @head: the place to add it in the first list.
|
||||
*
|
||||
* Each of the lists is a queue.
|
||||
* The list at @list is reinitialised
|
||||
*/
|
||||
static inline void list_splice_tail_init(struct list_head *list,
|
||||
struct list_head *head)
|
||||
{
|
||||
if (!list_empty(list)) {
|
||||
__list_splice(list, head->prev, head);
|
||||
INIT_LIST_HEAD(list);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* list_entry - get the struct for this entry
|
||||
* @ptr: the &struct list_head pointer.
|
||||
* @type: the type of the struct this is embedded in.
|
||||
* @member: the name of the list_struct within the struct.
|
||||
*/
|
||||
#define list_entry(ptr, type, member) \
|
||||
container_of(ptr, type, member)
|
||||
|
||||
/**
|
||||
* list_first_entry - get the first element from a list
|
||||
* @ptr: the list head to take the element from.
|
||||
* @type: the type of the struct this is embedded in.
|
||||
* @member: the name of the list_struct within the struct.
|
||||
*
|
||||
* Note, that list is expected to be not empty.
|
||||
*/
|
||||
#define list_first_entry(ptr, type, member) \
|
||||
list_entry((ptr)->next, type, member)
|
||||
|
||||
/**
|
||||
* list_for_each - iterate over a list
|
||||
* @pos: the &struct list_head to use as a loop cursor.
|
||||
* @head: the head for your list.
|
||||
*/
|
||||
#define list_for_each(pos, head) \
|
||||
for (pos = (head)->next; pos != (head); pos = pos->next)
|
||||
|
||||
/**
|
||||
* __list_for_each - iterate over a list
|
||||
* @pos: the &struct list_head to use as a loop cursor.
|
||||
* @head: the head for your list.
|
||||
*
|
||||
* This variant doesn't differ from list_for_each() any more.
|
||||
* We don't do prefetching in either case.
|
||||
*/
|
||||
#define __list_for_each(pos, head) \
|
||||
for (pos = (head)->next; pos != (head); pos = pos->next)
|
||||
|
||||
/**
|
||||
* list_for_each_prev - iterate over a list backwards
|
||||
* @pos: the &struct list_head to use as a loop cursor.
|
||||
* @head: the head for your list.
|
||||
*/
|
||||
#define list_for_each_prev(pos, head) \
|
||||
for (pos = (head)->prev; pos != (head); pos = pos->prev)
|
||||
|
||||
/**
|
||||
* list_for_each_safe - iterate over a list safe against removal of list entry
|
||||
* @pos: the &struct list_head to use as a loop cursor.
|
||||
* @n: another &struct list_head to use as temporary storage
|
||||
* @head: the head for your list.
|
||||
*/
|
||||
#define list_for_each_safe(pos, n, head) \
|
||||
for (pos = (head)->next, n = pos->next; pos != (head); \
|
||||
pos = n, n = pos->next)
|
||||
|
||||
/**
|
||||
* list_for_each_prev_safe - iterate over a list backwards safe against removal of list entry
|
||||
* @pos: the &struct list_head to use as a loop cursor.
|
||||
* @n: another &struct list_head to use as temporary storage
|
||||
* @head: the head for your list.
|
||||
*/
|
||||
#define list_for_each_prev_safe(pos, n, head) \
|
||||
for (pos = (head)->prev, n = pos->prev; \
|
||||
pos != (head); \
|
||||
pos = n, n = pos->prev)
|
||||
|
||||
/**
|
||||
* list_for_each_entry - iterate over list of given type
|
||||
* @pos: the type * to use as a loop cursor.
|
||||
* @head: the head for your list.
|
||||
* @member: the name of the list_struct within the struct.
|
||||
*/
|
||||
#define list_for_each_entry(pos, head, member) \
|
||||
for (pos = list_entry((head)->next, typeof(*pos), member); \
|
||||
&pos->member != (head); \
|
||||
pos = list_entry(pos->member.next, typeof(*pos), member))
|
||||
|
||||
/**
|
||||
* list_for_each_entry_reverse - iterate backwards over list of given type.
|
||||
* @pos: the type * to use as a loop cursor.
|
||||
* @head: the head for your list.
|
||||
* @member: the name of the list_struct within the struct.
|
||||
*/
|
||||
#define list_for_each_entry_reverse(pos, head, member) \
|
||||
for (pos = list_entry((head)->prev, typeof(*pos), member); \
|
||||
&pos->member != (head); \
|
||||
pos = list_entry(pos->member.prev, typeof(*pos), member))
|
||||
|
||||
/**
|
||||
* list_prepare_entry - prepare a pos entry for use in list_for_each_entry_continue()
|
||||
* @pos: the type * to use as a start point
|
||||
* @head: the head of the list
|
||||
* @member: the name of the list_struct within the struct.
|
||||
*
|
||||
* Prepares a pos entry for use as a start point in list_for_each_entry_continue().
|
||||
*/
|
||||
#define list_prepare_entry(pos, head, member) \
|
||||
((pos) ? : list_entry(head, typeof(*pos), member))
|
||||
|
||||
/**
|
||||
* list_for_each_entry_continue - continue iteration over list of given type
|
||||
* @pos: the type * to use as a loop cursor.
|
||||
* @head: the head for your list.
|
||||
* @member: the name of the list_struct within the struct.
|
||||
*
|
||||
* Continue to iterate over list of given type, continuing after
|
||||
* the current position.
|
||||
*/
|
||||
#define list_for_each_entry_continue(pos, head, member) \
|
||||
for (pos = list_entry(pos->member.next, typeof(*pos), member); \
|
||||
&pos->member != (head); \
|
||||
pos = list_entry(pos->member.next, typeof(*pos), member))
|
||||
|
||||
/**
|
||||
* list_for_each_entry_continue_reverse - iterate backwards from the given point
|
||||
* @pos: the type * to use as a loop cursor.
|
||||
* @head: the head for your list.
|
||||
* @member: the name of the list_struct within the struct.
|
||||
*
|
||||
* Start to iterate over list of given type backwards, continuing after
|
||||
* the current position.
|
||||
*/
|
||||
#define list_for_each_entry_continue_reverse(pos, head, member) \
|
||||
for (pos = list_entry(pos->member.prev, typeof(*pos), member); \
|
||||
&pos->member != (head); \
|
||||
pos = list_entry(pos->member.prev, typeof(*pos), member))
|
||||
|
||||
/**
|
||||
* list_for_each_entry_from - iterate over list of given type from the current point
|
||||
* @pos: the type * to use as a loop cursor.
|
||||
* @head: the head for your list.
|
||||
* @member: the name of the list_struct within the struct.
|
||||
*
|
||||
* Iterate over list of given type, continuing from current position.
|
||||
*/
|
||||
#define list_for_each_entry_from(pos, head, member) \
|
||||
for (; &pos->member != (head); \
|
||||
pos = list_entry(pos->member.next, typeof(*pos), member))
|
||||
|
||||
/**
|
||||
* list_for_each_entry_safe - iterate over list of given type safe against removal of list entry
|
||||
* @pos: the type * to use as a loop cursor.
|
||||
* @n: another type * to use as temporary storage
|
||||
* @head: the head for your list.
|
||||
* @member: the name of the list_struct within the struct.
|
||||
*/
|
||||
#define list_for_each_entry_safe(pos, n, head, member) \
|
||||
for (pos = list_entry((head)->next, typeof(*pos), member), \
|
||||
n = list_entry(pos->member.next, typeof(*pos), member); \
|
||||
&pos->member != (head); \
|
||||
pos = n, n = list_entry(n->member.next, typeof(*n), member))
|
||||
|
||||
/**
|
||||
* list_for_each_entry_safe_continue - continue list iteration safe against removal
|
||||
* @pos: the type * to use as a loop cursor.
|
||||
* @n: another type * to use as temporary storage
|
||||
* @head: the head for your list.
|
||||
* @member: the name of the list_struct within the struct.
|
||||
*
|
||||
* Iterate over list of given type, continuing after current point,
|
||||
* safe against removal of list entry.
|
||||
*/
|
||||
#define list_for_each_entry_safe_continue(pos, n, head, member) \
|
||||
for (pos = list_entry(pos->member.next, typeof(*pos), member), \
|
||||
n = list_entry(pos->member.next, typeof(*pos), member); \
|
||||
&pos->member != (head); \
|
||||
pos = n, n = list_entry(n->member.next, typeof(*n), member))
|
||||
|
||||
/**
|
||||
* list_for_each_entry_safe_from - iterate over list from current point safe against removal
|
||||
* @pos: the type * to use as a loop cursor.
|
||||
* @n: another type * to use as temporary storage
|
||||
* @head: the head for your list.
|
||||
* @member: the name of the list_struct within the struct.
|
||||
*
|
||||
* Iterate over list of given type from current point, safe against
|
||||
* removal of list entry.
|
||||
*/
|
||||
#define list_for_each_entry_safe_from(pos, n, head, member) \
|
||||
for (n = list_entry(pos->member.next, typeof(*pos), member); \
|
||||
&pos->member != (head); \
|
||||
pos = n, n = list_entry(n->member.next, typeof(*n), member))
|
||||
|
||||
/**
|
||||
* list_for_each_entry_safe_reverse - iterate backwards over list safe against removal
|
||||
* @pos: the type * to use as a loop cursor.
|
||||
* @n: another type * to use as temporary storage
|
||||
* @head: the head for your list.
|
||||
* @member: the name of the list_struct within the struct.
|
||||
*
|
||||
* Iterate backwards over list of given type, safe against removal
|
||||
* of list entry.
|
||||
*/
|
||||
#define list_for_each_entry_safe_reverse(pos, n, head, member) \
|
||||
for (pos = list_entry((head)->prev, typeof(*pos), member), \
|
||||
n = list_entry(pos->member.prev, typeof(*pos), member); \
|
||||
&pos->member != (head); \
|
||||
pos = n, n = list_entry(n->member.prev, typeof(*n), member))
|
||||
|
||||
/**
|
||||
* list_safe_reset_next - reset a stale list_for_each_entry_safe loop
|
||||
* @pos: the loop cursor used in the list_for_each_entry_safe loop
|
||||
* @n: temporary storage used in list_for_each_entry_safe
|
||||
* @member: the name of the list_struct within the struct.
|
||||
*
|
||||
* list_safe_reset_next is not safe to use in general if the list may be
|
||||
* modified concurrently (eg. the lock is dropped in the loop body). An
|
||||
* exception to this is if the cursor element (pos) is pinned in the list,
|
||||
* and list_safe_reset_next is called after re-taking the lock and before
|
||||
* completing the current iteration of the loop body.
|
||||
*/
|
||||
#define list_safe_reset_next(pos, n, member) \
|
||||
n = list_entry(pos->member.next, typeof(*pos), member)
|
||||
|
||||
|
||||
/*
|
||||
* Double linked lists with a single pointer list head.
|
||||
* Mostly useful for hash tables where the two pointer list head is
|
||||
* too wasteful.
|
||||
* You lose the ability to access the tail in O(1).
|
||||
*/
|
||||
|
||||
struct hlist_head {
|
||||
struct hlist_node *first;
|
||||
};
|
||||
|
||||
struct hlist_node {
|
||||
struct hlist_node *next, **pprev;
|
||||
};
|
||||
|
||||
#define HLIST_HEAD_INIT { .first = NULL }
|
||||
#define HLIST_HEAD(name) struct hlist_head name = { .first = NULL }
|
||||
#define INIT_HLIST_HEAD(ptr) ((ptr)->first = NULL)
|
||||
static inline void INIT_HLIST_NODE(struct hlist_node *h)
|
||||
{
|
||||
h->next = NULL;
|
||||
h->pprev = NULL;
|
||||
}
|
||||
|
||||
static inline int hlist_unhashed(const struct hlist_node *h)
|
||||
{
|
||||
return !h->pprev;
|
||||
}
|
||||
|
||||
static inline int hlist_empty(const struct hlist_head *h)
|
||||
{
|
||||
return !h->first;
|
||||
}
|
||||
|
||||
static inline void __hlist_del(struct hlist_node *n)
|
||||
{
|
||||
struct hlist_node *next = n->next;
|
||||
struct hlist_node **pprev = n->pprev;
|
||||
*pprev = next;
|
||||
if (next)
|
||||
next->pprev = pprev;
|
||||
}
|
||||
|
||||
#define LIST_POISON1 NULL
|
||||
#define LIST_POISON2 NULL
|
||||
|
||||
static inline void hlist_del(struct hlist_node *n)
|
||||
{
|
||||
__hlist_del(n);
|
||||
n->next = LIST_POISON1;
|
||||
n->pprev = LIST_POISON2;
|
||||
}
|
||||
|
||||
static inline void hlist_del_init(struct hlist_node *n)
|
||||
{
|
||||
if (!hlist_unhashed(n)) {
|
||||
__hlist_del(n);
|
||||
INIT_HLIST_NODE(n);
|
||||
}
|
||||
}
|
||||
|
||||
static inline void hlist_add_head(struct hlist_node *n, struct hlist_head *h)
|
||||
{
|
||||
struct hlist_node *first = h->first;
|
||||
n->next = first;
|
||||
if (first)
|
||||
first->pprev = &n->next;
|
||||
h->first = n;
|
||||
n->pprev = &h->first;
|
||||
}
|
||||
|
||||
/* next must be != NULL */
|
||||
static inline void hlist_add_before(struct hlist_node *n,
|
||||
struct hlist_node *next)
|
||||
{
|
||||
n->pprev = next->pprev;
|
||||
n->next = next;
|
||||
next->pprev = &n->next;
|
||||
*(n->pprev) = n;
|
||||
}
|
||||
|
||||
static inline void hlist_add_after(struct hlist_node *n,
|
||||
struct hlist_node *next)
|
||||
{
|
||||
next->next = n->next;
|
||||
n->next = next;
|
||||
next->pprev = &n->next;
|
||||
|
||||
if(next->next)
|
||||
next->next->pprev = &next->next;
|
||||
}
|
||||
|
||||
/* after that we'll appear to be on some hlist and hlist_del will work */
|
||||
static inline void hlist_add_fake(struct hlist_node *n)
|
||||
{
|
||||
n->pprev = &n->next;
|
||||
}
|
||||
|
||||
/*
|
||||
* Move a list from one list head to another. Fixup the pprev
|
||||
* reference of the first entry if it exists.
|
||||
*/
|
||||
static inline void hlist_move_list(struct hlist_head *old,
|
||||
struct hlist_head *new)
|
||||
{
|
||||
new->first = old->first;
|
||||
if (new->first)
|
||||
new->first->pprev = &new->first;
|
||||
old->first = NULL;
|
||||
}
|
||||
|
||||
#define hlist_entry(ptr, type, member) container_of(ptr,type,member)
|
||||
|
||||
#define hlist_for_each(pos, head) \
|
||||
for (pos = (head)->first; pos ; pos = pos->next)
|
||||
|
||||
#define hlist_for_each_safe(pos, n, head) \
|
||||
for (pos = (head)->first; pos && ({ n = pos->next; 1; }); \
|
||||
pos = n)
|
||||
|
||||
/**
|
||||
* hlist_for_each_entry - iterate over list of given type
|
||||
* @tpos: the type * to use as a loop cursor.
|
||||
* @pos: the &struct hlist_node to use as a loop cursor.
|
||||
* @head: the head for your list.
|
||||
* @member: the name of the hlist_node within the struct.
|
||||
*/
|
||||
#define hlist_for_each_entry(tpos, pos, head, member) \
|
||||
for (pos = (head)->first; \
|
||||
pos && \
|
||||
({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
|
||||
pos = pos->next)
|
||||
|
||||
/**
|
||||
* hlist_for_each_entry_continue - iterate over a hlist continuing after current point
|
||||
* @tpos: the type * to use as a loop cursor.
|
||||
* @pos: the &struct hlist_node to use as a loop cursor.
|
||||
* @member: the name of the hlist_node within the struct.
|
||||
*/
|
||||
#define hlist_for_each_entry_continue(tpos, pos, member) \
|
||||
for (pos = (pos)->next; \
|
||||
pos && \
|
||||
({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
|
||||
pos = pos->next)
|
||||
|
||||
/**
|
||||
* hlist_for_each_entry_from - iterate over a hlist continuing from current point
|
||||
* @tpos: the type * to use as a loop cursor.
|
||||
* @pos: the &struct hlist_node to use as a loop cursor.
|
||||
* @member: the name of the hlist_node within the struct.
|
||||
*/
|
||||
#define hlist_for_each_entry_from(tpos, pos, member) \
|
||||
for (; pos && \
|
||||
({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
|
||||
pos = pos->next)
|
||||
|
||||
/**
|
||||
* hlist_for_each_entry_safe - iterate over list of given type safe against removal of list entry
|
||||
* @tpos: the type * to use as a loop cursor.
|
||||
* @pos: the &struct hlist_node to use as a loop cursor.
|
||||
* @n: another &struct hlist_node to use as temporary storage
|
||||
* @head: the head for your list.
|
||||
* @member: the name of the hlist_node within the struct.
|
||||
*/
|
||||
#define hlist_for_each_entry_safe(tpos, pos, n, head, member) \
|
||||
for (pos = (head)->first; \
|
||||
pos && ({ n = pos->next; 1; }) && \
|
||||
({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
|
||||
pos = n)
|
||||
|
||||
|
||||
#endif
|
||||
@@ -40,10 +40,10 @@
|
||||
#include <cookies.h>
|
||||
#include <tun.h>
|
||||
#include <main.h>
|
||||
#include <list.h>
|
||||
#include <ccan/list/list.h>
|
||||
#include "pam.h"
|
||||
|
||||
static int send_auth_reply(main_server_st* s, struct proc_list_st* proc,
|
||||
static int send_auth_reply(main_server_st* s, struct proc_st* proc,
|
||||
cmd_auth_reply_t r, struct lease_st* lease)
|
||||
{
|
||||
struct iovec iov[6];
|
||||
@@ -98,7 +98,7 @@ static int send_auth_reply(main_server_st* s, struct proc_list_st* proc,
|
||||
return(sendmsg(proc->fd, &hdr, 0));
|
||||
}
|
||||
|
||||
static int handle_auth_cookie_req(main_server_st* s, struct proc_list_st* proc,
|
||||
static int handle_auth_cookie_req(main_server_st* s, struct proc_st* proc,
|
||||
const struct cmd_auth_cookie_req_st * req, struct lease_st **lease)
|
||||
{
|
||||
int ret;
|
||||
@@ -123,7 +123,7 @@ struct stored_cookie_st sc;
|
||||
}
|
||||
|
||||
static
|
||||
int generate_and_store_vals(main_server_st *s, struct proc_list_st* proc)
|
||||
int generate_and_store_vals(main_server_st *s, struct proc_st* proc)
|
||||
{
|
||||
int ret;
|
||||
struct stored_cookie_st sc;
|
||||
@@ -149,7 +149,7 @@ struct stored_cookie_st sc;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int handle_auth_req(main_server_st *s, struct proc_list_st* proc,
|
||||
static int handle_auth_req(main_server_st *s, struct proc_st* proc,
|
||||
const struct cmd_auth_req_st * req, struct lease_st **lease)
|
||||
{
|
||||
int ret = -1;
|
||||
@@ -191,7 +191,7 @@ unsigned username_set = 0;
|
||||
return ret;
|
||||
}
|
||||
|
||||
int handle_commands(main_server_st *s, struct proc_list_st* proc)
|
||||
int handle_commands(main_server_st *s, struct proc_st* proc)
|
||||
{
|
||||
struct iovec iov[2];
|
||||
char buf[128];
|
||||
|
||||
@@ -35,14 +35,13 @@
|
||||
#include <gnutls/crypto.h>
|
||||
#include <tlslib.h>
|
||||
#include "ipc.h"
|
||||
#include <hash.h>
|
||||
#include <hash-pjw-bare.h>
|
||||
#include <ccan/hash/hash.h>
|
||||
|
||||
#include <vpn.h>
|
||||
#include <main.h>
|
||||
#include <tlslib.h>
|
||||
|
||||
int send_resume_fetch_reply(main_server_st* s, struct proc_list_st * proc,
|
||||
int send_resume_fetch_reply(main_server_st* s, struct proc_st * proc,
|
||||
cmd_resume_reply_t r, struct cmd_resume_fetch_reply_st * reply)
|
||||
{
|
||||
struct iovec iov[3];
|
||||
@@ -64,26 +63,30 @@ int send_resume_fetch_reply(main_server_st* s, struct proc_list_st * proc,
|
||||
return(sendmsg(proc->fd, &hdr, 0));
|
||||
}
|
||||
|
||||
int handle_resume_delete_req(main_server_st* s, struct proc_list_st * proc,
|
||||
int handle_resume_delete_req(main_server_st* s, struct proc_st * proc,
|
||||
const struct cmd_resume_fetch_req_st * req)
|
||||
{
|
||||
size_t key;
|
||||
tls_cache_st* cache;
|
||||
struct hlist_node *pos, *tmp;
|
||||
key = hash_pjw_bare(req->session_id, req->session_id_size);
|
||||
struct htable_iter iter;
|
||||
size_t key;
|
||||
|
||||
hash_for_each_possible_safe(s->tls_db->entry, cache, pos, tmp, list, key) {
|
||||
key = hash_stable_8(req->session_id, req->session_id_size, 0);
|
||||
|
||||
cache = htable_firstval(&s->tls_db->ht, &iter, key);
|
||||
while(cache != NULL) {
|
||||
if (req->session_id_size == cache->session_id_size &&
|
||||
memcmp (req->session_id, cache->session_id, req->session_id_size) == 0) {
|
||||
|
||||
cache->session_data_size = 0;
|
||||
cache->session_id_size = 0;
|
||||
|
||||
hash_del(&cache->list);
|
||||
htable_delval(&s->tls_db->ht, &iter);
|
||||
free(cache);
|
||||
s->tls_db->entries--;
|
||||
return 0;
|
||||
}
|
||||
|
||||
cache = htable_nextval(&s->tls_db->ht, &iter, key);
|
||||
}
|
||||
|
||||
return 0;
|
||||
@@ -98,18 +101,20 @@ static int ip_cmp(const struct sockaddr_storage *s1, const struct sockaddr_stora
|
||||
}
|
||||
}
|
||||
|
||||
int handle_resume_fetch_req(main_server_st* s, struct proc_list_st * proc,
|
||||
int handle_resume_fetch_req(main_server_st* s, struct proc_st * proc,
|
||||
const struct cmd_resume_fetch_req_st * req,
|
||||
struct cmd_resume_fetch_reply_st * rep)
|
||||
{
|
||||
size_t key;
|
||||
tls_cache_st* cache;
|
||||
struct hlist_node *pos;
|
||||
struct htable_iter iter;
|
||||
size_t key;
|
||||
|
||||
key = hash_pjw_bare(req->session_id, req->session_id_size);
|
||||
rep->reply = REP_RESUME_FAILED;
|
||||
|
||||
hash_for_each_possible(s->tls_db->entry, cache, pos, list, key) {
|
||||
key = hash_stable_8(req->session_id, req->session_id_size, 0);
|
||||
|
||||
cache = htable_firstval(&s->tls_db->ht, &iter, key);
|
||||
while(cache != NULL) {
|
||||
if (req->session_id_size == cache->session_id_size &&
|
||||
memcmp (req->session_id, cache->session_id, req->session_id_size) == 0) {
|
||||
|
||||
@@ -124,13 +129,15 @@ struct hlist_node *pos;
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
cache = htable_nextval(&s->tls_db->ht, &iter, key);
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
}
|
||||
|
||||
int handle_resume_store_req(main_server_st* s, struct proc_list_st * proc,
|
||||
int handle_resume_store_req(main_server_st* s, struct proc_st * proc,
|
||||
const struct cmd_resume_store_req_st * req)
|
||||
{
|
||||
tls_cache_st* cache;
|
||||
@@ -147,7 +154,7 @@ size_t key;
|
||||
s->tls_db->entries >= DEFAULT_MAX_CACHED_TLS_SESSIONS(s->tls_db)))
|
||||
return -1;
|
||||
|
||||
key = hash_pjw_bare(req->session_id, req->session_id_size);
|
||||
key = hash_stable_8(req->session_id, req->session_id_size, 0);
|
||||
|
||||
cache = malloc(sizeof(*cache));
|
||||
if (cache == NULL)
|
||||
@@ -161,7 +168,7 @@ size_t key;
|
||||
memcpy(cache->session_data, req->session_data, req->session_data_size);
|
||||
memcpy(&cache->remote_addr, &proc->remote_addr, proc->remote_addr_len);
|
||||
|
||||
hash_add(s->tls_db->entry, &cache->list, key);
|
||||
htable_add(&s->tls_db->ht, key, cache);
|
||||
s->tls_db->entries++;
|
||||
|
||||
return 0;
|
||||
@@ -170,13 +177,13 @@ size_t key;
|
||||
void expire_tls_sessions(main_server_st *s)
|
||||
{
|
||||
tls_cache_st* cache;
|
||||
int bkt;
|
||||
struct hlist_node *pos, *tmp;
|
||||
struct htable_iter iter;
|
||||
time_t now, exp;
|
||||
|
||||
now = time(0);
|
||||
|
||||
hash_for_each_safe(s->tls_db->entry, bkt, pos, tmp, cache, list) {
|
||||
cache = htable_first(&s->tls_db->ht, &iter);
|
||||
while(cache != NULL) {
|
||||
#if GNUTLS_VERSION_NUMBER >= 0x030107
|
||||
gnutls_datum_t d;
|
||||
|
||||
@@ -191,10 +198,11 @@ time_t now, exp;
|
||||
cache->session_data_size = 0;
|
||||
cache->session_id_size = 0;
|
||||
|
||||
hash_del(&cache->list);
|
||||
htable_delval(&s->tls_db->ht, &iter);
|
||||
free(cache);
|
||||
s->tls_db->entries--;
|
||||
}
|
||||
cache = htable_next(&s->tls_db->ht, &iter);
|
||||
}
|
||||
|
||||
return;
|
||||
|
||||
@@ -39,9 +39,9 @@
|
||||
#include <cookies.h>
|
||||
#include <tun.h>
|
||||
#include <main.h>
|
||||
#include <list.h>
|
||||
#include <ccan/list/list.h>
|
||||
|
||||
void call_disconnect_script(main_server_st *s, struct proc_list_st* proc)
|
||||
void call_disconnect_script(main_server_st *s, struct proc_st* proc)
|
||||
{
|
||||
pid_t pid;
|
||||
int ret;
|
||||
@@ -89,7 +89,7 @@ int ret;
|
||||
}
|
||||
}
|
||||
|
||||
int call_connect_script(main_server_st *s, struct proc_list_st* proc, struct lease_st* lease)
|
||||
int call_connect_script(main_server_st *s, struct proc_st* proc, struct lease_st* lease)
|
||||
{
|
||||
pid_t pid;
|
||||
int ret, status;
|
||||
|
||||
61
src/main.c
61
src/main.c
@@ -41,7 +41,7 @@
|
||||
#include <worker.h>
|
||||
#include <cookies.h>
|
||||
#include <tun.h>
|
||||
#include <list.h>
|
||||
#include <ccan/list/list.h>
|
||||
|
||||
int syslog_open = 0;
|
||||
static unsigned int terminate = 0;
|
||||
@@ -63,9 +63,10 @@ listen_ports(struct cfg_st* config, struct listen_list_st *list, const char *nod
|
||||
char portname[6];
|
||||
int s, y;
|
||||
char buf[512];
|
||||
struct listen_list_st *tmp;
|
||||
struct listener_st *tmp;
|
||||
|
||||
INIT_LIST_HEAD(&list->list);
|
||||
list_head_init(&list->head);
|
||||
list->total = 0;
|
||||
|
||||
snprintf(portname, sizeof(portname), "%d", listen_port);
|
||||
|
||||
@@ -149,9 +150,10 @@ listen_ports(struct cfg_st* config, struct listen_list_st *list, const char *nod
|
||||
}
|
||||
}
|
||||
|
||||
tmp = calloc(1, sizeof(struct listen_list_st));
|
||||
tmp = calloc(1, sizeof(struct listener_st));
|
||||
tmp->fd = s;
|
||||
list_add(&(tmp->list), &(list->list));
|
||||
list_add(&list->head, &(tmp->list));
|
||||
list->total++;
|
||||
}
|
||||
|
||||
fflush(stderr);
|
||||
@@ -285,22 +287,20 @@ static void drop_privileges(struct cfg_st *config)
|
||||
/* clears the server llist and clist. To be used after fork() */
|
||||
void clear_lists(main_server_st *s)
|
||||
{
|
||||
struct list_head *cq;
|
||||
struct list_head *pos;
|
||||
struct listen_list_st *ltmp;
|
||||
struct proc_list_st *ctmp;
|
||||
struct listener_st *ltmp, *lpos;
|
||||
struct proc_st *ctmp, *cpos;
|
||||
|
||||
list_for_each_safe(pos, cq, &s->llist->list) {
|
||||
ltmp = list_entry(pos, struct listen_list_st, list);
|
||||
list_for_each_safe(&s->llist->head, ltmp, lpos, list) {
|
||||
close(ltmp->fd);
|
||||
list_del(<mp->list);
|
||||
s->llist->total--;
|
||||
}
|
||||
|
||||
list_for_each_safe(pos, cq, &s->clist->list) {
|
||||
ctmp = list_entry(pos, struct proc_list_st, list);
|
||||
list_for_each_safe(&s->clist->head, ctmp, cpos, list) {
|
||||
if (ctmp->fd >= 0)
|
||||
close(ctmp->fd);
|
||||
list_del(&ctmp->list);
|
||||
s->clist->total--;
|
||||
}
|
||||
|
||||
tls_cache_deinit(s->tls_db);
|
||||
@@ -308,17 +308,15 @@ void clear_lists(main_server_st *s)
|
||||
|
||||
static void kill_children(struct proc_list_st* clist)
|
||||
{
|
||||
struct list_head *pos;
|
||||
struct proc_list_st *ctmp;
|
||||
struct proc_st *ctmp;
|
||||
|
||||
list_for_each(pos, &clist->list) {
|
||||
ctmp = list_entry(pos, struct proc_list_st, list);
|
||||
list_for_each(&clist->head, ctmp, list) {
|
||||
if (ctmp->pid != -1)
|
||||
kill(ctmp->pid, SIGTERM);
|
||||
}
|
||||
}
|
||||
|
||||
static void remove_proc(struct proc_list_st *ctmp)
|
||||
static void remove_proc(struct proc_st *ctmp)
|
||||
{
|
||||
/* close the intercomm fd */
|
||||
if (ctmp->fd >= 0)
|
||||
@@ -343,10 +341,8 @@ int main(int argc, char** argv)
|
||||
struct tls_st creds;
|
||||
struct listen_list_st llist;
|
||||
struct proc_list_st clist;
|
||||
struct listen_list_st *ltmp;
|
||||
struct proc_list_st *ctmp;
|
||||
struct list_head *cq;
|
||||
struct list_head *pos;
|
||||
struct listener_st *ltmp;
|
||||
struct proc_st *ctmp, *cpos;
|
||||
struct tun_st tun;
|
||||
fd_set rd;
|
||||
int val, n = 0, ret;
|
||||
@@ -358,7 +354,7 @@ int main(int argc, char** argv)
|
||||
main_server_st s;
|
||||
tls_cache_db_st* tls_db;
|
||||
|
||||
INIT_LIST_HEAD(&clist.list);
|
||||
list_head_init(&clist.head);
|
||||
tun_st_init(&tun);
|
||||
tls_cache_init(&config, &tls_db);
|
||||
|
||||
@@ -468,9 +464,7 @@ int main(int argc, char** argv)
|
||||
|
||||
FD_ZERO(&rd);
|
||||
|
||||
list_for_each(pos, &llist.list) {
|
||||
ltmp = list_entry(pos, struct listen_list_st, list);
|
||||
|
||||
list_for_each(&llist.head, ltmp, list) {
|
||||
val = fcntl(ltmp->fd, F_GETFL, 0);
|
||||
if ((val == -1)
|
||||
|| (fcntl(ltmp->fd, F_SETFL, val | O_NONBLOCK) <
|
||||
@@ -483,9 +477,7 @@ int main(int argc, char** argv)
|
||||
n = MAX(n, ltmp->fd);
|
||||
}
|
||||
|
||||
list_for_each(pos, &clist.list) {
|
||||
ctmp = list_entry(pos, struct proc_list_st, list);
|
||||
|
||||
list_for_each(&clist.head, ctmp, list) {
|
||||
FD_SET(ctmp->fd, &rd);
|
||||
n = MAX(n, ctmp->fd);
|
||||
}
|
||||
@@ -504,8 +496,7 @@ int main(int argc, char** argv)
|
||||
}
|
||||
|
||||
/* Check for new connections to accept */
|
||||
list_for_each(pos, &llist.list) {
|
||||
ltmp = list_entry(pos, struct listen_list_st, list);
|
||||
list_for_each(&llist.head, ltmp, list) {
|
||||
if (FD_ISSET(ltmp->fd, &rd)) {
|
||||
ws.remote_addr_len = sizeof(ws.remote_addr);
|
||||
fd = accept(ltmp->fd, (void*)&ws.remote_addr, &ws.remote_addr_len);
|
||||
@@ -555,7 +546,7 @@ int main(int argc, char** argv)
|
||||
fork_failed:
|
||||
close(cmd_fd[0]);
|
||||
} else { /* parent */
|
||||
ctmp = calloc(1, sizeof(struct proc_list_st));
|
||||
ctmp = calloc(1, sizeof(struct proc_st));
|
||||
if (ctmp == NULL) {
|
||||
kill(pid, SIGTERM);
|
||||
goto fork_failed;
|
||||
@@ -567,7 +558,7 @@ fork_failed:
|
||||
ctmp->fd = cmd_fd[0];
|
||||
set_cloexec_flag (cmd_fd[0], 1);
|
||||
|
||||
list_add(&(ctmp->list), &(clist.list));
|
||||
list_add(&clist.head, &(ctmp->list));
|
||||
active_clients++;
|
||||
}
|
||||
close(cmd_fd[1]);
|
||||
@@ -576,9 +567,7 @@ fork_failed:
|
||||
}
|
||||
|
||||
/* Check for any pending commands */
|
||||
list_for_each_safe(pos, cq, &clist.list) {
|
||||
ctmp = list_entry(pos, struct proc_list_st, list);
|
||||
|
||||
list_for_each_safe(&clist.head, ctmp, cpos, list) {
|
||||
if (FD_ISSET(ctmp->fd, &rd)) {
|
||||
ret = handle_commands(&s, ctmp);
|
||||
if (ret < 0) {
|
||||
|
||||
32
src/main.h
32
src/main.h
@@ -11,13 +11,18 @@
|
||||
|
||||
int cmd_parser (int argc, char **argv, struct cfg_st* config);
|
||||
|
||||
struct listen_list_st {
|
||||
struct list_head list;
|
||||
struct listener_st {
|
||||
struct list_node list;
|
||||
int fd;
|
||||
};
|
||||
|
||||
struct proc_list_st {
|
||||
struct list_head list;
|
||||
struct listen_list_st {
|
||||
struct list_head head;
|
||||
unsigned int total;
|
||||
};
|
||||
|
||||
struct proc_st {
|
||||
struct list_node list;
|
||||
int fd;
|
||||
pid_t pid;
|
||||
struct sockaddr_storage remote_addr; /* peer address */
|
||||
@@ -31,6 +36,11 @@ struct proc_list_st {
|
||||
struct lease_st* lease;
|
||||
};
|
||||
|
||||
struct proc_list_st {
|
||||
struct list_head head;
|
||||
unsigned int total;
|
||||
};
|
||||
|
||||
typedef struct main_server_st {
|
||||
struct cfg_st *config;
|
||||
struct tun_st *tun;
|
||||
@@ -42,24 +52,24 @@ typedef struct main_server_st {
|
||||
|
||||
void clear_lists(main_server_st *s);
|
||||
|
||||
int handle_commands(main_server_st *s, struct proc_list_st* cur);
|
||||
int handle_commands(main_server_st *s, struct proc_st* cur);
|
||||
|
||||
int call_connect_script(main_server_st *s, struct proc_list_st* cur, struct lease_st*);
|
||||
void call_disconnect_script(main_server_st *s, struct proc_list_st* cur);
|
||||
int call_connect_script(main_server_st *s, struct proc_st* cur, struct lease_st*);
|
||||
void call_disconnect_script(main_server_st *s, struct proc_st* cur);
|
||||
|
||||
void expire_tls_sessions(main_server_st *s);
|
||||
|
||||
int send_resume_fetch_reply(main_server_st* s, struct proc_list_st* proc,
|
||||
int send_resume_fetch_reply(main_server_st* s, struct proc_st* proc,
|
||||
cmd_resume_reply_t r, struct cmd_resume_fetch_reply_st * reply);
|
||||
|
||||
int handle_resume_delete_req(main_server_st* s, struct proc_list_st* proc,
|
||||
int handle_resume_delete_req(main_server_st* s, struct proc_st* proc,
|
||||
const struct cmd_resume_fetch_req_st * req);
|
||||
|
||||
int handle_resume_fetch_req(main_server_st* s, struct proc_list_st* proc,
|
||||
int handle_resume_fetch_req(main_server_st* s, struct proc_st* proc,
|
||||
const struct cmd_resume_fetch_req_st * req,
|
||||
struct cmd_resume_fetch_reply_st * rep);
|
||||
|
||||
int handle_resume_store_req(main_server_st* s, struct proc_list_st *proc,
|
||||
int handle_resume_store_req(main_server_st* s, struct proc_st *proc,
|
||||
const struct cmd_resume_store_req_st * req);
|
||||
|
||||
void expire_cookies(main_server_st* s);
|
||||
|
||||
22
src/tlslib.c
22
src/tlslib.c
@@ -31,6 +31,7 @@
|
||||
#include <limits.h>
|
||||
|
||||
#include <tlslib.h>
|
||||
#include <ccan/hash/hash.h>
|
||||
#include <vpn.h>
|
||||
|
||||
|
||||
@@ -116,6 +117,13 @@ void tls_fatal_close(gnutls_session_t session,
|
||||
gnutls_deinit(session);
|
||||
}
|
||||
|
||||
static size_t rehash(const void *_e, void *unused)
|
||||
{
|
||||
const tls_cache_st *e = _e;
|
||||
|
||||
return hash_stable_8(e->session_id, e->session_id_size, 0);
|
||||
}
|
||||
|
||||
void tls_cache_init(struct cfg_st* config, tls_cache_db_st** _db)
|
||||
{
|
||||
tls_cache_db_st * db;
|
||||
@@ -124,7 +132,7 @@ tls_cache_db_st * db;
|
||||
if (db == NULL)
|
||||
exit(1);
|
||||
|
||||
hash_init(db->entry);
|
||||
htable_init(&db->ht, rehash, NULL);
|
||||
db->entries = 0;
|
||||
|
||||
*_db = db;
|
||||
@@ -133,19 +141,21 @@ tls_cache_db_st * db;
|
||||
void tls_cache_deinit(tls_cache_db_st* db)
|
||||
{
|
||||
tls_cache_st* cache;
|
||||
int bkt;
|
||||
struct hlist_node *pos, *tmp;
|
||||
struct htable_iter iter;
|
||||
|
||||
hash_for_each_safe(db->entry, bkt, pos, tmp, cache, list) {
|
||||
cache = htable_first(&db->ht, &iter);
|
||||
while(cache != NULL) {
|
||||
if (cache->session_data_size > 0) {
|
||||
memset(cache->session_data, 0, cache->session_data_size);
|
||||
cache->session_data_size = 0;
|
||||
cache->session_id_size = 0;
|
||||
}
|
||||
hash_del(&cache->list);
|
||||
free(cache);
|
||||
db->entries--;
|
||||
|
||||
cache = htable_next(&db->ht, &iter);
|
||||
}
|
||||
htable_clear(&db->ht);
|
||||
db->entries = 0;
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -3,7 +3,7 @@
|
||||
|
||||
#include <gnutls/gnutls.h>
|
||||
#include <vpn.h>
|
||||
#include <hashtable.h>
|
||||
#include <ccan/htable/htable.h>
|
||||
|
||||
#define tls_puts(s, str) tls_send(s, str, sizeof(str)-1)
|
||||
|
||||
@@ -42,15 +42,13 @@ typedef struct
|
||||
|
||||
char session_data[MAX_SESSION_DATA_SIZE];
|
||||
unsigned int session_data_size;
|
||||
|
||||
struct hlist_node list;
|
||||
} tls_cache_st;
|
||||
|
||||
#define TLS_SESSION_EXPIRATION_TIME 600
|
||||
#define DEFAULT_MAX_CACHED_TLS_SESSIONS(db) HASH_SIZE(db->entry)
|
||||
#define DEFAULT_MAX_CACHED_TLS_SESSIONS(db) 256
|
||||
typedef struct
|
||||
{
|
||||
DECLARE_HASHTABLE(entry, 7);
|
||||
struct htable ht;
|
||||
unsigned int entries;
|
||||
} tls_cache_db_st;
|
||||
|
||||
|
||||
17
src/tun.c
17
src/tun.c
@@ -33,7 +33,7 @@
|
||||
|
||||
#include <vpn.h>
|
||||
#include <tun.h>
|
||||
#include <list.h>
|
||||
#include <ccan/list/list.h>
|
||||
|
||||
static int bignum_add1 (uint8_t * num, unsigned size)
|
||||
{
|
||||
@@ -313,11 +313,10 @@ int open_tun(const struct cfg_st *config, struct tun_st* tun, struct lease_st**
|
||||
struct ifreq ifr;
|
||||
unsigned int t;
|
||||
struct lease_st *lease = NULL;
|
||||
struct list_head *pos;
|
||||
struct lease_st *last4, *tmp;
|
||||
struct lease_st *last6;
|
||||
|
||||
if (list_empty(&tun->lease_list.list)) {
|
||||
if (list_empty(&tun->head)) {
|
||||
lease = calloc(1, sizeof(*lease));
|
||||
if (lease == NULL)
|
||||
return -1;
|
||||
@@ -330,13 +329,13 @@ int open_tun(const struct cfg_st *config, struct tun_st* tun, struct lease_st**
|
||||
}
|
||||
|
||||
/* Add into the list */
|
||||
list_add_tail( &lease->list, &tun->lease_list.list);
|
||||
list_add_tail( &tun->head, &lease->list);
|
||||
tun->total++;
|
||||
} else {
|
||||
last4 = last6 = NULL;
|
||||
|
||||
/* try to re-use an address */
|
||||
list_for_each(pos, &tun->lease_list.list) {
|
||||
tmp = list_entry(pos, struct lease_st, list);
|
||||
list_for_each(&tun->head, tmp, list) {
|
||||
if (tmp->in_use == 0) {
|
||||
lease = tmp;
|
||||
break;
|
||||
@@ -348,8 +347,7 @@ int open_tun(const struct cfg_st *config, struct tun_st* tun, struct lease_st**
|
||||
if (lease == NULL)
|
||||
return -1;
|
||||
|
||||
list_for_each_prev(pos, &tun->lease_list.list) {
|
||||
tmp = list_entry(pos, struct lease_st, list);
|
||||
list_for_each_rev(&tun->head, tmp, list) {
|
||||
if (tmp->rip4_len > 0)
|
||||
last4 = tmp;
|
||||
|
||||
@@ -367,7 +365,8 @@ int open_tun(const struct cfg_st *config, struct tun_st* tun, struct lease_st**
|
||||
}
|
||||
|
||||
/* Add into the list */
|
||||
list_add_tail( &lease->list, &tun->lease_list.list);
|
||||
list_add_tail( &tun->head, &lease->list);
|
||||
tun->total++;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
17
src/tun.h
17
src/tun.h
@@ -2,10 +2,10 @@
|
||||
# define TUN_H
|
||||
|
||||
#include <vpn.h>
|
||||
#include <list.h>
|
||||
#include <ccan/list/list.h>
|
||||
|
||||
struct lease_st {
|
||||
struct list_head list;
|
||||
struct list_node list;
|
||||
|
||||
char name[IFNAMSIZ];
|
||||
unsigned int tun_nr;
|
||||
@@ -28,24 +28,23 @@ struct lease_st {
|
||||
};
|
||||
|
||||
struct tun_st {
|
||||
struct lease_st lease_list;
|
||||
struct list_head head;
|
||||
unsigned total;
|
||||
};
|
||||
|
||||
inline static void tun_st_init(struct tun_st* ts)
|
||||
{
|
||||
memset(ts, 0, sizeof(*ts));
|
||||
INIT_LIST_HEAD(&ts->lease_list.list);
|
||||
list_head_init(&ts->head);
|
||||
}
|
||||
|
||||
inline static void tun_st_deinit(struct tun_st* ts)
|
||||
{
|
||||
struct list_head *cq;
|
||||
struct list_head *pos;
|
||||
struct lease_st *ltmp;
|
||||
struct lease_st *ltmp, *pos;
|
||||
|
||||
list_for_each_safe(pos, cq, &ts->lease_list.list) {
|
||||
ltmp = list_entry(pos, struct lease_st, list);
|
||||
list_for_each_safe(&ts->head, ltmp, pos, list) {
|
||||
list_del(<mp->list);
|
||||
ts->total--;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user