Ruby: ext/zlib/zlib-1.2.13/examples/gzlog.h Source File

Ruby 3.0.5p211 (2022-11-24 revision ba5cf0f7c52d4d35cc6a173c89eda98ceffa2dcf)

gzlog.h
Go to the documentation of this file.
1/* gzlog.h
2 Copyright (C) 2004, 2008, 2012 Mark Adler, all rights reserved
3 version 2.2, 14 Aug 2012
4
5 This software is provided 'as-is', without any express or implied
6 warranty. In no event will the author be held liable for any damages
7 arising from the use of this software.
8
9 Permission is granted to anyone to use this software for any purpose,
10 including commercial applications, and to alter it and redistribute it
11 freely, subject to the following restrictions:
12
13 1. The origin of this software must not be misrepresented; you must not
14 claim that you wrote the original software. If you use this software
15 in a product, an acknowledgment in the product documentation would be
16 appreciated but is not required.
17 2. Altered source versions must be plainly marked as such, and must not be
18 misrepresented as being the original software.
19 3. This notice may not be removed or altered from any source distribution.
20
21 Mark Adler madler@alumni.caltech.edu
22 */
23
24/* Version History:
25 1.0 26 Nov 2004 First version
26 2.0 25 Apr 2008 Complete redesign for recovery of interrupted operations
27 Interface changed slightly in that now path is a prefix
28 Compression now occurs as needed during gzlog_write()
29 gzlog_write() now always leaves the log file as valid gzip
30 2.1 8 Jul 2012 Fix argument checks in gzlog_compress() and gzlog_write()
31 2.2 14 Aug 2012 Clean up signed comparisons
32 */
33
34/*
35 The gzlog object allows writing short messages to a gzipped log file,
36 opening the log file locked for small bursts, and then closing it. The log
37 object works by appending stored (uncompressed) data to the gzip file until
38 1 MB has been accumulated. At that time, the stored data is compressed, and
39 replaces the uncompressed data in the file. The log file is truncated to
40 its new size at that time. After each write operation, the log file is a
41 valid gzip file that can decompressed to recover what was written.
42
43 The gzlog operations can be interrupted at any point due to an application or
44 system crash, and the log file will be recovered the next time the log is
45 opened with gzlog_open().
46 */
47
48#ifndef GZLOG_H
49#define GZLOG_H
50
51/* gzlog object type */
52 typedef void gzlog;
53
54/* Open a gzlog object, creating the log file if it does not exist. Return
55 NULL on error. Note that gzlog_open() could take a while to complete if it
56 has to wait to verify that a lock is stale (possibly for five minutes), or
57 if there is significant contention with other instantiations of this object
58 when locking the resource. path is the prefix of the file names created by
59 this object. If path is "foo", then the log file will be "foo.gz", and
60 other auxiliary files will be created and destroyed during the process:
61 "foo.dict" for a compression dictionary, "foo.temp" for a temporary (next)
62 dictionary, "foo.add" for data being added or compressed, "foo.lock" for the
63 lock file, and "foo.repairs" to log recovery operations performed due to
64 interrupted gzlog operations. A gzlog_open() followed by a gzlog_close()
65 will recover a previously interrupted operation, if any. */
66 gzlog *gzlog_open(char *path);
67
68/* Write to a gzlog object. Return zero on success, -1 if there is a file i/o
69 error on any of the gzlog files (this should not happen if gzlog_open()
70 succeeded, unless the device has run out of space or leftover auxiliary
71 files have permissions or ownership that prevent their use), -2 if there is
72 a memory allocation failure, or -3 if the log argument is invalid (e.g. if
73 it was not created by gzlog_open()). This function will write data to the
74 file uncompressed, until 1 MB has been accumulated, at which time that data
75 will be compressed. The log file will be a valid gzip file upon successful
76 return. */
77int gzlog_write(gzlog *log, void *data, size_t len);
78
79/* Force compression of any uncompressed data in the log. This should be used
80 sparingly, if at all. The main application would be when a log file will
81 not be appended to again. If this is used to compress frequently while
82 appending, it will both significantly increase the execution time and
83 reduce the compression ratio. The return codes are the same as for
84 gzlog_write(). */
85int gzlog_compress(gzlog *log);
86
87/* Close a gzlog object. Return zero on success, -3 if the log argument is
88 invalid. The log object is freed, and so cannot be referenced again. */
89int gzlog_close(gzlog *log);
90
91#endif
len
uint8_t len
Definition: escape.c:17
gzlog
void gzlog
Definition: gzlog.h:52
gzlog_write
int gzlog_write(gzlog *log, void *data, size_t len)
Definition: gzlog.c:997
gzlog_open
gzlog * gzlog_open(char *path)
Definition: gzlog.c:867
gzlog_compress
int gzlog_compress(gzlog *log)
Definition: gzlog.c:910
gzlog_close
int gzlog_close(gzlog *log)
Definition: gzlog.c:1044
log
Definition: gzlog.c:289