2 * ppp_comp.c - STREAMS module for kernel-level compression and CCP support.
4 * Copyright (c) 1994 The Australian National University.
7 * Permission to use, copy, modify, and distribute this software and its
8 * documentation is hereby granted, provided that the above copyright
9 * notice appears in all copies. This software is provided without any
10 * warranty, express or implied. The Australian National University
11 * makes no representations about the suitability of this software for
14 * IN NO EVENT SHALL THE AUSTRALIAN NATIONAL UNIVERSITY BE LIABLE TO ANY
15 * PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
16 * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
17 * THE AUSTRALIAN NATIONAL UNIVERSITY HAS BEEN ADVISED OF THE POSSIBILITY
20 * THE AUSTRALIAN NATIONAL UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES,
21 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
22 * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
23 * ON AN "AS IS" BASIS, AND THE AUSTRALIAN NATIONAL UNIVERSITY HAS NO
24 * OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS,
27 * $Id: ppp_comp.c,v 1.4 1996/06/26 00:54:20 paulus Exp $
31 * This file is used under SVR4, Solaris 2, SunOS 4, and Digital UNIX.
34 #include <sys/types.h>
35 #include <sys/param.h>
36 #include <sys/errno.h>
37 #include <sys/stream.h>
41 #include <sys/cmn_err.h>
47 #include <net/ppp_defs.h>
48 #include <net/pppio.h>
53 #include <sys/protosw.h>
56 #include <netinet/in.h>
57 #include <netinet/in_systm.h>
58 #include <netinet/ip.h>
59 #include <net/vjcompress.h>
61 #define PACKETPTR mblk_t *
62 #include <net/ppp-comp.h>
64 MOD_OPEN_DECL(ppp_comp_open);
65 MOD_CLOSE_DECL(ppp_comp_close);
66 static int ppp_comp_rput __P((queue_t *, mblk_t *));
67 static int ppp_comp_rsrv __P((queue_t *));
68 static int ppp_comp_wput __P((queue_t *, mblk_t *));
69 static int ppp_comp_wsrv __P((queue_t *));
70 static void ppp_comp_ccp __P((queue_t *, mblk_t *, int));
71 static int msg_byte __P((mblk_t *, unsigned int));
73 /* Extract byte i of message mp. */
74 #define MSG_BYTE(mp, i) ((i) < (mp)->b_wptr - (mp)->b_rptr? (mp)->b_rptr[i]: \
77 /* Is this LCP packet one we have to transmit using LCP defaults? */
78 #define LCP_USE_DFLT(mp) (1 <= (code = MSG_BYTE((mp), 4)) && code <= 7)
80 #define PPP_COMP_ID 0xbadf
81 static struct module_info minfo = {
82 PPP_COMP_ID, "ppp_comp", 0, INFPSZ, 16384, 4096,
85 static struct qinit r_init = {
86 ppp_comp_rput, ppp_comp_rsrv, ppp_comp_open, ppp_comp_close,
90 static struct qinit w_init = {
91 ppp_comp_wput, ppp_comp_wsrv, NULL, NULL, NULL, &minfo, NULL
94 struct streamtab ppp_compinfo = {
95 &r_init, &w_init, NULL, NULL
98 int ppp_comp_count; /* number of module instances in use */
102 static void ppp_comp_alloc __P((comp_state_t *));
103 typedef struct memreq {
113 typedef struct comp_state {
118 struct compressor *xcomp;
120 struct compressor *rcomp;
122 struct vjcompress vj_comp;
124 struct pppstat stats;
133 extern task_t first_task;
136 /* Bits in flags are as defined in pppio.h. */
137 #define CCP_ERR (CCP_ERROR | CCP_FATALERROR)
138 #define LAST_MOD 0x1000000 /* no ppp modules below us */
140 #define MAX_IPHDR 128 /* max TCP/IP header size */
141 #define MAX_VJHDR 20 /* max VJ compressed header size (?) */
143 #undef MIN /* just in case */
144 #define MIN(a, b) ((a) < (b)? (a): (b))
147 * List of compressors we know about.
150 extern struct compressor ppp_bsd_compress;
151 extern struct compressor ppp_deflate;
153 struct compressor *ppp_compressors[] = {
164 * STREAMS module entry points.
166 MOD_OPEN(ppp_comp_open)
173 if (q->q_ptr == NULL) {
174 cp = (comp_state_t *) ALLOC_SLEEP(sizeof(comp_state_t));
177 WR(q)->q_ptr = q->q_ptr = (caddr_t) cp;
178 bzero((caddr_t)cp, sizeof(comp_state_t));
183 vj_compress_init(&cp->vj_comp, -1);
187 if (!(thread = kernel_thread_w_arg(first_task, ppp_comp_alloc, (void *)cp)))
195 MOD_CLOSE(ppp_comp_close)
200 cp = (comp_state_t *) q->q_ptr;
202 if (cp->xstate != NULL)
203 (*cp->xcomp->comp_free)(cp->xstate);
204 if (cp->rstate != NULL)
205 (*cp->rcomp->decomp_free)(cp->rstate);
208 printf("ppp_comp_close: NULL thread!\n");
210 thread_deallocate(cp->thread);
212 FREE(cp, sizeof(comp_state_t));
214 OTHERQ(q)->q_ptr = NULL;
222 /* thread for calling back to a compressor's memory allocator
223 * Needed for Digital UNIX since it's VM can't handle requests
224 * for large amounts of memory without blocking. The thread
225 * provides a context in which we can call a memory allocator
229 ppp_comp_alloc(comp_state_t *cp)
231 unsigned char *opt_data;
233 struct compressor *comp;
236 #if (MAJOR_VERSION <= 2)
238 /* In 2.x and earlier the argument gets passed
239 * in the thread structure itself. Yuck.
241 thread = current_thread();
242 cp = thread->reply_port;
243 thread->reply_port = PORT_NULL;
248 assert_wait((vm_offset_t)&cp->memreq.comp, TRUE);
250 opt_data = cp->memreq.comp;
251 len = cp->memreq.len;
252 cmd = cp->memreq.cmd;
254 if (cmd == PPPIO_XCOMP) {
256 cp->memreq.mem = (*comp->comp_alloc)(opt_data, len);
259 cp->memreq.mem = (*comp->decomp_alloc)(opt_data, len);
262 cp->memreq.ret = ENOSR;
264 bcopy(opt_data, cp->memreq.mem, len);
266 /* have to free thunk here, since there's
267 * no guarantee that the user will call the ioctl
268 * again if we've taken a long time to complete
277 /* here's the deal with memory allocation under Digital UNIX.
278 * Some other may also benefit from this...
279 * We can't ask for huge chunks of memory in a context where
280 * the caller can't be put to sleep (like, here.) The alloc
281 * is likely to fail. Instead we do this: the first time we
282 * get called, kick off a thread to do the allocation. Return
283 * immediately to the caller with EAGAIN, as an indication that
284 * they should send down the ioctl again. By the time the
285 * second call comes in it's likely that the memory allocation
286 * thread will have returned with the requested memory. We will
287 * continue to return EAGAIN however until the thread has completed.
288 * When it has, we return zero (and the memory) if the allocator
289 * was successful and ENOSR otherwise.
291 * Callers of the RCOMP and XCOMP ioctls are encouraged (but not
292 * required) to loop for some number of iterations with a small
293 * delay in the loop body (for instance a 1/10-th second "sleep"
306 struct compressor **comp;
307 struct ppp_stats *psp;
308 struct ppp_comp_stats *csp;
309 unsigned char *opt_data;
310 int nxslots, nrslots;
312 cp = (comp_state_t *) q->q_ptr;
313 switch (mp->b_datap->db_type) {
320 iop = (struct iocblk *) mp->b_rptr;
322 switch (iop->ioc_cmd) {
325 /* set/get CCP state */
326 if (iop->ioc_count != 2 * sizeof(int))
328 flags = ((int *) mp->b_cont->b_rptr)[0];
329 mask = ((int *) mp->b_cont->b_rptr)[1];
330 cp->flags = (cp->flags & ~mask) | (flags & mask);
331 if ((mask & CCP_ISOPEN) && (flags & CCP_ISOPEN) == 0) {
332 if (cp->xstate != NULL) {
333 (*cp->xcomp->comp_free)(cp->xstate);
336 if (cp->rstate != NULL) {
337 (*cp->rcomp->decomp_free)(cp->rstate);
340 cp->flags &= ~CCP_ISUP;
343 iop->ioc_count = sizeof(int);
344 ((int *) mp->b_cont->b_rptr)[0] = cp->flags;
345 mp->b_cont->b_wptr = mp->b_cont->b_rptr + sizeof(int);
350 * Initialize VJ compressor/decompressor
352 if (iop->ioc_count != 2)
354 nxslots = mp->b_cont->b_rptr[0] + 1;
355 nrslots = mp->b_cont->b_rptr[1] + 1;
356 if (nxslots > MAX_STATES || nrslots > MAX_STATES)
358 vj_compress_init(&cp->vj_comp, nxslots);
359 cp->vj_last_ierrors = cp->stats.ppp_ierrors;
366 if (iop->ioc_count <= 0)
368 opt_data = mp->b_cont->b_rptr;
369 len = mp->b_cont->b_wptr - opt_data;
370 if (len > iop->ioc_count)
371 len = iop->ioc_count;
372 if (opt_data[1] < 2 || opt_data[1] > len)
374 for (comp = ppp_compressors; *comp != NULL; ++comp)
375 if ((*comp)->compress_proto == opt_data[0]) {
376 /* here's the handler! */
378 if (iop->ioc_cmd == PPPIO_XCOMP) {
380 /* A previous call may have fetched memory for a compressor
381 * that's now being retired or reset. Free it using it's
382 * mechanism for freeing stuff.
384 if (cp->xstate != NULL) {
385 (*cp->xcomp->comp_free)(cp->xstate);
390 /* Account for an orpahned call to get memory.
391 * Free that memory up and go on.
393 * The trick is that we need to be able to tell
394 * the difference between an old call that kicked
395 * off a thread where the memory was subsequently
396 * orphaned, and the memory we're really interested
397 * in. The thread helps by stamping the memory it
398 * allocated with the parameters for the compressor
399 * it belongs to. If the parameters match then this
400 * is the memory we want (whether it was an actual
401 * orphan or not we don't care.) If the parameters
402 * don't match then this is an orphan.
404 * Note that cp->memreq.ret is the synchronization
405 * point: we set it to EAGAIN in this function, then
406 * wait for the thread to set it to something other
407 * than EAGAIN before we fool with the data structure
408 * again. Basically, if ret != EAGAIN then the thread
409 * is working and it owns the memreq struture.
411 if (cp->memreq.ret == 0 && cp->memreq.mem != NULL &&
412 bcmp(cp->memreq.mem, opt_data, len)) {
413 (*cp->xcomp->comp_free)(cp->memreq.mem);
417 /* First time through, prime the pump and kick
418 * off the thread. Subsequent times though, the thread
419 * is either busy (ret == EAGAIN) or finsihed (mem != NULL)
422 if (cp->memreq.ret == 0 && cp->memreq.mem == NULL) {
423 cp->memreq.comp = ALLOC_NOSLEEP(len);
424 if (!cp->memreq.comp) {
425 printf("gack! can't get memory for thunk\n");
428 bcopy(opt_data, cp->memreq.comp, len);
429 cp->memreq.len = len;
430 cp->memreq.cmd = PPPIO_XCOMP;
432 cp->memreq.ret = EAGAIN;
433 thread_wakeup((vm_offset_t)&cp->memreq.comp);
436 /* Collect results from the thread, and reset the
437 * mechanism for the next attempt to allocate memory
438 * If the thread isn't finished (ret == EAGAIN) then
439 * don't reset and just return.
441 if ((error = cp->memreq.ret) != EAGAIN) {
442 cp->xstate = cp->memreq.mem;
448 cp->xstate = (*comp)->comp_alloc(opt_data, len);
449 if (cp->xstate == NULL)
453 if (cp->rstate != NULL) {
454 (*cp->rcomp->decomp_free)(cp->rstate);
458 if (cp->memreq.ret == 0 && cp->memreq.mem != NULL &&
459 bcmp(cp->memreq.mem, opt_data, len)) {
460 (*cp->rcomp->comp_free)(cp->memreq.mem);
463 if (cp->memreq.ret == 0 && cp->memreq.mem == NULL) {
464 cp->memreq.comp = ALLOC_NOSLEEP(len);
465 if (!cp->memreq.comp) {
466 printf("gack! can't get memory for thunk\n");
469 bcopy(opt_data, cp->memreq.comp, len);
470 cp->memreq.len = len;
471 cp->memreq.cmd = PPPIO_RCOMP;
473 cp->memreq.ret = EAGAIN;
474 thread_wakeup((vm_offset_t)&cp->memreq.comp);
476 if ((error = cp->memreq.ret) != EAGAIN) {
477 cp->rstate = cp->memreq.mem;
483 cp->rstate = (*comp)->decomp_alloc(opt_data, len);
484 if (cp->rstate == NULL)
494 if ((cp->flags & LAST_MOD) == 0) {
495 error = -1; /* let the ppp_ahdl module handle it */
498 np = allocb(sizeof(struct ppp_stats), BPRI_HI);
506 psp = (struct ppp_stats *) np->b_wptr;
507 np->b_wptr += sizeof(struct ppp_stats);
508 iop->ioc_count = sizeof(struct ppp_stats);
510 psp->vj = cp->vj_comp.stats;
515 np = allocb(sizeof(struct ppp_comp_stats), BPRI_HI);
523 csp = (struct ppp_comp_stats *) np->b_wptr;
524 np->b_wptr += sizeof(struct ppp_comp_stats);
525 iop->ioc_count = sizeof(struct ppp_comp_stats);
526 bzero((caddr_t)csp, sizeof(struct ppp_comp_stats));
528 (*cp->xcomp->comp_stat)(cp->xstate, &csp->c);
530 (*cp->rcomp->decomp_stat)(cp->rstate, &csp->d);
535 cp->flags |= LAST_MOD;
546 else if (error == 0) {
547 mp->b_datap->db_type = M_IOCACK;
550 mp->b_datap->db_type = M_IOCNAK;
551 iop->ioc_error = error;
558 switch (*mp->b_rptr) {
560 cp->mtu = ((unsigned short *)mp->b_rptr)[1];
563 cp->mru = ((unsigned short *)mp->b_rptr)[1];
566 cp->unit = mp->b_rptr[1];
581 mblk_t *mp, *cmp = NULL, *np;
583 int len, proto, type, hlen, code;
585 unsigned char *vjhdr, *dp;
587 cp = (comp_state_t *) q->q_ptr;
588 while ((mp = getq(q)) != 0) {
589 /* assert(mp->b_datap->db_type == M_DATA) */
590 if (!canputnext(q)) {
596 * First check the packet length and work out what the protocol is.
599 if (len < PPP_HDRLEN) {
600 DPRINT1("ppp_comp_wsrv: bogus short packet (%d)\n", len);
602 cp->stats.ppp_oerrors++;
603 putctl1(RD(q)->q_next, M_CTL, PPPCTL_OERROR);
606 proto = (MSG_BYTE(mp, 2) << 8) + MSG_BYTE(mp, 3);
609 * Make sure we've got enough data in the first mblk
610 * and that we are its only user.
614 else if (proto = PPP_IP)
615 hlen = PPP_HDRLEN + MAX_IPHDR;
620 if (mp->b_wptr < mp->b_rptr + hlen || mp->b_datap->db_ref > 1) {
623 DPRINT1("ppp_comp_wsrv: pullup failed (%d)\n", hlen);
624 cp->stats.ppp_oerrors++;
625 putctl1(RD(q)->q_next, M_CTL, PPPCTL_OERROR);
629 proto = PPP_PROTOCOL(mp->b_rptr);
632 * Do VJ compression if requested.
634 if (proto == PPP_IP && (cp->flags & COMP_VJC)) {
635 ip = (struct ip *) (mp->b_rptr + PPP_HDRLEN);
636 if (ip->ip_p == IPPROTO_TCP) {
637 type = vj_compress_tcp(ip, len - PPP_HDRLEN, &cp->vj_comp,
638 (cp->flags & COMP_VJCCID), &vjhdr);
640 case TYPE_UNCOMPRESSED_TCP:
641 mp->b_rptr[3] = proto = PPP_VJC_UNCOMP;
643 case TYPE_COMPRESSED_TCP:
644 dp = vjhdr - PPP_HDRLEN;
645 dp[1] = mp->b_rptr[1]; /* copy control field */
646 dp[0] = mp->b_rptr[0]; /* copy address field */
647 dp[2] = 0; /* set protocol field */
648 dp[3] = proto = PPP_VJC_COMP;
656 * Do packet compression if enabled.
658 if (proto == PPP_CCP)
659 ppp_comp_ccp(q, mp, 0);
660 else if (proto != PPP_LCP && (cp->flags & CCP_COMP_RUN)
661 && cp->xstate != NULL) {
663 (*cp->xcomp->compress)(cp->xstate, &cmp, mp, len,
664 (cp->flags & CCP_ISUP? cp->mtu: 0));
672 * Do address/control and protocol compression if enabled.
674 if ((cp->flags & COMP_AC)
675 && !(proto == PPP_LCP && LCP_USE_DFLT(mp))) {
676 mp->b_rptr += 2; /* drop the address & ctrl fields */
677 if (proto < 0x100 && (cp->flags & COMP_PROT))
678 ++mp->b_rptr; /* drop the high protocol byte */
679 } else if (proto < 0x100 && (cp->flags & COMP_PROT)) {
680 /* shuffle up the address & ctrl fields */
681 mp->b_rptr[2] = mp->b_rptr[1];
682 mp->b_rptr[1] = mp->b_rptr[0];
686 cp->stats.ppp_opackets++;
687 cp->stats.ppp_obytes += msgdsize(mp);
699 struct ppp_stats *psp;
701 cp = (comp_state_t *) q->q_ptr;
702 switch (mp->b_datap->db_type) {
709 iop = (struct iocblk *) mp->b_rptr;
710 switch (iop->ioc_cmd) {
713 * Catch this on the way back from the ppp_ahdl module
714 * so we can fill in the VJ stats.
716 if (mp->b_cont == 0 || iop->ioc_count != sizeof(struct ppp_stats))
718 psp = (struct ppp_stats *) mp->b_cont->b_rptr;
719 psp->vj = cp->vj_comp.stats;
726 switch (mp->b_rptr[0]) {
728 ++cp->stats.ppp_ierrors;
731 ++cp->stats.ppp_oerrors;
747 mblk_t *mp, *dmp = NULL, *np;
750 int len, hlen, vjlen;
753 cp = (comp_state_t *) q->q_ptr;
754 while ((mp = getq(q)) != 0) {
755 /* assert(mp->b_datap->db_type == M_DATA) */
756 if (!canputnext(q)) {
762 cp->stats.ppp_ibytes += len;
763 cp->stats.ppp_ipackets++;
766 * First work out the protocol and where the PPP header ends.
769 proto = MSG_BYTE(mp, 0);
770 if (proto == PPP_ALLSTATIONS) {
772 proto = MSG_BYTE(mp, 2);
774 if ((proto & 1) == 0) {
776 proto = (proto << 8) + MSG_BYTE(mp, i);
781 * Now reconstruct a complete, contiguous PPP header at the
782 * start of the packet.
784 if (hlen < ((cp->flags & DECOMP_AC)? 0: 2)
785 + ((cp->flags & DECOMP_PROT)? 1: 2)) {
789 if (mp->b_rptr + hlen > mp->b_wptr) {
790 adjmsg(mp, hlen); /* XXX check this call */
793 if (hlen != PPP_HDRLEN) {
795 * We need to put some bytes on the front of the packet
796 * to make a full-length PPP header.
797 * If we can put them in *mp, we do, otherwise we
798 * tack another mblk on the front.
799 * XXX we really shouldn't need to carry around
800 * the address and control at this stage.
802 dp = mp->b_rptr + hlen - PPP_HDRLEN;
803 if (dp < mp->b_datap->db_base || mp->b_datap->db_ref > 1) {
804 np = allocb(PPP_HDRLEN, BPRI_MED);
811 mp->b_wptr += PPP_HDRLEN;
815 dp[0] = PPP_ALLSTATIONS;
822 * Now see if we have a compressed packet to decompress,
823 * or a CCP packet to take notice of.
825 proto = PPP_PROTOCOL(mp->b_rptr);
826 if (proto == PPP_CCP) {
828 if (mp->b_wptr < mp->b_rptr + len) {
833 ppp_comp_ccp(q, mp, 1);
834 } else if (proto == PPP_COMP) {
835 if ((cp->flags & CCP_ISUP)
836 && (cp->flags & CCP_DECOMP_RUN) && cp->rstate
837 && (cp->flags & CCP_ERR) == 0) {
838 rv = (*cp->rcomp->decompress)(cp->rstate, mp, &dmp);
844 /* no error, but no packet returned either. */
849 cp->flags |= CCP_ERROR;
850 ++cp->stats.ppp_ierrors;
851 putctl1(q->q_next, M_CTL, PPPCTL_IERROR);
853 case DECOMP_FATALERROR:
854 cp->flags |= CCP_FATALERROR;
855 ++cp->stats.ppp_ierrors;
856 putctl1(q->q_next, M_CTL, PPPCTL_IERROR);
860 } else if (cp->rstate && (cp->flags & CCP_DECOMP_RUN)) {
861 (*cp->rcomp->incomp)(cp->rstate, mp);
865 * Now do VJ decompression.
867 proto = PPP_PROTOCOL(mp->b_rptr);
868 if (proto == PPP_VJC_COMP || proto == PPP_VJC_UNCOMP) {
869 len = msgdsize(mp) - PPP_HDRLEN;
870 if ((cp->flags & DECOMP_VJC) == 0 || len <= 0)
874 * Advance past the ppp header.
875 * Here we assume that the whole PPP header is in the first mblk.
878 dp = np->b_rptr + PPP_HDRLEN;
879 if (dp >= mp->b_wptr) {
885 * Make sure we have sufficient contiguous data at this point.
887 hlen = (proto == PPP_VJC_COMP)? MAX_VJHDR: MAX_IPHDR;
890 if (np->b_wptr < dp + hlen || np->b_datap->db_ref > 1) {
891 PULLUP(mp, hlen + PPP_HDRLEN);
895 dp = np->b_rptr + PPP_HDRLEN;
898 if (proto == PPP_VJC_COMP) {
900 * Decompress VJ-compressed packet.
901 * First reset compressor if an input error has occurred.
903 if (cp->stats.ppp_ierrors != cp->vj_last_ierrors) {
904 DPRINT1("ppp%d: resetting VJ\n", cp->unit);
905 vj_uncompress_err(&cp->vj_comp);
906 cp->vj_last_ierrors = cp->stats.ppp_ierrors;
909 vjlen = vj_uncompress_tcp(dp, np->b_wptr - dp, len,
910 &cp->vj_comp, &iphdr, &iphlen);
914 DPRINT2("ppp%d: vj_uncomp_tcp failed, pkt len %d [",
916 for (i = 0; i < len && i < 8; ++i)
917 DPRINT1(" %x", dp[i]);
918 DPRINT3("] c=%d u=%d e=%d\n",
919 cp->vj_comp.stats.vjs_compressedin,
920 cp->vj_comp.stats.vjs_uncompressedin,
921 cp->vj_comp.stats.vjs_errorin);
923 ++cp->vj_last_ierrors; /* so we don't reset next time */
927 /* drop ppp and vj headers off */
932 mp->b_rptr = dp + vjlen;
934 /* allocate a new mblk for the ppp and ip headers */
935 if ((np = allocb(iphlen + PPP_HDRLEN + 4, BPRI_MED)) == 0)
937 dp = np->b_rptr; /* prepend mblk with TCP/IP hdr */
938 dp[0] = PPP_ALLSTATIONS; /* reconstruct PPP header */
942 bcopy((caddr_t)iphdr, (caddr_t)dp + PPP_HDRLEN, iphlen);
943 np->b_wptr = dp + iphlen + PPP_HDRLEN;
946 /* XXX there seems to be a bug which causes panics in strread
947 if we make an mbuf with only the IP header in it :-( */
948 if (mp->b_wptr - mp->b_rptr > 4) {
949 bcopy((caddr_t)mp->b_rptr, (caddr_t)np->b_wptr, 4);
953 bcopy((caddr_t)mp->b_rptr, (caddr_t)np->b_wptr,
954 mp->b_wptr - mp->b_rptr);
955 np->b_wptr += mp->b_wptr - mp->b_rptr;
956 np->b_cont = mp->b_cont;
964 * "Decompress" a VJ-uncompressed packet.
966 cp->vj_last_ierrors = cp->stats.ppp_ierrors;
967 if (!vj_uncompress_uncomp(dp, hlen, &cp->vj_comp)) {
969 DPRINT2("ppp%d: vj_uncomp_uncomp failed, pkt len %d\n",
972 ++cp->vj_last_ierrors; /* don't need to reset next time */
975 mp->b_rptr[3] = PPP_IP; /* fix up the PPP protocol field */
985 cp->stats.ppp_ierrors++;
986 putctl1(q->q_next, M_CTL, PPPCTL_IERROR);
991 * Handle a CCP packet being sent or received.
992 * Here all the data in the packet is in a single mbuf.
995 ppp_comp_ccp(q, mp, rcvd)
1005 if (len < PPP_HDRLEN + CCP_HDRLEN)
1008 cp = (comp_state_t *) q->q_ptr;
1009 dp = mp->b_rptr + PPP_HDRLEN;
1011 clen = CCP_LENGTH(dp);
1015 switch (CCP_CODE(dp)) {
1019 cp->flags &= ~CCP_ISUP;
1023 if ((cp->flags & (CCP_ISOPEN | CCP_ISUP)) == CCP_ISOPEN
1024 && clen >= CCP_HDRLEN + CCP_OPT_MINLEN
1025 && clen >= CCP_HDRLEN + CCP_OPT_LENGTH(dp + CCP_HDRLEN)) {
1027 if (cp->xstate != NULL
1028 && (*cp->xcomp->comp_init)
1029 (cp->xstate, dp + CCP_HDRLEN, clen - CCP_HDRLEN,
1031 cp->flags |= CCP_COMP_RUN;
1033 if (cp->rstate != NULL
1034 && (*cp->rcomp->decomp_init)
1035 (cp->rstate, dp + CCP_HDRLEN, clen - CCP_HDRLEN,
1036 cp->unit, 0, cp->mru, 0))
1037 cp->flags = (cp->flags & ~CCP_ERR) | CCP_DECOMP_RUN;
1043 if (cp->flags & CCP_ISUP) {
1045 if (cp->xstate && (cp->flags & CCP_COMP_RUN))
1046 (*cp->xcomp->comp_reset)(cp->xstate);
1048 if (cp->rstate && (cp->flags & CCP_DECOMP_RUN)) {
1049 (*cp->rcomp->decomp_reset)(cp->rstate);
1050 cp->flags &= ~CCP_ERROR;
1066 DPRINT2("mp=%x cont=%x ", mp, mp->b_cont);
1067 DPRINT3("rptr=%x wptr=%x datap=%x\n", mp->b_rptr, mp->b_wptr, db);
1068 DPRINT2(" base=%x lim=%x", db->db_base, db->db_lim);
1069 DPRINT2(" ref=%d type=%d\n", db->db_ref, db->db_type);
1080 while (mp != 0 && i >= mp->b_wptr - mp->b_rptr)
1084 return mp->b_rptr[i];