@@ -23,6 +23,10 @@

 #include <sys/types.h>

 #include <sys/stat.h>

+

+#ifdef USE_MPOOL

+#include mpool.h

+#endif

 #ifdef __cplusplus

 extern "C"

@@ -152,6 +156,10 @@ struct cl_engine {

     /* PUA categories (to be included or excluded) */

     char *pua_cats;

+

+#ifdef USE_MPOOL

+    mpool_t *mempool;

+#endif

 };

 struct cl_limits {

@@ -35,6 +35,10 @@

 #include "str.h"

 #include "others.h"

+#ifdef USE_MPOOL

+#include "mpool.h"

+#endif

+

 struct dconf_module {

     const char	*mname;	    /* module name */

     const char	*sname;	    /* submodule name */

@@ -108,13 +112,20 @@ static struct dconf_module modules[] = {

     { NULL,	    NULL,	    0,			    0 }

 };

+#ifdef USE_MPOOL

+struct cli_dconf *cli_dconf_init(mpool_t mempool)

+#else

 struct cli_dconf *cli_dconf_init(void)

+#endif

 {

 	unsigned int i;

 	struct cli_dconf *dconf;

-

+#ifdef USE_MPOOL

+    dconf = (struct cli_dconf *) mpool_calloc(mempool, sizeof(struct cli_dconf), 1, NULL);

+#else

     dconf = (struct cli_dconf *) cli_calloc(sizeof(struct cli_dconf), 1);

+#endif

     if(!dconf)

 	return NULL;

@@ -29,6 +29,10 @@

 #include "cltypes.h"

 #include "cvd.h"

+#ifdef USE_MPOOL

+#include "mpool.h"

+#endif

+

 struct cli_dconf {

     uint32_t pe;

     uint32_t elf;

@@ -97,7 +101,11 @@ struct cli_dconf {

 #define PHISHING_CONF_ENGINE   0x1

 #define PHISHING_CONF_ENTCONV  0x2

+#ifdef USE_MPOOL

+struct cli_dconf *cli_dconf_init(mpool_t);

+#else

 struct cli_dconf *cli_dconf_init(void);

+#endif

 void cli_dconf_print(struct cli_dconf *dconf);

 int cli_dconf_load(FILE *fs, struct cl_engine **engine, unsigned int options, struct cli_dbio *dbio);

 #endif

@@ -39,6 +39,10 @@

 #include "str.h"

 #include "readdb.h"

+#ifdef USE_MPOOL

+#include "mpool.h"

+#endif

+

 uint8_t cli_ac_mindepth = AC_DEFAULT_MIN_DEPTH;

 uint8_t cli_ac_maxdepth = AC_DEFAULT_MAX_DEPTH;

@@ -66,7 +70,11 @@ int cli_ac_addpatt(struct cli_matcher *root, struct cli_ac_patt *pattern)

     for(i = 0; i < len; i++) {

 	if(!pt->trans) {

+#ifdef USE_MPOOL

+	    pt->trans = (struct cli_ac_node **) mpool_calloc(root->mempool, 256, sizeof(struct cli_ac_node *), NULL);

+#else

 	    pt->trans = (struct cli_ac_node **) cli_calloc(256, sizeof(struct cli_ac_node *));

+#endif

 	    if(!pt->trans) {

 		cli_errmsg("cli_ac_addpatt: Can't allocate memory for pt->trans\n");

 		return CL_EMEM;

@@ -76,17 +84,29 @@ int cli_ac_addpatt(struct cli_matcher *root, struct cli_ac_patt *pattern)

 	next = pt->trans[(unsigned char) (pattern->pattern[i] & 0xff)]; 

 	if(!next) {

+#ifdef USE_MPOOL

+	    next = (struct cli_ac_node *) mpool_calloc(root->mempool, 1, sizeof(struct cli_ac_node), NULL);

+#else

 	    next = (struct cli_ac_node *) cli_calloc(1, sizeof(struct cli_ac_node));

+#endif

 	    if(!next) {

 		cli_errmsg("cli_ac_addpatt: Can't allocate memory for AC node\n");

 		return CL_EMEM;

 	    }

 	    if(i != len - 1) {

+#ifdef USE_MPOOL

+		next->trans = (struct cli_ac_node **) mpool_calloc(root->mempool, 256, sizeof(struct cli_ac_node *), NULL);

+#else

 		next->trans = (struct cli_ac_node **) cli_calloc(256, sizeof(struct cli_ac_node *));

+#endif

 		if(!next->trans) {

 		    cli_errmsg("cli_ac_addpatt: Can't allocate memory for next->trans\n");

+#ifdef USE_MPOOL

+		    mpool_free(root->mempool, next);

+#else

 		    free(next);

+#endif

 		    return CL_EMEM;

 		}

 	    } else {

@@ -94,13 +114,22 @@ int cli_ac_addpatt(struct cli_matcher *root, struct cli_ac_patt *pattern)

 	    }

 	    root->ac_nodes++;

+#ifdef USE_MPOOL

+	    newtable = mpool_resize(root->mempool, root->ac_nodetable, root->ac_nodes * sizeof(struct cli_ac_node *), NULL);

+#else

 	    newtable = cli_realloc(root->ac_nodetable, root->ac_nodes * sizeof(struct cli_ac_node *));

+#endif

 	    if(!newtable) {

 		root->ac_nodes--;

 		cli_errmsg("cli_ac_addpatt: Can't realloc ac_nodetable\n");

 		if(next->trans)

+#ifdef USE_MPOOL

+		    mpool_free(root->mempool, next->trans);

+		mpool_free(root->mempool, next);

+#else

 		    free(next->trans);

 		free(next);

+#endif

 		return CL_EMEM;

 	    }

 	    root->ac_nodetable = (struct cli_ac_node **) newtable;

@@ -114,7 +143,11 @@ int cli_ac_addpatt(struct cli_matcher *root, struct cli_ac_patt *pattern)

     }

     root->ac_patterns++;

+#ifdef USE_MPOOL

+    newtable = mpool_resize(root->mempool, root->ac_pattable, root->ac_patterns * sizeof(struct cli_ac_patt *), NULL);

+#else

     newtable = cli_realloc(root->ac_pattable, root->ac_patterns * sizeof(struct cli_ac_patt *));

+#endif

     if(!newtable) {

 	root->ac_patterns--;

 	cli_errmsg("cli_ac_addpatt: Can't realloc ac_pattable\n");

@@ -299,16 +332,28 @@ int cli_ac_buildtrie(struct cli_matcher *root)

 int cli_ac_init(struct cli_matcher *root, uint8_t mindepth, uint8_t maxdepth)

 {

+#ifdef USE_MPOOL

+    root->ac_root = (struct cli_ac_node *) mpool_calloc(root->mempool, 1, sizeof(struct cli_ac_node), NULL);

+#else

     root->ac_root = (struct cli_ac_node *) cli_calloc(1, sizeof(struct cli_ac_node));

+#endif

     if(!root->ac_root) {

 	cli_errmsg("cli_ac_init: Can't allocate memory for ac_root\n");

 	return CL_EMEM;

     }

+#ifdef USE_MPOOL

+    root->ac_root->trans = (struct cli_ac_node **) mpool_calloc(root->mempool, 256, sizeof(struct cli_ac_node *), NULL);

+#else

     root->ac_root->trans = (struct cli_ac_node **) cli_calloc(256, sizeof(struct cli_ac_node *));

+#endif

     if(!root->ac_root->trans) {

 	cli_errmsg("cli_ac_init: Can't allocate memory for ac_root->trans\n");

+#ifdef USE_MPOOL

+	mpool_free(engine->mempool, root->ac_root, sizeof(struct cli_ac_node));

+#else

 	free(root->ac_root);

+#endif

 	return CL_EMEM;

     }

@@ -318,7 +363,11 @@ int cli_ac_init(struct cli_matcher *root, uint8_t mindepth, uint8_t maxdepth)

     return CL_SUCCESS;

 }

+#ifdef USE_MPOOL

+static void ac_free_alt(mpool_t *mempool, struct cli_ac_patt *p)

+#else

 static void ac_free_alt(struct cli_ac_patt *p)

+#endif

 {

 	uint16_t i;

 	struct cli_ac_alt *a1, *a2;

@@ -333,11 +382,20 @@ static void ac_free_alt(struct cli_ac_patt *p)

 	    a2 = a1;

 	    a1 = a1->next;

 	    if(a2->str)

+#ifdef USE_MPOOL

+		mpool_free(mempool, a2->str);

+	    mpool_free(mempool, a2);

+#else

 		free(a2->str);

 	    free(a2);

+#endif

 	}

     }

+#ifdef USE_MPOOL

+    mpool_free(mempool, p->alttable);

+#else

     free(p->alttable);

+#endif

 }

 void cli_ac_free(struct cli_matcher *root)

@@ -1093,8 +1151,11 @@ int cli_ac_addsig(struct cli_matcher *root, const char *virname, const char *hex

     if(strlen(hexsig) / 2 < root->ac_mindepth)

 	return CL_EPATSHORT;

-

+#ifdef USE_MPOOL

+    if((new = (struct cli_ac_patt *) mpool_calloc(root->mempool, 1, sizeof(struct cli_ac_patt), NULL)) == NULL)

+#else

     if((new = (struct cli_ac_patt *) cli_calloc(1, sizeof(struct cli_ac_patt))) == NULL)

+#endif

 	return CL_EMEM;

     new->rtype = rtype;

@@ -1114,7 +1175,11 @@ int cli_ac_addsig(struct cli_matcher *root, const char *virname, const char *hex

     if(strchr(hexsig, '[')) {

 	if(!(hexcpy = cli_strdup(hexsig))) {

+#ifdef USE_MPOOL

+	    mpool_free(root->mempool, new);

+#else

 	    free(new);

+#endif

 	    return CL_EMEM;

 	}

@@ -1179,14 +1244,22 @@ int cli_ac_addsig(struct cli_matcher *root, const char *virname, const char *hex

 	if(error) {

 	    free(hexcpy);

+#ifdef USE_MPOOL

+	    mpool_free(root->mempool, new);

+#else

 	    free(new);

+#endif

 	    return error;

 	}

 	hex = cli_strdup(hex);

 	free(hexcpy);

 	if(!hex) {

+#ifdef USE_MPOOL

+	    mpool_free(root->mempool, new);

+#else

 	    free(new);

+#endif

 	    return CL_EMEM;

 	}

     }

@@ -1197,13 +1270,22 @@ int cli_ac_addsig(struct cli_matcher *root, const char *virname, const char *hex

 	if(hex) {

 	    hexcpy = hex;

 	} else if(!(hexcpy = cli_strdup(hexsig))) {

+#ifdef USE_MPOOL

+	    mpool_free(root->mempool, new);

+#else

 	    free(new);

+#endif

 	    return CL_EMEM;

 	}

+#ifdef USE_MPOOL

+	if(!(hexnew = (char *) mpool_calloc(root->mempool, strlen(hexsig) + 1, 1, NULL))) {

+	    mpool_free(root->mempool, new);

+#else

 	if(!(hexnew = (char *) cli_calloc(strlen(hexsig) + 1, 1))) {

-	    free(hexcpy);

 	    free(new);

+#endif

+	    free(hexcpy);

 	    return CL_EMEM;

 	}

@@ -1225,7 +1307,11 @@ int cli_ac_addsig(struct cli_matcher *root, const char *virname, const char *hex

 	    }

 	    *start++ = 0;

+#ifdef USE_MPOOL

+	    newalt = (struct cli_ac_alt *) mpool_calloc(root->mempool, 1, sizeof(struct cli_ac_alt), NULL);

+#else

 	    newalt = (struct cli_ac_alt *) cli_calloc(1, sizeof(struct cli_ac_alt));

+#endif

 	    if(!newalt) {

 		cli_errmsg("cli_ac_addsig: Can't allocate newalt\n");

 		error = CL_EMEM;

@@ -1233,10 +1319,19 @@ int cli_ac_addsig(struct cli_matcher *root, const char *virname, const char *hex

 	    }

 	    new->alt++;

+

+#ifdef USE_MPOOL

+	    newtable = (struct cli_ac_alt **) mpool_resize(root->mempool, new->alttable, new->alt * sizeof(struct cli_ac_alt *), NULL);

+#else

 	    newtable = (struct cli_ac_alt **) cli_realloc(new->alttable, new->alt * sizeof(struct cli_ac_alt *));

+#endif

 	    if(!newtable) {

 		new->alt--;

+#ifdef USE_MPOOL

+		mpool_free(root->mempool, newalt);

+#else

 		free(newalt);

+#endif

 		cli_errmsg("cli_ac_addsig: Can't realloc new->alttable\n");

 		error = CL_EMEM;

 		break;

@@ -1256,7 +1351,11 @@ int cli_ac_addsig(struct cli_matcher *root, const char *virname, const char *hex

 	    if(3 * newalt->num - 1 == (uint16_t) strlen(pt)) {

 		newalt->chmode = 1;

+#ifdef USE_MPOOL

+		newalt->str = (unsigned char *) mpool_alloc(root->mempool, newalt->num, NULL);

+#else

 		newalt->str = (unsigned char *) cli_malloc(newalt->num);

+#endif

 		if(!newalt->str) {

 		    cli_errmsg("cli_ac_addsig: Can't allocate newalt->str\n");

 		    error = CL_EMEM;

@@ -1285,7 +1384,11 @@ int cli_ac_addsig(struct cli_matcher *root, const char *virname, const char *hex

 			while(altpt->next)

 			    altpt = altpt->next;

+#ifdef USE_MPOOL

+			altpt->next = (struct cli_ac_alt *) mpool_calloc(root->mempool, 1, sizeof(struct cli_ac_alt), NULL);

+#else

 			altpt->next = (struct cli_ac_alt *) cli_calloc(1, sizeof(struct cli_ac_alt));

+#endif

 			if(!altpt->next) {

 			    cli_errmsg("cli_ac_addsig: Can't allocate altpt->next\n");

 			    error = CL_EMEM;

@@ -1318,20 +1421,46 @@ int cli_ac_addsig(struct cli_matcher *root, const char *virname, const char *hex

 	if(error) {

 	    if(new->alt) {

 		free(hex);

+#ifdef USE_MPOOL

+		ac_free_alt(root->mempool, new);

+	    }

+	    mpool_free(root->mempool, new);

+#else

 		ac_free_alt(new);

 	    }

 	    free(new);

+#endif

 	    return error;

 	}

     }

-    if((new->pattern = cli_hex2ui(hex ? hex : hexsig)) == NULL) {

+#ifdef USE_MPOOL

+{

+    unsigned int mpoolhexlen = (strlen(hex ? hex : hexsig) / 2 + 1) * sizeof(uint16_t);

+    uint16_t *mpoolpatt = cli_hex2ui(hex ? hex : hexsig);

+    if(mpoolpatt) {

+        if((new->pattern = mpool_alloc(root->mempool, mpoolhexlen, NULL)) != NULL)

+	    memcpy(new->pattern, mpoolpatt, mpoolhexlen);

+	free(mpoolpatt);

+    } else new->pattern = NULL;

+}

+#else

+    new->pattern = cli_hex2ui(hex ? hex : hexsig)

+#endif

+

+    if(new->pattern == NULL) {

 	if(new->alt)

+#ifdef USE_MPOOL

+	    ac_free_alt(root->mempool, new);

+	mpool_free(root->mempool, new);

+#else

 	    ac_free_alt(new);

-	free(hex);

 	free(new);

+#endif

+	free(hex);

 	return CL_EMALFDB;

     }

+

     new->length = strlen(hex ? hex : hexsig) / 2;

     free(hex);

@@ -1375,9 +1504,15 @@ int cli_ac_addsig(struct cli_matcher *root, const char *virname, const char *hex

 	if(plen < root->ac_mindepth) {

 	    cli_errmsg("cli_ac_addsig: Can't find a static subpattern of length %u\n", root->ac_mindepth);

+#ifdef USE_MPOOL

+	    ac_free_alt(root->mempool, new);

+	    mpool_free(root->mempool, new->pattern);

+	    mpool_free(root->mempool, new);

+#else

 	    ac_free_alt(new);

 	    free(new->pattern);

 	    free(new);

+#endif

 	    return CL_EMALFDB;

 	}

@@ -1394,11 +1529,28 @@ int cli_ac_addsig(struct cli_matcher *root, const char *virname, const char *hex

     if(new->length > root->maxpatlen)

 	root->maxpatlen = new->length;

+#ifdef USE_MPOOL

+{

+    char *mpoolvirname = cli_virname((char *) virname, options & CL_DB_OFFICIAL, 0);

+    if(mpoolvirname) {

+        unsigned int mpoolvirnamesz = strlen(mpoolvirname) + 1;

+        if((new->virname = mpool_alloc(root->mempool, mpoolvirnamesz, NULL)) != NULL)

+	    memcpy(new->virname, mpoolvirname, mpoolvirnamesz);

+    } else new->virname = NULL;

+}

+#else

     new->virname = cli_virname((char *) virname, options & CL_DB_OFFICIAL, 0);

+#endif

     if(!new->virname) {

+#ifdef USE_MPOOL

+	new->prefix ? mpool_free(root->mempool, new->prefix) : mpool_free(root->mempool, new->pattern);

+	ac_free_alt(root->mempool, new);

+	mpool_free(root->mempool, new);

+#else

 	new->prefix ? free(new->prefix) : free(new->pattern);

 	ac_free_alt(new);

 	free(new);

+#endif

 	return CL_EMEM;

     }

@@ -1406,23 +1558,48 @@ int cli_ac_addsig(struct cli_matcher *root, const char *virname, const char *hex

 	root->ac_lsigtable[new->lsigid[1]]->virname = new->virname;

     if(offset) {

+#ifdef USE_MPOOL

+	char *mpooloffset = cli_strdup(offset);

+	if(mpooloffset) {

+	    unsigned int mpooloffsetsz = strlen(mpooloffset) + 1;

+	    if((new->offset = mpool_alloc(root->mempool, mpooloffsetsz, NULL)))

+	        memcpy(new->offset, mpooloffset, mpooloffsetsz);

+	} else new->offset = NULL;

+#else

 	new->offset = cli_strdup(offset);

+#endif

 	if(!new->offset) {

+#ifdef USE_MPOOL

+	    new->prefix ? mpool_free(rool->mempool, new->prefix) : mpool_free(root->mempool, new->pattern);

+	    ac_free_alt(root->mempool, new);

+	    mpool_free(root->mempool, new->virname);

+	    mpool_free(root->mempool, new);

+#else

 	    new->prefix ? free(new->prefix) : free(new->pattern);

 	    ac_free_alt(new);

 	    free(new->virname);

 	    free(new);

+#endif

 	    return CL_EMEM;

 	}

     }

     if((ret = cli_ac_addpatt(root, new))) {

+#ifdef USE_MPOOL

+	new->prefix ? mpool_free(rool->mempool, new->prefix) : mpool_free(root->mempool, new->pattern);

+	mpool_free(root->mempool, new->virname);

+	ac_free_alt(root->mempool, new);

+	if(new->offset)

+	    mpool_free(root->mempool, new->offset);

+	mpool_free(root->mempool, new);

+#else

 	new->prefix ? free(new->prefix) : free(new->pattern);

 	free(new->virname);

 	ac_free_alt(new);

 	if(new->offset)

 	    free(new->offset);

 	free(new);

+#endif

 	return ret;

     }

@@ -32,6 +32,10 @@

 #include "matcher-bm.h"

 #include "filetypes.h"

+#ifdef USE_MPOOL

+#include "mpool.h"

+#endif

+

 #define BM_MIN_LENGTH	3

 #define BM_BLOCK_SIZE	3

 #define HASH(a,b,c) (211 * a + 37 * b + c)

@@ -97,12 +101,19 @@ int cli_bm_init(struct cli_matcher *root)

 {

 	uint16_t i, size = HASH(255, 255, 255) + 1;

-

+#ifdef USE_MPOOL

+    if(!(root->bm_shift = (uint8_t *) mpool_calloc(root->mempool, size, sizeof(uint8_t), NULL)))

+#else

     if(!(root->bm_shift = (uint8_t *) cli_calloc(size, sizeof(uint8_t))))

+#endif

 	return CL_EMEM;

     if(!(root->bm_suffix = (struct cli_bm_patt **) cli_calloc(size, sizeof(struct cli_bm_patt *)))) {

+#ifdef USE_MPOOL

+	mpool_free(root->mempool, root->bm_shift, size * sizeof(uint8_t));

+#else

 	free(root->bm_shift);

+#endif

 	return CL_EMEM;

     }

@@ -34,6 +34,11 @@

 #include "matcher-bm.h"

 #include "hashtab.h"

+#ifdef USE_MPOOL

+#include "mpool.h"

+#endif

+

+

 #define CLI_MATCH_WILDCARD	0xff00

 #define CLI_MATCH_CHAR		0x0000

 #define CLI_MATCH_IGNORE	0x0100

@@ -80,6 +85,7 @@ struct cli_matcher {

     uint16_t maxpatlen;

     uint8_t ac_only;

+    mpool_t mempool;

 };

 struct cli_meta_node {

new file mode 100644

@@ -0,0 +1,86 @@

+2006-05-31  Gray Watson  <>

+

+	* Version 2.1.0 released.

+

+	* Added MPOOL_ERROR_PNT_OVER to distinguish between pointer

+	overwrite and mpool structure overwrite.

+

+2005-05-20  Gray Watson  <>

+

+	* Version 2.0.0 released.

+

+	* First external publication of library.

+

+Thu Mar  4 10:14:21 1999  Gray Watson  <>

+

+	* Reworked the way the blocks were split up.

+

+	* Removed the round arguments.  Not used.

+

+Wed Mar  3 19:29:38 1999  Gray Watson  <>

+

+	* Moved to random().  Fucking rand() was hiding a lot of problems

+ 	from me.

+

+	* Added some additional sanity checks in free().

+

+	* Added mpool_set_max_pages to the library.

+

+Thu Feb 25 12:41:51 1999  Gray Watson  <>

+

+	* Added log_function transaction callback.

+

+Thu Feb 25 09:53:33 1999  Gray Watson  <>

+

+	* Changed the default page size to 16 * getpagesize.

+

+Wed Feb 24 17:52:52 1999  Gray Watson  <>

+

+	* Major reworking of internals to simplify structures. 

+

+Fri Feb 19 12:52:55 1999  Gray Watson  <>

+

+	* Made a number of changes to the internals which removed the

+ 	addr_to_block as a performance pig.

+

+Tue Feb 16 21:11:23 1999  Gray Watson  <>

+

+	* Added ability for free to look up in the free bit lists for

+ 	memory to use.

+

+	* Added mpool_clear.  Good idea.

+

+Thu Feb 11 02:53:45 1999  Gray Watson  <>

+

+	* Finally a working version.  Looks much better.

+

+	* Added rounding sizes so it will allocate aligned memory.

+

+	* Added minimum size to the mpool_free function to speed it up.

+

+Wed Feb 10 23:30:48 1999  Gray Watson  <>

+

+	* Version 1 with new fine grained memory resolution almost

+ 	working.

+

+Fri May  2 02:26:28 1997  Gray Watson  <>

+

+	* Moved to MAP_PRIVATE from MAP_SHARED.

+

+	* Fixed the min/max handling.

+

+	* Added additional info to mpool_stat.

+

+Thu May  1 16:51:06 1997  Gray Watson  <>

+

+	* Added page-size information request.

+

+	* Added better no-memory errors.

+

+Thu Apr 24 01:58:41 1997  Gray Watson  <>

+

+	* Added handling of null for debugging purposes.

+

+Mon Apr 14 03:31:26 1997  Gray Watson  <>

+

+	* Started the mpool routines.

new file mode 100644

@@ -0,0 +1,56 @@

+#

+# $Id: Makefile.all,v 1.1.1.1 2005/05/20 19:58:29 gray Exp $

+#

+

+HFLS	= mpool.h

+OBJS	= mpool.o

+

+CC	= cc

+

+CFLAGS	= -g -I. $(DEFINES)

+#CFLAGS	= -g -I.

+LDFLAGS	=

+RANLIB	= ranlib

+

+DESTDIR	= /usr/local

+TEST	= mpool_t

+LIBRARY	= libmpool.a

+

+all : $(LIBRARY) $(UTIL)

+

+clean :

+	rm -f a.out core *.o *.t

+	rm -f $(LIBRARY) $(TEST)

+

+install : $(HFLS) $(LIBRARY)

+	install -c -m 444 $(HFLS) $(DESTDIR)/include

+	install -c -m 444 $(LIBRARY) $(DESTDIR)/lib

+	$(RANLIB) $(DESTDIR)/libo/$(LIBRARY)

+

+$(LIBRARY) : $(OBJS)

+	ar cr $(LIBRARY) $?

+	$(RANLIB) $@

+

+tests : $(TEST)

+

+$(TEST) : $(TEST).o $(LIBRARY)

+	rm -f $@

+	$(CC) $(LDFLAGS) $(TEST).o $(LIBRARY)

+	mv a.out $@

+

+$(UTIL) : $(UTIL).o $(LIBRARY)

+	rm -f $@

+	$(CC) $(LDFLAGS) $(UTIL).o $(LIBRARY)

+	mv a.out $@

+

+.c.o :

+	rm -f $@

+	$(CC) $(CFLAGS) -c $< -o $@

+

+#

+# Below are dependencies that are automatically generated by make

+# depend.  Please do not edit by hand.

+#

+

+mpool.o: mpool.c mpool.h mpool_loc.h

+mpool_t.o: mpool_t.c mpool.h

new file mode 100644

@@ -0,0 +1,11 @@

+-------------------------------------------------------------------------------

+$Id: NEWS,v 1.2 2006/05/31 20:28:31 gray Exp $

+-------------------------------------------------------------------------------

+

+Version 2.1.0:

+

+	* Added MPOOL_ERROR_PNT_OVER to show pointer overwrites.

+

+Version 2.0.0:

+

+	* Initial external release of library after use since 1996.

new file mode 100644

@@ -0,0 +1,46 @@

+-------------------------------------------------------------------------------

+$Id: README,v 1.2 2005/05/22 19:49:30 gray Exp $

+-------------------------------------------------------------------------------

+

+BACKGROUND:

+

+This is a memory pool library which was written to allow a program to

+have heaps that it could destroy without fragmenting memory.  You can

+have multiple heaps and reset them easily completely reclaiming the

+memory (as opposed to standard heaps).

+

+With it you can mpool_open() a new heap, then mpool_alloc(),

+mpool_calloc(), mpool_realloc(), mpool_free() to your heart's content.

+Once you are done with the memory-pool you can run mpool_clear() or

+mpool_close() and completely remove the memory associated with the

+pools.  This is very handy if you are working with some large blocks

+of memory and want to reset back to a clean state.

+

+Check out the mpool.h file for more information.  Sorry for minimal

+docs.

+

+-------------------------------------------------------------------------------

+

+INSTALLATION:

+

+1) Typing 'make' should be enough to build libskip.a.

+2) Typing 'make tests' should make the mpool_t test program.

+

+-------------------------------------------------------------------------------

+

+REPOSITORY:

+

+The newest versions of the library are available from:

+

+	http://256.com/sources/mpool/

+

+-------------------------------------------------------------------------------

+

+AUTHOR:

+

+If you have any questions or problems feel free to send me mail.

+

+Gray Watson

+http://256.com/gray/

+

+-------------------------------------------------------------------------------

new file mode 100644

@@ -0,0 +1,1734 @@

+/*

+ * Memory pool routines.

+ *

+ * Copyright 1996 by Gray Watson.

+ *

+ * This file is part of the mpool package.

+ *

+ * Permission to use, copy, modify, and distribute this software for

+ * any purpose and without fee is hereby granted, provided that the

+ * above copyright notice and this permission notice appear in all

+ * copies, and that the name of Gray Watson not be used in advertising

+ * or publicity pertaining to distribution of the document or software

+ * without specific, written prior permission.

+ *

+ * Gray Watson makes no representations about the suitability of the

+ * software described herein for any purpose.  It is provided "as is"

+ * without express or implied warranty.

+ *

+ * The author may be reached via http://256.com/gray/

+ *

+ * $Id: mpool.c,v 1.5 2006/05/31 20:28:31 gray Exp $

+ */

+

+/*

+ * Memory-pool allocation routines.  I got sick of the GNU mmalloc

+ * library which was close to what we needed but did not exactly do

+ * what I wanted.

+ *

+ * The following uses mmap from /dev/zero.  It allows a number of

+ * allocations to be made inside of a memory pool then with a clear or

+ * close the pool can be reset without any memory fragmentation and

+ * growth problems.

+ */

+

+#include <errno.h>

+#include <fcntl.h>

+#include <stdio.h>

+#include <stdlib.h>

+#include <string.h>

+#include <unistd.h>

+#include <sys/mman.h>

+

+#ifdef DMALLOC

+#include "dmalloc.h"

+#endif

+

+#define MPOOL_MAIN

+

+#include "mpool.h"

+#include "mpool_loc.h"

+

+#ifdef __GNUC__

+#ident "$Id: mpool.c,v 1.5 2006/05/31 20:28:31 gray Exp $"

+#else

+static char *rcs_id = "$Id: mpool.c,v 1.5 2006/05/31 20:28:31 gray Exp $";

+#endif

+

+/* ACAB */

+#include <stddef.h>

+struct FRAG {

+  unsigned long frag_size;

+  void *frag_ptr;

+};

+#define FRAG_OVERHEAD (offsetof(struct FRAG, frag_ptr))

+

+/* version */

+static	char *version = "mpool library version 2.1.0";

+

+/* local variables */

+static	int		enabled_b = 0;		/* lib initialized? */

+static	unsigned int	min_bit_free_next = 0;	/* min size of next pnt */

+static	unsigned int	min_bit_free_size = 0;	/* min size of next + size */

+static	unsigned long	bit_array[MAX_BITS + 1]; /* size -> bit */

+

+/****************************** local utilities ******************************/

+

+/*

+ * static void startup

+ *

+ * DESCRIPTION:

+ *

+ * Perform any library level initialization.

+ *

+ * RETURNS:

+ *

+ * None.

+ *

+ * ARGUMENTS:

+ *

+ * None.

+ */

+static	void	startup(void)

+{

+  int		bit_c;

+  unsigned long	size = 1;

+  

+  if (enabled_b) {

+    return;

+  }

+  

+  /* allocate our free bit array list */

+  for (bit_c = 0; bit_c <= MAX_BITS; bit_c++) {

+    bit_array[bit_c] = size;

+    

+    /*

+     * Note our minimum number of bits that can store a pointer.  This

+     * is smallest address that we can have a linked list for.

+     */

+    if (min_bit_free_next == 0 && size >= sizeof(void *)) {

+      min_bit_free_next = bit_c;

+    }

+    /*

+     * Note our minimum number of bits that can store a pointer and

+     * the size of the block.

+     */

+    if (min_bit_free_size == 0 && size >= sizeof(mpool_free_t)) {