bugfix in obuck_slurp_refill

cards format has changed, do upgrade the version of the index

added a module that supports transparent compression of data streamed into
an output fastbuf.  on the other side, reading from the stream is also
transparent

* will be used for cards
* untested

Accept V33_LIZARD buckets without body -- such buckets can legally
arise when shep-cleanup trims an inactive bucket.

Also added debugging messages which helped to verify that zero-copy
is really invoked where it should.

Added sync_dir().

Added bfilesync().

Made `buckettool -x' show the header if in verbose mode.
Also use bbcopy_slow() for copying bucket contents.

Added obj_find_anum() which is obj_find_aval() combined with atol() and
a default value (this is a very common idiom at many places).

Added size_attr() which calculates size of a given attribute in the
current bucket format.

UTF8_SPACE turned to an inline function.
Added utf8_encoding_length() which measures expected length of an UTF-8
sequence according to its first byte.

obj_add_attr_ref() with an on-stack buffer is not advisable, better
allocate the buffer in the object pool.

When reading, the data end at b->bstop, not b->bufend.

Bucket fastbuf's have to be seekable, since shep-reap seeks on them
(although the seek will be inside the buffer [and thence optimized out
by bseek()] under all reasonable circumstances [it was triggered by
a bug in buck2obj]).

do not read the whole bucket into memory if only header is needed

New attributes are now added at the end of the list.

tiny bugfix :))

tiny optimization: do not make 2 function calls in adler32()

Fixed two bugs in parsing of buckets (one of them introduced by me a couple
of hours ago, the other aged).

Buckets of unknown format should be skipped properly, otherwise
bucket fetching can become confused.

`buckettool -c' (cat) now separates buckets by an empty line.

Parsing of PLAIN type buckets also ends after buck_len bytes.
obj_read_multi() is gone.

Reading of V30 buckets was broken (for example it didn't work when a bucket
had only header and no body). When fixing it, I've modified it to terminate
after buck_len bytes, so the terminating NUL character is no longer needed.

prune the original source code yet more

tiny bugfix

taken much faster implementation of Adler32 and put into a separate source-code

add Adler32 checksum to compressed V33 buckets

added adler32 functions

automatically add 0x80000000 to bucket-type specified on the command-line

improved an error message to catch an error

Added {b,}put_attr_separator().

Introduced late matchers and custom statistics [see Bug #860]. Converted
FILETYPE to this mechanism, it's no longer an exception.

pools.h -> mempool.h

I always wanted to rename the rather inconsistent memory pool modules.
After the big library earthquake I caused with my unicode.h changes,
this is the small fish, so let's go.

Arranged the module list.

Moved object reading and writing functions where they belong.

Many programs now don't need to link with libcharset.

Renamed fb-printf to ff-printf to keep fastbuf front-ends and back-ends apart.

Adapted to new unicode includes.

Adjust includes.

Unicode character type functions moved to charset/unicat.h
charset/unicode.h removed, because it's now empty.

Gone (some functions moved to the main lib, some were unused).

Moved the basic Unicode and UTF-8 functions to the main library.

Moved UTF-8 streams to lib/ff-utf8.[ch]  (`ff' prefix will denote fastbuf
front-ends, `fb' will be the back-ends).

patch obj_write{,_nocheck}() to use bput_attr_str() to support both V30 and V33 buckets

fbbuf_init_read() now has can_overwrite as an extra parameter.

Use bfilesize().

Introduced bfilesize().

Removed references to buck2obj.h and obj2buck.h.

Added #ifdef guards.

Merged obj2buck.h and buck2obj.h to object.h, the number of includes
started to grow insane.

No need to test for NULL when reallocating.

Added a note on xrealloc(NULL, x).

Use bbuf.h.

Include <stdlib.h> to get free().

Use lib/bbuf.h here.

Applications of gbuf.h to byte arrays are very common, so I've introduced
a special include for them.

can_overwrite_buffer fixes for bucket.c: added f->buffer resetting and
also don't forget to set can_overwrite_buffer on slurp fastbufs (this
involves a little dirty trick, see the comment).

fb-limfd was setting can_overwrite_buffer=2, but it forgot to do the buffer
resetting magic needed by bdirect_read_commit_modified().

Complain loudly if anybody asks us to generate buckets of an unknown
type (this can happen e.g. in the buckettool).

Small improvements to buckettool:

  o  Options are sorted alphabetically.
  o  dump_oattr() replaced by dump_oattrs() which dumps all the
     attributes.
  o  ASSERT that the bucket type is known.

- use buck2obj_parse() instead of obj_read_bucket() to separate the header
  and the body
- use the new interface for writing the attributes to the buckets

writing attributes to buckets totally rewritten according to MJ's remarks

- obj_parse_dump() generalized to store apart the header and the body, and
  renamed to buck2obj_parse()
- added new obj_parse_dump() with the same interface as before; it is a
  wrapper of buck2obj_parse()

a typo and FIXME

now, I have no contribution into the fastbuf code :))

Adapted buck2obj to the new rewritable buffers. I don't like too much
what I did with the `copied' variable, but I didn't know better.

Also, I've added the missing bdirect commits.

A better implementation of overwritable buffers.

one mis-commit fixed

obj_read_bucket() checks whether buck_type has a correct value

dump_parsed_bucket() simplified

- obj_read_bucket() takes a new parameter: struct mempool *pool
- buck2obj_alloc() takes no parameters at all now

interface of lizard_decompress_safe() has been simplified

avoid one pointer

obj_read_bucket()
- never tampers the fastbuf when parsing the header
- the body might by tampered under very special (and well commented) conditions

deleted obj_attr_to_bucket*().  sorry, I like them, however I have already
converted all sources to my version of these functions.  if we reintroduce
them, let us put them to obj2buck.[ch]

- buckettool updated to extract, cat, and create all kinds of buckets
- added parameter -r for raw (non-parsed) output

macros and inline functions for generating V33 buckets

- added buck2obj_flush() that flushed the memory pool (some caller only
  remember struct buck2obj_buf * and since it is not exported, they could not
  flush it by themselves)
- obj_read_bucket() returns the length of the header if requested
- adapted to growing buffers (gbuf.h)
- updated interface of bconfig()
- lizard_decompress_safe() automatically realloc's the buffer, hence the
  wrapper is not needed

BCONFIG_CAN_OVERWRITE is a read/write parameter, i.e. the used can
temporarily lower the rights.  I need it somewhere.

updated interface of lizard-safe.c

- encapsulation: hide struct lizard_buffer in the source code
  ===> interface changed, now it returns the pointer in one extra parameter
- lizard_alloc() allocates no memory, hence no size parameter needed
- lizard_realloc() made static and it is automatically called by the
  decompression routine

added a simple source-code for resizable buffers, I am going to need it at
3 places, so let us separate it

bigfix, now it works even for the 2nd time :-)

More checks.

Adjusted the checker.

Added a script for testing compilability of different feature sets.

obj_read_bucket() now gets the bucket length as a parameter, because
in many cases, the fastbuf continues after the end of the bucket.

If a V30 bucket ends with a NUL byte, eat that byte as well.

Also introduced obj_attr_to_bucket{,_num}() -- these functions take
a single attribute and encode it using the specified bucket type
for inclusion at the beginning of the bucket header. These functions
probably belong to obj2buck instead, but currently there is no such
file, so I'm leaving the moving to you.

Added bskip() which skips the given number of bytes by reading.
In the future, we can optimize it by seeking when possible.

Minor optimizations.

getbuck.c no longer starts with flushing the memory pool, since it belongs
to the caller.  hence I have added mp_flush() back everywhere again

- buck2obj_alloc() initially allocates no buffers
- buck2obj_realloc() only stretches the main buffer (and not the lizard)
  + it is not exported anymore
- if lizard_decompress_safe() returns EFBIG, its buffer is shrinked

hence buck2obj.c allocates no memory if not needed.  the internal buffer is
allocated when the first non-compact bucket is encountered and lizard's
buffer is allocated when the first compressed bucket is encountered.

Tried to improve the LZO format description.

- lizard_alloc() does not allocate anything if max_len == 0
- lizard_realloc() only allows stretching the memory and not shrinking

A little grammar fix.

buck2obj_convert() renamed to obj_read_bucket()

it is possible to specify whether the caller only wants the header or also
the body

define BUCK2OBJ_INITIAL_MAX_LEN

use lizard_realloc() instead of {free,alloc}

added lizard_realloc() to avoid restoring and reestablishing SIGSEGv handler

added buck2obj_realloc(), it is automatically called when needed

MJ's objections:
- test can_overwrite outside the loop in decode_attributes()
- mp_alloc() -> mp_alloc_fast_noalign()
- MAX() is a macro, be careful
- do not call bflush(body), but comment it in the header file