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

typo

implemented bconfig in the internal fastbuf

cannot ask for struct obuck_header due to remote indexing

OK, buck2obj looks nice now, so let us add it

implemented all 3 overwrite-policies

generalized BCONFIG_CAN_OVERWRITE to three different write policies

added the configuration item BCONFIG_CAN_OVERWRITE, which specifies whether the
caller is allowed to perform the following 0-copy write operation:

1. call bdirect_read_prepare()
2. modify the data directly in the buffer returned (e.g. put \0's there)
3. call bflush() before any seek operation to let the fastbuf know

modifications done at home, not yet incorporated MJ's objections:
- added buck2obj_{alloc,free}()
- extract_odes() renamed to buck2obj_convert() and simplified its interface.
  it flushes the memory pool and calls obj_new() as used e.g. in scanner.c
- attribute lengths are stored incremented s.t. 0-lengths are allowed
- the length of the compressed part is stored as U32 instead of UTF8 to allow
  0-copy compression
- temporary usage of object.c's oa_allocate removed and we call
  obj_add_attr_ref() instead of obj_add_attr()
- renamed constants BUCKET_TYPE_*
- defined internal macro RET_ERR()

- deleted unused BUCKET_TYPE_V30C
- added BUCKET_TYPE_V33 and BUCKET_TYPE_V33_LIZARD

- changed the format of struct oattr to allow 0-copy: byte val[] -> byte *val
- added obj_add_attr_ref() as a replacement for obj_add_attr()

reordered the if's in lizard_compress(): nicer, clearer, and faster

Mainline is now v3.3.

Marked the current version as 3.2.1, which is going to be the stable
version for summer.

a bugfix and polishing

generalized for extracting also uncompressed buckets in the new 0-copy
format (assumes BUCKET_TYPE_V30F = 0x80000003 is added into lib/bucket.h)

added a decoder from buckets to objects

just a proposed version for now (it even is not in the Makefile)

hmm, after a sys-call is not called, we do not have to fiddle with errno

added unhandle_signal() into sighandler.c

changed the default action to test

adapted to the new version of sighandler.c

sighandler.c:
- used sigaction() instead of signal()
- no need to re-register the signal handler now :-)
- renamed my_sighandler_t to sh_sighandler_t and changed the interface

- lizard_alloc() turns on the wrapper for SIGSEGV and lizard_free() restores
  its original value
- lizard_decompress_safe() registers quickly the SIGSEGV handler using the
  wrapper.  it saves 2 sys-calls.

- allocate 3 more bytes for unaligned memory access

added a wrapper for signal handlers in sighandler.c

hmm, if we use fast unaligned access when decompressing, we should allocate 3
more bytes after the memory

MJ's idea:
- only lock the memory by mprotect() once
- decompress into the middle of the buffer s.t. the barrier is at the distance
  as it used before
(needs adding one pointer to the structure)

MJ's suggestion:
use MAP_ANONYMOUS in mmap() instead of opening /dev/zero

incorporated MJ's suggestions:
- flush_copy_command() exploits fast unaligned memory access and memcpy()
lizard_compress():
- the test in_start==copy_start replaced by flag bof, in_start deleted
- if (copy_len > 0) replaced by if (copy_len)
- pos_bit |= 1<<4
- deleted testing cropping at BOF, it is obsolete now
lizard_decompress():
- at label perform_copy_command, we set expect_copy_command=2
- exploit fast unaligned memory access

Allow empty host name for unknown URL schemes.

`foo:///bar' should be considered OK now.

oops, one missing volatile :-)

crash tests changed:
- since the memory protection is removed after decompress_safe(), it makes
  no sense to check the read/write protection on the corresponding page
  ===> removed
- now, if the returned value is < 0, print errno
- try allocating a too small buffer
  OR setting too low expected length

added lizard-safe

- lizard.c split into lizard.c and lizard-safe.c
- added LGPL header

- low-level safe version of lizard_decompress() put into an extra source file

- use M_PRIVATE instead of M_SHARED
- use PROT_NONE instead of PROT_READ and only set/clear it for one page
  before/after the operation instead of doing it for all the array
- errno is set instead of returning different negative values
- use longjmp in the signal handler instead of die() and return -1
- use macro ALIGN()

print a fancy message when SIGSEGV is caught at the decompression

tested the wrapper guarding the safe decompression

added a wrapper for safe decompression (the page behind the decompression
buffer is set READ-ONLY)