aboutsummaryrefslogtreecommitdiffstats
path: root/lib/zlib_inflate/inflate_sync.c
diff options
context:
space:
mode:
authorLinus Torvalds <torvalds@ppc970.osdl.org>2005-04-16 18:20:36 -0400
committerLinus Torvalds <torvalds@ppc970.osdl.org>2005-04-16 18:20:36 -0400
commit1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 (patch)
tree0bba044c4ce775e45a88a51686b5d9f90697ea9d /lib/zlib_inflate/inflate_sync.c
Linux-2.6.12-rc2v2.6.12-rc2
Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
Diffstat (limited to 'lib/zlib_inflate/inflate_sync.c')
-rw-r--r--lib/zlib_inflate/inflate_sync.c148
1 files changed, 148 insertions, 0 deletions
diff --git a/lib/zlib_inflate/inflate_sync.c b/lib/zlib_inflate/inflate_sync.c
new file mode 100644
index 000000000000..e07bdb21f55c
--- /dev/null
+++ b/lib/zlib_inflate/inflate_sync.c
@@ -0,0 +1,148 @@
1/* inflate.c -- zlib interface to inflate modules
2 * Copyright (C) 1995-1998 Mark Adler
3 * For conditions of distribution and use, see copyright notice in zlib.h
4 */
5
6#include <linux/zutil.h>
7#include "infblock.h"
8#include "infutil.h"
9
10int zlib_inflateSync(
11 z_streamp z
12)
13{
14 uInt n; /* number of bytes to look at */
15 Byte *p; /* pointer to bytes */
16 uInt m; /* number of marker bytes found in a row */
17 uLong r, w; /* temporaries to save total_in and total_out */
18
19 /* set up */
20 if (z == NULL || z->state == NULL)
21 return Z_STREAM_ERROR;
22 if (z->state->mode != I_BAD)
23 {
24 z->state->mode = I_BAD;
25 z->state->sub.marker = 0;
26 }
27 if ((n = z->avail_in) == 0)
28 return Z_BUF_ERROR;
29 p = z->next_in;
30 m = z->state->sub.marker;
31
32 /* search */
33 while (n && m < 4)
34 {
35 static const Byte mark[4] = {0, 0, 0xff, 0xff};
36 if (*p == mark[m])
37 m++;
38 else if (*p)
39 m = 0;
40 else
41 m = 4 - m;
42 p++, n--;
43 }
44
45 /* restore */
46 z->total_in += p - z->next_in;
47 z->next_in = p;
48 z->avail_in = n;
49 z->state->sub.marker = m;
50
51 /* return no joy or set up to restart on a new block */
52 if (m != 4)
53 return Z_DATA_ERROR;
54 r = z->total_in; w = z->total_out;
55 zlib_inflateReset(z);
56 z->total_in = r; z->total_out = w;
57 z->state->mode = BLOCKS;
58 return Z_OK;
59}
60
61
62/* Returns true if inflate is currently at the end of a block generated
63 * by Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP
64 * implementation to provide an additional safety check. PPP uses Z_SYNC_FLUSH
65 * but removes the length bytes of the resulting empty stored block. When
66 * decompressing, PPP checks that at the end of input packet, inflate is
67 * waiting for these length bytes.
68 */
69int zlib_inflateSyncPoint(
70 z_streamp z
71)
72{
73 if (z == NULL || z->state == NULL || z->state->blocks == NULL)
74 return Z_STREAM_ERROR;
75 return zlib_inflate_blocks_sync_point(z->state->blocks);
76}
77
78/*
79 * This subroutine adds the data at next_in/avail_in to the output history
80 * without performing any output. The output buffer must be "caught up";
81 * i.e. no pending output (hence s->read equals s->write), and the state must
82 * be BLOCKS (i.e. we should be willing to see the start of a series of
83 * BLOCKS). On exit, the output will also be caught up, and the checksum
84 * will have been updated if need be.
85 */
86static int zlib_inflate_addhistory(inflate_blocks_statef *s,
87 z_stream *z)
88{
89 uLong b; /* bit buffer */ /* NOT USED HERE */
90 uInt k; /* bits in bit buffer */ /* NOT USED HERE */
91 uInt t; /* temporary storage */
92 Byte *p; /* input data pointer */
93 uInt n; /* bytes available there */
94 Byte *q; /* output window write pointer */
95 uInt m; /* bytes to end of window or read pointer */
96
97 if (s->read != s->write)
98 return Z_STREAM_ERROR;
99 if (s->mode != TYPE)
100 return Z_DATA_ERROR;
101
102 /* we're ready to rock */
103 LOAD
104 /* while there is input ready, copy to output buffer, moving
105 * pointers as needed.
106 */
107 while (n) {
108 t = n; /* how many to do */
109 /* is there room until end of buffer? */
110 if (t > m) t = m;
111 /* update check information */
112 if (s->checkfn != NULL)
113 s->check = (*s->checkfn)(s->check, q, t);
114 memcpy(q, p, t);
115 q += t;
116 p += t;
117 n -= t;
118 z->total_out += t;
119 s->read = q; /* drag read pointer forward */
120/* WWRAP */ /* expand WWRAP macro by hand to handle s->read */
121 if (q == s->end) {
122 s->read = q = s->window;
123 m = WAVAIL;
124 }
125 }
126 UPDATE
127 return Z_OK;
128}
129
130
131/*
132 * This subroutine adds the data at next_in/avail_in to the output history
133 * without performing any output. The output buffer must be "caught up";
134 * i.e. no pending output (hence s->read equals s->write), and the state must
135 * be BLOCKS (i.e. we should be willing to see the start of a series of
136 * BLOCKS). On exit, the output will also be caught up, and the checksum
137 * will have been updated if need be.
138 */
139
140int zlib_inflateIncomp(
141 z_stream *z
142
143)
144{
145 if (z->state->mode != BLOCKS)
146 return Z_DATA_ERROR;
147 return zlib_inflate_addhistory(z->state->blocks, z);
148}