#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <signal.h>
#include <setjmp.h>
#include <time.h>
#include <limits.h>
#include "memwatch.h"
#include <ctype.h>

Classes
struct	mwData_

struct	mwStat_

struct	mwGrabData_

struct	mwMarker_

Macros
#define	__MEMWATCH_C 1

#define	VERSION "2.71" /* the current version number */

#define	CHKVAL(mw) (0xFE0180L^(long)mw->count^(long)mw->size^(long)mw->line)

#define	FLUSH() mwFlush()

#define	TESTS(f, l) if(mwTestAlways) (void)mwTestNow(f,l,1)

#define	PRECHK 0x01234567L

#define	POSTCHK 0x76543210L

#define	mwBUFFER_TO_MW(p) ( (mwData) (void) ( ((char*)p)-mwDataSize-mwOverflowZoneSize ) )

#define	MW_NML 0x0001

#define	COMMIT "" /* Normal ANSI */

#define	CPPTEXT ""

#define	mwSTDERR mwLog

#define	MW_MUTEX_INIT()

#define	MW_MUTEX_TERM()

#define	MW_MUTEX_LOCK()

#define	MW_MUTEX_UNLOCK()

#define	mw16BIT 1

#define	mwROUNDALLOC_DEFAULT 2

#define	mwROUNDALLOC mwROUNDALLOC_DEFAULT

#define	AIPH() if( always_invoked ) { mwWrite("autocheck: <%ld> %s(%d) ", mwCounter, file, line ); always_invoked = 0; }

Typedefs
typedef struct mwData_	mwData

typedef struct mwStat_	mwStat

typedef struct mwGrabData_	mwGrabData

typedef struct mwMarker_	mwMarker

Functions
void	mwInit (void)

void	mwAbort (void)

void	mwTerm (void)

void	mwStatistics (int level)

void	mwAutoCheck (int onoff)

void	mwSetOutFunc (void(*func)(int))

int	mwTest (const char *file, int line, int items)

int	mwTestBuffer (const char file, int line, void p)

void	mwBreakOut (const char *cause)

void *	mwMark (void p, const char desc, const char *file, unsigned line)

void *	mwUnmark (void p, const char file, unsigned line)

int	mwAriHandler (const char *estr)

void	mwSetAriFunc (int(func)(const char ))

void *	mwMalloc (size_t size, const char *file, int line)

void *	mwRealloc (void p, size_t size, const char file, int line)

char *	mwStrdup (const char str, const char file, int line)

void	mwFree (void p, const char file, int line)

void *	mwCalloc (size_t a, size_t b, const char *file, int line)

void	mwFree_ (void *p)

void *	mwMalloc_ (size_t size)

void *	mwRealloc_ (void *p, size_t size)

void *	mwCalloc_ (size_t a, size_t b)

void	mwFlushNow (void)

void	mwDoFlush (int onoff)

void	mwLimit (long lim)

void	mwSetAriAction (int action)

int	mwAssert (int exp, const char exps, const char fn, int ln)

int	mwVerify (int exp, const char exps, const char fn, int ln)

void	mwTrace (const char *format,...)

unsigned	mwGrab (unsigned kb)

unsigned	mwDrop (unsigned kb)

void	mwNoMansLand (int level)

int	mwIsReadAddr (const void *p, unsigned len)

int	mwIsSafeAddr (void *p, unsigned len)

Macro Definition Documentation

◆ __MEMWATCH_C

#define __MEMWATCH_C 1

Definition at line 97 of file KalFitMemLeak.c.

◆ AIPH

#define AIPH ( ) if( always_invoked ) { mwWrite("autocheck: <%ld> %s(%d) ", mwCounter, file, line ); always_invoked = 0; }

Definition at line 2152 of file KalFitMemLeak.c.

◆ CHKVAL

#define CHKVAL ( mw ) (0xFE0180L^(long)mw->count^(long)mw->size^(long)mw->line)

Definition at line 140 of file KalFitMemLeak.c.

◆ COMMIT

#define COMMIT "" /* Normal ANSI */

Definition at line 153 of file KalFitMemLeak.c.

◆ CPPTEXT

#define CPPTEXT ""

Definition at line 159 of file KalFitMemLeak.c.

◆ FLUSH

#define FLUSH ( ) mwFlush()

Definition at line 141 of file KalFitMemLeak.c.

◆ mw16BIT

#define mw16BIT 1

Definition at line 199 of file KalFitMemLeak.c.

◆ MW_MUTEX_INIT

#define MW_MUTEX_INIT ( )

Definition at line 174 of file KalFitMemLeak.c.

◆ MW_MUTEX_LOCK

#define MW_MUTEX_LOCK ( )

Definition at line 176 of file KalFitMemLeak.c.

◆ MW_MUTEX_TERM

#define MW_MUTEX_TERM ( )

Definition at line 175 of file KalFitMemLeak.c.

◆ MW_MUTEX_UNLOCK

#define MW_MUTEX_UNLOCK ( )

Definition at line 177 of file KalFitMemLeak.c.

◆ MW_NML

#define MW_NML 0x0001

Definition at line 148 of file KalFitMemLeak.c.

◆ mwBUFFER_TO_MW

#define mwBUFFER_TO_MW ( p ) ( (mwData*) (void*) ( ((char*)p)-mwDataSize-mwOverflowZoneSize ) )

Definition at line 145 of file KalFitMemLeak.c.

◆ mwROUNDALLOC

#define mwROUNDALLOC mwROUNDALLOC_DEFAULT

Definition at line 217 of file KalFitMemLeak.c.

◆ mwROUNDALLOC_DEFAULT

#define mwROUNDALLOC_DEFAULT 2

Definition at line 200 of file KalFitMemLeak.c.

◆ mwSTDERR

#define mwSTDERR mwLog

Definition at line 165 of file KalFitMemLeak.c.

◆ POSTCHK

#define POSTCHK 0x76543210L

Definition at line 144 of file KalFitMemLeak.c.

◆ PRECHK

#define PRECHK 0x01234567L

Definition at line 143 of file KalFitMemLeak.c.

◆ TESTS

#define TESTS	(	f,
		l
	)	if(mwTestAlways) (void)mwTestNow(f,l,1)

Definition at line 142 of file KalFitMemLeak.c.

◆ VERSION

#define VERSION "2.71" /* the current version number */

Definition at line 139 of file KalFitMemLeak.c.

Typedef Documentation

◆ mwData

typedef struct mwData_ mwData

Definition at line 254 of file KalFitMemLeak.c.

◆ mwGrabData

typedef struct mwGrabData_ mwGrabData

Definition at line 282 of file KalFitMemLeak.c.

◆ mwMarker

typedef struct mwMarker_ mwMarker

Definition at line 289 of file KalFitMemLeak.c.

◆ mwStat

typedef struct mwStat_ mwStat

Definition at line 270 of file KalFitMemLeak.c.

Function Documentation

◆ mwAbort()

void mwAbort ( void )

Definition at line 517 of file KalFitMemLeak.c.

                     {
    mwData *mw;
    mwMarker *mrk;
    char *data;
    time_t tid;
    int c, i, j;
    int errors;
 
    tid = time( NULL );
    mwWrite( "\nStopped at %s\n", ctime( &tid) );
 
    if( !mwInited )
        mwWrite( "internal: mwAbort(): MEMWATCH not initialized!\n" );
 
    /* release the grab list */
    mwDropAll();
 
    /* report mwMarked items */
    while( mwFirstMark ) {
        mrk = mwFirstMark->next;
        mwWrite( "mark: %p: %s\n", mwFirstMark->host, mwFirstMark->text );
        free( mwFirstMark->text );
        free( mwFirstMark );
        mwFirstMark = mrk;
        mwErrors ++;
        }
 
    /* release all still allocated memory */
    errors = 0;
    while( mwHead != NULL && errors < 3 ) {
        if( !mwIsOwned(mwHead, __FILE__, __LINE__ ) ) {
            if( errors < 3 )
            {
                errors ++;
                mwWrite( "internal: NML/unfreed scan restarting\n" );
                FLUSH();
                mwHead = mwHead;
                continue;
            }
            mwWrite( "internal: NML/unfreed scan aborted, heap too damaged\n" );
            FLUSH();
            break;
            }
        mwFlushW(0);
        if( !(mwHead->flag & MW_NML) ) {
            mwErrors++;
            data = ((char*)mwHead)+mwDataSize;
            mwWrite( "unfreed: <%ld> %s(%d), %ld bytes at %p ",
                mwHead->count, mwHead->file, mwHead->line, (long)mwHead->size, data+mwOverflowZoneSize );
            if( mwCheckOF( data ) ) {
                mwWrite( "[underflowed] ");
                FLUSH();
                }
            if( mwCheckOF( (data+mwOverflowZoneSize+mwHead->size) ) ) {
                mwWrite( "[overflowed] ");
                FLUSH();
                }
            mwWrite( " \t{" );
            j = 16; if( mwHead->size < 16 ) j = (int) mwHead->size;
            for( i=0;i<16;i++ ) {
                if( i<j ) mwWrite( "%02X ",
                    (unsigned char) *(data+mwOverflowZoneSize+i) );
                else mwWrite( ".. " );
                }
            for( i=0;i<j;i++ ) {
                c = *(data+mwOverflowZoneSize+i);
                if( c < 32 || c > 126 ) c = '.';
                mwWrite( "%c", c );
                }
            mwWrite( "}\n" );
            mw = mwHead;
            mwUnlink( mw, __FILE__, __LINE__ );
            free( mw );
            }
        else {
            data = ((char*)mwHead) + mwDataSize + mwOverflowZoneSize;
            if( mwTestMem( data, mwHead->size, MW_VAL_NML ) ) {
                mwErrors++;
                mwWrite( "wild pointer: <%ld> NoMansLand %p alloc'd at %s(%d)\n",
                    mwHead->count, data + mwOverflowZoneSize, mwHead->file, mwHead->line );
                FLUSH();
                }
            mwNmlNumAlloc --;
            mwNmlCurAlloc -= mwHead->size;
            mw = mwHead;
            mwUnlink( mw, __FILE__, __LINE__ );
            free( mw );
            }
        }
 
    if( mwNmlNumAlloc ) mwWrite("internal: NoMansLand block counter %ld, not zero\n", mwNmlNumAlloc );
    if( mwNmlCurAlloc ) mwWrite("internal: NoMansLand byte counter %ld, not zero\n", mwNmlCurAlloc );
 
    /* report statistics */
    mwStatReport();
    FLUSH();
 
    mwInited = 0;
    mwHead = mwTail = NULL;
    if( mwErrors )
        fprintf(mwSTDERR,"MEMWATCH detected %ld anomalies\n",mwErrors);
    mwLogFile( NULL );
    mwErrors = 0;
 
    MW_MUTEX_TERM();
 
    }

Referenced by mwInit(), and mwTerm().

◆ mwAriHandler()

int mwAriHandler ( const char * estr )

Definition at line 848 of file KalFitMemLeak.c.

                                     {
    mwAutoInit();
    return mwARI( estr );
    }

◆ mwAssert()

int mwAssert	(	int	exp,
		const char *	exps,
		const char *	fn,
		int	ln
	)

Definition at line 1228 of file KalFitMemLeak.c.

                                                                  {
    int i;
    char buffer[MW_TRACE_BUFFER+8];
    if( exp ) {
        return 0;
        }
    mwAutoInit();
    MW_MUTEX_LOCK();
    TESTS(fn,ln);
    mwIncErr();
    mwCounter++;
    mwWrite( "assert trap: <%ld> %s(%d), %s\n", mwCounter, fn, ln, exps );
    if( mwAriFunction != NULL ) {
        sprintf( buffer, "MEMWATCH: assert trap: %s(%d), %s", fn, ln, exps );
        i = (*mwAriFunction)(buffer);
        switch( i ) {
            case MW_ARI_IGNORE:
                mwWrite( "assert trap: <%ld> IGNORED - execution continues\n", mwCounter );
                MW_MUTEX_UNLOCK();
                return 0;
            case MW_ARI_RETRY:
                mwWrite( "assert trap: <%ld> RETRY - executing again\n", mwCounter );
                MW_MUTEX_UNLOCK();
                return 1;
            }
        }
    else {
        if( mwAriAction & MW_ARI_IGNORE ) {
            mwWrite( "assert trap: <%ld> AUTO IGNORED - execution continues\n", mwCounter );
            MW_MUTEX_UNLOCK();
            return 0;
            }
        fprintf(mwSTDERR,"\nMEMWATCH: assert trap: %s(%d), %s\n", fn, ln, exps );
        }
 
    FLUSH();
    (void) mwTestNow( fn, ln, 1 );
    FLUSH();
 
    if( mwAriAction & MW_ARI_NULLREAD ) {
        /* This is made in an attempt to kick in */
        /* any debuggers or OS stack traces */
        FLUSH();
        /*lint -save -e413 */
        i = *((int*)NULL);
        mwDummy( (char)i );
        /*lint -restore */
        }
 
    MW_MUTEX_UNLOCK();
    exit(255);
    /* NOT REACHED - the return statement is in to keep */
    /* stupid compilers from squeaking about differing return modes. */
    /* Smart compilers instead say 'code unreachable...' */
    /*lint -save -e527 */
    return 0;
    /*lint -restore */
    }

◆ mwAutoCheck()

void mwAutoCheck ( int onoff )

Definition at line 649 of file KalFitMemLeak.c.

                              {
    mwAutoInit();
    mwTestAlways = onoff;
    if( onoff ) mwTestFlags = MW_TEST_ALL;
    }

◆ mwBreakOut()

void mwBreakOut ( const char * cause )

Definition at line 709 of file KalFitMemLeak.c.

                                     {
    fprintf(mwSTDERR, "breakout: %s\n", cause);
    mwWrite("breakout: %s\n", cause );
    return;
    }

◆ mwCalloc()

void * mwCalloc	(	size_t	a,
		size_t	b,
		const char *	file,
		int	line
	)

Definition at line 1154 of file KalFitMemLeak.c.

                                                                 {
    void *p;
    size_t size = a * b;
    p = mwMalloc( size, file, line );
    if( p == NULL ) return NULL;
    memset( p, 0, size );
    return p;
    }

◆ mwCalloc_()

void * mwCalloc_	(	size_t	a,
		size_t	b
	)

Definition at line 1184 of file KalFitMemLeak.c.

                                      {
    MW_MUTEX_LOCK();
    TESTS(NULL,0);
    MW_MUTEX_UNLOCK();
    return calloc( a, b );
    }

◆ mwDoFlush()

void mwDoFlush ( int onoff )

Definition at line 1196 of file KalFitMemLeak.c.

                            {
    mwFlushW( onoff<1?0:onoff );
    if( onoff ) if( mwLogR() ) fflush( mwLogR() );
    return;
    }

◆ mwDrop()

unsigned mwDrop ( unsigned kb )

Definition at line 1377 of file KalFitMemLeak.c.

                               {
    TESTS(NULL,0);
    return mwDrop_( kb, MW_VAL_GRB, 0 );
    }

◆ mwFlushNow()

void mwFlushNow ( void )

Definition at line 1191 of file KalFitMemLeak.c.

                        {
    if( mwLogR() ) fflush( mwLogR() );
    return;
    }

◆ mwFree()

void mwFree	(	void *	p,
		const char *	file,
		int	line
	)

Definition at line 1051 of file KalFitMemLeak.c.

                                                   {
    int i;
    mwData* mw;
    char buffer[ sizeof(mwData) + (mwROUNDALLOC*3) + 64 ];
 
    /* this code is in support of C++ delete */
    if( file == NULL ) {
        mwFree_( p );
        MW_MUTEX_UNLOCK();
        return;
        }
 
    mwAutoInit();
 
    MW_MUTEX_LOCK();
    TESTS(file,line);
    mwCounter ++;
 
    /* on NULL free, write a warning and return */
    if( p == NULL ) {
        mwWrite( "NULL free: <%ld> %s(%d), NULL pointer free'd\n",
            mwCounter, file, line );
        FLUSH();
        MW_MUTEX_UNLOCK();
        return;
        }
 
    /* do the quick ownership test */
    mw = (mwData*) mwBUFFER_TO_MW( p );
 
    if( mwIsOwned( mw, file, line ) ) {
        (void) mwTestBuf( mw, file, line );
 
        /* if the buffer is an NML, treat this as a double-free */
        if( mw->flag & MW_NML )
        {
            if( *(((unsigned char*)mw)+mwDataSize+mwOverflowZoneSize) != MW_VAL_NML )
            {
                mwWrite( "internal: <%ld> %s(%d), no-mans-land MW-%p is corrupted\n",
                    mwCounter, file, line, mw );
            }
            goto check_dbl_free;
        }
 
        /* update the statistics */
        mwNumCurAlloc --;
        mwStatCurAlloc -= (long) mw->size;
        if( mwStatLevel ) mwStatFree( mw->size, mw->file, mw->line );
 
        /* we should either free the allocation or keep it as NML */
        if( mwNML ) {
            mw->flag |= MW_NML;
            mwNmlNumAlloc ++;
            mwNmlCurAlloc += (long) mw->size;
            memset( ((char*)mw)+mwDataSize+mwOverflowZoneSize, MW_VAL_NML, mw->size );
            }
        else {
            /* unlink the allocation, and enter the post-free data */
            mwUnlink( mw, file, line );
            memset( mw, MW_VAL_DEL,
                mw->size + mwDataSize+mwOverflowZoneSize+mwOverflowZoneSize );
            if( mwFBI ) {
                memset( mw, '.', mwDataSize + mwOverflowZoneSize );
                sprintf( buffer, "FBI<%ld>%s(%d)", mwCounter, file, line );
                strncpy( (char*)(void*)mw, buffer, mwDataSize + mwOverflowZoneSize );
                }
            free( mw );
            }
 
        /* add the pointer to the last-free track */
        mwLFfile[ mwLFcur ] = file;
        mwLFline[ mwLFcur ] = line;
        mwLastFree[ mwLFcur++ ] = p;
        if( mwLFcur == MW_FREE_LIST ) mwLFcur = 0;
 
        MW_MUTEX_UNLOCK();
        return;
        }
 
    /* check for double-freeing */
check_dbl_free:
    for(i=0;i<MW_FREE_LIST;i++) {
        if( mwLastFree[i] == p ) {
            mwIncErr();
            mwWrite( "double-free: <%ld> %s(%d), %p was"
                " freed from %s(%d)\n",
                mwCounter, file, line, p,
                mwLFfile[i], mwLFline[i] );
            FLUSH();
            MW_MUTEX_UNLOCK();
            return;
            }
        }
 
    /* some weird pointer... block the free */
    mwIncErr();
    mwWrite( "WILD free: <%ld> %s(%d), unknown pointer %p\n",
        mwCounter, file, line, p );
    FLUSH();
    MW_MUTEX_UNLOCK();
    return;
    }

◆ mwFree_()

void mwFree_ ( void * p )

Definition at line 1163 of file KalFitMemLeak.c.

                        {
    MW_MUTEX_LOCK();
    TESTS(NULL,0);
    MW_MUTEX_UNLOCK();
    free(p);
    }

◆ mwGrab()

unsigned mwGrab ( unsigned kb )

Definition at line 1372 of file KalFitMemLeak.c.

                               {
    TESTS(NULL,0);
    return mwGrab_( kb, MW_VAL_GRB, 0 );
    }

◆ mwInit()

void mwInit ( void )

Definition at line 413 of file KalFitMemLeak.c.

                    {
    time_t tid;
 
    if( mwInited++ > 0 ) return;
 
    MW_MUTEX_INIT();
 
    /* start a log if none is running */
    if( mwLogR() == NULL ) mwLogFile( "memwatch.log" );
    if( mwLogR() == NULL ) {
        int i;
        char buf[32];
        /* oops, could not open it! */
        /* probably because it's already open */
        /* so we try some other names */
        for( i=1; i<100; i++ ) {
            sprintf( buf, "memwat%02d.log", i );
            mwLogFile( buf );
            if( mwLogR() != NULL ) break;
            }
        }
 
    /* initialize the statistics */
    mwStatList = NULL;
    mwStatTotAlloc = 0L;
    mwStatCurAlloc = 0L;
    mwStatMaxAlloc = 0L;
    mwStatNumAlloc = 0L;
    mwNmlCurAlloc = 0L;
    mwNmlNumAlloc = 0L;
 
    /* calculate the buffer size to use for a mwData */
    mwDataSize = sizeof(mwData);
    while( mwDataSize % mwROUNDALLOC ) mwDataSize ++;
 
    /* write informational header if needed */
    if( !mwInfoWritten ) {
        mwInfoWritten = 1;
        (void) time( &tid );
        mwWrite(
            "\n============="
            " MEMWATCH " VERSION " Copyright (C) 1992-1999 Johan Lindh "
            "=============\n");
        mwWrite( "\nStarted at %s\n", ctime( &tid ) );
 
/**************************************************************** Generic */
        mwWrite( "Modes: " );
#ifdef mwNew
        mwWrite( "C++ " );
#endif /* mwNew */
#ifdef __STDC__
        mwWrite( "__STDC__ " );
#endif /* __STDC__ */
#ifdef mw16BIT
        mwWrite( "16-bit " );
#endif
#ifdef mw32BIT
        mwWrite( "32-bit " );
#endif
#ifdef mw64BIT
        mwWrite( "64-bit " );
#endif
        mwWrite( "mwDWORD==(" mwDWORD_DEFINED ")\n" );
        mwWrite( "mwROUNDALLOC==%d sizeof(mwData)==%d mwDataSize==%d\n",
            mwROUNDALLOC, sizeof(mwData), mwDataSize );
/**************************************************************** Generic */
 
/************************************************************ Microsoft C */
#ifdef _MSC_VER
        mwWrite( "Compiled using Microsoft C" CPPTEXT
            " %d.%02d\n", _MSC_VER / 100, _MSC_VER % 100 );
#endif /* _MSC_VER */
/************************************************************ Microsoft C */
 
/************************************************************** Borland C */
#ifdef __BORLANDC__
        mwWrite( "Compiled using Borland C"
#ifdef __cplusplus
            "++ %d.%01d\n", __BCPLUSPLUS__/0x100, (__BCPLUSPLUS__%0x100)/0x10 );
#else
            " %d.%01d\n", __BORLANDC__/0x100, (__BORLANDC__%0x100)/0x10 );
#endif /* __cplusplus */
#endif /* __BORLANDC__ */
/************************************************************** Borland C */
 
/************************************************************** Watcom C */
#ifdef __WATCOMC__
        mwWrite( "Compiled using Watcom C %d.%02d ",
            __WATCOMC__/100, __WATCOMC__%100 );
#ifdef __FLAT__
        mwWrite( "(32-bit flat model)" );
#endif /* __FLAT__ */
        mwWrite( "\n" );
#endif /* __WATCOMC__ */
/************************************************************** Watcom C */
 
        mwWrite( "\n" );
        FLUSH();
        }
 
    if( mwUseAtexit ) (void) atexit( mwAbort );
    return;
    }

◆ mwIsReadAddr()

int mwIsReadAddr	(	const void *	p,
		unsigned	len
	)

Definition at line 2491 of file KalFitMemLeak.c.

{
    if( p == NULL ) return 0;
    if( len == 0 ) return 1;
    return 1;
}

Referenced by mwMark().

◆ mwIsSafeAddr()

int mwIsSafeAddr	(	void *	p,
		unsigned	len
	)

Definition at line 2497 of file KalFitMemLeak.c.

{
    if( p == NULL ) return 0;
    if( len == 0 ) return 1;
    return 1;
}

◆ mwLimit()

void mwLimit ( long lim )

Definition at line 1202 of file KalFitMemLeak.c.

                         {
    TESTS(NULL,0);
    mwWrite("limit: old limit = ");
    if( !mwAllocLimit ) mwWrite( "none" );
    else mwWrite( "%ld bytes", mwAllocLimit );
    mwWrite( ", new limit = ");
    if( !lim ) {
        mwWrite( "none\n" );
        mwUseLimit = 0;
        }
    else {
        mwWrite( "%ld bytes\n", lim );
        mwUseLimit = 1;
        }
    mwAllocLimit = lim;
    FLUSH();
    }

◆ mwMalloc()

void * mwMalloc	(	size_t	size,
		const char *	file,
		int	line
	)

Definition at line 863 of file KalFitMemLeak.c.

                                                         {
    size_t needed;
    mwData *mw;
    char *ptr;
    void *p;
 
    mwAutoInit();
 
    MW_MUTEX_LOCK();
 
    TESTS(file,line);
 
    mwCounter ++;
    needed = mwDataSize + mwOverflowZoneSize*2 + size;
    if( needed < size )
    {
        /* theoretical case: req size + mw overhead exceeded size_t limits */
        return NULL;
    }
 
    /* if this allocation would violate the limit, fail it */
    if( mwUseLimit && ((long)size + mwStatCurAlloc > mwAllocLimit) ) {
        mwWrite( "limit fail: <%ld> %s(%d), %ld wanted %ld available\n",
            mwCounter, file, line, (long)size, mwAllocLimit - mwStatCurAlloc );
        mwIncErr();
        FLUSH();
        MW_MUTEX_UNLOCK();
        return NULL;
        }
 
    mw = (mwData*) malloc( needed );
    if( mw == NULL ) {
        if( mwFreeUp(needed,0) >= needed ) {
            mw = (mwData*) malloc(needed);
            if( mw == NULL ) {
                mwWrite( "internal: mwFreeUp(%u) reported success, but malloc() fails\n", needed );
                mwIncErr();
                FLUSH();
                }
            }
        if( mw == NULL ) {
            mwWrite( "fail: <%ld> %s(%d), %ld wanted %ld allocated\n",
                mwCounter, file, line, (long)size, mwStatCurAlloc );
            mwIncErr();
            FLUSH();
            MW_MUTEX_UNLOCK();
            return NULL;
            }
        }
 
    mw->count = mwCounter;
    mw->prev = NULL;
    mw->next = mwHead;
    mw->file = file;
    mw->size = size;
    mw->line = line;
    mw->flag = 0;
    mw->check = CHKVAL(mw);
 
    if( mwHead ) mwHead->prev = mw;
    mwHead = mw;
    if( mwTail == NULL ) mwTail = mw;
 
    ptr = ((char*)mw) + mwDataSize;
    mwWriteOF( ptr ); /* '*(long*)ptr = PRECHK;' */
    ptr += mwOverflowZoneSize;
    p = ptr;
    memset( ptr, MW_VAL_NEW, size );
    ptr += size;
    mwWriteOF( ptr ); /* '*(long*)ptr = POSTCHK;' */
 
    mwNumCurAlloc ++;
    mwStatCurAlloc += (long) size;
    mwStatTotAlloc += (long) size;
    if( mwStatCurAlloc > mwStatMaxAlloc )
        mwStatMaxAlloc = mwStatCurAlloc;
    mwStatNumAlloc ++;
 
    if( mwStatLevel ) mwStatAlloc( size, file, line );
 
    MW_MUTEX_UNLOCK();
    return p;
    }

◆ mwMalloc_()

void * mwMalloc_ ( size_t size )

Definition at line 1170 of file KalFitMemLeak.c.

                               {
    MW_MUTEX_LOCK();
    TESTS(NULL,0);
    MW_MUTEX_UNLOCK();
    return malloc( size );
    }

◆ mwMark()

void * mwMark	(	void *	p,
		const char *	desc,
		const char *	file,
		unsigned	line
	)

Definition at line 718 of file KalFitMemLeak.c.

                                                                            {
    mwMarker *mrk;
    unsigned n, isnew;
    char *buf;
    int tot, oflow = 0;
    char wherebuf[128];
 
    mwAutoInit();
    TESTS(NULL,0);
 
    if( desc == NULL ) desc = "unknown";
    if( file == NULL ) file = "unknown";
 
    tot = sprintf( wherebuf, "%.48s called from %s(%d)", desc, file, line );
    if( tot >= (int)sizeof(wherebuf) ) { wherebuf[sizeof(wherebuf)-1] = 0; oflow = 1; }
 
    if( p == NULL ) {
        mwWrite("mark: %s(%d), no mark for NULL:'%s' may be set\n", file, line, desc );
        return p;
        }
 
    if( mwFirstMark != NULL && !mwIsReadAddr( mwFirstMark, sizeof( mwMarker ) ) )
    {
        mwWrite("mark: %s(%d), mwFirstMark (%p) is trashed, can't mark for %s\n",
            file, line, mwFirstMark, desc );
        return p;
    }
 
    for( mrk=mwFirstMark; mrk; mrk=mrk->next )
    {
        if( mrk->next != NULL && !mwIsReadAddr( mrk->next, sizeof( mwMarker ) ) )
        {
            mwWrite("mark: %s(%d), mark(%p)->next(%p) is trashed, can't mark for %s\n",
                file, line, mrk, mrk->next, desc );
            return p;
        }
        if( mrk->host == p ) break;
    }
 
    if( mrk == NULL ) {
        isnew = 1;
        mrk = (mwMarker*) malloc( sizeof( mwMarker ) );
        if( mrk == NULL ) {
            mwWrite("mark: %s(%d), no mark for %p:'%s', out of memory\n", file, line, p, desc );
            return p;
            }
        mrk->next = NULL;
        n = 0;
        }
    else {
        isnew = 0;
        n = strlen( mrk->text );
        }
 
    n += strlen( wherebuf );
    buf = (char*) malloc( n+3 );
    if( buf == NULL ) {
        if( isnew ) free( mrk );
        mwWrite("mark: %s(%d), no mark for %p:'%s', out of memory\n", file, line, p, desc );
        return p;
        }
 
    if( isnew ) {
        memcpy( buf, wherebuf, n+1 );
        mrk->next = mwFirstMark;
        mrk->host = p;
        mrk->text = buf;
        mrk->level = 1;
        mwFirstMark = mrk;
        }
    else {
        strcpy( buf, mrk->text );
        strcat( buf, ", " );
        strcat( buf, wherebuf );
        free( mrk->text );
        mrk->text = buf;
        mrk->level ++;
        }
 
    if( oflow ) {
        mwIncErr();
        mwTrace( " [WARNING: OUTPUT BUFFER OVERFLOW - SYSTEM UNSTABLE]\n" );
        }
    return p;
    }

◆ mwNoMansLand()

void mwNoMansLand ( int level )

Definition at line 1489 of file KalFitMemLeak.c.

                               {
    mwAutoInit();
    TESTS(NULL,0);
    switch( level ) {
        case MW_NML_NONE:
            (void) mwDrop_( 0, MW_VAL_NML, 0 );
            break;
        case MW_NML_FREE:
            break;
        case MW_NML_ALL:
            (void) mwGrab_( 0, MW_VAL_NML, 0 );
            break;
        default:
            return;
        }
    mwNML = level;
    }

◆ mwRealloc()

void * mwRealloc	(	void *	p,
		size_t	size,
		const char *	file,
		int	line
	)

Definition at line 947 of file KalFitMemLeak.c.

                                                                   {
    int oldUseLimit, i;
    mwData *mw;
    char *ptr;
 
    mwAutoInit();
 
    if( p == NULL ) return mwMalloc( size, file, line );
    if( size == 0 ) { mwFree( p, file, line ); return NULL; }
 
    MW_MUTEX_LOCK();
 
    /* do the quick ownership test */
    mw = (mwData*) mwBUFFER_TO_MW( p );
    if( mwIsOwned( mw, file, line ) ) {
 
        /* if the buffer is an NML, treat this as a double-free */
        if( mw->flag & MW_NML )
        {
            mwIncErr();
            if( *((unsigned char*)(mw)+mwDataSize+mwOverflowZoneSize) != MW_VAL_NML )
            {
                mwWrite( "internal: <%ld> %s(%d), no-mans-land MW-%p is corrupted\n",
                    mwCounter, file, line, mw );
            }
            goto check_dbl_free;
        }
 
        /* if this allocation would violate the limit, fail it */
        if( mwUseLimit && ((long)size + mwStatCurAlloc - (long)mw->size > mwAllocLimit) ) {
            TESTS(file,line);
            mwCounter ++;
            mwWrite( "limit fail: <%ld> %s(%d), %ld wanted %ld available\n",
                mwCounter, file, line, (unsigned long)size - mw->size, mwAllocLimit - mwStatCurAlloc );
            mwIncErr();
            FLUSH();
            MW_MUTEX_UNLOCK();
            return NULL;
            }
 
        /* fake realloc operation */
        oldUseLimit = mwUseLimit;
        mwUseLimit = 0;
        ptr = (char*) mwMalloc( size, file, line );
        if( ptr != NULL ) {
            if( size < mw->size )
                memcpy( ptr, p, size );
            else
                memcpy( ptr, p, mw->size );
            mwFree( p, file, line );
            }
        mwUseLimit = oldUseLimit;
        MW_MUTEX_UNLOCK();
        return (void*) ptr;
        }
 
    /* Unknown pointer! */
 
    /* using free'd pointer? */
check_dbl_free:
    for(i=0;i<MW_FREE_LIST;i++) {
        if( mwLastFree[i] == p ) {
            mwIncErr();
            mwWrite( "realloc: <%ld> %s(%d), %p was"
                " freed from %s(%d)\n",
                mwCounter, file, line, p,
                mwLFfile[i], mwLFline[i] );
            FLUSH();
            MW_MUTEX_UNLOCK();
            return NULL;
            }
        }
 
    /* some weird pointer */
    mwIncErr();
    mwWrite( "realloc: <%ld> %s(%d), unknown pointer %p\n",
        mwCounter, file, line, p );
    FLUSH();
    MW_MUTEX_UNLOCK();
    return NULL;
    }

◆ mwRealloc_()

void * mwRealloc_	(	void *	p,
		size_t	size
	)

Definition at line 1177 of file KalFitMemLeak.c.

                                         {
    MW_MUTEX_LOCK();
    TESTS(NULL,0);
    MW_MUTEX_UNLOCK();
    return realloc( p, size );
    }

◆ mwSetAriAction()

void mwSetAriAction ( int action )

Definition at line 1220 of file KalFitMemLeak.c.

                                  {
    MW_MUTEX_LOCK();
    TESTS(NULL,0);
    mwAriAction = action;
    MW_MUTEX_UNLOCK();
    return;
    }

◆ mwSetAriFunc()

void mwSetAriFunc ( int(*)(const char *) func )

Definition at line 854 of file KalFitMemLeak.c.

                                               {
    mwAutoInit();
    mwAriFunction = func;
    }

◆ mwSetOutFunc()

void mwSetOutFunc ( void(*)(int) func )

Definition at line 655 of file KalFitMemLeak.c.

                                       {
    mwAutoInit();
    mwOutFunction = func;
    }

◆ mwStatistics()

void mwStatistics ( int level )

Definition at line 637 of file KalFitMemLeak.c.

{
    mwAutoInit();
    if( level<0 ) level=0;
    if( mwStatLevel != level )
    {
        mwWrite( "statistics: now collecting on a %s basis\n",
            level<1?"global":(level<2?"module":"line") );
        mwStatLevel = level;
    }
}

◆ mwStrdup()

char * mwStrdup	(	const char *	str,
		const char *	file,
		int	line
	)

Definition at line 1029 of file KalFitMemLeak.c.

                                                              {
    size_t len;
    char *newstring;
 
    MW_MUTEX_LOCK();
 
    if( str == NULL ) {
        mwIncErr();
        mwWrite( "strdup: <%ld> %s(%d), strdup(NULL) called\n",
            mwCounter, file, line );
        FLUSH();
        MW_MUTEX_UNLOCK();
        return NULL;
        }
 
    len = strlen( str ) + 1;
    newstring = (char*) mwMalloc( len, file, line );
    if( newstring != NULL ) memcpy( newstring, str, len );
    MW_MUTEX_UNLOCK();
    return newstring;
    }

◆ mwTerm()

void mwTerm ( void )

Definition at line 625 of file KalFitMemLeak.c.

                    {
    if( mwInited == 1 )
    {
        mwAbort();
        return;
    }
    if( !mwInited )
        mwWrite("internal: mwTerm(): MEMWATCH has not been started!\n");
    else
        mwInited --;
    }

◆ mwTest()

int mwTest	(	const char *	file,
		int	line,
		int	items
	)

Definition at line 685 of file KalFitMemLeak.c.

                                                    {
    mwAutoInit();
    mwTestFlags = items;
    return mwTestNow( file, line, 0 );
    }

◆ mwTestBuffer()

int mwTestBuffer	(	const char *	file,
		int	line,
		void *	p
	)

Definition at line 695 of file KalFitMemLeak.c.

                                                        {
    mwData* mw;
 
    mwAutoInit();
 
    /* do the quick ownership test */
    mw = (mwData*) mwBUFFER_TO_MW( p );
 
    if( mwIsOwned( mw, file, line ) ) {
        return mwTestBuf( mw, file, line );
        }
    return 1;
    }

◆ mwTrace()

void mwTrace	(	const char *	format,
			...
	)

Definition at line 1343 of file KalFitMemLeak.c.

                                        {
    int tot, oflow = 0;
    va_list mark;
 
    mwAutoInit();
    MW_MUTEX_LOCK();
    TESTS(NULL,0);
    if( mwOutFunction == NULL ) mwOutFunction = mwDefaultOutFunc;
 
    va_start( mark, format );
    tot = vsprintf( mwPrintBuf, format, mark );
    va_end( mark );
    if( tot >= MW_TRACE_BUFFER ) { mwPrintBuf[MW_TRACE_BUFFER] = 0; oflow = 1; }
    for(tot=0;mwPrintBuf[tot];tot++)
        (*mwOutFunction)( mwPrintBuf[tot] );
    if( oflow ) {
        mwIncErr();
        mwTrace( " [WARNING: OUTPUT BUFFER OVERFLOW - SYSTEM UNSTABLE]\n" );
        }
 
    FLUSH();
    MW_MUTEX_UNLOCK();
    }

◆ mwUnmark()

void * mwUnmark	(	void *	p,
		const char *	file,
		unsigned	line
	)

Definition at line 804 of file KalFitMemLeak.c.

                                                           {
    mwMarker *mrk, *prv;
    mrk = mwFirstMark;
    prv = NULL;
    while( mrk ) {
        if( mrk->host == p ) {
            if( mrk->level < 2 ) {
                if( prv ) prv->next = mrk->next;
                else mwFirstMark = mrk->next;
                free( mrk->text );
                free( mrk );
                return p;
                }
            mrk->level --;
            return p;
            }
        prv = mrk;
        mrk = mrk->next;
        }
    mwWrite("mark: %s(%d), no mark found for %p\n", file, line, p );
    return p;
    }

◆ mwVerify()

int mwVerify	(	int	exp,
		const char *	exps,
		const char *	fn,
		int	ln
	)

Definition at line 1287 of file KalFitMemLeak.c.

                                                                  {
    int i;
    char buffer[MW_TRACE_BUFFER+8];
    if( exp ) {
        return 0;
        }
    mwAutoInit();
    MW_MUTEX_LOCK();
    TESTS(fn,ln);
    mwIncErr();
    mwCounter++;
    mwWrite( "verify trap: <%ld> %s(%d), %s\n", mwCounter, fn, ln, exps );
    if( mwAriFunction != NULL ) {
        sprintf( buffer, "MEMWATCH: verify trap: %s(%d), %s", fn, ln, exps );
        i = (*mwAriFunction)(buffer);
        if( i == 0 ) {
            mwWrite( "verify trap: <%ld> IGNORED - execution continues\n", mwCounter );
            MW_MUTEX_UNLOCK();
            return 0;
            }
        if( i == 1 ) {
            mwWrite( "verify trap: <%ld> RETRY - executing again\n", mwCounter );
            MW_MUTEX_UNLOCK();
            return 1;
            }
        }
    else {
        if( mwAriAction & MW_ARI_NULLREAD ) {
            /* This is made in an attempt to kick in */
            /* any debuggers or OS stack traces */
            FLUSH();
            /*lint -save -e413 */
            i = *((int*)NULL);
            mwDummy( (char)i );
            /*lint -restore */
            }
        if( mwAriAction & MW_ARI_IGNORE ) {
            mwWrite( "verify trap: <%ld> AUTO IGNORED - execution continues\n", mwCounter );
            MW_MUTEX_UNLOCK();
            return 0;
            }
        fprintf(mwSTDERR,"\nMEMWATCH: verify trap: %s(%d), %s\n", fn, ln, exps );
        }
    FLUSH();
    (void) mwTestNow( fn, ln, 1 );
    FLUSH();
    MW_MUTEX_UNLOCK();
    exit(255);
    /* NOT REACHED - the return statement is in to keep */
    /* stupid compilers from squeaking about differing return modes. */
    /* Smart compilers instead say 'code unreachable...' */
    /*lint -save -e527 */
    return 0;
    /*lint -restore */
    }

Classes

Macros

Typedefs

Functions