/*

 * gzlog.c

 * Copyright (C) 2004 Mark Adler

 * For conditions of distribution and use, see copyright notice in gzlog.h

 * version 1.0, 26 Nov 2004

 *

 */

#include <string.h>             /* memcmp() */

#include <stdlib.h>             /* malloc(), free(), NULL */

#include <sys/types.h>          /* size_t, off_t */

#include <unistd.h>             /* read(), close(), sleep(), ftruncate(), */

                                /* lseek() */

#include <fcntl.h>              /* open() */

#include <sys/file.h>           /* flock() */

#include "zlib.h"               /* deflateInit2(), deflate(), deflateEnd() */

#include "gzlog.h"              /* interface */

#define local static

/* log object structure */

typedef struct {

    int id;                 /* object identifier */

    int fd;                 /* log file descriptor */

    off_t extra;            /* offset of extra "ap" subfield */

    off_t mark_off;         /* offset of marked data */

    off_t last_off;         /* offset of last block */

    unsigned long crc;      /* uncompressed crc */

    unsigned long len;      /* uncompressed length (modulo 2^32) */

    unsigned stored;        /* length of current stored block */

} gz_log;

#define GZLOGID 19334       /* gz_log object identifier */

#define LOCK_RETRY 1            /* retry lock once a second */

#define LOCK_PATIENCE 1200      /* try about twenty minutes before forcing */

/* acquire a lock on a file */

local int lock(int fd)

{

    int patience;

    /* try to lock every LOCK_RETRY seconds for LOCK_PATIENCE seconds */

    patience = LOCK_PATIENCE;

    do {

        if (flock(fd, LOCK_EX + LOCK_NB) == 0)

            return 0;

        (void)sleep(LOCK_RETRY);

        patience -= LOCK_RETRY;

    } while (patience > 0);

    /* we've run out of patience -- give up */

    return -1;

}

/* release lock */

local void unlock(int fd)

{

    (void)flock(fd, LOCK_UN);

}

/* release a log object */

local void log_clean(gz_log *log)

{

    unlock(log->fd);

    (void)close(log->fd);

    free(log);

}

/* read an unsigned long from a byte buffer little-endian */

local unsigned long make_ulg(unsigned char *buf)

{

    int n;

    unsigned long val;

    val = (unsigned long)(*buf++);

    for (n = 8; n < 32; n += 8)

        val += (unsigned long)(*buf++) << n;

    return val;

}

/* read an off_t from a byte buffer little-endian */

local off_t make_off(unsigned char *buf)

{

    int n;

    off_t val;

    val = (off_t)(*buf++);

    for (n = 8; n < 64; n += 8)

        val += (off_t)(*buf++) << n;

    return val;

}

/* write an unsigned long little-endian to byte buffer */

local void dice_ulg(unsigned long val, unsigned char *buf)

{

    int n;

    for (n = 0; n < 4; n++) {

        *buf++ = val & 0xff;

        val >>= 8;

    }

}

/* write an off_t little-endian to byte buffer */

local void dice_off(off_t val, unsigned char *buf)

{

    int n;

    for (n = 0; n < 8; n++) {

        *buf++ = val & 0xff;

        val >>= 8;

    }

}

/* initial, empty gzip file for appending */

local char empty_gz[] = {

    0x1f, 0x8b,                 /* magic gzip id */

    8,                          /* compression method is deflate */

    4,                          /* there is an extra field */

    0, 0, 0, 0,                 /* no modification time provided */

    0, 0xff,                    /* no extra flags, no OS */

    20, 0, 'a', 'p', 16, 0,     /* extra field with "ap" subfield */

    32, 0, 0, 0, 0, 0, 0, 0,    /* offset of uncompressed data */

    32, 0, 0, 0, 0, 0, 0, 0,    /* offset of last block */

    1, 0, 0, 0xff, 0xff,        /* empty stored block (last) */

    0, 0, 0, 0,                 /* crc */

    0, 0, 0, 0                  /* uncompressed length */

};

/* initialize a log object with locking */

void *gzlog_open(char *path)

{

    unsigned xlen;

    unsigned char temp[20];

    unsigned sub_len;

    int good;

    gz_log *log;

    /* allocate log structure */

    log = malloc(sizeof(gz_log));

    if (log == NULL)

        return NULL;

    log->id = GZLOGID;

    /* open file, creating it if necessary, and locking it */

    log->fd = open(path, O_RDWR | O_CREAT, 0600);

    if (log->fd < 0) {

        free(log);

        return NULL;

    }

    if (lock(log->fd)) {

        close(log->fd);

        free(log);

        return NULL;

    }

    /* if file is empty, write new gzip stream */

    if (lseek(log->fd, 0, SEEK_END) == 0) {

        if (write(log->fd, empty_gz, sizeof(empty_gz)) != sizeof(empty_gz)) {

            log_clean(log);

            return NULL;

        }

    }

    /* check gzip header */

    (void)lseek(log->fd, 0, SEEK_SET);

    if (read(log->fd, temp, 12) != 12 || temp[0] != 0x1f ||

        temp[1] != 0x8b || temp[2] != 8 || (temp[3] & 4) == 0) {

        log_clean(log);

        return NULL;

    }

    /* process extra field to find "ap" sub-field */

    xlen = temp[10] + (temp[11] << 8);

    good = 0;

    while (xlen) {

        if (xlen < 4 || read(log->fd, temp, 4) != 4)

            break;

        sub_len = temp[2];

        sub_len += temp[3] << 8;

        xlen -= 4;

        if (memcmp(temp, "ap", 2) == 0 && sub_len == 16) {

            good = 1;

            break;

        }

        if (xlen < sub_len)

            break;

        (void)lseek(log->fd, sub_len, SEEK_CUR);

        xlen -= sub_len;

    }

    if (!good) {

        log_clean(log);

        return NULL;

    }

    /* read in "ap" sub-field */

    log->extra = lseek(log->fd, 0, SEEK_CUR);

    if (read(log->fd, temp, 16) != 16) {

        log_clean(log);

        return NULL;

    }

    log->mark_off = make_off(temp);

    log->last_off = make_off(temp + 8);

    /* get crc, length of gzip file */

    (void)lseek(log->fd, log->last_off, SEEK_SET);

    if (read(log->fd, temp, 13) != 13 ||

        memcmp(temp, "\001\000\000\377\377", 5) != 0) {

        log_clean(log);

        return NULL;

    }

    log->crc = make_ulg(temp + 5);

    log->len = make_ulg(temp + 9);

    /* set up to write over empty last block */

    (void)lseek(log->fd, log->last_off + 5, SEEK_SET);

    log->stored = 0;

    return (void *)log;

}

/* maximum amount to put in a stored block before starting a new one */

#define MAX_BLOCK 16384

/* write a block to a log object */

int gzlog_write(void *obj, char *data, size_t len)

{

    size_t some;

    unsigned char temp[5];

    gz_log *log;

    /* check object */

    log = (gz_log *)obj;

    if (log == NULL || log->id != GZLOGID)

        return 1;

    /* write stored blocks until all of the input is written */

    do {

        some = MAX_BLOCK - log->stored;

        if (some > len)

            some = len;

        if (write(log->fd, data, some) != some)

            return 1;

        log->crc = crc32(log->crc, data, some);

        log->len += some;

        len -= some;

        data += some;

        log->stored += some;

        /* if the stored block is full, end it and start another */

        if (log->stored == MAX_BLOCK) {

            (void)lseek(log->fd, log->last_off, SEEK_SET);

            temp[0] = 0;

            dice_ulg(log->stored + ((unsigned long)(~log->stored) << 16),

                     temp + 1);

            if (write(log->fd, temp, 5) != 5)

                return 1;

            log->last_off = lseek(log->fd, log->stored, SEEK_CUR);

            (void)lseek(log->fd, 5, SEEK_CUR);

            log->stored = 0;

        }

    } while (len);

    return 0;

}

/* recompress the remaining stored deflate data in place */

local int recomp(gz_log *log)

{

    z_stream strm;

    size_t len, max;

    unsigned char *in;

    unsigned char *out;

    unsigned char temp[16];

    /* allocate space and read it all in (it's around 1 MB) */

    len = log->last_off - log->mark_off;

    max = len + (len >> 12) + (len >> 14) + 11;

    out = malloc(max);

    if (out == NULL)

        return 1;

    in = malloc(len);

    if (in == NULL) {

        free(out);

        return 1;

    }

    (void)lseek(log->fd, log->mark_off, SEEK_SET);

    if (read(log->fd, in, len) != len) {

        free(in);

        free(out);

        return 1;

    }

    /* recompress in memory, decoding stored data as we go */

    /* note: this assumes that unsigned is four bytes or more */

    /*       consider not making that assumption */

    strm.zalloc = Z_NULL;

    strm.zfree = Z_NULL;

    strm.opaque = Z_NULL;

    if (deflateInit2(&strm, Z_BEST_COMPRESSION, Z_DEFLATED, -15, 8,

        Z_DEFAULT_STRATEGY) != Z_OK) {

        free(in);

        free(out);

        return 1;

    }

    strm.next_in = in;

    strm.avail_out = max;

    strm.next_out = out;

    while (len >= 5) {

        if (strm.next_in[0] != 0)

            break;

        strm.avail_in = strm.next_in[1] + (strm.next_in[2] << 8);

        strm.next_in += 5;

        len -= 5;

        if (strm.avail_in != 0) {

            if (len < strm.avail_in)

                break;

            len -= strm.avail_in;

            (void)deflate(&strm, Z_NO_FLUSH);

            if (strm.avail_in != 0 || strm.avail_out == 0)

                break;

        }

    }

    (void)deflate(&strm, Z_SYNC_FLUSH);

    (void)deflateEnd(&strm);

    free(in);

    if (len != 0 || strm.avail_out == 0) {

        free(out);

        return 1;

    }

    /* overwrite stored data with compressed data */

    (void)lseek(log->fd, log->mark_off, SEEK_SET);

    len = max - strm.avail_out;

    if (write(log->fd, out, len) != len) {

        free(out);

        return 1;

    }

    free(out);

    /* write last empty block, crc, and length */

    log->mark_off = log->last_off = lseek(log->fd, 0, SEEK_CUR);

    temp[0] = 1;

    dice_ulg(0xffffL << 16, temp + 1);

    dice_ulg(log->crc, temp + 5);

    dice_ulg(log->len, temp + 9);

    if (write(log->fd, temp, 13) != 13)

        return 1;

    /* truncate file to discard remaining stored data and old trailer */

    ftruncate(log->fd, lseek(log->fd, 0, SEEK_CUR));

    /* update extra field to point to new last empty block */

    (void)lseek(log->fd, log->extra, SEEK_SET);

    dice_off(log->mark_off, temp);

    dice_off(log->last_off, temp + 8);

    if (write(log->fd, temp, 16) != 16)

        return 1;

    return 0;

}

/* maximum accumulation of stored blocks before compressing */

#define MAX_STORED 1048576

/* close log object */

int gzlog_close(void *obj)

{

    unsigned char temp[8];

    gz_log *log;

    /* check object */

    log = (gz_log *)obj;

    if (log == NULL || log->id != GZLOGID)

        return 1;

    /* go to start of most recent block being written */

    (void)lseek(log->fd, log->last_off, SEEK_SET);

    /* if some stuff was put there, update block */

    if (log->stored) {

        temp[0] = 0;

        dice_ulg(log->stored + ((unsigned long)(~log->stored) << 16),

                 temp + 1);

        if (write(log->fd, temp, 5) != 5)

            return 1;

        log->last_off = lseek(log->fd, log->stored, SEEK_CUR);

    }

    /* write last block (empty) */

    if (write(log->fd, "\001\000\000\377\377", 5) != 5)

        return 1;

    /* write updated crc and uncompressed length */

    dice_ulg(log->crc, temp);

    dice_ulg(log->len, temp + 4);

    if (write(log->fd, temp, 8) != 8)

        return 1;

    /* put offset of that last block in gzip extra block */

    (void)lseek(log->fd, log->extra + 8, SEEK_SET);

    dice_off(log->last_off, temp);

    if (write(log->fd, temp, 8) != 8)

        return 1;

    /* if more than 1 MB stored, then time to compress it */

    if (log->last_off - log->mark_off > MAX_STORED) {

        if (recomp(log))

            return 1;

    }

    /* unlock and close file */

    log_clean(log);

    return 0;

}