xref: /freebsd/sys/netgraph/ng_deflate.c (revision 148a8da8) 
1 /*-
2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3  *
4  * Copyright (c) 2006 Alexander Motin <mav@alkar.net>
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice unmodified, this list of conditions, and the following
12  *    disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27  * SUCH DAMAGE.
28  *
29  * $FreeBSD$
30  */
31 
32 /*
33  * Deflate PPP compression netgraph node type.
34  */
35 
36 #include <sys/param.h>
37 #include <sys/systm.h>
38 #include <sys/kernel.h>
39 #include <sys/mbuf.h>
40 #include <sys/malloc.h>
41 #include <sys/endian.h>
42 #include <sys/errno.h>
43 #include <sys/syslog.h>
44 #include <sys/zlib.h>
45 
46 #include <netgraph/ng_message.h>
47 #include <netgraph/netgraph.h>
48 #include <netgraph/ng_parse.h>
49 #include <netgraph/ng_deflate.h>
50 
51 #include "opt_netgraph.h"
52 
53 static MALLOC_DEFINE(M_NETGRAPH_DEFLATE, "netgraph_deflate",
54     "netgraph deflate node");
55 
56 /* DEFLATE header length */
57 #define DEFLATE_HDRLEN		2
58 
59 #define PROT_COMPD		0x00fd
60 
61 #define DEFLATE_BUF_SIZE	4096
62 
63 /* Node private data */
64 struct ng_deflate_private {
65 	struct ng_deflate_config cfg;		/* configuration */
66 	u_char		inbuf[DEFLATE_BUF_SIZE];	/* input buffer */
67 	u_char		outbuf[DEFLATE_BUF_SIZE];	/* output buffer */
68 	z_stream 	cx;			/* compression context */
69 	struct ng_deflate_stats stats;		/* statistics */
70 	ng_ID_t		ctrlnode;		/* path to controlling node */
71 	uint16_t	seqnum;			/* sequence number */
72 	u_char		compress;		/* compress/decompress flag */
73 };
74 typedef struct ng_deflate_private *priv_p;
75 
76 /* Netgraph node methods */
77 static ng_constructor_t	ng_deflate_constructor;
78 static ng_rcvmsg_t	ng_deflate_rcvmsg;
79 static ng_shutdown_t	ng_deflate_shutdown;
80 static ng_newhook_t	ng_deflate_newhook;
81 static ng_rcvdata_t	ng_deflate_rcvdata;
82 static ng_disconnect_t	ng_deflate_disconnect;
83 
84 /* Helper functions */
85 static void	*z_alloc(void *, u_int items, u_int size);
86 static void	z_free(void *, void *ptr);
87 static int	ng_deflate_compress(node_p node,
88 		    struct mbuf *m, struct mbuf **resultp);
89 static int	ng_deflate_decompress(node_p node,
90 		    struct mbuf *m, struct mbuf **resultp);
91 static void	ng_deflate_reset_req(node_p node);
92 
93 /* Parse type for struct ng_deflate_config. */
94 static const struct ng_parse_struct_field ng_deflate_config_type_fields[]
95 	= NG_DEFLATE_CONFIG_INFO;
96 static const struct ng_parse_type ng_deflate_config_type = {
97 	&ng_parse_struct_type,
98 	ng_deflate_config_type_fields
99 };
100 
101 /* Parse type for struct ng_deflate_stat. */
102 static const struct ng_parse_struct_field ng_deflate_stats_type_fields[]
103 	= NG_DEFLATE_STATS_INFO;
104 static const struct ng_parse_type ng_deflate_stat_type = {
105 	&ng_parse_struct_type,
106 	ng_deflate_stats_type_fields
107 };
108 
109 /* List of commands and how to convert arguments to/from ASCII. */
110 static const struct ng_cmdlist ng_deflate_cmds[] = {
111 	{
112 	  NGM_DEFLATE_COOKIE,
113 	  NGM_DEFLATE_CONFIG,
114 	  "config",
115 	  &ng_deflate_config_type,
116 	  NULL
117 	},
118 	{
119 	  NGM_DEFLATE_COOKIE,
120 	  NGM_DEFLATE_RESETREQ,
121 	  "resetreq",
122 	  NULL,
123 	  NULL
124 	},
125 	{
126 	  NGM_DEFLATE_COOKIE,
127 	  NGM_DEFLATE_GET_STATS,
128 	  "getstats",
129 	  NULL,
130 	  &ng_deflate_stat_type
131 	},
132 	{
133 	  NGM_DEFLATE_COOKIE,
134 	  NGM_DEFLATE_CLR_STATS,
135 	  "clrstats",
136 	  NULL,
137 	  NULL
138 	},
139 	{
140 	  NGM_DEFLATE_COOKIE,
141 	  NGM_DEFLATE_GETCLR_STATS,
142 	  "getclrstats",
143 	  NULL,
144 	  &ng_deflate_stat_type
145 	},
146 	{ 0 }
147 };
148 
149 /* Node type descriptor */
150 static struct ng_type ng_deflate_typestruct = {
151 	.version =	NG_ABI_VERSION,
152 	.name =		NG_DEFLATE_NODE_TYPE,
153 	.constructor =	ng_deflate_constructor,
154 	.rcvmsg =	ng_deflate_rcvmsg,
155 	.shutdown =	ng_deflate_shutdown,
156 	.newhook =	ng_deflate_newhook,
157 	.rcvdata =	ng_deflate_rcvdata,
158 	.disconnect =	ng_deflate_disconnect,
159 	.cmdlist =	ng_deflate_cmds,
160 };
161 NETGRAPH_INIT(deflate, &ng_deflate_typestruct);
162 
163 /* Depend on separate zlib module. */
164 MODULE_DEPEND(ng_deflate, zlib, 1, 1, 1);
165 
166 #define ERROUT(x)	do { error = (x); goto done; } while (0)
167 
168 /************************************************************************
169 			NETGRAPH NODE STUFF
170  ************************************************************************/
171 
172 /*
173  * Node type constructor
174  */
175 static int
176 ng_deflate_constructor(node_p node)
177 {
178 	priv_p priv;
179 
180 	/* Allocate private structure. */
181 	priv = malloc(sizeof(*priv), M_NETGRAPH_DEFLATE, M_WAITOK | M_ZERO);
182 
183 	NG_NODE_SET_PRIVATE(node, priv);
184 
185 	/* This node is not thread safe. */
186 	NG_NODE_FORCE_WRITER(node);
187 
188 	/* Done */
189 	return (0);
190 }
191 
192 /*
193  * Give our OK for a hook to be added.
194  */
195 static int
196 ng_deflate_newhook(node_p node, hook_p hook, const char *name)
197 {
198 	const priv_p priv = NG_NODE_PRIVATE(node);
199 
200 	if (NG_NODE_NUMHOOKS(node) > 0)
201 		return (EINVAL);
202 
203 	if (strcmp(name, NG_DEFLATE_HOOK_COMP) == 0)
204 		priv->compress = 1;
205 	else if (strcmp(name, NG_DEFLATE_HOOK_DECOMP) == 0)
206 		priv->compress = 0;
207 	else
208 		return (EINVAL);
209 
210 	return (0);
211 }
212 
213 /*
214  * Receive a control message
215  */
216 static int
217 ng_deflate_rcvmsg(node_p node, item_p item, hook_p lasthook)
218 {
219 	const priv_p priv = NG_NODE_PRIVATE(node);
220 	struct ng_mesg *resp = NULL;
221 	int error = 0;
222 	struct ng_mesg *msg;
223 
224 	NGI_GET_MSG(item, msg);
225 
226 	if (msg->header.typecookie != NGM_DEFLATE_COOKIE)
227 		ERROUT(EINVAL);
228 
229 	switch (msg->header.cmd) {
230 	case NGM_DEFLATE_CONFIG:
231 	    {
232 		struct ng_deflate_config *const cfg
233 		    = (struct ng_deflate_config *)msg->data;
234 
235 		/* Check configuration. */
236 		if (msg->header.arglen != sizeof(*cfg))
237 			ERROUT(EINVAL);
238 		if (cfg->enable) {
239 		    if (cfg->windowBits < 8 || cfg->windowBits > 15)
240 			ERROUT(EINVAL);
241 		} else
242 		    cfg->windowBits = 0;
243 
244 		/* Clear previous state. */
245 		if (priv->cfg.enable) {
246 			if (priv->compress)
247 				deflateEnd(&priv->cx);
248 			else
249 				inflateEnd(&priv->cx);
250 			priv->cfg.enable = 0;
251 		}
252 
253 		/* Configuration is OK, reset to it. */
254 		priv->cfg = *cfg;
255 
256 		if (priv->cfg.enable) {
257 			priv->cx.next_in = NULL;
258 			priv->cx.zalloc = z_alloc;
259 			priv->cx.zfree = z_free;
260 			int res;
261 			if (priv->compress) {
262 				if ((res = deflateInit2(&priv->cx,
263 				    Z_DEFAULT_COMPRESSION, Z_DEFLATED,
264 				    -cfg->windowBits, 8,
265 				    Z_DEFAULT_STRATEGY)) != Z_OK) {
266 					log(LOG_NOTICE,
267 					    "deflateInit2: error %d, %s\n",
268 					    res, priv->cx.msg);
269 					priv->cfg.enable = 0;
270 					ERROUT(ENOMEM);
271 				}
272 			} else {
273 				if ((res = inflateInit2(&priv->cx,
274 				    -cfg->windowBits)) != Z_OK) {
275 					log(LOG_NOTICE,
276 					    "inflateInit2: error %d, %s\n",
277 					    res, priv->cx.msg);
278 					priv->cfg.enable = 0;
279 					ERROUT(ENOMEM);
280 				}
281 			}
282 		}
283 
284 		/* Initialize other state. */
285 		priv->seqnum = 0;
286 
287 		/* Save return address so we can send reset-req's */
288 		priv->ctrlnode = NGI_RETADDR(item);
289 		break;
290 	    }
291 
292 	case NGM_DEFLATE_RESETREQ:
293 		ng_deflate_reset_req(node);
294 		break;
295 
296 	case NGM_DEFLATE_GET_STATS:
297 	case NGM_DEFLATE_CLR_STATS:
298 	case NGM_DEFLATE_GETCLR_STATS:
299 		/* Create response if requested. */
300 		if (msg->header.cmd != NGM_DEFLATE_CLR_STATS) {
301 			NG_MKRESPONSE(resp, msg,
302 			    sizeof(struct ng_deflate_stats), M_NOWAIT);
303 			if (resp == NULL)
304 				ERROUT(ENOMEM);
305 			bcopy(&priv->stats, resp->data,
306 			    sizeof(struct ng_deflate_stats));
307 		}
308 
309 		/* Clear stats if requested. */
310 		if (msg->header.cmd != NGM_DEFLATE_GET_STATS)
311 			bzero(&priv->stats,
312 			    sizeof(struct ng_deflate_stats));
313 		break;
314 
315 	default:
316 		error = EINVAL;
317 		break;
318 	}
319 done:
320 	NG_RESPOND_MSG(error, node, item, resp);
321 	NG_FREE_MSG(msg);
322 	return (error);
323 }
324 
325 /*
326  * Receive incoming data on our hook.
327  */
328 static int
329 ng_deflate_rcvdata(hook_p hook, item_p item)
330 {
331 	const node_p node = NG_HOOK_NODE(hook);
332 	const priv_p priv = NG_NODE_PRIVATE(node);
333 	struct mbuf *m, *out;
334 	int error;
335 
336 	if (!priv->cfg.enable) {
337 		NG_FREE_ITEM(item);
338 		return (ENXIO);
339 	}
340 
341 	NGI_GET_M(item, m);
342 	/* Compress */
343 	if (priv->compress) {
344 		if ((error = ng_deflate_compress(node, m, &out)) != 0) {
345 			NG_FREE_ITEM(item);
346 			log(LOG_NOTICE, "%s: error: %d\n", __func__, error);
347 			return (error);
348 		}
349 
350 	} else { /* Decompress */
351 		if ((error = ng_deflate_decompress(node, m, &out)) != 0) {
352 			NG_FREE_ITEM(item);
353 			log(LOG_NOTICE, "%s: error: %d\n", __func__, error);
354 			if (priv->ctrlnode != 0) {
355 				struct ng_mesg *msg;
356 
357 				/* Need to send a reset-request. */
358 				NG_MKMESSAGE(msg, NGM_DEFLATE_COOKIE,
359 				    NGM_DEFLATE_RESETREQ, 0, M_NOWAIT);
360 				if (msg == NULL)
361 					return (error);
362 				NG_SEND_MSG_ID(error, node, msg,
363 					priv->ctrlnode, 0);
364 			}
365 			return (error);
366 		}
367 	}
368 
369 	NG_FWD_NEW_DATA(error, item, hook, out);
370 	return (error);
371 }
372 
373 /*
374  * Destroy node.
375  */
376 static int
377 ng_deflate_shutdown(node_p node)
378 {
379 	const priv_p priv = NG_NODE_PRIVATE(node);
380 
381 	/* Take down netgraph node. */
382 	if (priv->cfg.enable) {
383 	    if (priv->compress)
384 		deflateEnd(&priv->cx);
385 	    else
386 		inflateEnd(&priv->cx);
387 	}
388 
389 	free(priv, M_NETGRAPH_DEFLATE);
390 	NG_NODE_SET_PRIVATE(node, NULL);
391 	NG_NODE_UNREF(node);		/* let the node escape */
392 	return (0);
393 }
394 
395 /*
396  * Hook disconnection
397  */
398 static int
399 ng_deflate_disconnect(hook_p hook)
400 {
401 	const node_p node = NG_HOOK_NODE(hook);
402 	const priv_p priv = NG_NODE_PRIVATE(node);
403 
404 	if (priv->cfg.enable) {
405 	    if (priv->compress)
406 		deflateEnd(&priv->cx);
407 	    else
408 		inflateEnd(&priv->cx);
409 	    priv->cfg.enable = 0;
410 	}
411 
412 	/* Go away if no longer connected. */
413 	if ((NG_NODE_NUMHOOKS(node) == 0) && NG_NODE_IS_VALID(node))
414 		ng_rmnode_self(node);
415 	return (0);
416 }
417 
418 /************************************************************************
419 			HELPER STUFF
420  ************************************************************************/
421 
422 /*
423  * Space allocation and freeing routines for use by zlib routines.
424  */
425 
426 static void *
427 z_alloc(void *notused, u_int items, u_int size)
428 {
429 
430 	return (malloc(items * size, M_NETGRAPH_DEFLATE, M_NOWAIT));
431 }
432 
433 static void
434 z_free(void *notused, void *ptr)
435 {
436 
437 	free(ptr, M_NETGRAPH_DEFLATE);
438 }
439 
440 /*
441  * Compress/encrypt a packet and put the result in a new mbuf at *resultp.
442  * The original mbuf is not free'd.
443  */
444 static int
445 ng_deflate_compress(node_p node, struct mbuf *m, struct mbuf **resultp)
446 {
447 	const priv_p 	priv = NG_NODE_PRIVATE(node);
448 	int 		outlen, inlen;
449 	int 		rtn;
450 
451 	/* Initialize. */
452 	*resultp = NULL;
453 
454 	inlen = m->m_pkthdr.len;
455 
456 	priv->stats.FramesPlain++;
457 	priv->stats.InOctets+=inlen;
458 
459 	if (inlen > DEFLATE_BUF_SIZE) {
460 		priv->stats.Errors++;
461 		NG_FREE_M(m);
462 		return (ENOMEM);
463 	}
464 
465 	/* We must own the mbuf chain exclusively to modify it. */
466 	m = m_unshare(m, M_NOWAIT);
467 	if (m == NULL) {
468 		priv->stats.Errors++;
469 		return (ENOMEM);
470 	}
471 
472 	/* Work with contiguous regions of memory. */
473 	m_copydata(m, 0, inlen, (caddr_t)priv->inbuf);
474 	outlen = DEFLATE_BUF_SIZE;
475 
476 	/* Compress "inbuf" into "outbuf". */
477 	/* Prepare to compress. */
478 	if (priv->inbuf[0] != 0) {
479 		priv->cx.next_in = priv->inbuf;
480 		priv->cx.avail_in = inlen;
481 	} else {
482 		priv->cx.next_in = priv->inbuf + 1; /* compress protocol */
483 		priv->cx.avail_in = inlen - 1;
484 	}
485 	priv->cx.next_out = priv->outbuf + 2 + DEFLATE_HDRLEN;
486 	priv->cx.avail_out = outlen - 2 - DEFLATE_HDRLEN;
487 
488 	/* Compress. */
489 	rtn = deflate(&priv->cx, Z_PACKET_FLUSH);
490 
491 	/* Check return value. */
492 	if (rtn != Z_OK) {
493 		priv->stats.Errors++;
494 		log(LOG_NOTICE, "ng_deflate: compression error: %d (%s)\n",
495 		    rtn, priv->cx.msg);
496 		NG_FREE_M(m);
497 		return (EINVAL);
498 	}
499 
500 	/* Calculate resulting size. */
501 	outlen -= priv->cx.avail_out;
502 
503 	/* If we can't compress this packet, send it as-is. */
504 	if (outlen > inlen) {
505 		/* Return original packet uncompressed. */
506 		*resultp = m;
507 		priv->stats.FramesUncomp++;
508 		priv->stats.OutOctets+=inlen;
509 	} else {
510 		/* Install header. */
511 		be16enc(priv->outbuf, PROT_COMPD);
512 		be16enc(priv->outbuf + 2, priv->seqnum);
513 
514 		/* Return packet in an mbuf. */
515 		m_copyback(m, 0, outlen, (caddr_t)priv->outbuf);
516 		if (m->m_pkthdr.len < outlen) {
517 			m_freem(m);
518 			priv->stats.Errors++;
519 			return (ENOMEM);
520 		} else if (outlen < m->m_pkthdr.len)
521 			m_adj(m, outlen - m->m_pkthdr.len);
522 		*resultp = m;
523 		priv->stats.FramesComp++;
524 		priv->stats.OutOctets+=outlen;
525 	}
526 
527 	/* Update sequence number. */
528 	priv->seqnum++;
529 
530 	return (0);
531 }
532 
533 /*
534  * Decompress/decrypt packet and put the result in a new mbuf at *resultp.
535  * The original mbuf is not free'd.
536  */
537 static int
538 ng_deflate_decompress(node_p node, struct mbuf *m, struct mbuf **resultp)
539 {
540 	const priv_p 	priv = NG_NODE_PRIVATE(node);
541 	int 		outlen, inlen;
542 	int 		rtn;
543 	uint16_t	proto;
544 	int		offset;
545 	uint16_t	rseqnum;
546 
547 	/* Initialize. */
548 	*resultp = NULL;
549 
550 	inlen = m->m_pkthdr.len;
551 
552 	if (inlen > DEFLATE_BUF_SIZE) {
553 		priv->stats.Errors++;
554 		NG_FREE_M(m);
555 		priv->seqnum = 0;
556 		return (ENOMEM);
557 	}
558 
559 	/* We must own the mbuf chain exclusively to modify it. */
560 	m = m_unshare(m, M_NOWAIT);
561 	if (m == NULL) {
562 		priv->stats.Errors++;
563 		return (ENOMEM);
564 	}
565 
566 	/* Work with contiguous regions of memory. */
567 	m_copydata(m, 0, inlen, (caddr_t)priv->inbuf);
568 
569 	/* Separate proto. */
570 	if ((priv->inbuf[0] & 0x01) != 0) {
571 		proto = priv->inbuf[0];
572 		offset = 1;
573 	} else {
574 		proto = be16dec(priv->inbuf);
575 		offset = 2;
576 	}
577 
578 	priv->stats.InOctets += inlen;
579 
580 	/* Packet is compressed, so decompress. */
581 	if (proto == PROT_COMPD) {
582 		priv->stats.FramesComp++;
583 
584 		/* Check sequence number. */
585 		rseqnum = be16dec(priv->inbuf + offset);
586 		offset += 2;
587 		if (rseqnum != priv->seqnum) {
588 			priv->stats.Errors++;
589 			log(LOG_NOTICE, "ng_deflate: wrong sequence: %u "
590 			    "instead of %u\n", rseqnum, priv->seqnum);
591 			NG_FREE_M(m);
592 			priv->seqnum = 0;
593 			return (EPIPE);
594 		}
595 
596 		outlen = DEFLATE_BUF_SIZE;
597 
598     		/* Decompress "inbuf" into "outbuf". */
599 		/* Prepare to decompress. */
600 		priv->cx.next_in = priv->inbuf + offset;
601 		priv->cx.avail_in = inlen - offset;
602 		/* Reserve space for protocol decompression. */
603 		priv->cx.next_out = priv->outbuf + 1;
604 		priv->cx.avail_out = outlen - 1;
605 
606 		/* Decompress. */
607 		rtn = inflate(&priv->cx, Z_PACKET_FLUSH);
608 
609 		/* Check return value. */
610 		if (rtn != Z_OK && rtn != Z_STREAM_END) {
611 			priv->stats.Errors++;
612 			NG_FREE_M(m);
613 			priv->seqnum = 0;
614 			log(LOG_NOTICE, "%s: decompression error: %d (%s)\n",
615 			    __func__, rtn, priv->cx.msg);
616 
617 			switch (rtn) {
618 			case Z_MEM_ERROR:
619 				return (ENOMEM);
620 			case Z_DATA_ERROR:
621 				return (EIO);
622 			default:
623 				return (EINVAL);
624 			}
625 		}
626 
627 		/* Calculate resulting size. */
628 		outlen -= priv->cx.avail_out;
629 
630 		/* Decompress protocol. */
631 		if ((priv->outbuf[1] & 0x01) != 0) {
632 			priv->outbuf[0] = 0;
633 			/* Return packet in an mbuf. */
634 			m_copyback(m, 0, outlen, (caddr_t)priv->outbuf);
635 		} else {
636 			outlen--;
637 			/* Return packet in an mbuf. */
638 			m_copyback(m, 0, outlen, (caddr_t)(priv->outbuf + 1));
639 		}
640 		if (m->m_pkthdr.len < outlen) {
641 			m_freem(m);
642 			priv->stats.Errors++;
643 			priv->seqnum = 0;
644 			return (ENOMEM);
645 		} else if (outlen < m->m_pkthdr.len)
646 			m_adj(m, outlen - m->m_pkthdr.len);
647 		*resultp = m;
648 		priv->stats.FramesPlain++;
649 		priv->stats.OutOctets+=outlen;
650 
651 	} else { /* Packet is not compressed, just update dictionary. */
652 		priv->stats.FramesUncomp++;
653 		if (priv->inbuf[0] == 0) {
654 		    priv->cx.next_in = priv->inbuf + 1; /* compress protocol */
655 		    priv->cx.avail_in = inlen - 1;
656 		} else {
657 		    priv->cx.next_in = priv->inbuf;
658 		    priv->cx.avail_in = inlen;
659 		}
660 
661 		rtn = inflateIncomp(&priv->cx);
662 
663 		/* Check return value */
664 		if (rtn != Z_OK) {
665 			priv->stats.Errors++;
666 			log(LOG_NOTICE, "%s: inflateIncomp error: %d (%s)\n",
667 			    __func__, rtn, priv->cx.msg);
668 			NG_FREE_M(m);
669 			priv->seqnum = 0;
670 			return (EINVAL);
671 		}
672 
673 		*resultp = m;
674 		priv->stats.FramesPlain++;
675 		priv->stats.OutOctets += inlen;
676 	}
677 
678 	/* Update sequence number. */
679 	priv->seqnum++;
680 
681 	return (0);
682 }
683 
684 /*
685  * The peer has sent us a CCP ResetRequest, so reset our transmit state.
686  */
687 static void
688 ng_deflate_reset_req(node_p node)
689 {
690 	const priv_p priv = NG_NODE_PRIVATE(node);
691 
692 	priv->seqnum = 0;
693 	if (priv->cfg.enable) {
694 	    if (priv->compress)
695 		deflateReset(&priv->cx);
696 	    else
697 		inflateReset(&priv->cx);
698 	}
699 }
700 
701