X-Git-Url: http://git.ozlabs.org/?p=ppp.git;a=blobdiff_plain;f=modules%2Fppp_comp.c;h=9cb77c306920536345c4cd516ada4befdcb02f77;hp=0e28c3354bb4ea1645a181c9c29f6c5883ec0a5d;hb=7a4dc0ff500aaa176a41965d8d4ad15a97a70904;hpb=5c678fe1d4c90d83236a0a7e860381002bddaf02

diff --git a/modules/ppp_comp.c b/modules/ppp_comp.c
index 0e28c33..9cb77c3 100644
--- a/modules/ppp_comp.c
+++ b/modules/ppp_comp.c
@@ -24,7 +24,7 @@
  * OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS,
  * OR MODIFICATIONS.
  *
- * $Id: ppp_comp.c,v 1.4 1996/06/26 00:54:20 paulus Exp $
+ * $Id: ppp_comp.c,v 1.10 1999/02/26 10:52:07 paulus Exp $
  */
 
 /*
@@ -42,6 +42,9 @@
 #include <sys/ddi.h>
 #else
 #include <sys/user.h>
+#ifdef __osf__
+#include <sys/cmn_err.h>
+#endif
 #endif /* SVR4 */
 
 #include <net/ppp_defs.h>
@@ -79,7 +82,11 @@ static int msg_byte __P((mblk_t *, unsigned int));
 
 #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 = {
@@ -91,21 +98,22 @@ 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;
-    void *mem;
-    int len;
+    unsigned char comp_opts[20];
     int cmd;
-    int ret;
+    int thread_status;
+    char *returned_mem;
 } memreq_t;
 
 #endif
@@ -136,6 +144,7 @@ extern task_t first_task;
 /* 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 (?) */
@@ -147,8 +156,12 @@ extern task_t first_task;
  * List of compressors we know about.
  */
 
+#if DO_BSD_COMPRESS
 extern struct compressor ppp_bsd_compress;
-extern struct compressor ppp_deflate;
+#endif
+#if DO_DEFLATE
+extern struct compressor ppp_deflate, ppp_deflate_draft;
+#endif
 
 struct compressor *ppp_compressors[] = {
 #if DO_BSD_COMPRESS
@@ -156,6 +169,7 @@ struct compressor *ppp_compressors[] = {
 #endif
 #if DO_DEFLATE
     &ppp_deflate,
+    &ppp_deflate_draft,
 #endif
     NULL
 };
@@ -174,20 +188,19 @@ MOD_OPEN(ppp_comp_open)
 	cp = (comp_state_t *) ALLOC_SLEEP(sizeof(comp_state_t));
 	if (cp == NULL)
 	    OPEN_ERROR(ENOSR);
-	WR(q)->q_ptr = q->q_ptr = (caddr_t) cp;
 	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_MRU;
+	cp->mtu = PPP_MTU;
 	cp->xstate = NULL;
 	cp->rstate = NULL;
 	vj_compress_init(&cp->vj_comp, -1);
-	++ppp_comp_count;
-	qprocson(q);
 #ifdef __osf__
 	if (!(thread = kernel_thread_w_arg(first_task, ppp_comp_alloc, (void *)cp)))
 		OPEN_ERROR(ENOSR);
 	cp->thread = thread;
 #endif
+	qprocson(q);
     }
     return 0;
 }
@@ -207,12 +220,11 @@ MOD_CLOSE(ppp_comp_close)
 	if (!cp->thread)
 	    printf("ppp_comp_close: NULL thread!\n");
 	else
-	    thread_deallocate(cp->thread);
+	    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;
 }
@@ -228,12 +240,13 @@ MOD_CLOSE(ppp_comp_close)
 static void
 ppp_comp_alloc(comp_state_t *cp)
 {
-    unsigned char *opt_data;
     int len, cmd;
-    struct compressor *comp;
+    unsigned char *compressor_options;
     thread_t thread;
+    void *(*comp_allocator)();
+
 
-#if (MAJOR_VERSION <= 2)
+#if defined(MAJOR_VERSION) && (MAJOR_VERSION <= 2)
 
     /* In 2.x and earlier the argument gets passed
      * in the thread structure itself.  Yuck.
@@ -245,30 +258,29 @@ ppp_comp_alloc(comp_state_t *cp)
 #endif
 
     for (;;) {
-	assert_wait((vm_offset_t)&cp->memreq.comp, TRUE);
+	assert_wait((vm_offset_t)&cp->memreq.thread_status, TRUE);
 	thread_block();
-	opt_data = cp->memreq.comp;
-	len = cp->memreq.len;
-	cmd = cp->memreq.cmd;
 
-        if (cmd == PPPIO_XCOMP) {
-	    comp = cp->xcomp;
-	    cp->memreq.mem = (*comp->comp_alloc)(opt_data, len);
+	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 {
-	    comp = cp->rcomp;
-	    cp->memreq.mem = (*comp->decomp_alloc)(opt_data, len);
+	    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;
+	    }
 	}
-	if (!cp->memreq.mem)
-	    cp->memreq.ret = ENOSR;
-	else
-	    bcopy(opt_data, cp->memreq.mem, len);
-
-	/* have to free thunk here, since there's
-	 * no guarantee that the user will call the ioctl
-	 * again if we've taken a long time to complete
-	 */
-	FREE(opt_data, len);
-	cp->memreq.ret = 0;
     }
 }
 
@@ -300,7 +312,7 @@ ppp_comp_wput(q, mp)
 {
     struct iocblk *iop;
     comp_state_t *cp;
-    int error, len;
+    int error, len, n;
     int flags, mask;
     mblk_t *np;
     struct compressor **comp;
@@ -310,6 +322,12 @@ ppp_comp_wput(q, mp)
     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:
@@ -325,6 +343,10 @@ ppp_comp_wput(q, mp)
 	    /* 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);
@@ -351,6 +373,10 @@ ppp_comp_wput(q, mp)
 	     */
 	    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)
@@ -365,6 +391,10 @@ ppp_comp_wput(q, mp)
 	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)
@@ -375,8 +405,8 @@ ppp_comp_wput(q, mp)
 		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.
@@ -385,106 +415,72 @@ ppp_comp_wput(q, mp)
 			    (*cp->xcomp->comp_free)(cp->xstate);
 			    cp->xstate = NULL;
 			}
-
-#ifdef __osf__
-			/* Account for an orpahned call to get memory.
-			 * Free that memory up and go on.
-			 *
-			 * The trick is that we need to be able to tell
-			 * the difference between an old call that kicked
-			 * off a thread where the memory was subsequently
-			 * orphaned, and the memory we're really interested
-			 * in.  The thread helps by stamping the memory it
-			 * allocated with the parameters for the compressor
-			 * it belongs to.  If the parameters match then this
-			 * is the memory we want (whether it was an actual
-			 * orphan or not we don't care.)  If the parameters
-			 * don't match then this is an orphan.
-			 *
-			 * Note that cp->memreq.ret is the synchronization
-			 * point: we set it to EAGAIN in this function, then
-			 * wait for the thread to set it to something other
-			 * than EAGAIN before we fool with the data structure
-			 * again.  Basically, if ret != EAGAIN then the thread
-			 * is working and it owns the memreq struture.
+			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 (cp->memreq.ret == 0 && cp->memreq.mem != NULL &&
-			    bcmp(cp->memreq.mem, opt_data, len)) {
-			    (*cp->xcomp->comp_free)(cp->memreq.mem);
-			    cp->memreq.mem = 0;
+			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;
 			}
-
-			/* First time through, prime the pump and kick
-			 * off the thread.  Subsequent times though, the thread
-			 * is either busy (ret == EAGAIN) or finsihed (mem != NULL)
-			 * || (ret != 0)
+			/* fill in request for the thread and kick it off
 			 */
-			if (cp->memreq.ret == 0 && cp->memreq.mem == NULL) {
-			    cp->memreq.comp = ALLOC_NOSLEEP(len);
-			    if (!cp->memreq.comp) {
-				printf("gack! can't get memory for thunk\n");
-				return ENOSR;
-			    }
-			    bcopy(opt_data, cp->memreq.comp, len);
-			    cp->memreq.len = len;
+			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;
-			    cp->memreq.ret = EAGAIN;
-			    thread_wakeup((vm_offset_t)&cp->memreq.comp);
-			}
-
-			/* Collect results from the thread, and reset the
-			 * mechanism for the next attempt to allocate memory
-			 * If the thread isn't finished (ret == EAGAIN) then
-			 * don't reset and just return.
-			 */
-			if ((error = cp->memreq.ret) != EAGAIN) {
-			    cp->xstate = cp->memreq.mem;
-			    cp->memreq.mem = 0;
-			    cp->memreq.ret = 0;
+			    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
-			cp->xcomp = *comp;
-			cp->xstate = (*comp)->comp_alloc(opt_data, len);
-			if (cp->xstate == NULL)
-			    error = ENOSR;
-#endif
 		    } else {
-			if (cp->rstate != NULL) {
+			if (cp->rstate) {
 			    (*cp->rcomp->decomp_free)(cp->rstate);
 			    cp->rstate = NULL;
 			}
-#ifdef __osf__
-			if (cp->memreq.ret == 0 && cp->memreq.mem != NULL &&
-			    bcmp(cp->memreq.mem, opt_data, len)) {
-			    (*cp->rcomp->comp_free)(cp->memreq.mem);
-			    cp->memreq.mem = 0;
+			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.ret == 0 && cp->memreq.mem == NULL) {
-			    cp->memreq.comp = ALLOC_NOSLEEP(len);
-			    if (!cp->memreq.comp) {
-				printf("gack! can't get memory for thunk\n");
-				return ENOSR;
-			    }
-			    bcopy(opt_data, cp->memreq.comp, len);
-			    cp->memreq.len = len;
+			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;
-			    cp->memreq.ret = EAGAIN;
-			    thread_wakeup((vm_offset_t)&cp->memreq.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;
 			}
-			if ((error = cp->memreq.ret) != EAGAIN) {
-			    cp->rstate = cp->memreq.mem;
-			    cp->memreq.mem = 0;
-			    cp->memreq.ret = 0;
-			}
-#else
-			cp->rcomp = *comp;
-			cp->rstate = (*comp)->decomp_alloc(opt_data, len);
-			if (cp->rstate == NULL)
-			    error = ENOSR;
-#endif
 		    }
+#endif
 		    break;
 		}
 	    iop->ioc_count = 0;
@@ -531,6 +527,24 @@ ppp_comp_wput(q, mp)
 	    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;
@@ -572,6 +586,8 @@ ppp_comp_wput(q, mp)
     default:
 	putnext(q, mp);
     }
+
+    return 0;
 }
 
 static int
@@ -585,11 +601,21 @@ ppp_comp_wsrv(q)
     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) */
-	if (!canputnext(q)) {
+#ifdef PRIOQ
+        if (!bcanputnext(q,mp->b_band))
+#else
+        if (!canputnext(q))
+#endif PRIOQ
+	{
 	    putbq(q, mp);
-	    return;
+	    break;
 	}
 
 	/*
@@ -609,9 +635,9 @@ ppp_comp_wsrv(q)
 	 * Make sure we've got enough data in the first mblk
 	 * and that we are its only user.
 	 */
-	if (proto = PPP_CCP)
+	if (proto == PPP_CCP)
 	    hlen = len;
-	else if (proto = PPP_IP)
+	else if (proto == PPP_IP)
 	    hlen = PPP_HDRLEN + MAX_IPHDR;
 	else
 	    hlen = PPP_HDRLEN;
@@ -626,7 +652,6 @@ ppp_comp_wsrv(q)
 		continue;
 	    }
 	}
-	proto = PPP_PROTOCOL(mp->b_rptr);
 
 	/*
 	 * Do VJ compression if requested.
@@ -661,8 +686,11 @@ ppp_comp_wsrv(q)
 		 && cp->xstate != NULL) {
 	    len = msgdsize(mp);
 	    (*cp->xcomp->compress)(cp->xstate, &cmp, mp, len,
-				   (cp->flags & CCP_ISUP? cp->mtu: 0));
+			(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;
 	    }
@@ -687,6 +715,8 @@ ppp_comp_wsrv(q)
 	cp->stats.ppp_obytes += msgdsize(mp);
 	putnext(q, mp);
     }
+
+    return 0;
 }
 
 static int
@@ -699,6 +729,12 @@ ppp_comp_rput(q, mp)
     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:
@@ -737,6 +773,8 @@ ppp_comp_rput(q, mp)
     default:
 	putnext(q, mp);
     }
+
+    return 0;
 }
 
 static int
@@ -751,11 +789,16 @@ ppp_comp_rsrv(q)
     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);
-	    return;
+	    break;
 	}
 
 	len = msgdsize(mp);
@@ -901,7 +944,8 @@ ppp_comp_rsrv(q)
 		 * First reset compressor if an input error has occurred.
 		 */
 		if (cp->stats.ppp_ierrors != cp->vj_last_ierrors) {
-		    DPRINT1("ppp%d: resetting VJ\n", cp->unit);
+		    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;
 		}
@@ -909,17 +953,9 @@ ppp_comp_rsrv(q)
 		vjlen = vj_uncompress_tcp(dp, np->b_wptr - dp, len,
 					  &cp->vj_comp, &iphdr, &iphlen);
 		if (vjlen < 0) {
-#if DEBUG > 1
-		    int i;
-		    DPRINT2("ppp%d: vj_uncomp_tcp failed, pkt len %d [",
-			    cp->unit, len);
-		    for (i = 0; i < len && i < 8; ++i)
-			DPRINT1(" %x", dp[i]);
-		    DPRINT3("] c=%d u=%d e=%d\n",
-			    cp->vj_comp.stats.vjs_compressedin,
-			    cp->vj_comp.stats.vjs_uncompressedin,
-			    cp->vj_comp.stats.vjs_errorin);
-#endif
+		    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;
 		}
@@ -965,10 +1001,9 @@ ppp_comp_rsrv(q)
 		 */
 		cp->vj_last_ierrors = cp->stats.ppp_ierrors;
 		if (!vj_uncompress_uncomp(dp, hlen, &cp->vj_comp)) {
-#if DEBUG > 1
-		    DPRINT2("ppp%d: vj_uncomp_uncomp failed, pkt len %d\n",
-			    cp->unit, len);
-#endif
+		    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;
 		}
@@ -985,6 +1020,8 @@ ppp_comp_rsrv(q)
 	cp->stats.ppp_ierrors++;
 	putctl1(q->q_next, M_CTL, PPPCTL_IERROR);
     }
+
+    return 0;
 }
 
 /*
@@ -1027,13 +1064,13 @@ ppp_comp_ccp(q, mp, rcvd)
 		if (cp->xstate != NULL
 		    && (*cp->xcomp->comp_init)
 		        (cp->xstate, dp + CCP_HDRLEN, clen - CCP_HDRLEN,
-			 cp->unit, 0, 0))
+			 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, 0))
+			 cp->unit, 0, cp->mru, ((cp->flags & DBGLOG) != 0)))
 		    cp->flags = (cp->flags & ~CCP_ERR) | CCP_DECOMP_RUN;
 	    }
 	}
@@ -1055,7 +1092,7 @@ ppp_comp_ccp(q, mp, rcvd)
     }
 }
 
-#if DEBUG
+#if 0
 dump_msg(mp)
     mblk_t *mp;
 {