![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ppp_deflate.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / net|
Return to ppp_deflate.c CVS log | Up to [Apple XNU] / XNU / bsd / net |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /*
23: * ppp_deflate.c - interface the zlib procedures for Deflate compression
24: * and decompression (as used by gzip) to the PPP code.
25: * This version is for use with mbufs on BSD-derived systems.
26: *
27: * Copyright (c) 1994 The Australian National University.
28: * All rights reserved.
29: *
30: * Permission to use, copy, modify, and distribute this software and its
31: * documentation is hereby granted, provided that the above copyright
32: * notice appears in all copies. This software is provided without any
33: * warranty, express or implied. The Australian National University
34: * makes no representations about the suitability of this software for
35: * any purpose.
36: *
37: * IN NO EVENT SHALL THE AUSTRALIAN NATIONAL UNIVERSITY BE LIABLE TO ANY
38: * PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
39: * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
40: * THE AUSTRALIAN NATIONAL UNIVERSITY HAS BEEN ADVISED OF THE POSSIBILITY
41: * OF SUCH DAMAGE.
42: *
43: * THE AUSTRALIAN NATIONAL UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES,
44: * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
45: * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
46: * ON AN "AS IS" BASIS, AND THE AUSTRALIAN NATIONAL UNIVERSITY HAS NO
47: * OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS,
48: * OR MODIFICATIONS.
49: */
50:
51: #include <sys/param.h>
52: #include <sys/systm.h>
53: #include <sys/malloc.h>
54: #include <sys/mbuf.h>
55: #include <net/ppp_defs.h>
56: #include <net/zlib.h>
57:
58: #define PACKETPTR struct mbuf *
59: #include <net/ppp_comp.h>
60:
61: #if DO_DEFLATE
62:
63: #define DEFLATE_DEBUG 1
64:
65: /*
66: * State for a Deflate (de)compressor.
67: */
68: struct deflate_state {
69: int seqno;
70: int w_size;
71: int unit;
72: int hdrlen;
73: int mru;
74: int debug;
75: z_stream strm;
76: struct compstat stats;
77: };
78:
79: #define DEFLATE_OVHD 2 /* Deflate overhead/packet */
80:
81: static void *z_alloc __P((void *, u_int items, u_int size));
82: static void z_free __P((void *, void *ptr));
83: static void *z_comp_alloc __P((u_char *options, int opt_len));
84: static void *z_decomp_alloc __P((u_char *options, int opt_len));
85: static void z_comp_free __P((void *state));
86: static void z_decomp_free __P((void *state));
87: static int z_comp_init __P((void *state, u_char *options, int opt_len,
88: int unit, int hdrlen, int debug));
89: static int z_decomp_init __P((void *state, u_char *options, int opt_len,
90: int unit, int hdrlen, int mru, int debug));
91: static int z_compress __P((void *state, struct mbuf **mret,
92: struct mbuf *mp, int slen, int maxolen));
93: static void z_incomp __P((void *state, struct mbuf *dmsg));
94: static int z_decompress __P((void *state, struct mbuf *cmp,
95: struct mbuf **dmpp));
96: static void z_comp_reset __P((void *state));
97: static void z_decomp_reset __P((void *state));
98: static void z_comp_stats __P((void *state, struct compstat *stats));
99:
100: /*
101: * Procedures exported to if_ppp.c.
102: */
103: struct compressor ppp_deflate = {
104: CI_DEFLATE, /* compress_proto */
105: z_comp_alloc, /* comp_alloc */
106: z_comp_free, /* comp_free */
107: z_comp_init, /* comp_init */
108: z_comp_reset, /* comp_reset */
109: z_compress, /* compress */
110: z_comp_stats, /* comp_stat */
111: z_decomp_alloc, /* decomp_alloc */
112: z_decomp_free, /* decomp_free */
113: z_decomp_init, /* decomp_init */
114: z_decomp_reset, /* decomp_reset */
115: z_decompress, /* decompress */
116: z_incomp, /* incomp */
117: z_comp_stats, /* decomp_stat */
118: };
119:
120: struct compressor ppp_deflate_draft = {
121: CI_DEFLATE_DRAFT, /* compress_proto */
122: z_comp_alloc, /* comp_alloc */
123: z_comp_free, /* comp_free */
124: z_comp_init, /* comp_init */
125: z_comp_reset, /* comp_reset */
126: z_compress, /* compress */
127: z_comp_stats, /* comp_stat */
128: z_decomp_alloc, /* decomp_alloc */
129: z_decomp_free, /* decomp_free */
130: z_decomp_init, /* decomp_init */
131: z_decomp_reset, /* decomp_reset */
132: z_decompress, /* decompress */
133: z_incomp, /* incomp */
134: z_comp_stats, /* decomp_stat */
135: };
136:
137: /*
138: * Space allocation and freeing routines for use by zlib routines.
139: */
140: void *
141: z_alloc(notused, items, size)
142: void *notused;
143: u_int items, size;
144: {
145: void *ptr;
146:
147: MALLOC(ptr, void *, items * size, M_DEVBUF, M_NOWAIT);
148: return ptr;
149: }
150:
151: void
152: z_free(notused, ptr)
153: void *notused;
154: void *ptr;
155: {
156: FREE(ptr, M_DEVBUF);
157: }
158:
159: /*
160: * Allocate space for a compressor.
161: */
162: static void *
163: z_comp_alloc(options, opt_len)
164: u_char *options;
165: int opt_len;
166: {
167: struct deflate_state *state;
168: int w_size;
169:
170: if (opt_len != CILEN_DEFLATE
171: || (options[0] != CI_DEFLATE && options[0] != CI_DEFLATE_DRAFT)
172: || options[1] != CILEN_DEFLATE
173: || DEFLATE_METHOD(options[2]) != DEFLATE_METHOD_VAL
174: || options[3] != DEFLATE_CHK_SEQUENCE)
175: return NULL;
176: w_size = DEFLATE_SIZE(options[2]);
177: if (w_size < DEFLATE_MIN_SIZE || w_size > DEFLATE_MAX_SIZE)
178: return NULL;
179:
180: MALLOC(state, struct deflate_state *, sizeof(struct deflate_state),
181: M_DEVBUF, M_NOWAIT);
182: if (state == NULL)
183: return NULL;
184:
185: state->strm.next_in = NULL;
186: state->strm.zalloc = z_alloc;
187: state->strm.zfree = z_free;
188: if (deflateInit2(&state->strm, Z_DEFAULT_COMPRESSION, DEFLATE_METHOD_VAL,
189: -w_size, 8, Z_DEFAULT_STRATEGY) != Z_OK) {
190: FREE(state, M_DEVBUF);
191: return NULL;
192: }
193:
194: state->w_size = w_size;
195: bzero(&state->stats, sizeof(state->stats));
196: return (void *) state;
197: }
198:
199: static void
200: z_comp_free(arg)
201: void *arg;
202: {
203: struct deflate_state *state = (struct deflate_state *) arg;
204:
205: deflateEnd(&state->strm);
206: FREE(state, M_DEVBUF);
207: }
208:
209: static int
210: z_comp_init(arg, options, opt_len, unit, hdrlen, debug)
211: void *arg;
212: u_char *options;
213: int opt_len, unit, hdrlen, debug;
214: {
215: struct deflate_state *state = (struct deflate_state *) arg;
216:
217: if (opt_len < CILEN_DEFLATE
218: || (options[0] != CI_DEFLATE && options[0] != CI_DEFLATE_DRAFT)
219: || options[1] != CILEN_DEFLATE
220: || DEFLATE_METHOD(options[2]) != DEFLATE_METHOD_VAL
221: || DEFLATE_SIZE(options[2]) != state->w_size
222: || options[3] != DEFLATE_CHK_SEQUENCE)
223: return 0;
224:
225: state->seqno = 0;
226: state->unit = unit;
227: state->hdrlen = hdrlen;
228: state->debug = debug;
229:
230: deflateReset(&state->strm);
231:
232: return 1;
233: }
234:
235: static void
236: z_comp_reset(arg)
237: void *arg;
238: {
239: struct deflate_state *state = (struct deflate_state *) arg;
240:
241: state->seqno = 0;
242: deflateReset(&state->strm);
243: }
244:
245: int
246: z_compress(arg, mret, mp, orig_len, maxolen)
247: void *arg;
248: struct mbuf **mret; /* compressed packet (out) */
249: struct mbuf *mp; /* uncompressed packet (in) */
250: int orig_len, maxolen;
251: {
252: struct deflate_state *state = (struct deflate_state *) arg;
253: u_char *rptr, *wptr;
254: int proto, olen, wspace, r, flush;
255: struct mbuf *m;
256:
257: /*
258: * Check that the protocol is in the range we handle.
259: */
260: rptr = mtod(mp, u_char *);
261: proto = PPP_PROTOCOL(rptr);
262: if (proto > 0x3fff || proto == 0xfd || proto == 0xfb) {
263: *mret = NULL;
264: return orig_len;
265: }
266:
267: /* Allocate one mbuf initially. */
268: if (maxolen > orig_len)
269: maxolen = orig_len;
270: MGET(m, M_DONTWAIT, MT_DATA);
271: *mret = m;
272: if (m != NULL) {
273: m->m_len = 0;
274: if (maxolen + state->hdrlen > MLEN)
275: MCLGET(m, M_DONTWAIT);
276: wspace = M_TRAILINGSPACE(m);
277: if (state->hdrlen + PPP_HDRLEN + 2 < wspace) {
278: m->m_data += state->hdrlen;
279: wspace -= state->hdrlen;
280: }
281: wptr = mtod(m, u_char *);
282:
283: /*
284: * Copy over the PPP header and store the 2-byte sequence number.
285: */
286: wptr[0] = PPP_ADDRESS(rptr);
287: wptr[1] = PPP_CONTROL(rptr);
288: wptr[2] = PPP_COMP >> 8;
289: wptr[3] = PPP_COMP;
290: wptr += PPP_HDRLEN;
291: wptr[0] = state->seqno >> 8;
292: wptr[1] = state->seqno;
293: wptr += 2;
294: state->strm.next_out = wptr;
295: state->strm.avail_out = wspace - (PPP_HDRLEN + 2);
296: } else {
297: state->strm.next_out = NULL;
298: state->strm.avail_out = 1000000;
299: wptr = NULL;
300: wspace = 0;
301: }
302: ++state->seqno;
303:
304: rptr += (proto > 0xff)? 2: 3; /* skip 1st proto byte if 0 */
305: state->strm.next_in = rptr;
306: state->strm.avail_in = mtod(mp, u_char *) + mp->m_len - rptr;
307: mp = mp->m_next;
308: flush = (mp == NULL)? Z_PACKET_FLUSH: Z_NO_FLUSH;
309: olen = 0;
310: for (;;) {
311: r = deflate(&state->strm, flush);
312: if (r != Z_OK) {
313: printf("z_compress: deflate returned %d (%s)\n",
314: r, (state->strm.msg? state->strm.msg: ""));
315: break;
316: }
317: if (flush != Z_NO_FLUSH && state->strm.avail_out != 0)
318: break; /* all done */
319: if (state->strm.avail_in == 0 && mp != NULL) {
320: state->strm.next_in = mtod(mp, u_char *);
321: state->strm.avail_in = mp->m_len;
322: mp = mp->m_next;
323: if (mp == NULL)
324: flush = Z_PACKET_FLUSH;
325: }
326: if (state->strm.avail_out == 0) {
327: if (m != NULL) {
328: m->m_len = wspace;
329: olen += wspace;
330: MGET(m->m_next, M_DONTWAIT, MT_DATA);
331: m = m->m_next;
332: if (m != NULL) {
333: m->m_len = 0;
334: if (maxolen - olen > MLEN)
335: MCLGET(m, M_DONTWAIT);
336: state->strm.next_out = mtod(m, u_char *);
337: state->strm.avail_out = wspace = M_TRAILINGSPACE(m);
338: }
339: }
340: if (m == NULL) {
341: state->strm.next_out = NULL;
342: state->strm.avail_out = 1000000;
343: }
344: }
345: }
346: if (m != NULL)
347: olen += (m->m_len = wspace - state->strm.avail_out);
348:
349: /*
350: * See if we managed to reduce the size of the packet.
351: */
352: if (m != NULL && olen < orig_len) {
353: state->stats.comp_bytes += olen;
354: state->stats.comp_packets++;
355: } else {
356: if (*mret != NULL) {
357: m_freem(*mret);
358: *mret = NULL;
359: }
360: state->stats.inc_bytes += orig_len;
361: state->stats.inc_packets++;
362: olen = orig_len;
363: }
364: state->stats.unc_bytes += orig_len;
365: state->stats.unc_packets++;
366:
367: return olen;
368: }
369:
370: static void
371: z_comp_stats(arg, stats)
372: void *arg;
373: struct compstat *stats;
374: {
375: struct deflate_state *state = (struct deflate_state *) arg;
376: u_int out;
377:
378: *stats = state->stats;
379: stats->ratio = stats->unc_bytes;
380: out = stats->comp_bytes + stats->inc_bytes;
381: if (stats->ratio <= 0x7ffffff)
382: stats->ratio <<= 8;
383: else
384: out >>= 8;
385: if (out != 0)
386: stats->ratio /= out;
387: }
388:
389: /*
390: * Allocate space for a decompressor.
391: */
392: static void *
393: z_decomp_alloc(options, opt_len)
394: u_char *options;
395: int opt_len;
396: {
397: struct deflate_state *state;
398: int w_size;
399:
400: if (opt_len != CILEN_DEFLATE
401: || (options[0] != CI_DEFLATE && options[0] != CI_DEFLATE_DRAFT)
402: || options[1] != CILEN_DEFLATE
403: || DEFLATE_METHOD(options[2]) != DEFLATE_METHOD_VAL
404: || options[3] != DEFLATE_CHK_SEQUENCE)
405: return NULL;
406: w_size = DEFLATE_SIZE(options[2]);
407: if (w_size < DEFLATE_MIN_SIZE || w_size > DEFLATE_MAX_SIZE)
408: return NULL;
409:
410: MALLOC(state, struct deflate_state *, sizeof(struct deflate_state),
411: M_DEVBUF, M_NOWAIT);
412: if (state == NULL)
413: return NULL;
414:
415: state->strm.next_out = NULL;
416: state->strm.zalloc = z_alloc;
417: state->strm.zfree = z_free;
418: if (inflateInit2(&state->strm, -w_size) != Z_OK) {
419: FREE(state, M_DEVBUF);
420: return NULL;
421: }
422:
423: state->w_size = w_size;
424: bzero(&state->stats, sizeof(state->stats));
425: return (void *) state;
426: }
427:
428: static void
429: z_decomp_free(arg)
430: void *arg;
431: {
432: struct deflate_state *state = (struct deflate_state *) arg;
433:
434: inflateEnd(&state->strm);
435: FREE(state, M_DEVBUF);
436: }
437:
438: static int
439: z_decomp_init(arg, options, opt_len, unit, hdrlen, mru, debug)
440: void *arg;
441: u_char *options;
442: int opt_len, unit, hdrlen, mru, debug;
443: {
444: struct deflate_state *state = (struct deflate_state *) arg;
445:
446: if (opt_len < CILEN_DEFLATE
447: || (options[0] != CI_DEFLATE && options[0] != CI_DEFLATE_DRAFT)
448: || options[1] != CILEN_DEFLATE
449: || DEFLATE_METHOD(options[2]) != DEFLATE_METHOD_VAL
450: || DEFLATE_SIZE(options[2]) != state->w_size
451: || options[3] != DEFLATE_CHK_SEQUENCE)
452: return 0;
453:
454: state->seqno = 0;
455: state->unit = unit;
456: state->hdrlen = hdrlen;
457: state->debug = debug;
458: state->mru = mru;
459:
460: inflateReset(&state->strm);
461:
462: return 1;
463: }
464:
465: static void
466: z_decomp_reset(arg)
467: void *arg;
468: {
469: struct deflate_state *state = (struct deflate_state *) arg;
470:
471: state->seqno = 0;
472: inflateReset(&state->strm);
473: }
474:
475: /*
476: * Decompress a Deflate-compressed packet.
477: *
478: * Because of patent problems, we return DECOMP_ERROR for errors
479: * found by inspecting the input data and for system problems, but
480: * DECOMP_FATALERROR for any errors which could possibly be said to
481: * be being detected "after" decompression. For DECOMP_ERROR,
482: * we can issue a CCP reset-request; for DECOMP_FATALERROR, we may be
483: * infringing a patent of Motorola's if we do, so we take CCP down
484: * instead.
485: *
486: * Given that the frame has the correct sequence number and a good FCS,
487: * errors such as invalid codes in the input most likely indicate a
488: * bug, so we return DECOMP_FATALERROR for them in order to turn off
489: * compression, even though they are detected by inspecting the input.
490: */
491: int
492: z_decompress(arg, mi, mop)
493: void *arg;
494: struct mbuf *mi, **mop;
495: {
496: struct deflate_state *state = (struct deflate_state *) arg;
497: struct mbuf *mo, *mo_head;
498: u_char *rptr, *wptr;
499: int rlen, olen, ospace;
500: int seq, i, flush, r, decode_proto;
501: u_char hdr[PPP_HDRLEN + DEFLATE_OVHD];
502:
503: *mop = NULL;
504: rptr = mtod(mi, u_char *);
505: rlen = mi->m_len;
506: for (i = 0; i < PPP_HDRLEN + DEFLATE_OVHD; ++i) {
507: while (rlen <= 0) {
508: mi = mi->m_next;
509: if (mi == NULL)
510: return DECOMP_ERROR;
511: rptr = mtod(mi, u_char *);
512: rlen = mi->m_len;
513: }
514: hdr[i] = *rptr++;
515: --rlen;
516: }
517:
518: /* Check the sequence number. */
519: seq = (hdr[PPP_HDRLEN] << 8) + hdr[PPP_HDRLEN+1];
520: if (seq != state->seqno) {
521: if (state->debug)
522: printf("z_decompress%d: bad seq # %d, expected %d\n",
523: state->unit, seq, state->seqno);
524: return DECOMP_ERROR;
525: }
526: ++state->seqno;
527:
528: /* Allocate an output mbuf. */
529: MGETHDR(mo, M_DONTWAIT, MT_DATA);
530: if (mo == NULL)
531: return DECOMP_ERROR;
532: mo_head = mo;
533: mo->m_len = 0;
534: mo->m_next = NULL;
535: MCLGET(mo, M_DONTWAIT);
536: ospace = M_TRAILINGSPACE(mo);
537: if (state->hdrlen + PPP_HDRLEN < ospace) {
538: mo->m_data += state->hdrlen;
539: ospace -= state->hdrlen;
540: }
541:
542: /*
543: * Fill in the first part of the PPP header. The protocol field
544: * comes from the decompressed data.
545: */
546: wptr = mtod(mo, u_char *);
547: wptr[0] = PPP_ADDRESS(hdr);
548: wptr[1] = PPP_CONTROL(hdr);
549: wptr[2] = 0;
550:
551: /*
552: * Set up to call inflate. We set avail_out to 1 initially so we can
553: * look at the first byte of the output and decide whether we have
554: * a 1-byte or 2-byte protocol field.
555: */
556: state->strm.next_in = rptr;
557: state->strm.avail_in = rlen;
558: mi = mi->m_next;
559: flush = (mi == NULL)? Z_PACKET_FLUSH: Z_NO_FLUSH;
560: rlen += PPP_HDRLEN + DEFLATE_OVHD;
561: state->strm.next_out = wptr + 3;
562: state->strm.avail_out = 1;
563: decode_proto = 1;
564: olen = PPP_HDRLEN;
565:
566: /*
567: * Call inflate, supplying more input or output as needed.
568: */
569: for (;;) {
570: r = inflate(&state->strm, flush);
571: if (r != Z_OK) {
572: #if !DEFLATE_DEBUG
573: if (state->debug)
574: #endif
575: printf("z_decompress%d: inflate returned %d (%s)\n",
576: state->unit, r, (state->strm.msg? state->strm.msg: ""));
577: m_freem(mo_head);
578: return DECOMP_FATALERROR;
579: }
580: if (flush != Z_NO_FLUSH && state->strm.avail_out != 0)
581: break; /* all done */
582: if (state->strm.avail_in == 0 && mi != NULL) {
583: state->strm.next_in = mtod(mi, u_char *);
584: state->strm.avail_in = mi->m_len;
585: rlen += mi->m_len;
586: mi = mi->m_next;
587: if (mi == NULL)
588: flush = Z_PACKET_FLUSH;
589: }
590: if (state->strm.avail_out == 0) {
591: if (decode_proto) {
592: state->strm.avail_out = ospace - PPP_HDRLEN;
593: if ((wptr[3] & 1) == 0) {
594: /* 2-byte protocol field */
595: wptr[2] = wptr[3];
596: --state->strm.next_out;
597: ++state->strm.avail_out;
598: --olen;
599: }
600: decode_proto = 0;
601: } else {
602: mo->m_len = ospace;
603: olen += ospace;
604: MGET(mo->m_next, M_DONTWAIT, MT_DATA);
605: mo = mo->m_next;
606: if (mo == NULL) {
607: m_freem(mo_head);
608: return DECOMP_ERROR;
609: }
610: MCLGET(mo, M_DONTWAIT);
611: state->strm.next_out = mtod(mo, u_char *);
612: state->strm.avail_out = ospace = M_TRAILINGSPACE(mo);
613: }
614: }
615: }
616: if (decode_proto) {
617: m_freem(mo_head);
618: return DECOMP_ERROR;
619: }
620: olen += (mo->m_len = ospace - state->strm.avail_out);
621: #if DEFLATE_DEBUG
622: if (state->debug && olen > state->mru + PPP_HDRLEN)
623: printf("ppp_deflate%d: exceeded mru (%d > %d)\n",
624: state->unit, olen, state->mru + PPP_HDRLEN);
625: #endif
626:
627: state->stats.unc_bytes += olen;
628: state->stats.unc_packets++;
629: state->stats.comp_bytes += rlen;
630: state->stats.comp_packets++;
631:
632: *mop = mo_head;
633: return DECOMP_OK;
634: }
635:
636: /*
637: * Incompressible data has arrived - add it to the history.
638: */
639: static void
640: z_incomp(arg, mi)
641: void *arg;
642: struct mbuf *mi;
643: {
644: struct deflate_state *state = (struct deflate_state *) arg;
645: u_char *rptr;
646: int rlen, proto, r;
647:
648: /*
649: * Check that the protocol is one we handle.
650: */
651: rptr = mtod(mi, u_char *);
652: proto = PPP_PROTOCOL(rptr);
653: if (proto > 0x3fff || proto == 0xfd || proto == 0xfb)
654: return;
655:
656: ++state->seqno;
657:
658: /*
659: * Iterate through the mbufs, adding the characters in them
660: * to the decompressor's history. For the first mbuf, we start
661: * at the either the 1st or 2nd byte of the protocol field,
662: * depending on whether the protocol value is compressible.
663: */
664: rlen = mi->m_len;
665: state->strm.next_in = rptr + 3;
666: state->strm.avail_in = rlen - 3;
667: if (proto > 0xff) {
668: --state->strm.next_in;
669: ++state->strm.avail_in;
670: }
671: for (;;) {
672: r = inflateIncomp(&state->strm);
673: if (r != Z_OK) {
674: /* gak! */
675: #if !DEFLATE_DEBUG
676: if (state->debug)
677: #endif
678: printf("z_incomp%d: inflateIncomp returned %d (%s)\n",
679: state->unit, r, (state->strm.msg? state->strm.msg: ""));
680: return;
681: }
682: mi = mi->m_next;
683: if (mi == NULL)
684: break;
685: state->strm.next_in = mtod(mi, u_char *);
686: state->strm.avail_in = mi->m_len;
687: rlen += mi->m_len;
688: }
689:
690: /*
691: * Update stats.
692: */
693: state->stats.inc_bytes += rlen;
694: state->stats.inc_packets++;
695: state->stats.unc_bytes += rlen;
696: state->stats.unc_packets++;
697: }
698:
699: #endif /* DO_DEFLATE */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.