diff options
Diffstat (limited to 'mdk-stage1/ppp/solaris/ppp_comp.c')
| -rw-r--r-- | mdk-stage1/ppp/solaris/ppp_comp.c | 1126 |
1 files changed, 1126 insertions, 0 deletions
diff --git a/mdk-stage1/ppp/solaris/ppp_comp.c b/mdk-stage1/ppp/solaris/ppp_comp.c new file mode 100644 index 000000000..f6eef5ab1 --- /dev/null +++ b/mdk-stage1/ppp/solaris/ppp_comp.c @@ -0,0 +1,1126 @@ +/* + * ppp_comp.c - STREAMS module for kernel-level compression and CCP support. + * + * Copyright (c) 1994 The Australian National University. + * All rights reserved. + * + * Permission to use, copy, modify, and distribute this software and its + * documentation is hereby granted, provided that the above copyright + * notice appears in all copies. This software is provided without any + * warranty, express or implied. The Australian National University + * makes no representations about the suitability of this software for + * any purpose. + * + * IN NO EVENT SHALL THE AUSTRALIAN NATIONAL UNIVERSITY BE LIABLE TO ANY + * PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES + * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF + * THE AUSTRALIAN NATIONAL UNIVERSITY HAS BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * THE AUSTRALIAN NATIONAL UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + * ON AN "AS IS" BASIS, AND THE AUSTRALIAN NATIONAL UNIVERSITY HAS NO + * OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, + * OR MODIFICATIONS. + * + * $Id$ + */ + +/* + * This file is used under SVR4, Solaris 2, SunOS 4, and Digital UNIX. + */ + +#include <sys/types.h> +#include <sys/param.h> +#include <sys/errno.h> +#include <sys/stream.h> + +#ifdef SVR4 +#include <sys/conf.h> +#include <sys/cmn_err.h> +#include <sys/ddi.h> +#else +#include <sys/user.h> +#ifdef __osf__ +#include <sys/cmn_err.h> +#endif +#endif /* SVR4 */ + +#include <net/ppp_defs.h> +#include <net/pppio.h> +#include "ppp_mod.h" + +#ifdef __osf__ +#include <sys/mbuf.h> +#include <sys/protosw.h> +#endif + +#include <netinet/in.h> +#include <netinet/in_systm.h> +#include <netinet/ip.h> +#include <net/vjcompress.h> + +#define PACKETPTR mblk_t * +#include <net/ppp-comp.h> + +MOD_OPEN_DECL(ppp_comp_open); +MOD_CLOSE_DECL(ppp_comp_close); +static int ppp_comp_rput __P((queue_t *, mblk_t *)); +static int ppp_comp_rsrv __P((queue_t *)); +static int ppp_comp_wput __P((queue_t *, mblk_t *)); +static int ppp_comp_wsrv __P((queue_t *)); +static void ppp_comp_ccp __P((queue_t *, mblk_t *, int)); +static int msg_byte __P((mblk_t *, unsigned int)); + +/* Extract byte i of message mp. */ +#define MSG_BYTE(mp, i) ((i) < (mp)->b_wptr - (mp)->b_rptr? (mp)->b_rptr[i]: \ + msg_byte((mp), (i))) + +/* Is this LCP packet one we have to transmit using LCP defaults? */ +#define LCP_USE_DFLT(mp) (1 <= (code = MSG_BYTE((mp), 4)) && code <= 7) + +#define PPP_COMP_ID 0xbadf +static struct module_info minfo = { +#ifdef PRIOQ + PPP_COMP_ID, "ppp_comp", 0, INFPSZ, 16512, 16384, +#else + PPP_COMP_ID, "ppp_comp", 0, INFPSZ, 16384, 4096, +#endif +}; + +static struct qinit r_init = { + ppp_comp_rput, ppp_comp_rsrv, ppp_comp_open, ppp_comp_close, + NULL, &minfo, NULL +}; + +static struct qinit w_init = { + ppp_comp_wput, ppp_comp_wsrv, NULL, NULL, NULL, &minfo, NULL +}; + +#if defined(SVR4) && !defined(SOL2) +int pcmpdevflag = 0; +#define ppp_compinfo pcmpinfo +#endif +struct streamtab ppp_compinfo = { + &r_init, &w_init, NULL, NULL +}; + +int ppp_comp_count; /* number of module instances in use */ + +#ifdef __osf__ + +static void ppp_comp_alloc __P((comp_state_t *)); +typedef struct memreq { + unsigned char comp_opts[20]; + int cmd; + int thread_status; + char *returned_mem; +} memreq_t; + +#endif + +typedef struct comp_state { + int flags; + int mru; + int mtu; + int unit; + struct compressor *xcomp; + void *xstate; + struct compressor *rcomp; + void *rstate; + struct vjcompress vj_comp; + int vj_last_ierrors; + struct pppstat stats; +#ifdef __osf__ + memreq_t memreq; + thread_t thread; +#endif +} comp_state_t; + + +#ifdef __osf__ +extern task_t first_task; +#endif + +/* Bits in flags are as defined in pppio.h. */ +#define CCP_ERR (CCP_ERROR | CCP_FATALERROR) +#define LAST_MOD 0x1000000 /* no ppp modules below us */ +#define DBGLOG 0x2000000 /* log debugging stuff */ + +#define MAX_IPHDR 128 /* max TCP/IP header size */ +#define MAX_VJHDR 20 /* max VJ compressed header size (?) */ + +#undef MIN /* just in case */ +#define MIN(a, b) ((a) < (b)? (a): (b)) + +/* + * List of compressors we know about. + */ + +#if DO_BSD_COMPRESS +extern struct compressor ppp_bsd_compress; +#endif +#if DO_DEFLATE +extern struct compressor ppp_deflate, ppp_deflate_draft; +#endif + +struct compressor *ppp_compressors[] = { +#if DO_BSD_COMPRESS + &ppp_bsd_compress, +#endif +#if DO_DEFLATE + &ppp_deflate, + &ppp_deflate_draft, +#endif + NULL +}; + +/* + * STREAMS module entry points. + */ +MOD_OPEN(ppp_comp_open) +{ + comp_state_t *cp; +#ifdef __osf__ + thread_t thread; +#endif + + if (q->q_ptr == NULL) { + cp = (comp_state_t *) ALLOC_SLEEP(sizeof(comp_state_t)); + if (cp == NULL) + OPEN_ERROR(ENOSR); + bzero((caddr_t)cp, sizeof(comp_state_t)); + WR(q)->q_ptr = q->q_ptr = (caddr_t) cp; + cp->mru = PPP_MRU; + cp->mtu = PPP_MTU; + cp->xstate = NULL; + cp->rstate = NULL; + vj_compress_init(&cp->vj_comp, -1); +#ifdef __osf__ + if (!(thread = kernel_thread_w_arg(first_task, ppp_comp_alloc, (void *)cp))) + OPEN_ERROR(ENOSR); + cp->thread = thread; +#endif + ++ppp_comp_count; + qprocson(q); + } + return 0; +} + +MOD_CLOSE(ppp_comp_close) +{ + comp_state_t *cp; + + qprocsoff(q); + cp = (comp_state_t *) q->q_ptr; + if (cp != NULL) { + if (cp->xstate != NULL) + (*cp->xcomp->comp_free)(cp->xstate); + if (cp->rstate != NULL) + (*cp->rcomp->decomp_free)(cp->rstate); +#ifdef __osf__ + if (!cp->thread) + printf("ppp_comp_close: NULL thread!\n"); + else + thread_terminate(cp->thread); +#endif + FREE(cp, sizeof(comp_state_t)); + q->q_ptr = NULL; + OTHERQ(q)->q_ptr = NULL; + --ppp_comp_count; + } + return 0; +} + +#ifdef __osf__ + +/* thread for calling back to a compressor's memory allocator + * Needed for Digital UNIX since it's VM can't handle requests + * for large amounts of memory without blocking. The thread + * provides a context in which we can call a memory allocator + * that may block. + */ +static void +ppp_comp_alloc(comp_state_t *cp) +{ + int len, cmd; + unsigned char *compressor_options; + thread_t thread; + void *(*comp_allocator)(); + + +#if defined(MAJOR_VERSION) && (MAJOR_VERSION <= 2) + + /* In 2.x and earlier the argument gets passed + * in the thread structure itself. Yuck. + */ + thread = current_thread(); + cp = thread->reply_port; + thread->reply_port = PORT_NULL; + +#endif + + for (;;) { + assert_wait((vm_offset_t)&cp->memreq.thread_status, TRUE); + thread_block(); + + if (thread_should_halt(current_thread())) + thread_halt_self(); + cmd = cp->memreq.cmd; + compressor_options = &cp->memreq.comp_opts[0]; + len = compressor_options[1]; + if (cmd == PPPIO_XCOMP) { + cp->memreq.returned_mem = cp->xcomp->comp_alloc(compressor_options, len); + if (!cp->memreq.returned_mem) { + cp->memreq.thread_status = ENOSR; + } else { + cp->memreq.thread_status = 0; + } + } else { + cp->memreq.returned_mem = cp->rcomp->decomp_alloc(compressor_options, len); + if (!cp->memreq.returned_mem) { + cp->memreq.thread_status = ENOSR; + } else { + cp->memreq.thread_status = 0; + } + } + } +} + +#endif /* __osf__ */ + +/* here's the deal with memory allocation under Digital UNIX. + * Some other may also benefit from this... + * We can't ask for huge chunks of memory in a context where + * the caller can't be put to sleep (like, here.) The alloc + * is likely to fail. Instead we do this: the first time we + * get called, kick off a thread to do the allocation. Return + * immediately to the caller with EAGAIN, as an indication that + * they should send down the ioctl again. By the time the + * second call comes in it's likely that the memory allocation + * thread will have returned with the requested memory. We will + * continue to return EAGAIN however until the thread has completed. + * When it has, we return zero (and the memory) if the allocator + * was successful and ENOSR otherwise. + * + * Callers of the RCOMP and XCOMP ioctls are encouraged (but not + * required) to loop for some number of iterations with a small + * delay in the loop body (for instance a 1/10-th second "sleep" + * via select.) + */ +static int +ppp_comp_wput(q, mp) + queue_t *q; + mblk_t *mp; +{ + struct iocblk *iop; + comp_state_t *cp; + int error, len, n; + int flags, mask; + mblk_t *np; + struct compressor **comp; + struct ppp_stats *psp; + struct ppp_comp_stats *csp; + unsigned char *opt_data; + int nxslots, nrslots; + + cp = (comp_state_t *) q->q_ptr; + if (cp == 0) { + DPRINT("cp == 0 in ppp_comp_wput\n"); + freemsg(mp); + return 0; + } + + switch (mp->b_datap->db_type) { + + case M_DATA: + putq(q, mp); + break; + + case M_IOCTL: + iop = (struct iocblk *) mp->b_rptr; + error = EINVAL; + switch (iop->ioc_cmd) { + + case PPPIO_CFLAGS: + /* set/get CCP state */ + if (iop->ioc_count != 2 * sizeof(int)) + break; + if (mp->b_cont == 0) { + DPRINT1("ppp_comp_wput/%d: PPPIO_CFLAGS b_cont = 0!\n", cp->unit); + break; + } + flags = ((int *) mp->b_cont->b_rptr)[0]; + mask = ((int *) mp->b_cont->b_rptr)[1]; + cp->flags = (cp->flags & ~mask) | (flags & mask); + if ((mask & CCP_ISOPEN) && (flags & CCP_ISOPEN) == 0) { + if (cp->xstate != NULL) { + (*cp->xcomp->comp_free)(cp->xstate); + cp->xstate = NULL; + } + if (cp->rstate != NULL) { + (*cp->rcomp->decomp_free)(cp->rstate); + cp->rstate = NULL; + } + cp->flags &= ~CCP_ISUP; + } + error = 0; + iop->ioc_count = sizeof(int); + ((int *) mp->b_cont->b_rptr)[0] = cp->flags; + mp->b_cont->b_wptr = mp->b_cont->b_rptr + sizeof(int); + break; + + case PPPIO_VJINIT: + /* + * Initialize VJ compressor/decompressor + */ + if (iop->ioc_count != 2) + break; + if (mp->b_cont == 0) { + DPRINT1("ppp_comp_wput/%d: PPPIO_VJINIT b_cont = 0!\n", cp->unit); + break; + } + nxslots = mp->b_cont->b_rptr[0] + 1; + nrslots = mp->b_cont->b_rptr[1] + 1; + if (nxslots > MAX_STATES || nrslots > MAX_STATES) + break; + vj_compress_init(&cp->vj_comp, nxslots); + cp->vj_last_ierrors = cp->stats.ppp_ierrors; + error = 0; + iop->ioc_count = 0; + break; + + case PPPIO_XCOMP: + case PPPIO_RCOMP: + if (iop->ioc_count <= 0) + break; + if (mp->b_cont == 0) { + DPRINT1("ppp_comp_wput/%d: PPPIO_[XR]COMP b_cont = 0!\n", cp->unit); + break; + } + opt_data = mp->b_cont->b_rptr; + len = mp->b_cont->b_wptr - opt_data; + if (len > iop->ioc_count) + len = iop->ioc_count; + if (opt_data[1] < 2 || opt_data[1] > len) + break; + for (comp = ppp_compressors; *comp != NULL; ++comp) + if ((*comp)->compress_proto == opt_data[0]) { + /* here's the handler! */ + error = 0; +#ifndef __osf__ + if (iop->ioc_cmd == PPPIO_XCOMP) { + /* A previous call may have fetched memory for a compressor + * that's now being retired or reset. Free it using it's + * mechanism for freeing stuff. + */ + if (cp->xstate != NULL) { + (*cp->xcomp->comp_free)(cp->xstate); + cp->xstate = NULL; + } + cp->xcomp = *comp; + cp->xstate = (*comp)->comp_alloc(opt_data, len); + if (cp->xstate == NULL) + error = ENOSR; + } else { + if (cp->rstate != NULL) { + (*cp->rcomp->decomp_free)(cp->rstate); + cp->rstate = NULL; + } + cp->rcomp = *comp; + cp->rstate = (*comp)->decomp_alloc(opt_data, len); + if (cp->rstate == NULL) + error = ENOSR; + } +#else + if ((error = cp->memreq.thread_status) != EAGAIN) + if (iop->ioc_cmd == PPPIO_XCOMP) { + if (cp->xstate) { + (*cp->xcomp->comp_free)(cp->xstate); + cp->xstate = 0; + } + /* sanity check for compressor options + */ + if (sizeof (cp->memreq.comp_opts) < len) { + printf("can't handle options for compressor %d (%d)\n", opt_data[0], + opt_data[1]); + cp->memreq.thread_status = ENOSR; + cp->memreq.returned_mem = 0; + } + /* fill in request for the thread and kick it off + */ + if (cp->memreq.thread_status == 0 && !cp->memreq.returned_mem) { + bcopy(opt_data, cp->memreq.comp_opts, len); + cp->memreq.cmd = PPPIO_XCOMP; + cp->xcomp = *comp; + error = cp->memreq.thread_status = EAGAIN; + thread_wakeup((vm_offset_t)&cp->memreq.thread_status); + } else { + cp->xstate = cp->memreq.returned_mem; + cp->memreq.returned_mem = 0; + cp->memreq.thread_status = 0; + } + } else { + if (cp->rstate) { + (*cp->rcomp->decomp_free)(cp->rstate); + cp->rstate = NULL; + } + if (sizeof (cp->memreq.comp_opts) < len) { + printf("can't handle options for compressor %d (%d)\n", opt_data[0], + opt_data[1]); + cp->memreq.thread_status = ENOSR; + cp->memreq.returned_mem = 0; + } + if (cp->memreq.thread_status == 0 && !cp->memreq.returned_mem) { + bcopy(opt_data, cp->memreq.comp_opts, len); + cp->memreq.cmd = PPPIO_RCOMP; + cp->rcomp = *comp; + error = cp->memreq.thread_status = EAGAIN; + thread_wakeup((vm_offset_t)&cp->memreq.thread_status); + } else { + cp->rstate = cp->memreq.returned_mem; + cp->memreq.returned_mem = 0; + cp->memreq.thread_status = 0; + } + } +#endif + break; + } + iop->ioc_count = 0; + break; + + case PPPIO_GETSTAT: + if ((cp->flags & LAST_MOD) == 0) { + error = -1; /* let the ppp_ahdl module handle it */ + break; + } + np = allocb(sizeof(struct ppp_stats), BPRI_HI); + if (np == 0) { + error = ENOSR; + break; + } + if (mp->b_cont != 0) + freemsg(mp->b_cont); + mp->b_cont = np; + psp = (struct ppp_stats *) np->b_wptr; + np->b_wptr += sizeof(struct ppp_stats); + iop->ioc_count = sizeof(struct ppp_stats); + psp->p = cp->stats; + psp->vj = cp->vj_comp.stats; + error = 0; + break; + + case PPPIO_GETCSTAT: + np = allocb(sizeof(struct ppp_comp_stats), BPRI_HI); + if (np == 0) { + error = ENOSR; + break; + } + if (mp->b_cont != 0) + freemsg(mp->b_cont); + mp->b_cont = np; + csp = (struct ppp_comp_stats *) np->b_wptr; + np->b_wptr += sizeof(struct ppp_comp_stats); + iop->ioc_count = sizeof(struct ppp_comp_stats); + bzero((caddr_t)csp, sizeof(struct ppp_comp_stats)); + if (cp->xstate != 0) + (*cp->xcomp->comp_stat)(cp->xstate, &csp->c); + if (cp->rstate != 0) + (*cp->rcomp->decomp_stat)(cp->rstate, &csp->d); + error = 0; + break; + + case PPPIO_DEBUG: + if (iop->ioc_count != sizeof(int)) + break; + if (mp->b_cont == 0) { + DPRINT1("ppp_comp_wput/%d: PPPIO_DEBUG b_cont = 0!\n", cp->unit); + break; + } + n = *(int *)mp->b_cont->b_rptr; + if (n == PPPDBG_LOG + PPPDBG_COMP) { + DPRINT1("ppp_comp%d: debug log enabled\n", cp->unit); + cp->flags |= DBGLOG; + error = 0; + iop->ioc_count = 0; + } else { + error = -1; + } + break; + + case PPPIO_LASTMOD: + cp->flags |= LAST_MOD; + error = 0; + break; + + default: + error = -1; + break; + } + + if (error < 0) + putnext(q, mp); + else if (error == 0) { + mp->b_datap->db_type = M_IOCACK; + qreply(q, mp); + } else { + mp->b_datap->db_type = M_IOCNAK; + iop->ioc_error = error; + iop->ioc_count = 0; + qreply(q, mp); + } + break; + + case M_CTL: + switch (*mp->b_rptr) { + case PPPCTL_MTU: + cp->mtu = ((unsigned short *)mp->b_rptr)[1]; + break; + case PPPCTL_MRU: + cp->mru = ((unsigned short *)mp->b_rptr)[1]; + break; + case PPPCTL_UNIT: + cp->unit = mp->b_rptr[1]; + break; + } + putnext(q, mp); + break; + + default: + putnext(q, mp); + } + + return 0; +} + +static int +ppp_comp_wsrv(q) + queue_t *q; +{ + mblk_t *mp, *cmp = NULL; + comp_state_t *cp; + int len, proto, type, hlen, code; + struct ip *ip; + unsigned char *vjhdr, *dp; + + cp = (comp_state_t *) q->q_ptr; + if (cp == 0) { + DPRINT("cp == 0 in ppp_comp_wsrv\n"); + return 0; + } + + while ((mp = getq(q)) != 0) { + /* assert(mp->b_datap->db_type == M_DATA) */ +#ifdef PRIOQ + if (!bcanputnext(q,mp->b_band)) +#else + if (!canputnext(q)) +#endif PRIOQ + { + putbq(q, mp); + break; + } + + /* + * First check the packet length and work out what the protocol is. + */ + len = msgdsize(mp); + if (len < PPP_HDRLEN) { + DPRINT1("ppp_comp_wsrv: bogus short packet (%d)\n", len); + freemsg(mp); + cp->stats.ppp_oerrors++; + putctl1(RD(q)->q_next, M_CTL, PPPCTL_OERROR); + continue; + } + proto = (MSG_BYTE(mp, 2) << 8) + MSG_BYTE(mp, 3); + + /* + * Make sure we've got enough data in the first mblk + * and that we are its only user. + */ + if (proto == PPP_CCP) + hlen = len; + else if (proto == PPP_IP) + hlen = PPP_HDRLEN + MAX_IPHDR; + else + hlen = PPP_HDRLEN; + if (hlen > len) + hlen = len; + if (mp->b_wptr < mp->b_rptr + hlen || mp->b_datap->db_ref > 1) { + PULLUP(mp, hlen); + if (mp == 0) { + DPRINT1("ppp_comp_wsrv: pullup failed (%d)\n", hlen); + cp->stats.ppp_oerrors++; + putctl1(RD(q)->q_next, M_CTL, PPPCTL_OERROR); + continue; + } + } + + /* + * Do VJ compression if requested. + */ + if (proto == PPP_IP && (cp->flags & COMP_VJC)) { + ip = (struct ip *) (mp->b_rptr + PPP_HDRLEN); + if (ip->ip_p == IPPROTO_TCP) { + type = vj_compress_tcp(ip, len - PPP_HDRLEN, &cp->vj_comp, + (cp->flags & COMP_VJCCID), &vjhdr); + switch (type) { + case TYPE_UNCOMPRESSED_TCP: + mp->b_rptr[3] = proto = PPP_VJC_UNCOMP; + break; + case TYPE_COMPRESSED_TCP: + dp = vjhdr - PPP_HDRLEN; + dp[1] = mp->b_rptr[1]; /* copy control field */ + dp[0] = mp->b_rptr[0]; /* copy address field */ + dp[2] = 0; /* set protocol field */ + dp[3] = proto = PPP_VJC_COMP; + mp->b_rptr = dp; + break; + } + } + } + + /* + * Do packet compression if enabled. + */ + if (proto == PPP_CCP) + ppp_comp_ccp(q, mp, 0); + else if (proto != PPP_LCP && (cp->flags & CCP_COMP_RUN) + && cp->xstate != NULL) { + len = msgdsize(mp); + (*cp->xcomp->compress)(cp->xstate, &cmp, mp, len, + (cp->flags & CCP_ISUP? cp->mtu + PPP_HDRLEN: 0)); + if (cmp != NULL) { +#ifdef PRIOQ + cmp->b_band=mp->b_band; +#endif PRIOQ + freemsg(mp); + mp = cmp; + } + } + + /* + * Do address/control and protocol compression if enabled. + */ + if ((cp->flags & COMP_AC) + && !(proto == PPP_LCP && LCP_USE_DFLT(mp))) { + mp->b_rptr += 2; /* drop the address & ctrl fields */ + if (proto < 0x100 && (cp->flags & COMP_PROT)) + ++mp->b_rptr; /* drop the high protocol byte */ + } else if (proto < 0x100 && (cp->flags & COMP_PROT)) { + /* shuffle up the address & ctrl fields */ + mp->b_rptr[2] = mp->b_rptr[1]; + mp->b_rptr[1] = mp->b_rptr[0]; + ++mp->b_rptr; + } + + cp->stats.ppp_opackets++; + cp->stats.ppp_obytes += msgdsize(mp); + putnext(q, mp); + } + + return 0; +} + +static int +ppp_comp_rput(q, mp) + queue_t *q; + mblk_t *mp; +{ + comp_state_t *cp; + struct iocblk *iop; + struct ppp_stats *psp; + + cp = (comp_state_t *) q->q_ptr; + if (cp == 0) { + DPRINT("cp == 0 in ppp_comp_rput\n"); + freemsg(mp); + return 0; + } + + switch (mp->b_datap->db_type) { + + case M_DATA: + putq(q, mp); + break; + + case M_IOCACK: + iop = (struct iocblk *) mp->b_rptr; + switch (iop->ioc_cmd) { + case PPPIO_GETSTAT: + /* + * Catch this on the way back from the ppp_ahdl module + * so we can fill in the VJ stats. + */ + if (mp->b_cont == 0 || iop->ioc_count != sizeof(struct ppp_stats)) + break; + psp = (struct ppp_stats *) mp->b_cont->b_rptr; + psp->vj = cp->vj_comp.stats; + break; + } + putnext(q, mp); + break; + + case M_CTL: + switch (mp->b_rptr[0]) { + case PPPCTL_IERROR: + ++cp->stats.ppp_ierrors; + break; + case PPPCTL_OERROR: + ++cp->stats.ppp_oerrors; + break; + } + putnext(q, mp); + break; + + default: + putnext(q, mp); + } + + return 0; +} + +static int +ppp_comp_rsrv(q) + queue_t *q; +{ + int proto, rv, i; + mblk_t *mp, *dmp = NULL, *np; + uchar_t *dp, *iphdr; + comp_state_t *cp; + int len, hlen, vjlen; + u_int iphlen; + + cp = (comp_state_t *) q->q_ptr; + if (cp == 0) { + DPRINT("cp == 0 in ppp_comp_rsrv\n"); + return 0; + } + + while ((mp = getq(q)) != 0) { + /* assert(mp->b_datap->db_type == M_DATA) */ + if (!canputnext(q)) { + putbq(q, mp); + break; + } + + len = msgdsize(mp); + cp->stats.ppp_ibytes += len; + cp->stats.ppp_ipackets++; + + /* + * First work out the protocol and where the PPP header ends. + */ + i = 0; + proto = MSG_BYTE(mp, 0); + if (proto == PPP_ALLSTATIONS) { + i = 2; + proto = MSG_BYTE(mp, 2); + } + if ((proto & 1) == 0) { + ++i; + proto = (proto << 8) + MSG_BYTE(mp, i); + } + hlen = i + 1; + + /* + * Now reconstruct a complete, contiguous PPP header at the + * start of the packet. + */ + if (hlen < ((cp->flags & DECOMP_AC)? 0: 2) + + ((cp->flags & DECOMP_PROT)? 1: 2)) { + /* count these? */ + goto bad; + } + if (mp->b_rptr + hlen > mp->b_wptr) { + adjmsg(mp, hlen); /* XXX check this call */ + hlen = 0; + } + if (hlen != PPP_HDRLEN) { + /* + * We need to put some bytes on the front of the packet + * to make a full-length PPP header. + * If we can put them in *mp, we do, otherwise we + * tack another mblk on the front. + * XXX we really shouldn't need to carry around + * the address and control at this stage. + */ + dp = mp->b_rptr + hlen - PPP_HDRLEN; + if (dp < mp->b_datap->db_base || mp->b_datap->db_ref > 1) { + np = allocb(PPP_HDRLEN, BPRI_MED); + if (np == 0) + goto bad; + np->b_cont = mp; + mp->b_rptr += hlen; + mp = np; + dp = mp->b_wptr; + mp->b_wptr += PPP_HDRLEN; + } else + mp->b_rptr = dp; + + dp[0] = PPP_ALLSTATIONS; + dp[1] = PPP_UI; + dp[2] = proto >> 8; + dp[3] = proto; + } + + /* + * Now see if we have a compressed packet to decompress, + * or a CCP packet to take notice of. + */ + proto = PPP_PROTOCOL(mp->b_rptr); + if (proto == PPP_CCP) { + len = msgdsize(mp); + if (mp->b_wptr < mp->b_rptr + len) { + PULLUP(mp, len); + if (mp == 0) + goto bad; + } + ppp_comp_ccp(q, mp, 1); + } else if (proto == PPP_COMP) { + if ((cp->flags & CCP_ISUP) + && (cp->flags & CCP_DECOMP_RUN) && cp->rstate + && (cp->flags & CCP_ERR) == 0) { + rv = (*cp->rcomp->decompress)(cp->rstate, mp, &dmp); + switch (rv) { + case DECOMP_OK: + freemsg(mp); + mp = dmp; + if (mp == NULL) { + /* no error, but no packet returned either. */ + continue; + } + break; + case DECOMP_ERROR: + cp->flags |= CCP_ERROR; + ++cp->stats.ppp_ierrors; + putctl1(q->q_next, M_CTL, PPPCTL_IERROR); + break; + case DECOMP_FATALERROR: + cp->flags |= CCP_FATALERROR; + ++cp->stats.ppp_ierrors; + putctl1(q->q_next, M_CTL, PPPCTL_IERROR); + break; + } + } + } else if (cp->rstate && (cp->flags & CCP_DECOMP_RUN)) { + (*cp->rcomp->incomp)(cp->rstate, mp); + } + + /* + * Now do VJ decompression. + */ + proto = PPP_PROTOCOL(mp->b_rptr); + if (proto == PPP_VJC_COMP || proto == PPP_VJC_UNCOMP) { + len = msgdsize(mp) - PPP_HDRLEN; + if ((cp->flags & DECOMP_VJC) == 0 || len <= 0) + goto bad; + + /* + * Advance past the ppp header. + * Here we assume that the whole PPP header is in the first mblk. + */ + np = mp; + dp = np->b_rptr + PPP_HDRLEN; + if (dp >= mp->b_wptr) { + np = np->b_cont; + dp = np->b_rptr; + } + + /* + * Make sure we have sufficient contiguous data at this point. + */ + hlen = (proto == PPP_VJC_COMP)? MAX_VJHDR: MAX_IPHDR; + if (hlen > len) + hlen = len; + if (np->b_wptr < dp + hlen || np->b_datap->db_ref > 1) { + PULLUP(mp, hlen + PPP_HDRLEN); + if (mp == 0) + goto bad; + np = mp; + dp = np->b_rptr + PPP_HDRLEN; + } + + if (proto == PPP_VJC_COMP) { + /* + * Decompress VJ-compressed packet. + * First reset compressor if an input error has occurred. + */ + if (cp->stats.ppp_ierrors != cp->vj_last_ierrors) { + if (cp->flags & DBGLOG) + DPRINT1("ppp%d: resetting VJ\n", cp->unit); + vj_uncompress_err(&cp->vj_comp); + cp->vj_last_ierrors = cp->stats.ppp_ierrors; + } + + vjlen = vj_uncompress_tcp(dp, np->b_wptr - dp, len, + &cp->vj_comp, &iphdr, &iphlen); + if (vjlen < 0) { + if (cp->flags & DBGLOG) + DPRINT2("ppp%d: vj_uncomp_tcp failed, pkt len %d\n", + cp->unit, len); + ++cp->vj_last_ierrors; /* so we don't reset next time */ + goto bad; + } + + /* drop ppp and vj headers off */ + if (mp != np) { + freeb(mp); + mp = np; + } + mp->b_rptr = dp + vjlen; + + /* allocate a new mblk for the ppp and ip headers */ + if ((np = allocb(iphlen + PPP_HDRLEN + 4, BPRI_MED)) == 0) + goto bad; + dp = np->b_rptr; /* prepend mblk with TCP/IP hdr */ + dp[0] = PPP_ALLSTATIONS; /* reconstruct PPP header */ + dp[1] = PPP_UI; + dp[2] = PPP_IP >> 8; + dp[3] = PPP_IP; + bcopy((caddr_t)iphdr, (caddr_t)dp + PPP_HDRLEN, iphlen); + np->b_wptr = dp + iphlen + PPP_HDRLEN; + np->b_cont = mp; + + /* XXX there seems to be a bug which causes panics in strread + if we make an mbuf with only the IP header in it :-( */ + if (mp->b_wptr - mp->b_rptr > 4) { + bcopy((caddr_t)mp->b_rptr, (caddr_t)np->b_wptr, 4); + mp->b_rptr += 4; + np->b_wptr += 4; + } else { + bcopy((caddr_t)mp->b_rptr, (caddr_t)np->b_wptr, + mp->b_wptr - mp->b_rptr); + np->b_wptr += mp->b_wptr - mp->b_rptr; + np->b_cont = mp->b_cont; + freeb(mp); + } + + mp = np; + + } else { + /* + * "Decompress" a VJ-uncompressed packet. + */ + cp->vj_last_ierrors = cp->stats.ppp_ierrors; + if (!vj_uncompress_uncomp(dp, hlen, &cp->vj_comp)) { + if (cp->flags & DBGLOG) + DPRINT2("ppp%d: vj_uncomp_uncomp failed, pkt len %d\n", + cp->unit, len); + ++cp->vj_last_ierrors; /* don't need to reset next time */ + goto bad; + } + mp->b_rptr[3] = PPP_IP; /* fix up the PPP protocol field */ + } + } + + putnext(q, mp); + continue; + + bad: + if (mp != 0) + freemsg(mp); + cp->stats.ppp_ierrors++; + putctl1(q->q_next, M_CTL, PPPCTL_IERROR); + } + + return 0; +} + +/* + * Handle a CCP packet being sent or received. + * Here all the data in the packet is in a single mbuf. + */ +static void +ppp_comp_ccp(q, mp, rcvd) + queue_t *q; + mblk_t *mp; + int rcvd; +{ + int len, clen; + comp_state_t *cp; + unsigned char *dp; + + len = msgdsize(mp); + if (len < PPP_HDRLEN + CCP_HDRLEN) + return; + + cp = (comp_state_t *) q->q_ptr; + dp = mp->b_rptr + PPP_HDRLEN; + len -= PPP_HDRLEN; + clen = CCP_LENGTH(dp); + if (clen > len) + return; + + switch (CCP_CODE(dp)) { + case CCP_CONFREQ: + case CCP_TERMREQ: + case CCP_TERMACK: + cp->flags &= ~CCP_ISUP; + break; + + case CCP_CONFACK: + if ((cp->flags & (CCP_ISOPEN | CCP_ISUP)) == CCP_ISOPEN + && clen >= CCP_HDRLEN + CCP_OPT_MINLEN + && clen >= CCP_HDRLEN + CCP_OPT_LENGTH(dp + CCP_HDRLEN)) { + if (!rcvd) { + if (cp->xstate != NULL + && (*cp->xcomp->comp_init) + (cp->xstate, dp + CCP_HDRLEN, clen - CCP_HDRLEN, + cp->unit, 0, ((cp->flags & DBGLOG) != 0))) + cp->flags |= CCP_COMP_RUN; + } else { + if (cp->rstate != NULL + && (*cp->rcomp->decomp_init) + (cp->rstate, dp + CCP_HDRLEN, clen - CCP_HDRLEN, + cp->unit, 0, cp->mru, ((cp->flags & DBGLOG) != 0))) + cp->flags = (cp->flags & ~CCP_ERR) | CCP_DECOMP_RUN; + } + } + break; + + case CCP_RESETACK: + if (cp->flags & CCP_ISUP) { + if (!rcvd) { + if (cp->xstate && (cp->flags & CCP_COMP_RUN)) + (*cp->xcomp->comp_reset)(cp->xstate); + } else { + if (cp->rstate && (cp->flags & CCP_DECOMP_RUN)) { + (*cp->rcomp->decomp_reset)(cp->rstate); + cp->flags &= ~CCP_ERROR; + } + } + } + break; + } +} + +#if 0 +dump_msg(mp) + mblk_t *mp; +{ + dblk_t *db; + + while (mp != 0) { + db = mp->b_datap; + DPRINT2("mp=%x cont=%x ", mp, mp->b_cont); + DPRINT3("rptr=%x wptr=%x datap=%x\n", mp->b_rptr, mp->b_wptr, db); + DPRINT2(" base=%x lim=%x", db->db_base, db->db_lim); + DPRINT2(" ref=%d type=%d\n", db->db_ref, db->db_type); + mp = mp->b_cont; + } +} +#endif + +static int +msg_byte(mp, i) + mblk_t *mp; + unsigned int i; +{ + while (mp != 0 && i >= mp->b_wptr - mp->b_rptr) + mp = mp->b_cont; + if (mp == 0) + return -1; + return mp->b_rptr[i]; +} |