- 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)

lizzard -> lizard

(the files have been renamed directly in CVS a few minutes earlier)

improved the test tool, now it is easy to verify the compression

added lizzard

updated the maximum prolong-factor

sped up approximately 6 times:
- the whole idea of 2 hash-tables (for 3- and 4- matches) was bad
- also, collision link-lists with errors were too bad
===> greatly simplified: only one hash-table/hash-function/link-list/... for
3-matches, double-linked link-list that can be maintained in constant time
while preserving correctness, links to strings made implicit (hence the data
structures is half-size and it fits better into the CPU-cache), no arithmetics
when computing the hash-function, tuned constants determining the compression
level, commented out code for 2-matches, ...

debugged, now it is fully functional:
- a lot of typos (especially priorities of operators in C and variable name
  mismatches)
- bit-format errors (forgotten additive constants or negations)
- do not use hash_rec[0]
- wrong entries in the collision link-lists must NOT appear in the beginning
  ==> saved time when verifying and solved some strange cases

- changed constants determining the maximum prolong-factor
- added a simple test-tool

implemented fast compression and decompression routines

I have spent a lot of time on them and they just compile.  I have never
tested them.  The test program will follow soon.

Improved cvslog script.

When processing the `-S' option, work on a copy, so that the command
line displayed by `ps' is undisturbed.

Removed redundant <stdarg.h>.

Split logging functions to two files to avoid linking the full switching
machinery to all programs which use trivial logging to stdout.

The logger now exports the name of the current log file and calls a special
hook on die(). Also corrected log_switch_{en,dis}able().

stralloc -> strdup.

Added xstrdup() and new logging functions.

Added functions for manual control of log switching. (Will be used by the
shepherd master.)

cfg_stralloc() -> cfg_strdup() and use mp_strdup() to implement it.

Renamed stralloc() to xstrdup() to be consistent with libc terminology
and also with mp_strdup().

Oops, this worked only by a chance.

Added the new pool-str module.

Added mp_strcat() and mp_multicat().

Fixed the comment.

- 0x08 (BACKSPACE) is a blank character and it is accepted as an ASCII-character
- 0x7f is also accepted as an ASCII-character
- both gather/content.c and gather/charset.c now use the same function
  Cblank() to test it

Changed locking rules. Scans and appends can peacefully co-exist now.
Should solve the problems with shep-reap waiting for bucket file transmission
to finish.

When logging to a file, redirect fd1 to the log file as well.

Multi-part objects (with header and body separated by an empty line and terminated
either by EOF or by a NUL byte) are very common, so let's introduce a special
function for reading them.

Got tired by repeating the same `gather pieces from incomplete reads' subroutine.

Added a simple test.

Add new modules.

Use format_exit_status(). One more ASSERT.

Including <stdarg.h> in lib/lib.h enables us to finally export vlog_msg()
which I was missing for several times.

Added exitstatus and runcmd functions. Finally decided to include <stdarg.h>
in lib.h.

Added a couple of functions for running of external commands with error
checking. A nice replacement for system().

Added a new module for formatting of process exit status messages.

Added one more check.

More enhancement to the main loop library: Export all lists for easy inspection
(reading only) by the callers. When a process exits, construct a nice tombstone
string for it.

Read and write functions accept void pointers instead of byte*.

Added a universal main loop with timers, file descriptor polling and process
watching. Inspired by the glib main loop, but this one has a much nicer
interface.

It will be used in the Shepherd master and if it turns out to be useful,
I'll convert the other programs to use it some day.

Interface to our own regex library.