1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause 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 <contrib/zlib/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 int ng_deflate_compress(node_p, struct mbuf *, struct mbuf **); 86 static int ng_deflate_decompress(node_p, struct mbuf *, struct mbuf **); 87 static void ng_deflate_reset_req(node_p); 88 89 /* Parse type for struct ng_deflate_config. */ 90 static const struct ng_parse_struct_field ng_deflate_config_type_fields[] 91 = NG_DEFLATE_CONFIG_INFO; 92 static const struct ng_parse_type ng_deflate_config_type = { 93 &ng_parse_struct_type, 94 ng_deflate_config_type_fields 95 }; 96 97 /* Parse type for struct ng_deflate_stat. */ 98 static const struct ng_parse_struct_field ng_deflate_stats_type_fields[] 99 = NG_DEFLATE_STATS_INFO; 100 static const struct ng_parse_type ng_deflate_stat_type = { 101 &ng_parse_struct_type, 102 ng_deflate_stats_type_fields 103 }; 104 105 /* List of commands and how to convert arguments to/from ASCII. */ 106 static const struct ng_cmdlist ng_deflate_cmds[] = { 107 { 108 NGM_DEFLATE_COOKIE, 109 NGM_DEFLATE_CONFIG, 110 "config", 111 &ng_deflate_config_type, 112 NULL 113 }, 114 { 115 NGM_DEFLATE_COOKIE, 116 NGM_DEFLATE_RESETREQ, 117 "resetreq", 118 NULL, 119 NULL 120 }, 121 { 122 NGM_DEFLATE_COOKIE, 123 NGM_DEFLATE_GET_STATS, 124 "getstats", 125 NULL, 126 &ng_deflate_stat_type 127 }, 128 { 129 NGM_DEFLATE_COOKIE, 130 NGM_DEFLATE_CLR_STATS, 131 "clrstats", 132 NULL, 133 NULL 134 }, 135 { 136 NGM_DEFLATE_COOKIE, 137 NGM_DEFLATE_GETCLR_STATS, 138 "getclrstats", 139 NULL, 140 &ng_deflate_stat_type 141 }, 142 { 0 } 143 }; 144 145 /* Node type descriptor */ 146 static struct ng_type ng_deflate_typestruct = { 147 .version = NG_ABI_VERSION, 148 .name = NG_DEFLATE_NODE_TYPE, 149 .constructor = ng_deflate_constructor, 150 .rcvmsg = ng_deflate_rcvmsg, 151 .shutdown = ng_deflate_shutdown, 152 .newhook = ng_deflate_newhook, 153 .rcvdata = ng_deflate_rcvdata, 154 .disconnect = ng_deflate_disconnect, 155 .cmdlist = ng_deflate_cmds, 156 }; 157 NETGRAPH_INIT(deflate, &ng_deflate_typestruct); 158 159 /* Depend on separate zlib module. */ 160 MODULE_DEPEND(ng_deflate, zlib, 1, 1, 1); 161 162 #define ERROUT(x) do { error = (x); goto done; } while (0) 163 164 /************************************************************************ 165 NETGRAPH NODE STUFF 166 ************************************************************************/ 167 168 /* 169 * Node type constructor 170 */ 171 static int 172 ng_deflate_constructor(node_p node) 173 { 174 priv_p priv; 175 176 /* Allocate private structure. */ 177 priv = malloc(sizeof(*priv), M_NETGRAPH_DEFLATE, M_WAITOK | M_ZERO); 178 179 NG_NODE_SET_PRIVATE(node, priv); 180 181 /* This node is not thread safe. */ 182 NG_NODE_FORCE_WRITER(node); 183 184 /* Done */ 185 return (0); 186 } 187 188 /* 189 * Give our OK for a hook to be added. 190 */ 191 static int 192 ng_deflate_newhook(node_p node, hook_p hook, const char *name) 193 { 194 const priv_p priv = NG_NODE_PRIVATE(node); 195 196 if (NG_NODE_NUMHOOKS(node) > 0) 197 return (EINVAL); 198 199 if (strcmp(name, NG_DEFLATE_HOOK_COMP) == 0) 200 priv->compress = 1; 201 else if (strcmp(name, NG_DEFLATE_HOOK_DECOMP) == 0) 202 priv->compress = 0; 203 else 204 return (EINVAL); 205 206 return (0); 207 } 208 209 /* 210 * Receive a control message 211 */ 212 static int 213 ng_deflate_rcvmsg(node_p node, item_p item, hook_p lasthook) 214 { 215 const priv_p priv = NG_NODE_PRIVATE(node); 216 struct ng_mesg *resp = NULL; 217 int error = 0; 218 struct ng_mesg *msg; 219 220 NGI_GET_MSG(item, msg); 221 222 if (msg->header.typecookie != NGM_DEFLATE_COOKIE) 223 ERROUT(EINVAL); 224 225 switch (msg->header.cmd) { 226 case NGM_DEFLATE_CONFIG: 227 { 228 struct ng_deflate_config *const cfg 229 = (struct ng_deflate_config *)msg->data; 230 231 /* Check configuration. */ 232 if (msg->header.arglen != sizeof(*cfg)) 233 ERROUT(EINVAL); 234 if (cfg->enable) { 235 if (cfg->windowBits < 8 || cfg->windowBits > 15) 236 ERROUT(EINVAL); 237 } else 238 cfg->windowBits = 0; 239 240 /* Clear previous state. */ 241 if (priv->cfg.enable) { 242 if (priv->compress) 243 deflateEnd(&priv->cx); 244 else 245 inflateEnd(&priv->cx); 246 priv->cfg.enable = 0; 247 } 248 249 /* Configuration is OK, reset to it. */ 250 priv->cfg = *cfg; 251 252 if (priv->cfg.enable) { 253 priv->cx.next_in = NULL; 254 int res; 255 if (priv->compress) { 256 if ((res = deflateInit2(&priv->cx, 257 Z_DEFAULT_COMPRESSION, Z_DEFLATED, 258 -cfg->windowBits, 8, 259 Z_DEFAULT_STRATEGY)) != Z_OK) { 260 log(LOG_NOTICE, 261 "deflateInit2: error %d, %s\n", 262 res, priv->cx.msg); 263 priv->cfg.enable = 0; 264 ERROUT(ENOMEM); 265 } 266 } else { 267 if ((res = inflateInit2(&priv->cx, 268 -cfg->windowBits)) != Z_OK) { 269 log(LOG_NOTICE, 270 "inflateInit2: error %d, %s\n", 271 res, priv->cx.msg); 272 priv->cfg.enable = 0; 273 ERROUT(ENOMEM); 274 } 275 } 276 } 277 278 /* Initialize other state. */ 279 priv->seqnum = 0; 280 281 /* Save return address so we can send reset-req's */ 282 priv->ctrlnode = NGI_RETADDR(item); 283 break; 284 } 285 286 case NGM_DEFLATE_RESETREQ: 287 ng_deflate_reset_req(node); 288 break; 289 290 case NGM_DEFLATE_GET_STATS: 291 case NGM_DEFLATE_CLR_STATS: 292 case NGM_DEFLATE_GETCLR_STATS: 293 /* Create response if requested. */ 294 if (msg->header.cmd != NGM_DEFLATE_CLR_STATS) { 295 NG_MKRESPONSE(resp, msg, 296 sizeof(struct ng_deflate_stats), M_NOWAIT); 297 if (resp == NULL) 298 ERROUT(ENOMEM); 299 bcopy(&priv->stats, resp->data, 300 sizeof(struct ng_deflate_stats)); 301 } 302 303 /* Clear stats if requested. */ 304 if (msg->header.cmd != NGM_DEFLATE_GET_STATS) 305 bzero(&priv->stats, 306 sizeof(struct ng_deflate_stats)); 307 break; 308 309 default: 310 error = EINVAL; 311 break; 312 } 313 done: 314 NG_RESPOND_MSG(error, node, item, resp); 315 NG_FREE_MSG(msg); 316 return (error); 317 } 318 319 /* 320 * Receive incoming data on our hook. 321 */ 322 static int 323 ng_deflate_rcvdata(hook_p hook, item_p item) 324 { 325 const node_p node = NG_HOOK_NODE(hook); 326 const priv_p priv = NG_NODE_PRIVATE(node); 327 struct mbuf *m, *out; 328 int error; 329 330 if (!priv->cfg.enable) { 331 NG_FREE_ITEM(item); 332 return (ENXIO); 333 } 334 335 NGI_GET_M(item, m); 336 /* Compress */ 337 if (priv->compress) { 338 if ((error = ng_deflate_compress(node, m, &out)) != 0) { 339 NG_FREE_ITEM(item); 340 log(LOG_NOTICE, "%s: error: %d\n", __func__, error); 341 return (error); 342 } 343 } else { /* Decompress */ 344 if ((error = ng_deflate_decompress(node, m, &out)) != 0) { 345 NG_FREE_ITEM(item); 346 log(LOG_NOTICE, "%s: error: %d\n", __func__, error); 347 if (priv->ctrlnode != 0) { 348 struct ng_mesg *msg; 349 350 /* Need to send a reset-request. */ 351 NG_MKMESSAGE(msg, NGM_DEFLATE_COOKIE, 352 NGM_DEFLATE_RESETREQ, 0, M_NOWAIT); 353 if (msg == NULL) 354 return (error); 355 NG_SEND_MSG_ID(error, node, msg, 356 priv->ctrlnode, 0); 357 } 358 return (error); 359 } 360 } 361 362 NG_FWD_NEW_DATA(error, item, hook, out); 363 return (error); 364 } 365 366 /* 367 * Destroy node. 368 */ 369 static int 370 ng_deflate_shutdown(node_p node) 371 { 372 const priv_p priv = NG_NODE_PRIVATE(node); 373 374 /* Take down netgraph node. */ 375 if (priv->cfg.enable) { 376 if (priv->compress) 377 deflateEnd(&priv->cx); 378 else 379 inflateEnd(&priv->cx); 380 } 381 382 free(priv, M_NETGRAPH_DEFLATE); 383 NG_NODE_SET_PRIVATE(node, NULL); 384 NG_NODE_UNREF(node); /* let the node escape */ 385 return (0); 386 } 387 388 /* 389 * Hook disconnection 390 */ 391 static int 392 ng_deflate_disconnect(hook_p hook) 393 { 394 const node_p node = NG_HOOK_NODE(hook); 395 const priv_p priv = NG_NODE_PRIVATE(node); 396 397 if (priv->cfg.enable) { 398 if (priv->compress) 399 deflateEnd(&priv->cx); 400 else 401 inflateEnd(&priv->cx); 402 priv->cfg.enable = 0; 403 } 404 405 /* Go away if no longer connected. */ 406 if ((NG_NODE_NUMHOOKS(node) == 0) && NG_NODE_IS_VALID(node)) 407 ng_rmnode_self(node); 408 return (0); 409 } 410 411 /************************************************************************ 412 HELPER STUFF 413 ************************************************************************/ 414 415 /* 416 * Compress/encrypt a packet and put the result in a new mbuf at *resultp. 417 * The original mbuf is not free'd. 418 */ 419 static int 420 ng_deflate_compress(node_p node, struct mbuf *m, struct mbuf **resultp) 421 { 422 const priv_p priv = NG_NODE_PRIVATE(node); 423 int outlen, inlen; 424 int rtn; 425 426 /* Initialize. */ 427 *resultp = NULL; 428 429 inlen = m->m_pkthdr.len; 430 431 priv->stats.FramesPlain++; 432 priv->stats.InOctets+=inlen; 433 434 if (inlen > DEFLATE_BUF_SIZE) { 435 priv->stats.Errors++; 436 NG_FREE_M(m); 437 return (ENOMEM); 438 } 439 440 /* We must own the mbuf chain exclusively to modify it. */ 441 m = m_unshare(m, M_NOWAIT); 442 if (m == NULL) { 443 priv->stats.Errors++; 444 return (ENOMEM); 445 } 446 447 /* Work with contiguous regions of memory. */ 448 m_copydata(m, 0, inlen, (caddr_t)priv->inbuf); 449 outlen = DEFLATE_BUF_SIZE; 450 451 /* Compress "inbuf" into "outbuf". */ 452 /* Prepare to compress. */ 453 if (priv->inbuf[0] != 0) { 454 priv->cx.next_in = priv->inbuf; 455 priv->cx.avail_in = inlen; 456 } else { 457 priv->cx.next_in = priv->inbuf + 1; /* compress protocol */ 458 priv->cx.avail_in = inlen - 1; 459 } 460 priv->cx.next_out = priv->outbuf + 2 + DEFLATE_HDRLEN; 461 priv->cx.avail_out = outlen - 2 - DEFLATE_HDRLEN; 462 463 /* Compress. */ 464 rtn = deflate(&priv->cx, Z_SYNC_FLUSH); 465 466 /* Check return value. */ 467 if (rtn != Z_OK) { 468 priv->stats.Errors++; 469 log(LOG_NOTICE, "ng_deflate: compression error: %d (%s)\n", 470 rtn, priv->cx.msg); 471 NG_FREE_M(m); 472 return (EINVAL); 473 } 474 475 /* Calculate resulting size. */ 476 outlen -= priv->cx.avail_out; 477 /* 478 * Z_SYNC_FLUSH completes the current deflate block and follows 479 * it with an empty stored block that is three bits plus filler 480 * bits to the next byte, followed by four bytes (00 00 ff ff). 481 * RFC 1979 Section 2.1, "Data" requires the four bytes be 482 * removed before transmission. 483 */ 484 outlen -= 4; 485 MPASS(outlen > 0); 486 MPASS(priv->outbuf[outlen + 0] == 0x00); 487 MPASS(priv->outbuf[outlen + 1] == 0x00); 488 MPASS(priv->outbuf[outlen + 2] == 0xff); 489 MPASS(priv->outbuf[outlen + 3] == 0xff); 490 491 /* If we can't compress this packet, send it as-is. */ 492 if (outlen > inlen) { 493 /* Return original packet uncompressed. */ 494 *resultp = m; 495 priv->stats.FramesUncomp++; 496 priv->stats.OutOctets+=inlen; 497 } else { 498 /* Install header. */ 499 be16enc(priv->outbuf, PROT_COMPD); 500 be16enc(priv->outbuf + 2, priv->seqnum); 501 502 /* Return packet in an mbuf. */ 503 m_copyback(m, 0, outlen, (caddr_t)priv->outbuf); 504 if (m->m_pkthdr.len < outlen) { 505 m_freem(m); 506 priv->stats.Errors++; 507 return (ENOMEM); 508 } else if (outlen < m->m_pkthdr.len) 509 m_adj(m, outlen - m->m_pkthdr.len); 510 *resultp = m; 511 priv->stats.FramesComp++; 512 priv->stats.OutOctets+=outlen; 513 } 514 515 /* Update sequence number. */ 516 priv->seqnum++; 517 518 return (0); 519 } 520 521 /* 522 * Decompress/decrypt packet and put the result in a new mbuf at *resultp. 523 * The original mbuf is not free'd. 524 */ 525 static int 526 ng_deflate_decompress(node_p node, struct mbuf *m, struct mbuf **resultp) 527 { 528 const priv_p priv = NG_NODE_PRIVATE(node); 529 int outlen, inlen, datalen; 530 int rtn; 531 uint16_t proto; 532 int offset; 533 uint16_t rseqnum; 534 u_char headbuf[5]; 535 static u_char EMPTY_BLOCK[4] = { 0x00, 0x00, 0xff, 0xff }; 536 537 /* Initialize. */ 538 *resultp = NULL; 539 540 inlen = m->m_pkthdr.len; 541 542 if (inlen > DEFLATE_BUF_SIZE) { 543 priv->stats.Errors++; 544 NG_FREE_M(m); 545 priv->seqnum = 0; 546 return (ENOMEM); 547 } 548 549 /* We must own the mbuf chain exclusively to modify it. */ 550 m = m_unshare(m, M_NOWAIT); 551 if (m == NULL) { 552 priv->stats.Errors++; 553 return (ENOMEM); 554 } 555 556 /* Work with contiguous regions of memory. */ 557 m_copydata(m, 0, inlen, (caddr_t)priv->inbuf); 558 559 /* Separate proto. */ 560 if ((priv->inbuf[0] & 0x01) != 0) { 561 proto = priv->inbuf[0]; 562 offset = 1; 563 } else { 564 proto = be16dec(priv->inbuf); 565 offset = 2; 566 } 567 568 priv->stats.InOctets += inlen; 569 570 /* Packet is compressed, so decompress. */ 571 if (proto == PROT_COMPD) { 572 priv->stats.FramesComp++; 573 574 /* Check sequence number. */ 575 rseqnum = be16dec(priv->inbuf + offset); 576 offset += 2; 577 if (rseqnum != priv->seqnum) { 578 priv->stats.Errors++; 579 log(LOG_NOTICE, "ng_deflate: wrong sequence: %u " 580 "instead of %u\n", rseqnum, priv->seqnum); 581 NG_FREE_M(m); 582 priv->seqnum = 0; 583 return (EPIPE); 584 } 585 586 outlen = DEFLATE_BUF_SIZE; 587 588 /* Decompress "inbuf" into "outbuf". */ 589 /* Prepare to decompress. */ 590 priv->cx.next_in = priv->inbuf + offset; 591 priv->cx.avail_in = inlen - offset; 592 /* Reserve space for protocol decompression. */ 593 priv->cx.next_out = priv->outbuf + 1; 594 priv->cx.avail_out = outlen - 1; 595 596 /* Decompress. */ 597 rtn = inflate(&priv->cx, Z_SYNC_FLUSH); 598 599 /* Check return value. */ 600 if (rtn != Z_OK && rtn != Z_STREAM_END) { 601 priv->stats.Errors++; 602 NG_FREE_M(m); 603 priv->seqnum = 0; 604 log(LOG_NOTICE, "%s: decompression error: %d (%s)\n", 605 __func__, rtn, priv->cx.msg); 606 607 switch (rtn) { 608 case Z_MEM_ERROR: 609 return (ENOMEM); 610 case Z_DATA_ERROR: 611 return (EIO); 612 default: 613 return (EINVAL); 614 } 615 } 616 617 /* Handle the EMPTY_BLOCK omitted by sender */ 618 if (inflateSyncPoint(&priv->cx)) { 619 priv->cx.avail_in = 4; 620 priv->cx.next_in = EMPTY_BLOCK; 621 inflate(&priv->cx, Z_SYNC_FLUSH); 622 } 623 624 /* Calculate resulting size. */ 625 outlen -= priv->cx.avail_out; 626 627 /* Decompress protocol. */ 628 if ((priv->outbuf[1] & 0x01) != 0) { 629 priv->outbuf[0] = 0; 630 /* Return packet in an mbuf. */ 631 m_copyback(m, 0, outlen, (caddr_t)priv->outbuf); 632 } else { 633 outlen--; 634 /* Return packet in an mbuf. */ 635 m_copyback(m, 0, outlen, (caddr_t)(priv->outbuf + 1)); 636 } 637 if (m->m_pkthdr.len < outlen) { 638 m_freem(m); 639 priv->stats.Errors++; 640 priv->seqnum = 0; 641 return (ENOMEM); 642 } else if (outlen < m->m_pkthdr.len) 643 m_adj(m, outlen - m->m_pkthdr.len); 644 *resultp = m; 645 priv->stats.FramesPlain++; 646 priv->stats.OutOctets+=outlen; 647 648 } else { 649 /* Packet is not compressed, just update dictionary. */ 650 priv->stats.FramesUncomp++; 651 652 /* 653 * Fake a header for uncompressed data block 654 */ 655 datalen = inlen - offset + 1; 656 headbuf[0] = 0x80; 657 headbuf[1] = datalen & 0xff; 658 headbuf[2] = datalen >> 8; 659 headbuf[3] = (~datalen) & 0xff; 660 headbuf[4] = (~datalen) >> 8; 661 662 priv->cx.next_in = headbuf; 663 priv->cx.avail_in = sizeof(headbuf); 664 priv->cx.next_out = priv->outbuf; 665 priv->cx.avail_out = DEFLATE_BUF_SIZE; 666 667 rtn = inflate(&priv->cx, Z_NO_FLUSH); 668 669 if (priv->inbuf[0] == 0) { 670 priv->cx.next_in = 671 priv->inbuf + 1; /* compress protocol */ 672 priv->cx.avail_in = inlen - 1; 673 } else { 674 priv->cx.next_in = priv->inbuf; 675 priv->cx.avail_in = inlen; 676 } 677 priv->cx.next_out = priv->outbuf; 678 priv->cx.avail_out = DEFLATE_BUF_SIZE; 679 680 rtn = inflate(&priv->cx, Z_SYNC_FLUSH); 681 682 /* Check return value */ 683 if (rtn != Z_OK) { 684 priv->stats.Errors++; 685 log(LOG_NOTICE, "%s: inflate error: %d (%s)\n", 686 __func__, rtn, priv->cx.msg); 687 NG_FREE_M(m); 688 priv->seqnum = 0; 689 return (EINVAL); 690 } 691 692 *resultp = m; 693 priv->stats.FramesPlain++; 694 priv->stats.OutOctets += inlen; 695 } 696 697 /* Update sequence number. */ 698 priv->seqnum++; 699 700 return (0); 701 } 702 703 /* 704 * The peer has sent us a CCP ResetRequest, so reset our transmit state. 705 */ 706 static void 707 ng_deflate_reset_req(node_p node) 708 { 709 const priv_p priv = NG_NODE_PRIVATE(node); 710 711 priv->seqnum = 0; 712 if (priv->cfg.enable) { 713 if (priv->compress) 714 deflateReset(&priv->cx); 715 else 716 inflateReset(&priv->cx); 717 } 718 } 719