X-Git-Url: http://git.ozlabs.org/?p=ppp.git;a=blobdiff_plain;f=ultrix%2Fppp-deflate.c;h=8c1a7211ba88ea66d292dbb1a7d7ea8b1eb9a334;hp=c6e62990b3d370d00bcf483be347c0dd6a6a57fa;hb=ae57a37fb6a716dddff877efde7c82a61f254c98;hpb=c5871dbfa014bb554c101e65150c48fc8ba80c7b diff --git a/ultrix/ppp-deflate.c b/ultrix/ppp-deflate.c index c6e6299..8c1a721 100644 --- a/ultrix/ppp-deflate.c +++ b/ultrix/ppp-deflate.c @@ -1,32 +1,40 @@ -/* $Id: ppp-deflate.c,v 1.1 1996/07/01 01:24:27 paulus Exp $ */ +/* $Id: ppp-deflate.c,v 1.6 2002/12/06 09:49:16 paulus Exp $ */ /* * ppp_deflate.c - interface the zlib procedures for Deflate compression * and decompression (as used by gzip) to the PPP code. * This version is for use with mbufs on BSD-derived systems. * - * Copyright (c) 1994 The Australian National University. - * All rights reserved. + * Copyright (c) 1994 Paul Mackerras. All rights reserved. * - * Permission to use, copy, modify, and distribute this software and its - * documentation is hereby granted, provided that the above copyright - * notice appears in all copies. This software is provided without any - * warranty, express or implied. The Australian National University - * makes no representations about the suitability of this software for - * any purpose. + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: * - * IN NO EVENT SHALL THE AUSTRALIAN NATIONAL UNIVERSITY BE LIABLE TO ANY - * PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES - * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF - * THE AUSTRALIAN NATIONAL UNIVERSITY HAS BEEN ADVISED OF THE POSSIBILITY - * OF SUCH DAMAGE. + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. * - * THE AUSTRALIAN NATIONAL UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES, - * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY - * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS - * ON AN "AS IS" BASIS, AND THE AUSTRALIAN NATIONAL UNIVERSITY HAS NO - * OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, - * OR MODIFICATIONS. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * 3. The name(s) of the authors of this software must not be used to + * endorse or promote products derived from this software without + * prior written permission. + * + * 4. Redistributions of any form whatsoever must retain the following + * acknowledgment: + * "This product includes software developed by Paul Mackerras + * ". + * + * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO + * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY + * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING + * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ #include "../h/param.h" @@ -59,7 +67,7 @@ struct deflate_state { #define DEFLATE_OVHD 2 /* Deflate overhead/packet */ static void *zalloc __P((void *, u_int items, u_int size)); -static void zfree __P((void *, void *ptr, u_int nb)); +static void zfree __P((void *, void *ptr)); static void *z_comp_alloc __P((u_char *options, int opt_len)); static void *z_decomp_alloc __P((u_char *options, int opt_len)); static void z_comp_free __P((void *state)); @@ -97,6 +105,32 @@ struct compressor ppp_deflate = { z_comp_stats, /* decomp_stat */ }; +struct compressor ppp_deflate_draft = { + CI_DEFLATE_DRAFT, /* compress_proto */ + z_comp_alloc, /* comp_alloc */ + z_comp_free, /* comp_free */ + z_comp_init, /* comp_init */ + z_comp_reset, /* comp_reset */ + z_compress, /* compress */ + z_comp_stats, /* comp_stat */ + z_decomp_alloc, /* decomp_alloc */ + z_decomp_free, /* decomp_free */ + z_decomp_init, /* decomp_init */ + z_decomp_reset, /* decomp_reset */ + z_decompress, /* decompress */ + z_incomp, /* incomp */ + z_comp_stats, /* decomp_stat */ +}; + +/* + * Some useful mbuf macros not in mbuf.h. + */ +#define M_IS_CLUSTER(m) ((m)->m_off > MMAXOFF) + +#define M_TRAILINGSPACE(m) \ + ((M_IS_CLUSTER(m) ? (u_int)(m)->m_clptr + M_CLUSTERSZ : MSIZE) \ + - ((m)->m_off + (m)->m_len)) + /* * Space allocation and freeing routines for use by zlib routines. */ @@ -112,10 +146,9 @@ zalloc(notused, items, size) } void -zfree(notused, ptr, nbytes) +zfree(notused, ptr) void *notused; void *ptr; - u_int nbytes; { KM_FREE(ptr, KM_DEVBUF); } @@ -131,7 +164,8 @@ z_comp_alloc(options, opt_len) struct deflate_state *state; int w_size; - if (opt_len != CILEN_DEFLATE || options[0] != CI_DEFLATE + if (opt_len != CILEN_DEFLATE + || (options[0] != CI_DEFLATE && options[0] != CI_DEFLATE_DRAFT) || options[1] != CILEN_DEFLATE || DEFLATE_METHOD(options[2]) != DEFLATE_METHOD_VAL || options[3] != DEFLATE_CHK_SEQUENCE) @@ -140,17 +174,18 @@ z_comp_alloc(options, opt_len) if (w_size < DEFLATE_MIN_SIZE || w_size > DEFLATE_MAX_SIZE) return NULL; - MALLOC(state, struct deflate_state *, sizeof(struct deflate_state), - M_DEVBUF, M_NOWAIT); + KM_ALLOC(state, struct deflate_state *, sizeof(struct deflate_state), + KM_DEVBUF, KM_NOARG); if (state == NULL) return NULL; + bzero(state, sizeof(struct deflate_state)); state->strm.next_in = NULL; - state->strm.zalloc = zalloc; - state->strm.zfree = zfree; + state->strm.zalloc = (alloc_func) zalloc; + state->strm.zfree = (free_func) zfree; if (deflateInit2(&state->strm, Z_DEFAULT_COMPRESSION, DEFLATE_METHOD_VAL, - -w_size, 8, Z_DEFAULT_STRATEGY, DEFLATE_OVHD+2) != Z_OK) { - FREE(state, M_DEVBUF); + -w_size, 8, Z_DEFAULT_STRATEGY) != Z_OK) { + KM_FREE(state, KM_DEVBUF); return NULL; } @@ -166,7 +201,7 @@ z_comp_free(arg) struct deflate_state *state = (struct deflate_state *) arg; deflateEnd(&state->strm); - FREE(state, M_DEVBUF); + KM_FREE(state, KM_DEVBUF); } static int @@ -177,7 +212,8 @@ z_comp_init(arg, options, opt_len, unit, hdrlen, debug) { struct deflate_state *state = (struct deflate_state *) arg; - if (opt_len < CILEN_DEFLATE || options[0] != CI_DEFLATE + if (opt_len < CILEN_DEFLATE + || (options[0] != CI_DEFLATE && options[0] != CI_DEFLATE_DRAFT) || options[1] != CILEN_DEFLATE || DEFLATE_METHOD(options[2]) != DEFLATE_METHOD_VAL || DEFLATE_SIZE(options[2]) != state->w_size @@ -214,7 +250,7 @@ z_compress(arg, mret, mp, orig_len, maxolen) struct deflate_state *state = (struct deflate_state *) arg; u_char *rptr, *wptr; int proto, olen, wspace, r, flush; - struct mbuf *m; + struct mbuf *m, *clp; /* * Check that the protocol is in the range we handle. @@ -232,12 +268,14 @@ z_compress(arg, mret, mp, orig_len, maxolen) MGET(m, M_DONTWAIT, MT_DATA); *mret = m; if (m != NULL) { + if (maxolen + state->hdrlen > MLEN) { + /* MCLGET is not a single statement!!! */ + MCLGET(m, clp) + } m->m_len = 0; - if (maxolen + state->hdrlen > MLEN) - MCLGET(m, M_DONTWAIT); wspace = M_TRAILINGSPACE(m); - if (state->hdrlen + PPP_HDRLEN + 2 < wspace) { - m->m_data += state->hdrlen; + if (state->hdrlen > 0 && state->hdrlen + PPP_HDRLEN + 2 < wspace) { + m->m_off += state->hdrlen; wspace -= state->hdrlen; } wptr = mtod(m, u_char *); @@ -292,9 +330,10 @@ z_compress(arg, mret, mp, orig_len, maxolen) MGET(m->m_next, M_DONTWAIT, MT_DATA); m = m->m_next; if (m != NULL) { + if (maxolen - olen > MLEN) { + MCLGET(m, clp) + } m->m_len = 0; - if (maxolen - olen > MLEN) - MCLGET(m, M_DONTWAIT); state->strm.next_out = mtod(m, u_char *); state->strm.avail_out = wspace = M_TRAILINGSPACE(m); } @@ -362,7 +401,8 @@ z_decomp_alloc(options, opt_len) struct deflate_state *state; int w_size; - if (opt_len != CILEN_DEFLATE || options[0] != CI_DEFLATE + if (opt_len != CILEN_DEFLATE + || (options[0] != CI_DEFLATE && options[0] != CI_DEFLATE_DRAFT) || options[1] != CILEN_DEFLATE || DEFLATE_METHOD(options[2]) != DEFLATE_METHOD_VAL || options[3] != DEFLATE_CHK_SEQUENCE) @@ -371,16 +411,17 @@ z_decomp_alloc(options, opt_len) if (w_size < DEFLATE_MIN_SIZE || w_size > DEFLATE_MAX_SIZE) return NULL; - MALLOC(state, struct deflate_state *, sizeof(struct deflate_state), - M_DEVBUF, M_NOWAIT); + KM_ALLOC(state, struct deflate_state *, sizeof(struct deflate_state), + KM_DEVBUF, KM_NOARG); if (state == NULL) return NULL; + bzero(state, sizeof(struct deflate_state)); state->strm.next_out = NULL; - state->strm.zalloc = zalloc; - state->strm.zfree = zfree; + state->strm.zalloc = (alloc_func) zalloc; + state->strm.zfree = (free_func) zfree; if (inflateInit2(&state->strm, -w_size) != Z_OK) { - FREE(state, M_DEVBUF); + KM_FREE(state, KM_DEVBUF); return NULL; } @@ -396,7 +437,7 @@ z_decomp_free(arg) struct deflate_state *state = (struct deflate_state *) arg; inflateEnd(&state->strm); - FREE(state, M_DEVBUF); + KM_FREE(state, KM_DEVBUF); } static int @@ -407,7 +448,8 @@ z_decomp_init(arg, options, opt_len, unit, hdrlen, mru, debug) { struct deflate_state *state = (struct deflate_state *) arg; - if (opt_len < CILEN_DEFLATE || options[0] != CI_DEFLATE + if (opt_len < CILEN_DEFLATE + || (options[0] != CI_DEFLATE && options[0] != CI_DEFLATE_DRAFT) || options[1] != CILEN_DEFLATE || DEFLATE_METHOD(options[2]) != DEFLATE_METHOD_VAL || DEFLATE_SIZE(options[2]) != state->w_size @@ -457,7 +499,7 @@ z_decompress(arg, mi, mop) struct mbuf *mi, **mop; { struct deflate_state *state = (struct deflate_state *) arg; - struct mbuf *mo, *mo_head; + struct mbuf *mo, *mo_head, *clp; u_char *rptr, *wptr; int rlen, olen, ospace; int seq, i, flush, r, decode_proto; @@ -489,16 +531,16 @@ z_decompress(arg, mi, mop) ++state->seqno; /* Allocate an output mbuf. */ - MGETHDR(mo, M_DONTWAIT, MT_DATA); + MGET(mo, M_DONTWAIT, MT_DATA); if (mo == NULL) return DECOMP_ERROR; mo_head = mo; - mo->m_len = 0; mo->m_next = NULL; - MCLGET(mo, M_DONTWAIT); + MCLGET(mo, clp) + mo->m_len = 0; ospace = M_TRAILINGSPACE(mo); - if (state->hdrlen + PPP_HDRLEN < ospace) { - mo->m_data += state->hdrlen; + if (state->hdrlen > 0 && state->hdrlen + PPP_HDRLEN < ospace) { + mo->m_off += state->hdrlen; ospace -= state->hdrlen; } @@ -568,7 +610,8 @@ z_decompress(arg, mi, mop) m_freem(mo_head); return DECOMP_ERROR; } - MCLGET(mo, M_DONTWAIT); + MCLGET(mo, clp) + mo->m_len = 0; state->strm.next_out = mtod(mo, u_char *); state->strm.avail_out = ospace = M_TRAILINGSPACE(mo); }