/* * 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;}