URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [zlib/] [examples/] [gzlog.c] - Blame information for rev 758

Go to most recent revision | Details | Compare with Previous | View Log


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

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [zlib/] [examples/] [gzlog.c] - Blame information for rev 758

Line No.	Rev	Author	Line
1	745	jeremybenn	`/*`
2			`* gzlog.c`
3			`* Copyright (C) 2004 Mark Adler`
4			`* For conditions of distribution and use, see copyright notice in gzlog.h`
5			`* version 1.0, 26 Nov 2004`
6			`*`
7			`*/`
8
9			`#include <string.h> /* memcmp() */`
10			`#include <stdlib.h> /* malloc(), free(), NULL */`
11			`#include <sys/types.h> /* size_t, off_t */`
12			`#include <unistd.h> /* read(), close(), sleep(), ftruncate(), */`
13			`/* lseek() */`
14			`#include <fcntl.h> /* open() */`
15			`#include <sys/file.h> /* flock() */`
16			`#include "zlib.h" /* deflateInit2(), deflate(), deflateEnd() */`
17
18			`#include "gzlog.h" /* interface */`
19			`#define local static`
20
21			`/* log object structure */`
22			`typedef struct {`
23			`int id; /* object identifier */`
24			`int fd; /* log file descriptor */`
25			`off_t extra; /* offset of extra "ap" subfield */`
26			`off_t mark_off; /* offset of marked data */`
27			`off_t last_off; /* offset of last block */`
28			`unsigned long crc; /* uncompressed crc */`
29			`unsigned long len; /* uncompressed length (modulo 2^32) */`
30			`unsigned stored; /* length of current stored block */`
31			`} gz_log;`
32
33			`#define GZLOGID 19334 /* gz_log object identifier */`
34
35			`#define LOCK_RETRY 1 /* retry lock once a second */`
36			`#define LOCK_PATIENCE 1200 /* try about twenty minutes before forcing */`
37
38			`/* acquire a lock on a file */`
39			`local int lock(int fd)`
40			`{`
41			`int patience;`
42
43			`/* try to lock every LOCK_RETRY seconds for LOCK_PATIENCE seconds */`
44			`patience = LOCK_PATIENCE;`
45			`do {`
46			`if (flock(fd, LOCK_EX + LOCK_NB) == 0)`
47			`return 0;`
48			`(void)sleep(LOCK_RETRY);`
49			`patience -= LOCK_RETRY;`
50			`} while (patience > 0);`
51
52			`/* we've run out of patience -- give up */`
53			`return -1;`
54			`}`
55
56			`/* release lock */`
57			`local void unlock(int fd)`
58			`{`
59			`(void)flock(fd, LOCK_UN);`
60			`}`
61
62			`/* release a log object */`
63			`local void log_clean(gz_log *log)`
64			`{`
65			`unlock(log->fd);`
66			`(void)close(log->fd);`
67			`free(log);`
68			`}`
69
70			`/* read an unsigned long from a byte buffer little-endian */`
71			`local unsigned long make_ulg(unsigned char *buf)`
72			`{`
73			`int n;`
74			`unsigned long val;`
75
76			`val = (unsigned long)(*buf++);`
77			`for (n = 8; n < 32; n += 8)`
78			`val += (unsigned long)(*buf++) << n;`
79			`return val;`
80			`}`
81
82			`/* read an off_t from a byte buffer little-endian */`
83			`local off_t make_off(unsigned char *buf)`
84			`{`
85			`int n;`
86			`off_t val;`
87
88			`val = (off_t)(*buf++);`
89			`for (n = 8; n < 64; n += 8)`
90			`val += (off_t)(*buf++) << n;`
91			`return val;`
92			`}`
93
94			`/* write an unsigned long little-endian to byte buffer */`
95			`local void dice_ulg(unsigned long val, unsigned char *buf)`
96			`{`
97			`int n;`
98
99			`for (n = 0; n < 4; n++) {`
100			`*buf++ = val & 0xff;`
101			`val >>= 8;`
102			`}`
103			`}`
104
105			`/* write an off_t little-endian to byte buffer */`
106			`local void dice_off(off_t val, unsigned char *buf)`
107			`{`
108			`int n;`
109
110			`for (n = 0; n < 8; n++) {`
111			`*buf++ = val & 0xff;`
112			`val >>= 8;`
113			`}`
114			`}`
115
116			`/* initial, empty gzip file for appending */`
117			`local char empty_gz[] = {`
118			`0x1f, 0x8b, /* magic gzip id */`
119			`8, /* compression method is deflate */`
120			`4, /* there is an extra field */`
121			`0, 0, 0, 0, /* no modification time provided */`
122			`0, 0xff, /* no extra flags, no OS */`
123			`20, 0, 'a', 'p', 16, 0, /* extra field with "ap" subfield */`
124			`32, 0, 0, 0, 0, 0, 0, 0, /* offset of uncompressed data */`
125			`32, 0, 0, 0, 0, 0, 0, 0, /* offset of last block */`
126			`1, 0, 0, 0xff, 0xff, /* empty stored block (last) */`
127			`0, 0, 0, 0, /* crc */`
128			`0, 0, 0, 0 /* uncompressed length */`
129			`};`
130
131			`/* initialize a log object with locking */`
132			`void gzlog_open(char path)`
133			`{`
134			`unsigned xlen;`
135			`unsigned char temp[20];`
136			`unsigned sub_len;`
137			`int good;`
138			`gz_log *log;`
139
140			`/* allocate log structure */`
141			`log = malloc(sizeof(gz_log));`
142			`if (log == NULL)`
143			`return NULL;`
144			`log->id = GZLOGID;`
145
146			`/* open file, creating it if necessary, and locking it */`
147			`log->fd = open(path, O_RDWR \| O_CREAT, 0600);`
148			`if (log->fd < 0) {`
149			`free(log);`
150			`return NULL;`
151			`}`
152			`if (lock(log->fd)) {`
153			`close(log->fd);`
154			`free(log);`
155			`return NULL;`
156			`}`
157
158			`/* if file is empty, write new gzip stream */`
159			`if (lseek(log->fd, 0, SEEK_END) == 0) {`
160			`if (write(log->fd, empty_gz, sizeof(empty_gz)) != sizeof(empty_gz)) {`
161			`log_clean(log);`
162			`return NULL;`
163			`}`
164			`}`
165
166			`/* check gzip header */`
167			`(void)lseek(log->fd, 0, SEEK_SET);`
168			`if (read(log->fd, temp, 12) != 12 \|\| temp[0] != 0x1f \|\|`
169			`temp[1] != 0x8b \|\| temp[2] != 8 \|\| (temp[3] & 4) == 0) {`
170			`log_clean(log);`
171			`return NULL;`
172			`}`
173
174			`/* process extra field to find "ap" sub-field */`
175			`xlen = temp[10] + (temp[11] << 8);`
176			`good = 0;`
177			`while (xlen) {`
178			`if (xlen < 4 \|\| read(log->fd, temp, 4) != 4)`
179			`break;`
180			`sub_len = temp[2];`
181			`sub_len += temp[3] << 8;`
182			`xlen -= 4;`
183			`if (memcmp(temp, "ap", 2) == 0 && sub_len == 16) {`
184			`good = 1;`
185			`break;`
186			`}`
187			`if (xlen < sub_len)`
188			`break;`
189			`(void)lseek(log->fd, sub_len, SEEK_CUR);`
190			`xlen -= sub_len;`
191			`}`
192			`if (!good) {`
193			`log_clean(log);`
194			`return NULL;`
195			`}`
196
197			`/* read in "ap" sub-field */`
198			`log->extra = lseek(log->fd, 0, SEEK_CUR);`
199			`if (read(log->fd, temp, 16) != 16) {`
200			`log_clean(log);`
201			`return NULL;`
202			`}`
203			`log->mark_off = make_off(temp);`
204			`log->last_off = make_off(temp + 8);`
205
206			`/* get crc, length of gzip file */`
207			`(void)lseek(log->fd, log->last_off, SEEK_SET);`
208			`if (read(log->fd, temp, 13) != 13 \|\|`
209			`memcmp(temp, "\001\000\000\377\377", 5) != 0) {`
210			`log_clean(log);`
211			`return NULL;`
212			`}`
213			`log->crc = make_ulg(temp + 5);`
214			`log->len = make_ulg(temp + 9);`
215
216			`/* set up to write over empty last block */`
217			`(void)lseek(log->fd, log->last_off + 5, SEEK_SET);`
218			`log->stored = 0;`
219			`return (void *)log;`
220			`}`
221
222			`/* maximum amount to put in a stored block before starting a new one */`
223			`#define MAX_BLOCK 16384`
224
225			`/* write a block to a log object */`
226			`int gzlog_write(void obj, char data, size_t len)`
227			`{`
228			`size_t some;`
229			`unsigned char temp[5];`
230			`gz_log *log;`
231
232			`/* check object */`
233			`log = (gz_log *)obj;`
234			`if (log == NULL \|\| log->id != GZLOGID)`
235			`return 1;`
236
237			`/* write stored blocks until all of the input is written */`
238			`do {`
239			`some = MAX_BLOCK - log->stored;`
240			`if (some > len)`
241			`some = len;`
242			`if (write(log->fd, data, some) != some)`
243			`return 1;`
244			`log->crc = crc32(log->crc, data, some);`
245			`log->len += some;`
246			`len -= some;`
247			`data += some;`
248			`log->stored += some;`
249
250			`/* if the stored block is full, end it and start another */`
251			`if (log->stored == MAX_BLOCK) {`
252			`(void)lseek(log->fd, log->last_off, SEEK_SET);`
253			`temp[0] = 0;`
254			`dice_ulg(log->stored + ((unsigned long)(~log->stored) << 16),`
255			`temp + 1);`
256			`if (write(log->fd, temp, 5) != 5)`
257			`return 1;`
258			`log->last_off = lseek(log->fd, log->stored, SEEK_CUR);`
259			`(void)lseek(log->fd, 5, SEEK_CUR);`
260			`log->stored = 0;`
261			`}`
262			`} while (len);`
263			`return 0;`
264			`}`
265
266			`/* recompress the remaining stored deflate data in place */`
267			`local int recomp(gz_log *log)`
268			`{`
269			`z_stream strm;`
270			`size_t len, max;`
271			`unsigned char *in;`
272			`unsigned char *out;`
273			`unsigned char temp[16];`
274
275			`/* allocate space and read it all in (it's around 1 MB) */`
276			`len = log->last_off - log->mark_off;`
277			`max = len + (len >> 12) + (len >> 14) + 11;`
278			`out = malloc(max);`
279			`if (out == NULL)`
280			`return 1;`
281			`in = malloc(len);`
282			`if (in == NULL) {`
283			`free(out);`
284			`return 1;`
285			`}`
286			`(void)lseek(log->fd, log->mark_off, SEEK_SET);`
287			`if (read(log->fd, in, len) != len) {`
288			`free(in);`
289			`free(out);`
290			`return 1;`
291			`}`
292
293			`/* recompress in memory, decoding stored data as we go */`
294			`/* note: this assumes that unsigned is four bytes or more */`
295			`/* consider not making that assumption */`
296			`strm.zalloc = Z_NULL;`
297			`strm.zfree = Z_NULL;`
298			`strm.opaque = Z_NULL;`
299			`if (deflateInit2(&strm, Z_BEST_COMPRESSION, Z_DEFLATED, -15, 8,`
300			`Z_DEFAULT_STRATEGY) != Z_OK) {`
301			`free(in);`
302			`free(out);`
303			`return 1;`
304			`}`
305			`strm.next_in = in;`
306			`strm.avail_out = max;`
307			`strm.next_out = out;`
308			`while (len >= 5) {`
309			`if (strm.next_in[0] != 0)`
310			`break;`
311			`strm.avail_in = strm.next_in[1] + (strm.next_in[2] << 8);`
312			`strm.next_in += 5;`
313			`len -= 5;`
314			`if (strm.avail_in != 0) {`
315			`if (len < strm.avail_in)`
316			`break;`
317			`len -= strm.avail_in;`
318			`(void)deflate(&strm, Z_NO_FLUSH);`
319			`if (strm.avail_in != 0 \|\| strm.avail_out == 0)`
320			`break;`
321			`}`
322			`}`
323			`(void)deflate(&strm, Z_SYNC_FLUSH);`
324			`(void)deflateEnd(&strm);`
325			`free(in);`
326			`if (len != 0 \|\| strm.avail_out == 0) {`
327			`free(out);`
328			`return 1;`
329			`}`
330
331			`/* overwrite stored data with compressed data */`
332			`(void)lseek(log->fd, log->mark_off, SEEK_SET);`
333			`len = max - strm.avail_out;`
334			`if (write(log->fd, out, len) != len) {`
335			`free(out);`
336			`return 1;`
337			`}`
338			`free(out);`
339
340			`/* write last empty block, crc, and length */`
341			`log->mark_off = log->last_off = lseek(log->fd, 0, SEEK_CUR);`
342			`temp[0] = 1;`
343			`dice_ulg(0xffffL << 16, temp + 1);`
344			`dice_ulg(log->crc, temp + 5);`
345			`dice_ulg(log->len, temp + 9);`
346			`if (write(log->fd, temp, 13) != 13)`
347			`return 1;`
348
349			`/* truncate file to discard remaining stored data and old trailer */`
350			`ftruncate(log->fd, lseek(log->fd, 0, SEEK_CUR));`
351
352			`/* update extra field to point to new last empty block */`
353			`(void)lseek(log->fd, log->extra, SEEK_SET);`
354			`dice_off(log->mark_off, temp);`
355			`dice_off(log->last_off, temp + 8);`
356			`if (write(log->fd, temp, 16) != 16)`
357			`return 1;`
358			`return 0;`
359			`}`
360
361			`/* maximum accumulation of stored blocks before compressing */`
362			`#define MAX_STORED 1048576`
363
364			`/* close log object */`
365			`int gzlog_close(void *obj)`
366			`{`
367			`unsigned char temp[8];`
368			`gz_log *log;`
369
370			`/* check object */`
371			`log = (gz_log *)obj;`
372			`if (log == NULL \|\| log->id != GZLOGID)`
373			`return 1;`
374
375			`/* go to start of most recent block being written */`
376			`(void)lseek(log->fd, log->last_off, SEEK_SET);`
377
378			`/* if some stuff was put there, update block */`
379			`if (log->stored) {`
380			`temp[0] = 0;`
381			`dice_ulg(log->stored + ((unsigned long)(~log->stored) << 16),`
382			`temp + 1);`
383			`if (write(log->fd, temp, 5) != 5)`
384			`return 1;`
385			`log->last_off = lseek(log->fd, log->stored, SEEK_CUR);`
386			`}`
387
388			`/* write last block (empty) */`
389			`if (write(log->fd, "\001\000\000\377\377", 5) != 5)`
390			`return 1;`
391
392			`/* write updated crc and uncompressed length */`
393			`dice_ulg(log->crc, temp);`
394			`dice_ulg(log->len, temp + 4);`
395			`if (write(log->fd, temp, 8) != 8)`
396			`return 1;`
397
398			`/* put offset of that last block in gzip extra block */`
399			`(void)lseek(log->fd, log->extra + 8, SEEK_SET);`
400			`dice_off(log->last_off, temp);`
401			`if (write(log->fd, temp, 8) != 8)`
402			`return 1;`
403
404			`/* if more than 1 MB stored, then time to compress it */`
405			`if (log->last_off - log->mark_off > MAX_STORED) {`
406			`if (recomp(log))`
407			`return 1;`
408			`}`
409
410			`/* unlock and close file */`
411			`log_clean(log);`
412			`return 0;`
413			`}`