opt: avoid function pointer arithmetic

Same fix as we used for ccan/typesafe_cb.

opt: fix memory leak in tests.

No only does this give us one more ccanlint point, it clears the way
to see if we introduce a *real* memory leak later.

opt: allow const arguments.

This need shows up most clearly with opt_usage_and_exit and gcc's
-Wwrite-strings, where string literals become "const char *".  Our
callbacks should take const void *: since we overload the arg field
already (to hold table size) it make sense to turn it into a proper
union.

opt: define NULL

Headers should stand alone; we use NULL, so we should make sure it's defined.

cast: fix cast of void * when we don't have GCC features.

I thought using sizeof() comparison to compare the types was clever,
but it doesn't work on void pointers, as sizeof(void) is illegal.

array_size: make sure tests work even without GCC features.

In this case, "work" means "fail to compile cleanly".

talloc: fix leak in test/run-set_allocator.c

failtest: print complete history when we detect a leak.

tdb2: fix arithmetic on void * pointer.

typesafe: fix warnings with gcc's -Wcast-qual

Don't implicitly cast away const in the tests.

typesafe: fix warnings with gcc's -Wpointer-arith

In particular, avoid doing arithmetic on NULL; decay the function to a
pointer using a trinary conditional instead.

tdb2: tdb_mkdata

It's common to want to create a struct tdb_data which contains a const
pointer, so add a helper to do so, and use it to clean up other -Wcast-qual
warnings.

tdb2: fix warnings with -Wcast-qual using ccan/cast.

cast: fix compilation with GCC's -Wcast-qual

Samba uses -Wcast-qual to warn about casting away const.  The kind of
coders who care about const correctness are likely to turn that option
on, so we should make sure it's compatible with cast_const().

tdb2: fix tools compilation.

tdb2: fix compile of test/run-check-callback.c

foreach: fix case where iterators are not on the stack.

The foreach garbage collection assumed that iterators were all on the
stack, but they could be on the heap or a global (or static) variable.
We can prevent the heap case by tricky use of macros to complain on
any iterator which isn't a single token, but we can't prevent
globals/statics.

So, if an iterator already seems to be "off" the stack, mark it as
such and simply never free it.

configurator: HAVE_STACK_GROWS_UPWARDS

foreach: allow a single argument to foreach_int() and foreach_ptr().

David Gibson noted that foreach requires more than one argument.
There's no particularly good reason for this, other than lack of
imagination on my part.

foreach: fix HAVE_FOR_LOOP_DECLARATION case.

tdb2: merge changes in design document.

tdb2: tdb_error()

This makes transition from tdb1 much simpler.

tdb2: TDB_SEQNUM and tdb_get_seqnum support.

As per TDB1, except that the sequence number is 63 bit.

tdb2: tdb_name and tdb_fd functions.

As per TDB1, with one enhancement: a non-NULL name argument passed to
tdb_open() with the TDB_INTERNAL flag is preserved so you can identify
internal TDBs too.

tdb2: remove tdb_null

We don't need this now, since we use explicit error numbers.

tdb2: tdb_deq: inline helper for comparing two struct tdb_data

Everyone writes their own, so provide a standard one.

tdb2: implement tdb_exists and tdb_parse_record

These are the same as the TDB1 functions; but note that there is no reliable
way to tell if tdb_exists() fails due to an error.  This simplifies the API,
but means you have to use tdb_fetch() if you really care.

tdb2: begin tdb1 to tdb2 porting guide.

tdb2: allow multiple opens of the same file.

Finally, we enable sharing of the struct tdb_file.  We add a reference count
so we can free the struct tdb_file when the last tdb is closed.

tdb2: set owner for locks

The last step before sharing struct tdb_file is to add a field to
identify which tdb context is holding each lock, so we can fail when
they conflict.

tdb2: rename tdb_lock_type to tdb_lock

Internal reshuffle which makes things shorter and neater.

tdb2: move mmap into struct tdb_file

It makes sense to share the mmap between multiple openers.

tdb2: move file operations into separate structure

This moves the fd and locking information into a new 'struct tdb_file',
opening the way for it to be shared by multiple tdb_open calls on the
same file.

tdb2: fix leak in test/run-remap-in-read_traverse.c

tdb2: move open routines into a separate file (open.c)

Simply tidying up.

tdb2: Implement tdb_get_flags, tdb_add_flag and tdb_remove_flag.

tdb2: make sure records with extra padding have a 0 byte.

As detailed in doc/design.lyx section 2.16 "Record Headers Are Not
Expandible", we make sure that if there is padding at the end of a record,
the first byte of padding is a zero.

tdb2: avoid writing uninitialized bytes in test/layout.c

tdb2: feature support.

As detailed in doc/design.lyx section 2.15 "Extending The Header Is
Difficult"; we add features_used and features_offered fields to the
header, so we can identify if we add new features, and then if someone
opens it who doesn't understand that feature.

tdb2: make tdb_check typesafe.

tdb2: typesafe traverse function

This make sure that the data being handed to the function in tdb_traverse
is the correct type.

tdb2: check for invalid flags in tdb_open.

This is vitally important for forwards compatibility.

tdb2: fix two bogus returns in check.c

Two missed cases in b21004624683 (tdb2: change API to return the error
value.)

tdb2: use vasprintf.

tdb2: use config.h instead of setting _XOPEN_SOURCE etc.

tdb2: update tools/speed.c, tools/tdbtool.c and tools/tdbtorture.c to new API

tdb2: clear bogus gcc uninitialized warnings with -O3

failtest: include config.h first

It's now important, since it defines _GNU_SOURCE.

ccanlint: fix gdb line in tests_pass helper.

Recent changes shifted line numbers in tap.c, so the break is now in
the wrong place.  We should probably have an explicit function we can
breakpoint instead.

tools: fix ctype.h and string usage.

Enable CCAN_STR_DEBUG in the default flags, so our tools get checked,
and fix up the resulting errors.

str: replacements for ctype functions.

The standard ctype.h variants will make you go insane if you
contemplate them for too long.

tap: fix isdigit and isspace usage.

isspace() and isdigit() want an unsigned value.

ciniparser: fix ctype.h usage, and lazy strrchr.

tolower(), toupper() and isupper want an unsigned value.  Also, fix
lazy cost-discarding inside strrchr for extra safety.

ccanlint: objects_build_with_stringchecks

If we detect any mention of a problematic string function, try compiling
the entire module with string debugging enabled.

str: provide checks for ctype.h char functions, and strstr and strchr functions.

In the former case, we were bitten by the fact that you don't pass a char
to isalpha() et al: you pass an int.  This means on most platforms you want
to do:

   if (isalpha((unsigned char)c)) ...

Insane?  Yes, but I assure you I'm not making this up.

Similarly, I've always wanted strstr, strchr and strrchr to return
const char * when given a const char * argument to search, to avoid
constness leak.

In both cases, the actual versions from the headers may be macros, so
we need to be very careful overriding them.  The result is that they
become out-of-line functions which is unacceptable for general
performance.

So we only activate these when CCAN_STR_DEBUG is defined.

build_assert: rename EXPR_BUILD_ASSERT to BUILD_ASSERT_OR_ZERO

Same thing (a BUILD_ASSERT which evaluates to zero), but there's a
strong preference for all modules to stick with their own names as
prefixes.

ccanlint: don't ever used pre-built modules as dependencies.

They're often out-of-date, and we're about to do special things to the
str module compile flags, so we don't *ever* want the default.

It doesn't add much to build times, and it eliminates a nasty source
of weird errors.

ccanlint: fix mangled output for 'make scores'

We need to flush stdout before forking.

tools: avoid needless post increment on size

Also add a note about a possible segfault.

tools: actually add non-source files to other_files in manifest

We don't use it for the moment, but Brad Hards noted that assigning to
dest ten continuing was pointless, revealing this bug.

alloc: avoid dead store to hdrlen

We only ever write to this variable, so can just be removed.

ciniparser: avoid dead store to sta

This is always overwritten later in the function.

ccan_tokenizer: avoid dead store

obe is always overwritten later.

tdb2: trivial spelling fixes

tdb: remove unused last_ptr

ciniparser: remove dead store

last is unconditionally set to zero later in this function.

alloc: remove unused variable

lp_bits was only ever written to.

asprintf: new asprintf module.

asprintf is a PITA to use, and it's not in POSIX anyway.  Provide
replacements, and also provide a nicer-to-use afmt() wrapper.

tools: Fixed unchecked *strrchr in a couple places.

tools/ccan_depends --compile ccan/module (without a trailing slash)
results in a segfault.

tools: Added "-I." to fix ccan_depends --compile

(Patched forward by Rusty)

asort: Remove constness from ctx pointer.

tdb2: Correct the comment explaining tdb_brlock().

cast: new limited cast package inspired by Jan Engelhardt's libhx.

ccanlint: give a point per compile_ok/compile_fail test

We get a point for every run or api test, rather than 1 point for all of them,
so be consistent.

ccanlint: don't fail just because we don't have positive tests.

cast package has all negative tests, plus testable examples.

configurator: more robust test for HAVE_NESTED_FUNCTIONS

Thanks to Andreas Schlick, we have a nicer test for when gcc warns about
trampolines (gcc 4.6's -Wtrampolines).  This works at any optimization level,
and means when that warning is enabled we recognize that we shouldn't allow
nested functions.

iscsi, nfs, opt, tap: use config.h instead of defining _GNU_SOURCE.

tdb2: update design.lyx

tdb2: failtest on tdb_fetch

Increase from:
1985 of 2553 lines covered
to:
2020 of 2552 lines covered

tdb2: failtest on tdb_store

Increase from:
1985 of 2553 lines covered
to:
2018 of 2552 lines covered

tdb2: failtest on tdb_expand

Increase from:
1962 of 2553 lines covered
to:
1985 of 2553 lines covered

tdb2: fix pread/pwrite error handling in fill and tdb_write.

The "ret < n" was done as an unsigned comparison, so it didn't work as
expected when ret was negative.

Simplest fix is to do an equals comparison everywhere, which is also
slightly stricter.

tdb2: allow read-only databases to use locking.

You can always specify the TDB_NOLOCK flag along with O_RDONLY for the old
behaviour.

tdb2: remove zero-length write optimization.

If benchmarking indicates a problem later, we can restore it.

tdb2: change API to return the error value.

Mostly a fairly simple transformation, since 0 still means success.

One new twist is that tdb_nextkey now frees the .dptr of the key; this
us usually what we want but does cause issues for our weird test code.

tdb2: rework tdb.c internal functions to return enum TDB_ERROR.

tdb2: rework summary.c internal functions to return enum TDB_ERROR.

tdb2: rework check.c internal functions to return enum TDB_ERROR.

Of course, we leave the API the same, but percolate error codes all the
way back to tdb_check().

tdb2: rework transaction.c internal functions to return enum TDB_ERROR.

In particular, tdb_needs_recovery() can now indicate an error occurred,
rather than returning true.

tdb2: rework free.c functions to return enum TDB_ERROR.

tdb2: rework hash.c functions to return enum TDB_ERROR.

This time we have to use our tri-value "tdb_bool_err" type to indicate
true, false, or error, which now allows us to correctly handle errors
in key matching (rather than treating it as a non-match).

tdb2: rework remaining io.c functions to return enum TDB_ERROR.

In particular, we replace the TDB_OFF_ERR ((off_t)-1) with a range of
negative error values.

tdb2: rework some io.c functions to encode errors in their pointer returns.

This causes a subtle enhancement in tdb_direct(): it previously
returned NULL on both "can't use direct access" or "some error
occurred", as the caller always uses read/write functions as a
fallback anyway.  Now we distinguish the error case.

tdb2: rework some io.c functions to return enum TDB_ERROR.

tdb2: rework io functions to return enum TDB_ERROR.

We have a series of I/O functions which change depending on whether we're
inside a transaction or not.  This makes them return enum TDB_ERROR instead
of int.

tdb2: restore file filling code.

This snuck in fe55330a which added the stats attribute.  Without it,
TDB works but is vulnerable to segmenation faults or write errors when
disk is exhausted.

tdb2: rework lock.c functions to return enum TDB_ERROR.

Make the other functions in lock.s return an error code, too.

tdb2: rework lock.c static functions to return enum TDB_ERROR.

We make tdb_brlock() and tdb_lock_gradual() return an error code directly:
the callers have to set tdb->ecode.

tdb2: Internal error helpers.

I use the "high pointers hold error numbers" trick, and also make
tdb_logerr return the error code, which enables the common case of
"return tdb_logerr(...)".

tdb2: make error numbers negative.

This prepares us for changing function returns over.