1 2 /* 3 * ng_vjc.c 4 * 5 * Copyright (c) 1996-1999 Whistle Communications, Inc. 6 * All rights reserved. 7 * 8 * Subject to the following obligations and disclaimer of warranty, use and 9 * redistribution of this software, in source or object code forms, with or 10 * without modifications are expressly permitted by Whistle Communications; 11 * provided, however, that: 12 * 1. Any and all reproductions of the source or object code must include the 13 * copyright notice above and the following disclaimer of warranties; and 14 * 2. No rights are granted, in any manner or form, to use Whistle 15 * Communications, Inc. trademarks, including the mark "WHISTLE 16 * COMMUNICATIONS" on advertising, endorsements, or otherwise except as 17 * such appears in the above copyright notice or in the software. 18 * 19 * THIS SOFTWARE IS BEING PROVIDED BY WHISTLE COMMUNICATIONS "AS IS", AND 20 * TO THE MAXIMUM EXTENT PERMITTED BY LAW, WHISTLE COMMUNICATIONS MAKES NO 21 * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING THIS SOFTWARE, 22 * INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED WARRANTIES OF 23 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT. 24 * WHISTLE COMMUNICATIONS DOES NOT WARRANT, GUARANTEE, OR MAKE ANY 25 * REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS OF THE USE OF THIS 26 * SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY, RELIABILITY OR OTHERWISE. 27 * IN NO EVENT SHALL WHISTLE COMMUNICATIONS BE LIABLE FOR ANY DAMAGES 28 * RESULTING FROM OR ARISING OUT OF ANY USE OF THIS SOFTWARE, INCLUDING 29 * WITHOUT LIMITATION, ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, 30 * PUNITIVE, OR CONSEQUENTIAL DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR 31 * SERVICES, LOSS OF USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY 32 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 33 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 34 * THIS SOFTWARE, EVEN IF WHISTLE COMMUNICATIONS IS ADVISED OF THE POSSIBILITY 35 * OF SUCH DAMAGE. 36 * 37 * Author: Archie Cobbs <archie@whistle.com> 38 * 39 * $FreeBSD$ 40 * $Whistle: ng_vjc.c,v 1.14 1999/01/28 23:54:54 julian Exp $ 41 */ 42 43 /* 44 * This node performs Van Jacobsen IP header (de)compression. 45 * You must have included net/slcompress.c in your kernel compilation. 46 */ 47 48 #include <sys/param.h> 49 #include <sys/systm.h> 50 #include <sys/errno.h> 51 #include <sys/kernel.h> 52 #include <sys/mbuf.h> 53 #include <sys/malloc.h> 54 #include <sys/conf.h> 55 #include <sys/errno.h> 56 #include <sys/socket.h> 57 #include <sys/syslog.h> 58 59 #include <netgraph/ng_message.h> 60 #include <netgraph/netgraph.h> 61 #include <netgraph/ng_vjc.h> 62 63 #include <netinet/in.h> 64 #include <netinet/in_systm.h> 65 #include <netinet/ip.h> 66 #include <netinet/tcp.h> 67 68 #include <net/slcompress.h> 69 70 /* Check agreement with slcompress.c */ 71 #if MAX_STATES != NG_VJC_MAX_CHANNELS 72 #error NG_VJC_MAX_CHANNELS must be the same as MAX_STATES 73 #endif 74 75 #define MAX_VJHEADER 16 76 77 /* Node private data */ 78 struct private { 79 struct ngm_vjc_config conf; 80 struct slcompress slc; 81 hook_p ip; 82 hook_p vjcomp; 83 hook_p vjuncomp; 84 hook_p vjip; 85 }; 86 typedef struct private *priv_p; 87 88 #define ERROUT(x) do { error = (x); goto done; } while (0) 89 90 /* Netgraph node methods */ 91 static int ng_vjc_constructor(node_p *nodep); 92 static int ng_vjc_rcvmsg(node_p node, struct ng_mesg *msg, 93 const char *retaddr, struct ng_mesg **resp); 94 static int ng_vjc_rmnode(node_p node); 95 static int ng_vjc_newhook(node_p node, hook_p hook, const char *name); 96 static int ng_vjc_rcvdata(hook_p hook, struct mbuf *m, meta_p t); 97 static int ng_vjc_disconnect(hook_p hook); 98 99 /* Helper stuff */ 100 static struct mbuf *ng_vjc_pulluphdrs(struct mbuf *m); 101 102 /* Node type descriptor */ 103 static struct ng_type typestruct = { 104 NG_VERSION, 105 NG_VJC_NODE_TYPE, 106 NULL, 107 ng_vjc_constructor, 108 ng_vjc_rcvmsg, 109 ng_vjc_rmnode, 110 ng_vjc_newhook, 111 NULL, 112 NULL, 113 ng_vjc_rcvdata, 114 ng_vjc_rcvdata, 115 ng_vjc_disconnect 116 }; 117 NETGRAPH_INIT(vjc, &typestruct); 118 119 /************************************************************************ 120 NETGRAPH NODE METHODS 121 ************************************************************************/ 122 123 /* 124 * Create a new node 125 */ 126 static int 127 ng_vjc_constructor(node_p *nodep) 128 { 129 priv_p priv; 130 int error; 131 132 /* Allocate private structure */ 133 MALLOC(priv, priv_p, sizeof(*priv), M_NETGRAPH, M_WAITOK); 134 if (priv == NULL) 135 return (ENOMEM); 136 bzero(priv, sizeof(*priv)); 137 138 /* Call generic node constructor */ 139 if ((error = ng_make_node_common(&typestruct, nodep))) { 140 FREE(priv, M_NETGRAPH); 141 return (error); 142 } 143 (*nodep)->private = priv; 144 145 /* Done */ 146 return (0); 147 } 148 149 /* 150 * Add a new hook 151 */ 152 static int 153 ng_vjc_newhook(node_p node, hook_p hook, const char *name) 154 { 155 const priv_p priv = (priv_p) node->private; 156 hook_p *hookp; 157 158 /* Get hook */ 159 if (!strcmp(name, NG_VJC_HOOK_IP)) 160 hookp = &priv->ip; 161 else if (!strcmp(name, NG_VJC_HOOK_VJCOMP)) 162 hookp = &priv->vjcomp; 163 else if (!strcmp(name, NG_VJC_HOOK_VJUNCOMP)) 164 hookp = &priv->vjuncomp; 165 else if (!strcmp(name, NG_VJC_HOOK_VJIP)) 166 hookp = &priv->vjip; 167 else 168 return (EINVAL); 169 170 /* See if already connected */ 171 if (*hookp) 172 return (EISCONN); 173 174 /* OK */ 175 *hookp = hook; 176 return (0); 177 } 178 179 /* 180 * Receive a control message 181 */ 182 static int 183 ng_vjc_rcvmsg(node_p node, struct ng_mesg *msg, 184 const char *raddr, struct ng_mesg **rptr) 185 { 186 const priv_p priv = (priv_p) node->private; 187 struct ng_mesg *resp = NULL; 188 int error = 0; 189 190 /* Check type cookie */ 191 switch (msg->header.typecookie) { 192 case NGM_VJC_COOKIE: 193 switch (msg->header.cmd) { 194 case NGM_VJC_SET_CONFIG: 195 { 196 struct ngm_vjc_config *const c = 197 (struct ngm_vjc_config *) msg->data; 198 199 if (msg->header.arglen != sizeof(*c)) 200 ERROUT(EINVAL); 201 if ((priv->conf.enableComp || priv->conf.enableDecomp) 202 && (c->enableComp || c->enableDecomp)) 203 ERROUT(EALREADY); 204 if (c->enableComp) { 205 if (c->numChannels > NG_VJC_MAX_CHANNELS 206 || c->numChannels < NG_VJC_MIN_CHANNELS) 207 ERROUT(EINVAL); 208 } else { 209 c->numChannels = NG_VJC_MAX_CHANNELS; 210 } 211 if (c->enableComp != 0 || c->enableDecomp != 0) { 212 bzero(&priv->slc, sizeof(priv->slc)); 213 sl_compress_init(&priv->slc, c->numChannels); 214 } 215 priv->conf = *c; 216 break; 217 } 218 case NGM_VJC_GET_STATE: 219 NG_MKRESPONSE(resp, msg, sizeof(priv->slc), M_NOWAIT); 220 if (resp == NULL) 221 ERROUT(ENOMEM); 222 *((struct slcompress *) resp->data) = priv->slc; 223 break; 224 case NGM_VJC_CLR_STATS: 225 priv->slc.sls_packets = 0; 226 priv->slc.sls_compressed = 0; 227 priv->slc.sls_searches = 0; 228 priv->slc.sls_misses = 0; 229 priv->slc.sls_uncompressedin = 0; 230 priv->slc.sls_compressedin = 0; 231 priv->slc.sls_errorin = 0; 232 priv->slc.sls_tossed = 0; 233 break; 234 case NGM_VJC_RECV_ERROR: 235 priv->slc.flags |= SLF_TOSS; 236 break; 237 default: 238 error = EINVAL; 239 break; 240 } 241 break; 242 default: 243 error = EINVAL; 244 break; 245 } 246 if (rptr) 247 *rptr = resp; 248 else if (resp) 249 FREE(resp, M_NETGRAPH); 250 251 done: 252 FREE(msg, M_NETGRAPH); 253 return (error); 254 } 255 256 /* 257 * Receive data 258 */ 259 static int 260 ng_vjc_rcvdata(hook_p hook, struct mbuf *m, meta_p meta) 261 { 262 const node_p node = hook->node; 263 const priv_p priv = (priv_p) node->private; 264 int error = 0; 265 266 if (hook == priv->ip) { /* outgoing packet */ 267 u_int type; 268 269 if (!priv->conf.enableComp) /* compression not enabled */ 270 type = TYPE_IP; 271 else { 272 struct ip *ip; 273 274 if ((m = ng_vjc_pulluphdrs(m)) == NULL) 275 ERROUT(ENOBUFS); 276 ip = mtod(m, struct ip *); 277 type = (ip->ip_p == IPPROTO_TCP) ? 278 sl_compress_tcp(m, ip, 279 &priv->slc, priv->conf.compressCID) : TYPE_IP; 280 } 281 switch (type) { 282 case TYPE_IP: 283 hook = priv->vjip; 284 break; 285 case TYPE_UNCOMPRESSED_TCP: 286 hook = priv->vjuncomp; 287 break; 288 case TYPE_COMPRESSED_TCP: 289 hook = priv->vjcomp; 290 break; 291 default: 292 panic(__FUNCTION__); 293 } 294 } else if (hook == priv->vjcomp) { /* incoming compressed packet */ 295 int vjlen; 296 u_int hlen; 297 u_char *hdr; 298 struct mbuf *mp; 299 300 /* Are we decompressing? */ 301 if (!priv->conf.enableDecomp) { 302 m_freem(m); 303 m = NULL; 304 ERROUT(ENETDOWN); 305 } 306 307 /* Uncompress packet to reconstruct TCP/IP header */ 308 if (m->m_len < MAX_VJHEADER && !(m = m_pullup(m, MAX_VJHEADER))) 309 ERROUT(ENOBUFS); 310 vjlen = sl_uncompress_tcp_core(mtod(m, u_char *), 311 m->m_len, m->m_pkthdr.len, TYPE_COMPRESSED_TCP, 312 &priv->slc, &hdr, &hlen); 313 if (vjlen <= 0) { 314 m_freem(m); 315 m = NULL; 316 ERROUT(EINVAL); 317 } 318 319 /* Copy the reconstructed TCP/IP headers into a new mbuf */ 320 MGETHDR(mp, M_DONTWAIT, MT_DATA); 321 if (!mp) 322 goto compfailmem; 323 mp->m_len = 0; 324 mp->m_next = NULL; 325 if (hlen > MHLEN) { 326 MCLGET(mp, M_DONTWAIT); 327 if (M_TRAILINGSPACE(mp) < hlen) { 328 m_freem(mp); /* can't get a cluster, drop */ 329 compfailmem: 330 m_freem(m); 331 m = NULL; 332 ERROUT(ENOBUFS); 333 } 334 } 335 bcopy(hdr, mtod(mp, u_char *), hlen); 336 mp->m_len = hlen; 337 338 /* Stick header and rest of packet together */ 339 m->m_data += vjlen; 340 m->m_len -= vjlen; 341 if (m->m_len <= M_TRAILINGSPACE(mp)) { 342 bcopy(mtod(m, u_char *), 343 mtod(mp, u_char *) + mp->m_len, m->m_len); 344 mp->m_len += m->m_len; 345 MFREE(m, mp->m_next); 346 } else 347 mp->m_next = m; 348 m = mp; 349 hook = priv->ip; 350 } else if (hook == priv->vjuncomp) { /* incoming uncompressed pkt */ 351 u_char *hdr; 352 u_int hlen; 353 354 /* Are we decompressing? */ 355 if (!priv->conf.enableDecomp) { 356 m_freem(m); 357 m = NULL; 358 ERROUT(ENETDOWN); 359 } 360 361 /* Run packet through uncompressor */ 362 if ((m = ng_vjc_pulluphdrs(m)) == NULL) 363 ERROUT(ENOBUFS); 364 if (sl_uncompress_tcp_core(mtod(m, u_char *), 365 m->m_len, m->m_pkthdr.len, TYPE_UNCOMPRESSED_TCP, 366 &priv->slc, &hdr, &hlen) < 0) { 367 m_freem(m); 368 m = NULL; 369 ERROUT(EINVAL); 370 } 371 hook = priv->ip; 372 } else if (hook == priv->vjip) /* incoming regular packet (bypass) */ 373 hook = priv->ip; 374 else 375 panic(__FUNCTION__); 376 377 done: 378 if (m) 379 NG_SEND_DATA(error, hook, m, meta); 380 else 381 NG_FREE_META(meta); 382 return (error); 383 } 384 385 /* 386 * Shutdown node 387 */ 388 static int 389 ng_vjc_rmnode(node_p node) 390 { 391 const priv_p priv = (priv_p) node->private; 392 393 node->flags |= NG_INVALID; 394 ng_cutlinks(node); 395 ng_unname(node); 396 bzero(priv, sizeof(*priv)); 397 FREE(priv, M_NETGRAPH); 398 node->private = NULL; 399 ng_unref(node); 400 return (0); 401 } 402 403 /* 404 * Hook disconnection 405 */ 406 static int 407 ng_vjc_disconnect(hook_p hook) 408 { 409 if (hook->node->numhooks == 0) 410 ng_rmnode(hook->node); 411 return (0); 412 } 413 414 /************************************************************************ 415 HELPER STUFF 416 ************************************************************************/ 417 418 /* 419 * Pull up the full IP and TCP headers of a packet. If packet is not 420 * a TCP packet, just pull up the IP header. 421 */ 422 static struct mbuf * 423 ng_vjc_pulluphdrs(struct mbuf *m) 424 { 425 struct ip *ip; 426 struct tcphdr *tcp; 427 int ihlen, thlen; 428 429 if (m->m_len < sizeof(*ip) && !(m = m_pullup(m, sizeof(*ip)))) 430 return (NULL); 431 ip = mtod(m, struct ip *); 432 if (ip->ip_p != IPPROTO_TCP) 433 return (m); 434 ihlen = ip->ip_hl << 2; 435 if (m->m_len < ihlen + sizeof(*tcp)) { 436 if (!(m = m_pullup(m, ihlen + sizeof(*tcp)))) 437 return (NULL); 438 ip = mtod(m, struct ip *); 439 } 440 tcp = (struct tcphdr *) ((u_char *) ip + ihlen); 441 thlen = tcp->th_off << 2; 442 if (m->m_len < ihlen + thlen) 443 m = m_pullup(m, ihlen + thlen); 444 return (m); 445 } 446 447