Chris@43: /* gzlog.h
Chris@43:   Copyright (C) 2004, 2008, 2012 Mark Adler, all rights reserved
Chris@43:   version 2.2, 14 Aug 2012
Chris@43: 
Chris@43:   This software is provided 'as-is', without any express or implied
Chris@43:   warranty.  In no event will the author be held liable for any damages
Chris@43:   arising from the use of this software.
Chris@43: 
Chris@43:   Permission is granted to anyone to use this software for any purpose,
Chris@43:   including commercial applications, and to alter it and redistribute it
Chris@43:   freely, subject to the following restrictions:
Chris@43: 
Chris@43:   1. The origin of this software must not be misrepresented; you must not
Chris@43:      claim that you wrote the original software. If you use this software
Chris@43:      in a product, an acknowledgment in the product documentation would be
Chris@43:      appreciated but is not required.
Chris@43:   2. Altered source versions must be plainly marked as such, and must not be
Chris@43:      misrepresented as being the original software.
Chris@43:   3. This notice may not be removed or altered from any source distribution.
Chris@43: 
Chris@43:   Mark Adler    madler@alumni.caltech.edu
Chris@43:  */
Chris@43: 
Chris@43: /* Version History:
Chris@43:    1.0  26 Nov 2004  First version
Chris@43:    2.0  25 Apr 2008  Complete redesign for recovery of interrupted operations
Chris@43:                      Interface changed slightly in that now path is a prefix
Chris@43:                      Compression now occurs as needed during gzlog_write()
Chris@43:                      gzlog_write() now always leaves the log file as valid gzip
Chris@43:    2.1   8 Jul 2012  Fix argument checks in gzlog_compress() and gzlog_write()
Chris@43:    2.2  14 Aug 2012  Clean up signed comparisons
Chris@43:  */
Chris@43: 
Chris@43: /*
Chris@43:    The gzlog object allows writing short messages to a gzipped log file,
Chris@43:    opening the log file locked for small bursts, and then closing it.  The log
Chris@43:    object works by appending stored (uncompressed) data to the gzip file until
Chris@43:    1 MB has been accumulated.  At that time, the stored data is compressed, and
Chris@43:    replaces the uncompressed data in the file.  The log file is truncated to
Chris@43:    its new size at that time.  After each write operation, the log file is a
Chris@43:    valid gzip file that can decompressed to recover what was written.
Chris@43: 
Chris@43:    The gzlog operations can be interupted at any point due to an application or
Chris@43:    system crash, and the log file will be recovered the next time the log is
Chris@43:    opened with gzlog_open().
Chris@43:  */
Chris@43: 
Chris@43: #ifndef GZLOG_H
Chris@43: #define GZLOG_H
Chris@43: 
Chris@43: /* gzlog object type */
Chris@43: typedef void gzlog;
Chris@43: 
Chris@43: /* Open a gzlog object, creating the log file if it does not exist.  Return
Chris@43:    NULL on error.  Note that gzlog_open() could take a while to complete if it
Chris@43:    has to wait to verify that a lock is stale (possibly for five minutes), or
Chris@43:    if there is significant contention with other instantiations of this object
Chris@43:    when locking the resource.  path is the prefix of the file names created by
Chris@43:    this object.  If path is "foo", then the log file will be "foo.gz", and
Chris@43:    other auxiliary files will be created and destroyed during the process:
Chris@43:    "foo.dict" for a compression dictionary, "foo.temp" for a temporary (next)
Chris@43:    dictionary, "foo.add" for data being added or compressed, "foo.lock" for the
Chris@43:    lock file, and "foo.repairs" to log recovery operations performed due to
Chris@43:    interrupted gzlog operations.  A gzlog_open() followed by a gzlog_close()
Chris@43:    will recover a previously interrupted operation, if any. */
Chris@43: gzlog *gzlog_open(char *path);
Chris@43: 
Chris@43: /* Write to a gzlog object.  Return zero on success, -1 if there is a file i/o
Chris@43:    error on any of the gzlog files (this should not happen if gzlog_open()
Chris@43:    succeeded, unless the device has run out of space or leftover auxiliary
Chris@43:    files have permissions or ownership that prevent their use), -2 if there is
Chris@43:    a memory allocation failure, or -3 if the log argument is invalid (e.g. if
Chris@43:    it was not created by gzlog_open()).  This function will write data to the
Chris@43:    file uncompressed, until 1 MB has been accumulated, at which time that data
Chris@43:    will be compressed.  The log file will be a valid gzip file upon successful
Chris@43:    return. */
Chris@43: int gzlog_write(gzlog *log, void *data, size_t len);
Chris@43: 
Chris@43: /* Force compression of any uncompressed data in the log.  This should be used
Chris@43:    sparingly, if at all.  The main application would be when a log file will
Chris@43:    not be appended to again.  If this is used to compress frequently while
Chris@43:    appending, it will both significantly increase the execution time and
Chris@43:    reduce the compression ratio.  The return codes are the same as for
Chris@43:    gzlog_write(). */
Chris@43: int gzlog_compress(gzlog *log);
Chris@43: 
Chris@43: /* Close a gzlog object.  Return zero on success, -3 if the log argument is
Chris@43:    invalid.  The log object is freed, and so cannot be referenced again. */
Chris@43: int gzlog_close(gzlog *log);
Chris@43: 
Chris@43: #endif