config.h: don't include in git repository.

We create and upload an example for the web anyway, if people really need it.

tools: Add create-ccan-tree utility

Add a script to create a ccan source tree for inclusion into projects'
distributed code.

create-ccan-tree takes a list of ccan modules and copies them, plus any
dependent modules, into a target directory. Enough build infrastructure
is added to build libccan.a from the ccan modules.

Typical usage for my project that uses talloc and read-write-all:

  lib/ccan.git/tools/create-ccan-tree --exclude-tests \
lib/ccan/ talloc read-write-all

- this uses a git submodule in $PWDlib/ccan.git to create a source tree
in $PWD/lib/ccan, containing code for talloc and read-write-all.

Signed-off-by: Jeremy Kerr <jeremy.kerr@canonical.com>

asort: fix test when typesafe_cb not supported.

Solaris CC seems to support typeof, but not __builtin_types_compatible_p.

cast: make sure suncc sees a constant.

cast_const() et. al. are supposed to be a constant expression, so you can do things like:
static char *p = cast_const(char *, (const char *)"hello");

Unfortunately, a cast to intptr_t and arithmetic makes suncc reject it as
a constant expression.  We need the cast, because (1) the expression could be
a void *, so we can't just add to it, and (2) gcc complains with -Wcast-qual
without it.

So instead of adding BUILD_BUG_OR_ZERO, we use a ? :, which keeps everyone happy.

ccan_tokenizer: don't assume __VA_ARGS__ can be empty.

That's a gcc extension.

cast: test/compile_fail-cast_static.c should fail without COMPOUND_LITERALS.

It still gave a warning on gcc, because casting a char to a char* gives a warning.  Not so on sun CC.

ccanlint: module_links test must link with module.

Gcc doesn't include unused inline functions, even without -O, but Solaris CC
does, so fails to link block_pool where one inline function refers to a
non-inline function.

asprintf: #include <stdarg.h> in test/run.c

We get away with it on Linux, not on Solaris.

ccanlint: tests_compile_coverage needs GCC.

We only support gcc/gcov so far.

ccanlint: add ilog dependency.

This only matters on non-gcc, where ilog functions are not just mapped to builtins.

tap: assume variadic macros.

The Sun C compiler has them, but fails this overzealous check.

opt: fix Solaris compile.

Need sys/termios.h for struct winsize.

iscsi: use <sys/filio.h> on Solaris.

Needed for FIONREAD.

alloc: fix return of void.

Sun CC complains.

tools: don't use __attribute__

We have compiler.h for that.

tools: fix bogus unreachable return.

tools/configurator: fix test for /proc/self/maps.

Header file was wrong, suncc gives warning about missing open prototype, causing configurator to fail.

Makefile: generate config.h in two stages

This means we don't create an empty file if configurator fails.

failtest: compile fix for OpenBSD

OpenBSD doesn't idempotent-wrap sys/mman.h, so when we #define mmap to
an alternative, it fails to compile when sys/mman.h is included again.

Workaround is not to #define mmap to add arguments on Open BSD.

Merge branch 'ccantool'

tools: move config.h reading to its own file

Move ccan_dir determination out to its own function, rather than implying it
by the first time we get the manifest of a module.

tools: explicit find_ccan_dir()

Move ccan_dir determination out to its own function, rather than implying it
by the first time we get the manifest of a module.

ccanlint: handle -x correctly with multiple modules.

After the first module we were resetting even the excluded tests, which caused
a segfault as they weren't initialized.

tools: determing ccan directory differently

Don't assume it's two levels above the module dir, instead look for
last "/ccan/" in path.  This is an incremental step towards nested
module directories.

tools: split out manifest from ccanlint

Other tools will soon want to use this, so make it independent.
(eg. ccantool).

tdb2: remove: it's now in SAMBA where it belongs.

htable: fix bug where first entry has hash of 0 or 1.

Thanks to Zoltán Lajos Kis for the bug report and test case!

failtest: don't assume FD_SETSIZE is maximum runtime fd.

This breaks when rlimit is less.  Unfortunately, valgrind (32 bit x86,
3.7.0.SVN, Ubuntu) fails to set the file limit properly on the test:
reducing it to the obvious getrlimit/setrlimit/getrlimit works fine,
so leaving diagnostics for another day.

ttxml: made alloc failure consistent - return NULL

ttxml: removed cruft from tests

ttxml: fixed license test

tdb: delete from CCAN.

This was an early experiment in putting code into CCAN, but TDB is a public
library distributed as part of the Samba sources; there is no reason to
publish it here (especially now the unit tests are also in Samba).

configurator: define HAVE_CCAN.

An interesting case came up with the tdb2 code in SAMBA recently.  It's a
public library, and it doesn't want to be dependent on CCAN, but the header
uses cast and typesafe_cb for extra type safety.

A good solution to this is to put dummy versions under !HAVE_CCAN.  Of course,
any CCAN config.h should define HAVE_CCAN.

tdb2: copy tdb1's changed expansion logic.

TDB2 uses the same expansion logic as TDB1, which got factored out
recently.  So update TDB2 to match.

tdb2: tdb1: use same expansion factor logic when expanding for new recovery area.

If we're expanding because the current recovery area is too small, we
expand only the amount we need.  This can quickly lead to exponential
growth when we have a slowly-expanding record (hence a
slowly-expanding transaction size).

(Syncs with tdb1 SAMBA patch 3a2a755e3380a8f81374009d463cd06161352507)

tdb2: Avoid a malloc/memcpy in _tdb1_store
(Syncs tdb2 with SAMBA tdb1's 664add17757836c5ee98618aef11371f412b6e44)

tdb2: careful on wrap.

It's much harder to wrap a 64-bit tdb2 than a 32-bit tdb1, but we should still
take care against bugs.

Also, we should *not* cast the length to a size_t when comparing it to
the stat result, in case size_t is 32 bit.

tdb2: be more careful on 4G files (tdb1).

I came across a tdb which had wrapped to 4G + 4K, and the contents had been
destroyed by processes which thought it only 4k long.  Fix this by checking
on open, and making tdb_oob() check for wrap itself.

Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
(Ported from tdb1 SAMBA commit b64494535dc62f4073fc6302847593ed6e6ec38b)

tdb: don't free old recovery area when expanding if already at EOF.

We allocate a new recovery area by expanding the file.  But if the
recovery area is already at the end of file (as shown in at least one
client case), we can simply expand the record, rather than freeing it
and creating a new one.

tdb: use same expansion factor logic when expanding for new recovery area.

If we're expanding because the current recovery area is too small, we
expand only the amount we need.  This can quickly lead to exponential
growth when we have a slowly-expanding record (hence a
slowly-expanding transaction size).

tdb: test exponential recovery expansion problem.

opt: much prettier usage (using terminal size)

opt: handle -Wcast-qual warnings.

opt: don't leak on exit (valgrind complains).

Recent real usage case showed this leak when we call opt_usage_and_exit:
we don't bother freeing before exit.  With valgrind, it matters.

list.h: opaque list iteration functionality

See https://github.com/rustyrussell/ccan/pull/1#issuecomment-2856561
for details.
(Reworked with minor cleanups -- Rusty)

container_of: add container_off_var macro

Based on patch by Andrey Smirnov <andrew.smirnov@gmail.com>:

    There is are certain use-cases when it is necessary to know the offset
    of the member in a structure's memory layout. One such use-case can be
    seen in `ccan/list/list.h' in macros `list_for_each' and
    `list_for_each_safe'. This commit implements said functionality with
    `container_of_var_off' macro.

Renamed container_of_var_off -> container_off_var now we have container_off.

check_type: fix incorrect documentation.

container_of: don't put member_ptr in container_off.

It's convenient to check that the member is the given type, but we can leave
that to the callers.

Makefile, configurator: Add additional debug flags to CFLAGS
Just adding `-g' to list of CFLAGS doesn't make gcc to generate debug
information required for macro expansion during debugging. Replacing
it with `-g3 -ggdb' rectifies this.

(configurator.c commit folded by Rusty)

opt: suggest they look at ccan/autodata.

Nice for distributed option declaration.

autodata: add example, clean up description a little.

Also add #include to AUTODATA_TYPE example, so ccanlint doesn't try to
put it inside a function (which works, for this, but gives a warning
about unused variables).

tools/doc_extract: trim trailing blank lines on sections.

Makes things a bit neater.

web: publish See Also: for modules which supply it.

tools/doc_extract: simplify handling fields with spaces in them.

eg. "See also" can match "see-also".

ccanlint: use ccan/autodata

Gets rid of generated file.

autodata: stash pointers in a binary.

This is a more portable variant of the ELF section trick.

configurator: HAVE_SECTION_START_STOP

ptr_valid: test whether a ptr is valid.

Very slow, but sometimes you need to know without crashing.

configurator: HAVE_PROC_SELF_MAPS

objset: new module.

ccanlint.1: fix description of per-test options for tests_pass_valgrind.

doc: man page for ccanlint.

ccanlint: remove argument to -k/--keep

It's much easier to simply say "keep all", and it simplifies the code
quite a bit.

ccanlint: use -t for --target not --timeout

I use --target far more than --timeout.

ccanlint: use traversal to trim tests we want to skip.

Rather than using a separate index of tetst to skip, make sure tests
we don't want to run are removed from the graph of tests to start
with.

This means that the "skip" field is only set when we fail a test (and
thus must be reset when we test the next module).

ccanlint: use node traverse for --target.

Rather than walking the list of tests manually, use
dgraph_traverse_to() to run the tests.

ccanlint: use dgraph module.

Instead of a linked list of tests, we use dgraph and strmap.

ccanlint: remove wart from info options.

Make info_exists() call add_info_options() directly, rather than detecting
that we've found _info inside the loop of tests.

It means targeting is now a global, which is a bit sucky.

dgraph: new module for directed graphs.

ccanlint: parse --verbose before anything else.

This way, we can debug really early failures (eg. during option
parsing).

ccanlint: get rid of separate class of compulsory tests.

It's reduced to a flag which means we stop processing the module.  We have
to enhance our dependencies a bit, but they've always been quite good.

This simplifies things quite a bit.

opt: add OPT_EARLY and opt_early_parse.

Parsing options like --verbose and --debug can be a pain.  You need to
have everything set up before invoking parse_args(), but that may be a
significant amount of work, for which you may want verbose or
debugging enabled.

Thus the concept of "early" args: you can nominate arguments to be
parse before anything else, using opt_early_parse().

strset, strmap: invert iterator function meaning.

Make a false return abort the iteration, not true.

The old way makes sense for search functions (true == I found it), but
other kinds of iteration are more common (brute force search is
probably dumb).

setset: fix API to match strmap and common sense.

strset_set -> strset_add
strset_clear -> strset_del
strset_test -> strset_get
strset_destroy -> strset_clear

strmap: allow const arguments to strset_iterate().

strset: allow const arguments to strset_iterate().

opt: fix up outdated comments in documentation.

opt: get rid of last remnant of getopt.

Testing code still using it.

tlist: remove type arg from tlist_top(), tlist_tail()

With the type canary, it's unnecessary.  Though the implementation is
a bit more awkward since they longer map directly through to list_top/tail.

list: don't multiple-evaluate arguments to tlist_top and tlist_tail

container_of: add container_off() helper.

Just like container_of() (with typechecking, etc), but return the offset
to the enclosing structure.

ttxml: exclude license_comment check so it doesn't fail ccanlint.

tdb2: display capability information in tdb_summary()

This means we know they're there in future, and what restrictions they
carry.

tdb2: add a capability list from the header.

This allows even more extensibility in future: in particular, the top
bits of each capability tell us what to do if we don't understand it:
fail the open, fail to open for write, or don't try to check the
format.

tdb_check needs to understand the capability list so it can know to
skip over it: each element in the list is prefixed with the type tag
and the length.

tdb2: provide tdb_layout_write() rather than implying it by new_tdb_layout arg.

Neater API.

tdb2: add an internal TDB_CANT_CHECK flag.

This will be used shortly to indicate that a TDB2 file indicates it
cannot be checked.

failtest: do trace via a FILE, not an fd.

The current mix of writing to an fd doesn't mix as well with
stderr/stdout.  And writing to a FILE * is more portable.

failtest: add --trace to replace --tracepath

This gives a much deeper insight into what failtest is doing; good for
debugging failtest itself.

failtest: save and restore file state inside child (on-demand)

We currently save all files in the parent, and restore them once
the child is gone.  That doesn't work in a case where the child
manipulates a file the parent doesn't currently have open, so
switch to a model where the child cleans itself up, using the
already-existing cleanup callbacks.

This means that we need to undo much more, especially restoring
file offsets.  We also need to handle the case where we've already
closed the file, and now we're cleaning up.  As a bonus, we now
handle open() with O_TRUNC properly.

The cleanup function now has two modes: one simply frees (so valgrind
doesn't complain about failtest leaking so the user can see real leaks
in their programs), the other restores things so the parent sees no
changes.

failtest: add comment about limitations of untracked pointers.

failtest: fix open in tests.

The argument is wrong, so the return was -1.  That currently works,
but it will beak with the next patch.  Fix the typo.

failtest: fix failpath on open.

And separate out the code which follows --failpath so failtest_close()
can use it too.

failtest: report failpath problems correctly.

It was the wrong way around, and also it's better to show the whole
remaining failpath rather than the current letter.

failtest: stop when leak detected.

Don't continue when we report a leak: tell the parent it's a failure.

tdb2: suppress failtest more than once on mmap.

Now we test failing mmap, ccanlint -v time has increased from 200 to
330 seconds.  Worse, tests no time out on my laptop.

Fix this, by preventing us from going down that particular rabbit hole.
ccanlint -v now takes 201 seconds again.

failtest: catch mmap.

mmap can also fail on out-of-memory, and for the coming change to the
way we save and restore files we want to know about them anyway.

tdb2: simplify failtest helper.

failtest now culls duplicates for itself (and more efficiently), so
don't replicate the logic here.  It changes things a bit, because
failtest uses backtraces rather than a simple call point to find
duplicates.

Also, fix one case (in run-11-simple-fetch.c) where we simply exited
rather than using failtest_exit().  We got away with it before, because
we never hit that particular failure pattern.

failtest: fix --debugpath

Calling failpath_string() here leaves the final letter randomly upper or
lower-cased, since call->fail is uninitialized.  This means we sometimes
don't match the debug string.

1) Initialize call->fail here so it will match the debug string.
2) If our calls don't match --debugpath, abort.
3) Don't match the final letter (which may be upper or lower case)
   when checking we're still on the path.  We could do better, but this is
   only a sanity-check anyway.

failtest: internally eliminate duplicate calls.

If we can get a backtrace, we can automatically eliminate identical
failures.  Surprisingly backtrace() is quite fast, but the savings for
the (naively-written) rbtree tests are impressive.  ccanlint -v time
drops from 43 seconds to 6 seconds.

configurator: HAVE_BACKTRACE