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