Added MemCheck build capability. Found and fixed a significant memory leak as...

Added MemCheck build capability.  Found and fixed a significant memory leak as a result of this, which would lose you whatever your MRU size was plus about another 130 bytes (for headers, FCS etc.) per pppconnect.

Version 1.20. Tagged as 'PPP-1_20'

!DSMemCheck,fd7

+| Copyright 1998 Acorn Computers Ltd
+|
+| Licensed under the Apache License, Version 2.0 (the "License");
+| you may not use this file except in compliance with the License.
+| You may obtain a copy of the License at
+|
+|     http://www.apache.org/licenses/LICENSE-2.0
+|
+| Unless required by applicable law or agreed to in writing, software
+| distributed under the License is distributed on an "AS IS" BASIS,
+| WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+| See the License for the specific language governing permissions and
+| limitations under the License.
+|
+Dir <Obey$Dir>
+wimpslot 2048k
+amu_machine ram THROWBACK=-throwback ASMBLOCKDRIVERS={FALSE} CCEXTRA="-g -fn" MEMCHECKCC="MemCheck.CC" MEMCHECKLD="MemCheck.DDTModLink"
\ No newline at end of file

Makefile

@@ -32,16 +32,16 @@ EXP_HDR	=	<export$dir>
 #
 MKDIR =		cdir
 AS =		objasm
-CC =		cc
+CC =		${MEMCHECKCC} cc
 CMHG =		cmhg
 CP =		copy
-LD =		link
+LD =		${MEMCHECKLD} link
 RM =		remove
 MODSQZ =	modsqz
 WIPE =		-wipe
 
 ASMFLAGS =	-depend !Depend ${THROWBACK} -predefine "BlockDrivers SETL ${ASMBLOCKDRIVERS}"
-CFLAGS =	-depend !Depend ${THROWBACK} ${INCLUDES} ${CBLOCKDRIVERS} -strict -wP -ffah 
+CFLAGS =	-depend !Depend ${THROWBACK} ${INCLUDES} ${CBLOCKDRIVERS} -strict -wP -ffah ${CCEXTRA}
 CMHGFLAGS =	-depend !Depend ${THROWBACK} ${INCLUDES} ${CBLOCKDRIVERS} -p
 CPFLAGS =	~cfr~v
 WFLAGS =	~c~v
@@ -67,7 +67,8 @@ UNIXLIB   = TCPIPLibs:o.unixlibzm
 LIBS =\
  ${INETLIB}\
  ${SOCKLIB}\
- ${UNIXLIB}
+ ${UNIXLIB}\
+# MemCheck:o.MC_M\
 		
 
 LIBSD =\

VersionASM

@@ -5,8 +5,8 @@
 			GBLA    Module_Version
 			GBLS	Module_MinorVersion
 			GBLS	Module_Date
-Module_MajorVersion	SETS    "1.19"
-Module_Version          SETA    1.19
+Module_MajorVersion	SETS    "1.20"
+Module_Version          SETA    120
 Module_MinorVersion	SETS	""
-Module_Date		SETS    "12 Mar 1998"
+Module_Date		SETS    "28 Apr 1998"
 		        END

VersionNum

-/* (1.19)
+/* (1.20)
  *
  * This file is automatically maintained by srccommit, do not edit manually.
  *
  */
-#define Module_MajorVersion_CMHG     	1.19
+#define Module_MajorVersion_CMHG     	1.20
 #define Module_MinorVersion_CMHG	
-#define Module_Date_CMHG      		12 Mar 1998
+#define Module_Date_CMHG      		28 Apr 1998
 
-#define Module_MajorVersion     	"1.19"
-#define Module_Version                  1.19
+#define Module_MajorVersion     	"1.20"
+#define Module_Version                  120
 #define Module_MinorVersion		""
-#define Module_Date      		"12 Mar 1998"
+#define Module_Date      		"28 Apr 1998"
 

c/if_ppp

@@ -140,6 +140,7 @@ static char *ack_if_ppp="Copyright (c) 1989 Carnegie Mellon University. "
 
 #include "pppd/minixlib.h"
 #include "pppd/main.h"
+#include "MemCheck/MemCheck.h"
 
 
 
@@ -304,11 +305,17 @@ void pppclose(int fd)
     /* Do some sort of buffer flush/ serial close */
     s = splimp();		/* paranoid; splnet probably ok */
     serial_finalise();
-                    MBCTL.freem(&MBCTL, sc->sc_outm);
-                    sc->sc_outm = NULL;
-                    MBCTL.freem(&MBCTL, sc->sc_m);
-                    sc->sc_m = NULL;
-                    pppdealloc(sc);
+
+    MBCTL.freem(&MBCTL, sc->sc_outm);
+    sc->sc_outm = NULL;
+    if (sc->sc_m)
+    {
+        MRESET(sc->sc_m);
+        free(mtod(sc->sc_m, void *));
+        MBCTL.freem(&MBCTL, sc->sc_m);
+        sc->sc_m = NULL;
+    }
+    pppdealloc(sc);
 
 
     unsplimp(s);
@@ -351,6 +358,7 @@ int pppread(int fd, u_char *p, int n)
 /*
  * Line specific (tty) write routine.
  */
+
 int pppwrite(int s, u_char *p, int nbytes)
 {
     struct ppp_softc *sc = &ppp_softc[s];
@@ -808,6 +816,7 @@ static struct mbuf *ppp_dequeue(struct ppp_softc *sc)
 	/* If the first mbuf is < or smaller than a PPP header, skip
 	   to the next one
 	 */
+
 	if (mp->m_len <= PPP_HDRLEN)
 	{
 	    mp = mp->m_next;
@@ -953,12 +962,16 @@ _kernel_oserror *start_handler(_kernel_swi_regs *r, void *pw)
 
     _kernel_irqs_on();
 
+    MemCheck_RegisterMiscBlock (r, sizeof (_kernel_swi_regs));
+
     pdebug ((LOG_DEBUG, "in_pppstart: %d", in_pppstart));
     if (!in_pppstart)
         pppstart(0);
    /* else
         serial_enableevents();*/
 
+    MemCheck_UnRegisterMiscBlock (r);
+
     return (NULL);
 
     NOT_USED (r);
@@ -1222,6 +1235,7 @@ void pppstart(int fd)
 /*
  * Allocate enough mbuf to handle current MRU.
  */
+
 static int pppgetm(struct ppp_softc *sc)
 {
     int len = HDROFF + sc->sc_mru + PPP_HDRLEN + PPP_FCSLEN;
@@ -1255,6 +1269,8 @@ static int pppgetm(struct ppp_softc *sc)
     return 1;
 }
 
+
+
 /*
  * PPP packet input routine.
  * The caller has checked and removed the FCS.
@@ -1564,7 +1580,9 @@ void pppinput(int c, int fd)
 
         /* Paranoia */
         if (!m)
+        {
             return;
+        }
 
         m->m_type = 0; /* Mark packet as unread */
         m->m_len = 0;

c/pppmodule

@@ -72,6 +72,8 @@
   #include "Trace.Trace.h"
 #endif
 
+#include "MemCheck/MemCheck.h"
+
 
 #define PPP_AlterSettings_Timeout        0
 
@@ -177,10 +179,12 @@ static _kernel_oserror *ppp_error(int error)
 /*
  * freelist - free an mbuf list
  */
+
 void freelist(struct mbuf *m0)
 {
     struct mbuf *m;
 
+
     while (m0)
     {
         m=m0->m_list;
@@ -324,22 +328,29 @@ static int do_singlefilter(_kernel_swi_regs *r)
     int unit = r->r[1];
     FilterSingleRef fs = ppp_softc[unit].inetfilter;
 
+    MemCheck_RegisterMiscBlock (r, sizeof (_kernel_swi_regs));
     /*
      * check whether claiming or releasing
      */
     if (r->r[0] & FILTER_RELEASE)
     {
 	if (!fs)
+	{
 	    /*
 	     * trying to free a non-existent claim
 	     */
+	    MemCheck_UnRegisterMiscBlock (r);
 	    return EINVAL;
+	}
 
 	if (fs->fs_handler != (void (*)())r->r[6] || fs->fs_pwptr != r->r[5])
+	{
 	    /*
 	     * trying to release somebody else's claim
 	     */
+	    MemCheck_UnRegisterMiscBlock (r);
 	    return EPERM;
+	}
 
 	/*
 	 * everything checks out, do the free
@@ -376,17 +387,20 @@ static int do_singlefilter(_kernel_swi_regs *r)
 		 * we can bring the card up live once again.
 		 */
 		if( (error = enioctl(unit, 1, 1)) != 0 )
+		{
 		    /*
 		     * return an error, but *do not* free the structure
 		     */
+		    MemCheck_UnRegisterMiscBlock (r);
 		    return error;
+		}
 
 		/*
 		 * set receive level for this unit to the
 		 * loosest address filtering necessary.
 		 */
 		update_addrlevel(unit);
-
+		MemCheck_UnRegisterMiscBlock (r);
 		return 0;
 	    }
 	    else
@@ -394,14 +408,18 @@ static int do_singlefilter(_kernel_swi_regs *r)
 		/*
 		 * this frame level is already claimed in some fashion
 		 */
+		MemCheck_UnRegisterMiscBlock (r);
 		return(INETERR_FILTERGONE);
 	}
 
 	if( (fs = (FilterSingleRef)malloc(sizeof(*fs))) == NULL )
+	{
 	    /*
 	     * cannot claim memory for this structure
 	     */
+	    MemCheck_UnRegisterMiscBlock (r);
 	    return(ENOMEM);
+	}
 
 	/*
 	 * check that we can bring the card up live
@@ -428,6 +446,7 @@ static int do_singlefilter(_kernel_swi_regs *r)
     }
 
     /* all OK */
+    MemCheck_UnRegisterMiscBlock (r);
     return(0);
 }
 
@@ -474,11 +493,19 @@ static void stats_init(void)
 
 static int ppp_filter(_kernel_swi_regs *r)
 {
-    int flags=r->r[0];
-    int unit=r->r[1];
-    int frametype=r->r[2];
-    int addrlevel=r->r[3];
-    int errlevel=r->r[4];
+    int flags;
+    int unit;
+    int frametype;
+    int addrlevel;
+    int errlevel;
+
+    MemCheck_RegisterMiscBlock (r, sizeof (_kernel_swi_regs));
+
+    flags     = r->r[0];
+    unit      = r->r[1];
+    frametype = r->r[2];
+    addrlevel = r->r[3];
+    errlevel  = r->r[4];
 
     pdebug ((LOG_DEBUG,
              "PPP_Filter: flags=%d unit=%d frametype=%d addrlevel=%d errlevel=%d\n",
@@ -491,16 +518,23 @@ static int ppp_filter(_kernel_swi_regs *r)
         unit >= NPPP ||
        !check_addrlevel(addrlevel) ||
        !check_errlevel(errlevel) )
+    {
+	MemCheck_UnRegisterMiscBlock (r);
 	return(EINVAL);
+    }
 
     /*
      * now check type and level
      */
     if( (GET_FRAMELEVEL(frametype)) != FRMLVL_E2SPECIFIC ||
         (GET_FRAMETYPE(frametype)) != ETHERTYPE_IP )
+    {
+	MemCheck_UnRegisterMiscBlock (r);
 	return(EINVAL);
+    }
 
     /* that's all */
+    MemCheck_UnRegisterMiscBlock (r);
     return(do_singlefilter(r));
 }
 
@@ -508,10 +542,15 @@ static int ppp_filter(_kernel_swi_regs *r)
 
 static int ppp_version(_kernel_swi_regs *r)
 {
+    MemCheck_RegisterMiscBlock (r, sizeof (_kernel_swi_regs));
     if( r->r[0] )
+    {
+	MemCheck_UnRegisterMiscBlock (r);
 	return(EINVAL);
+    }
 
     r->r[1] = DCIVERSION;
+    MemCheck_UnRegisterMiscBlock (r);
     return (0);
 }
 
@@ -519,11 +558,16 @@ static int ppp_version(_kernel_swi_regs *r)
 
 static int ppp_inquire(_kernel_swi_regs *r)
 {
+    MemCheck_RegisterMiscBlock (r, sizeof (_kernel_swi_regs));
     if( r->r[0] )
+    {
+	MemCheck_UnRegisterMiscBlock (r);
 	return(EINVAL);
+    }
 
     r->r[2] = ppp_softc[r->r[1]].dib.dib_inquire;
 
+    MemCheck_UnRegisterMiscBlock (r);
     return(0);
 }
 
@@ -531,14 +575,23 @@ static int ppp_inquire(_kernel_swi_regs *r)
 
 static int ppp_getmtu(_kernel_swi_regs *r)
 {
-    int flags=r->r[0];
-    int unit=r->r[1];
+    int flags;
+    int unit;
+
+    MemCheck_RegisterMiscBlock (r, sizeof (_kernel_swi_regs));
+
+    flags = r->r[0];
+    unit  = r->r[1];
 
     if (flags || unit < 0 || unit >= NPPP)
+    {
+	MemCheck_UnRegisterMiscBlock (r);
 	return EINVAL;
+    }
 
     r->r[2] = ppp_softc[unit].sc_mtu;
 
+    MemCheck_UnRegisterMiscBlock (r);
     return 0;
 }
 
@@ -546,14 +599,23 @@ static int ppp_getmtu(_kernel_swi_regs *r)
 
 static int ppp_setmtu(_kernel_swi_regs *r)
 {
-    int flags=r->r[0];
-    int unit=r->r[1];
+    int flags;
+    int unit;
+
+    MemCheck_RegisterMiscBlock (r, sizeof (_kernel_swi_regs));
+
+    flags = r->r[0];
+    unit  = r->r[1];
 
     if (flags || unit < 0 || unit >= NPPP)
+    {
+	MemCheck_UnRegisterMiscBlock (r);
 	return EINVAL;
+    }
 
     ppp_softc[unit].sc_mtu=r->r[2];
 
+    MemCheck_UnRegisterMiscBlock (r);
     return 0;
 }
 
@@ -569,27 +631,39 @@ int rxerrors;
 static int ppp_transmit(_kernel_swi_regs *r)
 {
     const static struct sockaddr dst={AF_INET}; /* Bodge! */
-    unsigned flags=r->r[0];
-    int unit=r->r[1];
-    unsigned type=r->r[2];
-    struct mbuf *m0=(struct mbuf *)r->r[3], *md, *md1, *m1, **m2, *temp;
+    unsigned flags;
+    int unit;
+    unsigned type;
+    struct mbuf *m0, *md, *md1, *m1, **m2, *temp;
     int error=0;
-#ifdef DEBUG
-    int packet_len, packet_count;
 
-    for (m0 = (struct mbuf *)r->r[3], packet_count = 1;
-         m0;
-         m0 = m0->m_list, packet_count++)
+    MemCheck_RegisterMiscBlock (r, sizeof (_kernel_swi_regs));
+
+    flags = r->r[0];
+    unit  = r->r[1];
+    type  = r->r[2];
+    m0    = (struct mbuf *) r->r[3];
+
+#ifdef DEBUG
     {
-        for (m1 = m0, packet_len = 0; m1; m1 = m1->m_next)
+        int packet_len, packet_count;
+        struct mbuf *  debug_m0;
+        struct mbuf *  debug_m1;
+
+        for (debug_m0 = (struct mbuf *)r->r[3], packet_count = 1;
+             debug_m0;
+             debug_m0 = debug_m0->m_list, packet_count++)
         {
-            packet_len += m1->m_len;
-        }
+            for (debug_m1 = debug_m0, packet_len = 0;
+                 debug_m1;
+                 debug_m1 = debug_m1->m_next)
+            {
+                packet_len += debug_m1->m_len;
+            }
 
-        syslog (LOG_DEBUG, "Packet %d length: %d", packet_count, packet_len);
+            syslog (LOG_DEBUG, "Packet %d length: %d", packet_count, packet_len);
+        }
     }
-
-    m0=(struct mbuf *)r->r[3];
 #endif
 
 
@@ -602,6 +676,7 @@ static int ppp_transmit(_kernel_swi_regs *r)
         if (!(flags & TX_PROTOSDATA))
             freelist(m0);
 
+	MemCheck_UnRegisterMiscBlock (r);
         return error;
     }
 #if 0
@@ -678,6 +753,7 @@ static int ppp_transmit(_kernel_swi_regs *r)
     else
         error=pppoutput(&ppp_softc[unit].dib, md, &dst);
 
+    MemCheck_UnRegisterMiscBlock (r);
     return error;
 }
 
@@ -685,11 +761,17 @@ static int ppp_transmit(_kernel_swi_regs *r)
 
 static int ppp_stats(_kernel_swi_regs *r)
 {
-    unsigned flags=r->r[0];
-    int unit=r->r[1];
-    struct stats *output=(struct stats *) r->r[2];
+    unsigned flags;
+    int unit;
+    struct stats *output;
     const struct stats *ps;
 
+    MemCheck_RegisterMiscBlock (r, sizeof (_kernel_swi_regs));
+
+    flags  = r->r[0];
+    unit   = r->r[1];
+    output = (struct stats *) r->r[2];
+
     switch (flags)
     {
         case 0:
@@ -701,11 +783,13 @@ static int ppp_stats(_kernel_swi_regs *r)
             break;
 
         default:
+            MemCheck_UnRegisterMiscBlock (r);
             return EINVAL;
     }
 
     memcpy(output, ps, sizeof(struct stats));
 
+    MemCheck_UnRegisterMiscBlock (r);
     return 0;
 }
 
@@ -713,8 +797,11 @@ static int ppp_stats(_kernel_swi_regs *r)
 
 static _kernel_oserror *ppp_alter_settings (_kernel_swi_regs *r)
 {
-    unsigned int reason_code = (unsigned int) r->r[0];
+    unsigned int reason_code;
+
+    MemCheck_RegisterMiscBlock (r, sizeof (_kernel_swi_regs));
 
+    reason_code = r->r[0];
 
     switch (reason_code)
     {
@@ -727,6 +814,7 @@ static _kernel_oserror *ppp_alter_settings (_kernel_swi_regs *r)
             {
                 _ppp_errblk.errnum = 0;
                 strcpy (_ppp_errblk.errmess, "PPP: bad idle time limit");
+                MemCheck_UnRegisterMiscBlock (r);
                 return (&_ppp_errblk);
             }
 
@@ -746,10 +834,12 @@ static _kernel_oserror *ppp_alter_settings (_kernel_swi_regs *r)
         default:
             _ppp_errblk.errnum = 0;
             strcpy (_ppp_errblk.errmess, "PPP: bad reason code");
+            MemCheck_UnRegisterMiscBlock (r);
             return (&_ppp_errblk);
             break;
     }
 
+    MemCheck_UnRegisterMiscBlock (r);
     return NULL;
 }
 
@@ -757,9 +847,12 @@ static _kernel_oserror *ppp_alter_settings (_kernel_swi_regs *r)
 
 static _kernel_oserror *ppp_status (_kernel_swi_regs *r)
 {
-    unsigned int reason_code = (unsigned int) r->r[0];
+    unsigned int reason_code;
     int interrupt_status;
 
+    MemCheck_RegisterMiscBlock (r, sizeof (_kernel_swi_regs));
+
+    reason_code = r->r[0];
 
     switch (reason_code)
     {
@@ -787,10 +880,12 @@ static _kernel_oserror *ppp_status (_kernel_swi_regs *r)
         default:
             _ppp_errblk.errnum = 0;
             strcpy (_ppp_errblk.errmess, "PPP: bad reason code");
+            MemCheck_UnRegisterMiscBlock (r);
             return (&_ppp_errblk);
             break;
     }
 
+    MemCheck_UnRegisterMiscBlock (r);
     return NULL;
 }
 
@@ -865,6 +960,79 @@ static void trace_exit (const char *fn)
 
 #endif
 
+
+
+
+#ifdef MemCheck_MEMCHECK
+
+static char    memcheck_buffer[1024 * 100];
+static char *  memcheck_ptr = memcheck_buffer;
+static FILE *  memcheck_out = 0;
+
+static int  memcheck_vprintf (void *        reference,
+                              const char *  format,
+                              va_list       args)
+{
+    int          n = 0;
+
+    if (memcheck_ptr < (memcheck_buffer + sizeof (memcheck_buffer)))
+    {
+        n = vsprintf (memcheck_ptr,
+                      format,
+                      args);
+        if (n > 0)
+        {
+            memcheck_ptr += n;
+        }
+    }
+    else
+    {
+        n = 0;
+    }
+
+    return n;
+}
+
+_kernel_oserror *  memcheck_output (_kernel_swi_regs *  r,
+                                    void *              pw)
+{
+    r = r;
+    pw = pw;
+
+    memcheck_out = fopen ("$.PPPMemCheck",
+                          "a+");
+    if (memcheck_out)
+    {
+        fwrite (memcheck_buffer,
+                1,
+                memcheck_ptr - memcheck_buffer,
+                memcheck_out);
+
+        fclose (memcheck_out);
+        memcheck_ptr = memcheck_buffer;
+    }
+
+    return NULL;
+}
+
+_kernel_oserror *  memcheck_callevery (_kernel_swi_regs *  r,
+                                       void *              pw)
+{
+    r = r;
+    pw = pw;
+
+    _swix (OS_AddCallBack,
+           _INR (0, 1),
+           memcheck_output_entry,
+           pw);
+
+    return NULL;
+}
+
+#endif
+
+
+
 /*
  * Module Initialisation code.
  */
@@ -885,6 +1053,28 @@ _kernel_oserror *ppp_initialise(const char *cmd_tail, int pbase, void *pw)
     finalising=0;
 #   endif
 
+
+    MemCheck_Init ();
+    MemCheck_RedirectToFunction (memcheck_vprintf, 0);
+    MemCheck_SetStoreMallocFunctions (1);
+    MemCheck_InterceptSCLStringFunctions();
+    MemCheck_SetQuitting (0, 0);
+    MemCheck_SetAccessQuitting (0, 0);
+    /* Don't output blocks on every diagnostic.  Alot of diagnostics are produced
+     * because of MemCheck faulting accesses to externally supplied mbuf data structures.
+     * There are too many instances of these to make it feasible to register them all as
+     * misc blocks.
+     */
+    MemCheck_SetAutoOutputBlocksInfo (0);
+
+#ifdef MemCheck_MEMCHECK
+    _swix (OS_CallEvery,
+           _INR (0, 2),
+           99,
+           memcheck_callevery_entry,
+           pw);
+#endif
+
     /*if( (error = ppp_init()) != 0 )
 	return(ppp_error(error));*/
 
@@ -1002,6 +1192,23 @@ _kernel_oserror *ppp_quit(int fatal, int podule, void *pw)
     /* Paranoia */
     serial_finalise();
 
+#ifdef MemCheck_MEMCHECK
+
+    _swix (OS_RemoveTickerEvent,
+           _INR (0, 1),
+           memcheck_callevery_entry,
+           pw);
+
+    _swix (OS_RemoveCallBack,
+           _INR (0, 1),
+           memcheck_output,
+           pw);
+
+    MemCheck_OutputBlocksInfo ();
+    memcheck_output (NULL, NULL);
+
+#endif
+
     return NULL;
 
     NOT_USED (fatal);
@@ -1016,6 +1223,7 @@ _kernel_oserror *ppp_quit(int fatal, int podule, void *pw)
  */
 static void handle_managerstatus(_kernel_swi_regs *r)
 {
+    MemCheck_RegisterMiscBlock (r, sizeof (_kernel_swi_regs));
     switch( r->r[0] )
     {
       case MbufManagerStatus_Started:
@@ -1057,6 +1265,7 @@ static void handle_managerstatus(_kernel_swi_regs *r)
       default:
 	break;
     }
+    MemCheck_UnRegisterMiscBlock (r);
 }
 
 /**********************************************************************/
@@ -1066,6 +1275,8 @@ void ppp_sc_handler(int sn, _kernel_swi_regs *r, void *pw)
 {
     NOT_USED (pw);
 
+    MemCheck_RegisterMiscBlock (r, sizeof (_kernel_swi_regs));
+
     if ((dialler_flags & DiallerFlags_UsingDialler) &&
         (sn == Service_DiallerStatus || sn == Service_DiallerBStatus))
     {
@@ -1137,6 +1348,7 @@ void ppp_sc_handler(int sn, _kernel_swi_regs *r, void *pw)
 	    break;
 	}
     }
+    MemCheck_UnRegisterMiscBlock (r);
 }
 
 /**********************************************************************/
@@ -1149,6 +1361,7 @@ _kernel_oserror *ppp_swi_handler(int swinum, _kernel_swi_regs *r, void *pw)
     struct swient *callp;
     int error, oldstate;
 
+    MemCheck_RegisterMiscBlock (r, sizeof (_kernel_swi_regs));
     NOT_USED(pw);
 
     /*
@@ -1167,7 +1380,10 @@ _kernel_oserror *ppp_swi_handler(int swinum, _kernel_swi_regs *r, void *pw)
      * given for all SWIs other than Version
      */
     if( swinum != DCI4Version && r->r[1] >= pppcnt  )
+    {
+        MemCheck_UnRegisterMiscBlock (r);
         return(ppp_error(ENXIO));
+    }
 
     pdebug ((LOG_DEBUG, "\021\06SWI %x...", swinum & 63));
 
@@ -1190,9 +1406,11 @@ _kernel_oserror *ppp_swi_handler(int swinum, _kernel_swi_regs *r, void *pw)
                 break;
 
             default:
+                MemCheck_UnRegisterMiscBlock (r);
                 return error_BAD_SWI;
         }
 
+        MemCheck_UnRegisterMiscBlock (r);
         return e;
     }
 
@@ -1203,6 +1421,7 @@ _kernel_oserror *ppp_swi_handler(int swinum, _kernel_swi_regs *r, void *pw)
 
     pdebug ((LOG_DEBUG, "error %d\021\07\n", error));
 
+    MemCheck_UnRegisterMiscBlock (r);
     return(ppp_error(error));
 }
 
@@ -1427,11 +1646,14 @@ _kernel_oserror *ppp_cli_handler(const char *arg_string, int arg_count,
     _kernel_oserror *e;
 
 
+    MemCheck_RegisterMiscBlock_String (arg_string);
+
     if( cmd_no >= sizeof(ppp_cli_call) / sizeof(ppp_cli_call[0]) )
     {
         _ppp_errblk.errnum = 42;
         sprintf(_ppp_errblk.errmess, "PPP: bad command number: %d\n",
                 cmd_no);
+        MemCheck_UnRegisterMiscBlock (arg_string);
         return &_ppp_errblk;
     }
 
@@ -1456,6 +1678,7 @@ _kernel_oserror *ppp_cli_handler(const char *arg_string, int arg_count,
             _ppp_errblk.errnum = 0;
             strcpy (_ppp_errblk.errmess,
                     "PPP: not enough memory to make copy of argument string\n");
+            MemCheck_UnRegisterMiscBlock (arg_string);
             return &_ppp_errblk;
         }
 
@@ -1518,6 +1741,7 @@ _kernel_oserror *ppp_cli_handler(const char *arg_string, int arg_count,
             _swix(OS_Write0, _IN(0), usage_string);
             _swix(OS_PrettyPrint, _INR(0,1),
                          "\rSyntax: *PPPConnect [arguments]", 0);
+            MemCheck_UnRegisterMiscBlock (arg_string);
             return NULL;
 
           case CMD_PPPDisconnect:
@@ -1531,15 +1755,18 @@ _kernel_oserror *ppp_cli_handler(const char *arg_string, int arg_count,
             break;
 
           default:
+            MemCheck_UnRegisterMiscBlock (arg_string);
             return NULL;
         }
 
+        MemCheck_UnRegisterMiscBlock (arg_string);
         return help_PRINT_BUFFER;
     }
 
     callp = &ppp_cli_call[cmd_no];
     e = callp->cli_call(margc, margv);
     free (w_arg_string);
+    MemCheck_UnRegisterMiscBlock (arg_string);
     return e;
 
     NOT_USED(pw);

c/serial

@@ -57,6 +57,7 @@
 #include "serial.h"
 
 #include "dialler.h"
+#include "MemCheck/MemCheck.h"
 
 #define TickerV 0x1C
 #define UpCallV 0x1D
@@ -763,6 +764,7 @@ _kernel_oserror *serial_initialise(struct ppp_softc *sc)
 extern unsigned int get_pc (void);
 int upcall_handler (_kernel_swi_regs *r, void *pw)
 {
+    MemCheck_RegisterMiscBlock (r, sizeof (_kernel_swi_regs));
     switch (r->r[0])
     {
         case 15:    /* DeviceRxDataPresent */
@@ -770,6 +772,7 @@ int upcall_handler (_kernel_swi_regs *r, void *pw)
             /* Only interested in the serial input stream */
             if (r->r[1] != serial_in)
             {
+                MemCheck_UnRegisterMiscBlock (r);
                 return (1);    /* Pass on the call */
             }
 
@@ -779,8 +782,8 @@ int upcall_handler (_kernel_swi_regs *r, void *pw)
 
         case 16:    /* DeviceThresAbove */
             pdebug ((LOG_DEBUG, "DeviceThresAbove (%d)", r->r[1]));
+            MemCheck_UnRegisterMiscBlock (r);
             return (1);    /* Pass on call */
-            break;
 
 
         case 17:    /* DeviceThresBelow */
@@ -789,7 +792,8 @@ int upcall_handler (_kernel_swi_regs *r, void *pw)
             /* Only interested in the serial output stream */
             if (r->r[1] != serial_out)
             {
-                return (1);    /* Pass on the call */
+                 MemCheck_UnRegisterMiscBlock (r);
+                 return (1);    /* Pass on the call */
             }
 
             if (serialevents_active)
@@ -816,9 +820,11 @@ int upcall_handler (_kernel_swi_regs *r, void *pw)
             break;
 
         default:
+            MemCheck_UnRegisterMiscBlock (r);
             return (1);    /* Pass on call */
     }
 
+    MemCheck_UnRegisterMiscBlock (r);
     return (0);    /* Intercept call */
 }
 

cmhg/PPPHdr

@@ -47,6 +47,10 @@ generic-veneers:	poll_entry/poll_handler,
 			term_entry/term_handler,
 			hupcheck_entry/hupcheck_handler
 
+// For MemCheck builds, add the following two generic veneers
+//			memcheck_callevery_entry/memcheck_callevery,
+//			memcheck_output_entry/memcheck_output
+
 #ifndef BLOCKDRIVERS
 vector-handlers:	upcall_entry/upcall_handler
 #endif

pppd/Makefile

@@ -27,7 +27,7 @@
 #
 MKDIR =		cdir
 AS =		objasm
-CC =		cc
+CC =		${MEMCHECKCC} cc
 CMHG =		cmhg
 CP =		copy
 LD =		link
@@ -36,7 +36,7 @@ MODSQZ =	modsqz
 WIPE =		-wipe
 
 ASMFLAGS =	-depend !Depend ${THROWBACK}
-CFLAGS =	-depend !Depend ${THROWBACK} ${INCLUDES} ${CBLOCKDRIVERS} -strict -Wp -ffah 
+CFLAGS =	-depend !Depend ${THROWBACK} ${INCLUDES} ${CBLOCKDRIVERS} -strict -Wp -ffah ${CCEXTRA} 
 CPFLAGS =	~cfr~v
 LDFLAGS =	-aof
 WFLAGS =	~c~v

pppd/c/auth

@@ -32,6 +32,10 @@
  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  */
 
+#ifdef MemCheck_MEMCHECK
+#pragma -c0
+#endif
+
 static char *ack_auth =
     "Copyright (c) 1993 The Australian National University. "
     "All rights reserved.";

pppd/c/ipcp

@@ -21,6 +21,10 @@
  * TODO:
  */
 
+#ifdef MemCheck_MEMCHECK
+#pragma -c0
+#endif
+
 /* Carnegie Mellon acknowledged in c.if_ppp */
 
 #include <stdio.h>

pppd/c/lcp

@@ -21,6 +21,11 @@
  * TODO:
  */
 
+
+#ifdef MemCheck_MEMCHECK
+#pragma -c0
+#endif
+
 /* Carnegie Mellon acknowledged in c.if_ppp */
 
 #include <stdio.h>
@@ -357,6 +362,7 @@ void lcp_sprotrej(int unit, u_char *p, int len)
 /*
  * lcp_resetci - Reset our CI.
  */
+
 static void lcp_resetci(fsm *f)
 {
     lcp_wantoptions[f->unit].magicnumber = magic();
@@ -369,6 +375,7 @@ static void lcp_resetci(fsm *f)
 /*
  * lcp_cilen - Return length of our CI.
  */
+
 static int lcp_cilen(fsm *f)
 {
     lcp_options *go = &lcp_gotoptions[f->unit];
@@ -392,10 +399,10 @@ static int lcp_cilen(fsm *f)
 	    LENCIVOID(go->neg_accompression));
 }
 
-
 /*
  * lcp_addci - Add our desired CIs to a packet.
  */
+
 static void lcp_addci(fsm *f, u_char *ucp, int *lenp)
 {
     lcp_options *go = &lcp_gotoptions[f->unit];
@@ -448,7 +455,6 @@ static void lcp_addci(fsm *f, u_char *ucp, int *lenp)
     }
 }
 
-
 /*
  * lcp_ackci - Ack our CIs.
  * This should not modify any state if the Ack is bad.
@@ -1608,3 +1614,7 @@ static void lcp_echo_lowerdown(int unit)
         lcp_echo_timer_running = 0;
     }
 }
+
+#ifdef MemCheck_MEMCHECK
+#pragma -c1
+#endif

pppd/c/options

@@ -407,7 +407,7 @@ int getword(FILE *f, char *word, int *newlinep, char *filename)
     /*
      * First skip white-space and comments
      */
-    while ((c = getc(f)) != EOF) {
+    while ((c = fgetc(f)) != EOF) {
 	if (c == '\\') {
 	    /*
 	     * \<newline> is ignored; \ followed by anything else
@@ -423,7 +423,7 @@ int getword(FILE *f, char *word, int *newlinep, char *filename)
 	    *newlinep = 1;	/* next word starts a line */
 	else if (c == '#') {
 	    /* comment - ignore until EOF or \n */
-	    while ((c = getc(f)) != EOF && c != '\n')
+	    while ((c = fgetc(f)) != EOF && c != '\n')
 		;
 	    if (c == EOF)
 		break;
@@ -470,8 +470,9 @@ int getword(FILE *f, char *word, int *newlinep, char *filename)
 	    if (c == '\\')
 		escape = 1;
 	}
-	if ((c = getc(f)) == EOF)
+        if ((c = fgetc (f)) == EOF)
 	    break;
+
     }
 
     if (ferror(f)) {