bsd/net/ppp_deflate.c

101 static void	z_comp_free(void *state);
102 static void	z_decomp_free(void *state);
103 static int	z_comp_init(void *state, u_char *options, int opt_len,
105 static int	z_decomp_init(void *state, u_char *options, int opt_len,
107 static int	z_compress(void *state, struct mbuf **mret,
109 static void	z_incomp(void *state, struct mbuf *dmsg);
110 static int	z_decompress(void *state, struct mbuf *cmp, struct mbuf **dmpp);
111 static void	z_comp_reset(void *state);
112 static void	z_decomp_reset(void *state);
113 static void	z_comp_stats(void *state, struct compstat *stats);
182     struct deflate_state *state;
195     MALLOC(state, struct deflate_state *, sizeof(struct deflate_state),
197     if (state == NULL)
200     state->strm.next_in = NULL;
201     state->strm.zalloc = z_alloc;
202     state->strm.zfree = z_free;
203     if (deflateInit2(&state->strm, Z_DEFAULT_COMPRESSION, DEFLATE_METHOD_VAL,
205 	FREE(state, M_DEVBUF);
209     state->w_size = w_size;
210     bzero(&state->stats, sizeof(state->stats));
211     return (void *) state;
218     struct deflate_state *state = (struct deflate_state *) arg;
220     deflateEnd(&state->strm);
221     FREE(state, M_DEVBUF);
230     struct deflate_state *state = (struct deflate_state *) arg;
236 	|| DEFLATE_SIZE(options[2]) != state->w_size
240     state->seqno = 0;
241     state->unit = unit;
242     state->hdrlen = hdrlen;
243     state->debug = debug;
245     deflateReset(&state->strm);
254     struct deflate_state *state = (struct deflate_state *) arg;
256     state->seqno = 0;
257     deflateReset(&state->strm);
267     struct deflate_state *state = (struct deflate_state *) arg;
289 	if (maxolen + state->hdrlen > MLEN)
292 	if (state->hdrlen + PPP_HDRLEN + 2 < wspace) {
293 	    m->m_data += state->hdrlen;
294 	    wspace -= state->hdrlen;
306 	wptr[0] = state->seqno >> 8;
307 	wptr[1] = state->seqno;
309 	state->strm.next_out = wptr;
310 	state->strm.avail_out = wspace - (PPP_HDRLEN + 2);
312 	state->strm.next_out = NULL;
313 	state->strm.avail_out = 1000000;
317     ++state->seqno;
320     state->strm.next_in = rptr;
321     state->strm.avail_in = mtod(mp, u_char *) + mp->m_len - rptr;
326 	r = deflate(&state->strm, flush);
329 		   r, (state->strm.msg? state->strm.msg: ""));
332 	if (flush != Z_NO_FLUSH && state->strm.avail_out != 0)
334 	if (state->strm.avail_in == 0 && mp != NULL) {
335 	    state->strm.next_in = mtod(mp, u_char *);
336 	    state->strm.avail_in = mp->m_len;
341 	if (state->strm.avail_out == 0) {
351 		    state->strm.next_out = mtod(m, u_char *);
352 		    state->strm.avail_out = wspace = M_TRAILINGSPACE(m);
356 		state->strm.next_out = NULL;
357 		state->strm.avail_out = 1000000;
362 	olen += (m->m_len = wspace - state->strm.avail_out);
368 	state->stats.comp_bytes += olen;
369 	state->stats.comp_packets++;
375 	state->stats.inc_bytes += orig_len;
376 	state->stats.inc_packets++;
379     state->stats.unc_bytes += orig_len;
380     state->stats.unc_packets++;
390     struct deflate_state *state = (struct deflate_state *) arg;
393     *stats = state->stats;
412     struct deflate_state *state;
425     MALLOC(state, struct deflate_state *, sizeof(struct deflate_state),
427     if (state == NULL)
430     state->strm.next_out = NULL;
431     state->strm.zalloc = z_alloc;
432     state->strm.zfree = z_free;
433     if (inflateInit2(&state->strm, -w_size) != Z_OK) {
434 	FREE(state, M_DEVBUF);
438     state->w_size = w_size;
439     bzero(&state->stats, sizeof(state->stats));
440     return (void *) state;
447     struct deflate_state *state = (struct deflate_state *) arg;
449     inflateEnd(&state->strm);
450     FREE(state, M_DEVBUF);
459     struct deflate_state *state = (struct deflate_state *) arg;
465 	|| DEFLATE_SIZE(options[2]) != state->w_size
469     state->seqno = 0;
470     state->unit = unit;
471     state->hdrlen = hdrlen;
472     state->debug = debug;
473     state->mru = mru;
475     inflateReset(&state->strm);
484     struct deflate_state *state = (struct deflate_state *) arg;
486     state->seqno = 0;
487     inflateReset(&state->strm);
511     struct deflate_state *state = (struct deflate_state *) arg;
535     if (seq != state->seqno) {
536 	if (state->debug)
538 		   state->unit, seq, state->seqno);
541     ++state->seqno;
552     if (state->hdrlen + PPP_HDRLEN < ospace) {
553 	mo->m_data += state->hdrlen;
554 	ospace -= state->hdrlen;
574     state->strm.next_in = rptr;
575     state->strm.avail_in = rlen;
579     state->strm.next_out = wptr + 3;
580     state->strm.avail_out = 1;
588 	r = inflate(&state->strm, flush);
591 	    if (state->debug)
594 		       state->unit, r, (state->strm.msg? state->strm.msg: ""));
598 	if (flush != Z_NO_FLUSH && state->strm.avail_out != 0)
600 	if (state->strm.avail_in == 0 && mi != NULL) {
601 	    state->strm.next_in = mtod(mi, u_char *);
602 	    state->strm.avail_in = mi->m_len;
608 	if (state->strm.avail_out == 0) {
610 		state->strm.avail_out = ospace - PPP_HDRLEN;
614 		    --state->strm.next_out;
615 		    ++state->strm.avail_out;
629 		state->strm.next_out = mtod(mo, u_char *);
630 		state->strm.avail_out = ospace = M_TRAILINGSPACE(mo);
638     olen += (mo->m_len = ospace - state->strm.avail_out);
640     if (state->debug && olen > state->mru + PPP_HDRLEN)
642 	       state->unit, olen, state->mru + PPP_HDRLEN);
645     state->stats.unc_bytes += olen;
646     state->stats.unc_packets++;
647     state->stats.comp_bytes += rlen;
648     state->stats.comp_packets++;
662     struct deflate_state *state = (struct deflate_state *) arg;
674     ++state->seqno;
683     state->strm.next_in = rptr + 3;
684     state->strm.avail_in = rlen - 3;
686 	--state->strm.next_in;
687 	++state->strm.avail_in;
690 	r = inflateIncomp(&state->strm);
694 	    if (state->debug)
697 		       state->unit, r, (state->strm.msg? state->strm.msg: ""));
703 	state->strm.next_in = mtod(mi, u_char *);
704 	state->strm.avail_in = mi->m_len;
711     state->stats.inc_bytes += rlen;
712     state->stats.inc_packets++;
713     state->stats.unc_bytes += rlen;
714     state->stats.unc_packets++;