1/*-
2 * Copyright (c) 2005-2008 Poul-Henning Kamp
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 *
| 1/*-
2 * Copyright (c) 2005-2008 Poul-Henning Kamp
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 *
|
26 * $FreeBSD: head/usr.sbin/fifolog/lib/fifolog_reader.c 209871 2010-07-10 11:40:31Z keramida $
| 26 * $FreeBSD: head/usr.sbin/fifolog/lib/fifolog_reader.c 219027 2011-02-25 09:40:17Z phk $
|
27 */
28
29#include <stdio.h>
30#include <unistd.h>
31#include <assert.h>
32#include <err.h>
33#include <time.h>
34#include <string.h>
35#include <stdlib.h>
36#include <zlib.h>
37#include <sys/endian.h>
38
39#include "fifolog.h"
40#include "libfifolog.h"
41#include "libfifolog_int.h"
42#include "miniobj.h"
43
44/*--------------------------------------------------------------------*/
45
46struct fifolog_reader {
47 unsigned magic;
48#define FIFOLOG_READER_MAGIC 0x1036d139
49 struct fifolog_file *ff;
50 unsigned olen;
| 27 */
28
29#include <stdio.h>
30#include <unistd.h>
31#include <assert.h>
32#include <err.h>
33#include <time.h>
34#include <string.h>
35#include <stdlib.h>
36#include <zlib.h>
37#include <sys/endian.h>
38
39#include "fifolog.h"
40#include "libfifolog.h"
41#include "libfifolog_int.h"
42#include "miniobj.h"
43
44/*--------------------------------------------------------------------*/
45
46struct fifolog_reader {
47 unsigned magic;
48#define FIFOLOG_READER_MAGIC 0x1036d139
49 struct fifolog_file *ff;
50 unsigned olen;
|
51 unsigned char *obuf;
| 51 unsigned char *obuf;
|
52 time_t now;
53};
54
55struct fifolog_reader *
56fifolog_reader_open(const char *fname)
57{
58 const char *retval;
59 struct fifolog_reader *fr;
60 int i;
61
62 fr = calloc(sizeof *fr, 1);
63 if (fr == NULL)
64 err(1, "Cannot malloc");
65
66 retval = fifolog_int_open(&fr->ff, fname, 0);
67 if (retval != NULL)
68 err(1, "%s", retval);
69
70 fr->olen = fr->ff->recsize * 16;
71 fr->obuf = calloc(fr->olen, 1);
72 if (fr->obuf == NULL)
73 err(1, "Cannot malloc");
74
75 i = inflateInit(fr->ff->zs);
76 assert(i == Z_OK);
77
| 52 time_t now;
53};
54
55struct fifolog_reader *
56fifolog_reader_open(const char *fname)
57{
58 const char *retval;
59 struct fifolog_reader *fr;
60 int i;
61
62 fr = calloc(sizeof *fr, 1);
63 if (fr == NULL)
64 err(1, "Cannot malloc");
65
66 retval = fifolog_int_open(&fr->ff, fname, 0);
67 if (retval != NULL)
68 err(1, "%s", retval);
69
70 fr->olen = fr->ff->recsize * 16;
71 fr->obuf = calloc(fr->olen, 1);
72 if (fr->obuf == NULL)
73 err(1, "Cannot malloc");
74
75 i = inflateInit(fr->ff->zs);
76 assert(i == Z_OK);
77
|
78 fr->magic = FIFOLOG_READER_MAGIC;
| 78 fr->magic = FIFOLOG_READER_MAGIC;
|
79 return (fr);
80}
81
82/*
83 * Find the next SYNC block
84 *
85 * Return:
86 * 0 - empty fifolog
87 * 1 - found sync block
88 * 2 - would have wrapped around
89 * 3 - End of written log.
90 */
91
92static int
93fifolog_reader_findsync(const struct fifolog_file *ff, off_t *o)
94{
95 int e;
96 unsigned seq, seqs;
97
98 assert(*o < ff->logsize);
99 e = fifolog_int_read(ff, *o);
100 if (e)
101 err(1, "Read error (%d) while looking for SYNC", e);
102 seq = be32dec(ff->recbuf);
103 if (*o == 0 && seq == 0)
104 return (0);
105
106 if (ff->recbuf[4] & FIFOLOG_FLG_SYNC)
107 return (1); /* That was easy... */
108 while(1) {
109 assert(*o < ff->logsize);
110 (*o)++;
111 seq++;
112 if (*o == ff->logsize)
113 return (2); /* wraparound */
114 e = fifolog_int_read(ff, *o);
115 if (e)
116 err(1, "Read error (%d) while looking for SYNC", e);
117 seqs = be32dec(ff->recbuf);
118 if (seqs != seq)
119 return (3); /* End of log */
120 if (ff->recbuf[4] & FIFOLOG_FLG_SYNC)
121 return (1); /* Bingo! */
122 }
123}
124
125/*
126 * Seek out a given timestamp
127 */
128
129off_t
130fifolog_reader_seek(const struct fifolog_reader *fr, time_t t0)
131{
132 off_t o, s, st;
133 time_t t, tt;
134 unsigned seq, seqs;
135 const char *retval;
136 int e;
137
138 CHECK_OBJ_NOTNULL(fr, FIFOLOG_READER_MAGIC);
139
140 /*
141 * First, find the first SYNC block
142 */
143 o = 0;
144 e = fifolog_reader_findsync(fr->ff, &o);
145 if (e == 0)
146 return (0); /* empty fifolog */
| 79 return (fr);
80}
81
82/*
83 * Find the next SYNC block
84 *
85 * Return:
86 * 0 - empty fifolog
87 * 1 - found sync block
88 * 2 - would have wrapped around
89 * 3 - End of written log.
90 */
91
92static int
93fifolog_reader_findsync(const struct fifolog_file *ff, off_t *o)
94{
95 int e;
96 unsigned seq, seqs;
97
98 assert(*o < ff->logsize);
99 e = fifolog_int_read(ff, *o);
100 if (e)
101 err(1, "Read error (%d) while looking for SYNC", e);
102 seq = be32dec(ff->recbuf);
103 if (*o == 0 && seq == 0)
104 return (0);
105
106 if (ff->recbuf[4] & FIFOLOG_FLG_SYNC)
107 return (1); /* That was easy... */
108 while(1) {
109 assert(*o < ff->logsize);
110 (*o)++;
111 seq++;
112 if (*o == ff->logsize)
113 return (2); /* wraparound */
114 e = fifolog_int_read(ff, *o);
115 if (e)
116 err(1, "Read error (%d) while looking for SYNC", e);
117 seqs = be32dec(ff->recbuf);
118 if (seqs != seq)
119 return (3); /* End of log */
120 if (ff->recbuf[4] & FIFOLOG_FLG_SYNC)
121 return (1); /* Bingo! */
122 }
123}
124
125/*
126 * Seek out a given timestamp
127 */
128
129off_t
130fifolog_reader_seek(const struct fifolog_reader *fr, time_t t0)
131{
132 off_t o, s, st;
133 time_t t, tt;
134 unsigned seq, seqs;
135 const char *retval;
136 int e;
137
138 CHECK_OBJ_NOTNULL(fr, FIFOLOG_READER_MAGIC);
139
140 /*
141 * First, find the first SYNC block
142 */
143 o = 0;
144 e = fifolog_reader_findsync(fr->ff, &o);
145 if (e == 0)
146 return (0); /* empty fifolog */
|
147 assert(e == 1);
| 147 assert(e == 1);
|
148
149 assert(fr->ff->recbuf[4] & FIFOLOG_FLG_SYNC);
150 seq = be32dec(fr->ff->recbuf);
151 t = be32dec(fr->ff->recbuf + 5);
152
153 if (t > t0) {
154 /* Check if there is a second older part we can use */
155 retval = fifolog_int_findend(fr->ff, &s);
156 if (retval != NULL)
157 err(1, "%s", retval);
158 s++;
159 e = fifolog_reader_findsync(fr->ff, &s);
160 if (e == 0)
161 return (0); /* empty fifolog */
162 if (e == 1) {
163 o = s;
164 seq = be32dec(fr->ff->recbuf);
165 t = be32dec(fr->ff->recbuf + 5);
166 }
167 }
168
169 /* Now do a binary search to find the sync block right before t0 */
170 s = st = (fr->ff->logsize - o) / 2;
171 while (s > 1) {
172 /* We know we shouldn't wrap */
173 if (o + st > fr->ff->logsize + 1) {
174 s = st = s / 2;
175 continue;
176 }
177 e = fifolog_int_read(fr->ff, o + st);
178 if (e) {
179 s = st = s / 2;
180 continue;
181 }
182 /* If not in same part, sequence won't match */
183 seqs = be32dec(fr->ff->recbuf);
184 if (seqs != seq + st) {
185 s = st = s / 2;
186 continue;
187 }
188 /* If not sync block, try next */
189 if (!(fr->ff->recbuf[4] & FIFOLOG_FLG_SYNC)) {
190 st++;
191 continue;
192 }
193 /* Check timestamp */
194 tt = be32dec(fr->ff->recbuf + 5);
195 if (tt >= t0) {
196 s = st = s / 2;
197 continue;
198 }
199 o += st;
200 seq = seqs;
201 }
202 fprintf(stderr, "Read from %jx\n", o * fr->ff->recsize);
203 return (o);
204}
205
206static unsigned char *
207fifolog_reader_chop(struct fifolog_reader *fr, fifolog_reader_render_t *func, void *priv)
208{
209 u_char *p, *q;
210 uint32_t v, w, u;
211
212 p = fr->obuf;
213 q = fr->obuf + (fr->olen - fr->ff->zs->avail_out);
214
215 while (1) {
216 /* Make sure we have a complete header */
217 if (p + 5 >= q)
218 return (p);
219 w = 4;
220 u = be32dec(p);
221 if (u & FIFOLOG_TIMESTAMP) {
222 fr->now = be32dec(p + 4);
223 w += 4;
224 }
225 if (u & FIFOLOG_LENGTH) {
226 v = p[w];
227 w++;
228 if (p + w + v >= q)
229 return (p);
230 } else {
231 for (v = 0; p + v + w < q && p[v + w] != '\0'; v++)
232 continue;
233 if (p + v + w >= q)
234 return (p);
235 v++;
236 }
237 func(priv, fr->now, u, p + w, v);
238 p += w + v;
239 }
240}
241
242/*
243 * Process fifolog until end of written log or provided timestamp
244 */
245
246void
247fifolog_reader_process(struct fifolog_reader *fr, off_t from, fifolog_reader_render_t *func, void *priv, time_t end)
248{
249 uint32_t seq, lseq;
250 off_t o = from;
251 int i, e;
252 time_t t;
253 u_char *p, *q;
254 z_stream *zs;
255
256 CHECK_OBJ_NOTNULL(fr, FIFOLOG_READER_MAGIC);
257 zs = fr->ff->zs;
258 lseq = 0;
259 while (1) {
260 e = fifolog_int_read(fr->ff, o);
261 if (e)
262 err(1, "Read error (%d)", e);
263 if (++o >= fr->ff->logsize)
264 o = 0;
265 seq = be32dec(fr->ff->recbuf);
266 if (lseq != 0 && seq != lseq + 1)
267 break;
268 lseq = seq;
269 zs->avail_in = fr->ff->recsize - 5;
270 zs->next_in = fr->ff->recbuf + 5;
271 if (fr->ff->recbuf[4] & FIFOLOG_FLG_1BYTE)
272 zs->avail_in -= fr->ff->recbuf[fr->ff->recsize - 1];
273 if (fr->ff->recbuf[4] & FIFOLOG_FLG_4BYTE)
274 zs->avail_in -=
275 be32dec(fr->ff->recbuf + fr->ff->recsize - 4);
276 if (fr->ff->recbuf[4] & FIFOLOG_FLG_SYNC) {
277 i = inflateReset(zs);
278 assert(i == Z_OK);
279 zs->next_out = fr->obuf;
280 zs->avail_out = fr->olen;
281 t = be32dec(fr->ff->recbuf + 5);
282 if (t > end)
283 break;
284 zs->next_in += 4;
285 zs->avail_in -= 4;
286 }
287
288 while(zs->avail_in > 0) {
289 i = inflate(zs, 0);
290 if (i == Z_BUF_ERROR) {
291#if 1
292 fprintf(stderr,
293 "Z_BUF_ERROR [%d,%d] [%d,%d,%d]\n",
294 (int)(zs->next_in - fr->ff->recbuf),
295 zs->avail_in,
296 (int)(zs->next_out - fr->obuf),
297 zs->avail_out, fr->olen);
298 exit (250);
299#else
| 148
149 assert(fr->ff->recbuf[4] & FIFOLOG_FLG_SYNC);
150 seq = be32dec(fr->ff->recbuf);
151 t = be32dec(fr->ff->recbuf + 5);
152
153 if (t > t0) {
154 /* Check if there is a second older part we can use */
155 retval = fifolog_int_findend(fr->ff, &s);
156 if (retval != NULL)
157 err(1, "%s", retval);
158 s++;
159 e = fifolog_reader_findsync(fr->ff, &s);
160 if (e == 0)
161 return (0); /* empty fifolog */
162 if (e == 1) {
163 o = s;
164 seq = be32dec(fr->ff->recbuf);
165 t = be32dec(fr->ff->recbuf + 5);
166 }
167 }
168
169 /* Now do a binary search to find the sync block right before t0 */
170 s = st = (fr->ff->logsize - o) / 2;
171 while (s > 1) {
172 /* We know we shouldn't wrap */
173 if (o + st > fr->ff->logsize + 1) {
174 s = st = s / 2;
175 continue;
176 }
177 e = fifolog_int_read(fr->ff, o + st);
178 if (e) {
179 s = st = s / 2;
180 continue;
181 }
182 /* If not in same part, sequence won't match */
183 seqs = be32dec(fr->ff->recbuf);
184 if (seqs != seq + st) {
185 s = st = s / 2;
186 continue;
187 }
188 /* If not sync block, try next */
189 if (!(fr->ff->recbuf[4] & FIFOLOG_FLG_SYNC)) {
190 st++;
191 continue;
192 }
193 /* Check timestamp */
194 tt = be32dec(fr->ff->recbuf + 5);
195 if (tt >= t0) {
196 s = st = s / 2;
197 continue;
198 }
199 o += st;
200 seq = seqs;
201 }
202 fprintf(stderr, "Read from %jx\n", o * fr->ff->recsize);
203 return (o);
204}
205
206static unsigned char *
207fifolog_reader_chop(struct fifolog_reader *fr, fifolog_reader_render_t *func, void *priv)
208{
209 u_char *p, *q;
210 uint32_t v, w, u;
211
212 p = fr->obuf;
213 q = fr->obuf + (fr->olen - fr->ff->zs->avail_out);
214
215 while (1) {
216 /* Make sure we have a complete header */
217 if (p + 5 >= q)
218 return (p);
219 w = 4;
220 u = be32dec(p);
221 if (u & FIFOLOG_TIMESTAMP) {
222 fr->now = be32dec(p + 4);
223 w += 4;
224 }
225 if (u & FIFOLOG_LENGTH) {
226 v = p[w];
227 w++;
228 if (p + w + v >= q)
229 return (p);
230 } else {
231 for (v = 0; p + v + w < q && p[v + w] != '\0'; v++)
232 continue;
233 if (p + v + w >= q)
234 return (p);
235 v++;
236 }
237 func(priv, fr->now, u, p + w, v);
238 p += w + v;
239 }
240}
241
242/*
243 * Process fifolog until end of written log or provided timestamp
244 */
245
246void
247fifolog_reader_process(struct fifolog_reader *fr, off_t from, fifolog_reader_render_t *func, void *priv, time_t end)
248{
249 uint32_t seq, lseq;
250 off_t o = from;
251 int i, e;
252 time_t t;
253 u_char *p, *q;
254 z_stream *zs;
255
256 CHECK_OBJ_NOTNULL(fr, FIFOLOG_READER_MAGIC);
257 zs = fr->ff->zs;
258 lseq = 0;
259 while (1) {
260 e = fifolog_int_read(fr->ff, o);
261 if (e)
262 err(1, "Read error (%d)", e);
263 if (++o >= fr->ff->logsize)
264 o = 0;
265 seq = be32dec(fr->ff->recbuf);
266 if (lseq != 0 && seq != lseq + 1)
267 break;
268 lseq = seq;
269 zs->avail_in = fr->ff->recsize - 5;
270 zs->next_in = fr->ff->recbuf + 5;
271 if (fr->ff->recbuf[4] & FIFOLOG_FLG_1BYTE)
272 zs->avail_in -= fr->ff->recbuf[fr->ff->recsize - 1];
273 if (fr->ff->recbuf[4] & FIFOLOG_FLG_4BYTE)
274 zs->avail_in -=
275 be32dec(fr->ff->recbuf + fr->ff->recsize - 4);
276 if (fr->ff->recbuf[4] & FIFOLOG_FLG_SYNC) {
277 i = inflateReset(zs);
278 assert(i == Z_OK);
279 zs->next_out = fr->obuf;
280 zs->avail_out = fr->olen;
281 t = be32dec(fr->ff->recbuf + 5);
282 if (t > end)
283 break;
284 zs->next_in += 4;
285 zs->avail_in -= 4;
286 }
287
288 while(zs->avail_in > 0) {
289 i = inflate(zs, 0);
290 if (i == Z_BUF_ERROR) {
291#if 1
292 fprintf(stderr,
293 "Z_BUF_ERROR [%d,%d] [%d,%d,%d]\n",
294 (int)(zs->next_in - fr->ff->recbuf),
295 zs->avail_in,
296 (int)(zs->next_out - fr->obuf),
297 zs->avail_out, fr->olen);
298 exit (250);
299#else
|
300
| 300
|
301 i = Z_OK;
302#endif
303 }
304 if (i == Z_STREAM_END) {
305 i = inflateReset(zs);
306 }
307 if (i != Z_OK) {
308 fprintf(stderr, "inflate = %d\n", i);
309 exit (250);
310 }
311 assert(i == Z_OK);
312 if (zs->avail_out != fr->olen) {
313 q = fr->obuf + (fr->olen - zs->avail_out);
314 p = fifolog_reader_chop(fr, func, priv);
| 301 i = Z_OK;
302#endif
303 }
304 if (i == Z_STREAM_END) {
305 i = inflateReset(zs);
306 }
307 if (i != Z_OK) {
308 fprintf(stderr, "inflate = %d\n", i);
309 exit (250);
310 }
311 assert(i == Z_OK);
312 if (zs->avail_out != fr->olen) {
313 q = fr->obuf + (fr->olen - zs->avail_out);
314 p = fifolog_reader_chop(fr, func, priv);
|
315 if (p < q)
| 315 if (p < q)
|
316 (void)memmove(fr->obuf, p, q - p);
317 zs->avail_out = fr->olen - (q - p);
318 zs->next_out = fr->obuf + (q - p);
319 }
320 }
321 }
322}
| 316 (void)memmove(fr->obuf, p, q - p);
317 zs->avail_out = fr->olen - (q - p);
318 zs->next_out = fr->obuf + (q - p);
319 }
320 }
321 }
322}
|