/* =====================================================================   File:	rmalloc.c   Author:	Rammi   Date:	11/16/1995 (started)   Reminder:	Use at your own risk.   Content:	Debug wrapper functions for the malloc library.   		For more information see rmalloc.h   Last Change: $Date: 2006/01/29 18:56:12 $   History:     $Log: rmalloc.c,v $   History:     Revision 1.9  2006/01/29 18:56:12  rammi   History:     Streamlined various things due to a proposal by Brant L Gurganus. Thanks Brant!   History:   History:     Revision 1.8  2003/01/31 15:47:52  rammi   History:     Changed signature of Rmalloc_set_flags() and Rmalloc_retag to return pointer.   History:   History:     Revision 1.7  2003/01/31 15:04:20  rammi   History:     Fixed unclosed comment.   History:   History:     Revision 1.6  2003/01/31 14:51:48  rammi   History:     Updated version to 1.16   History:   History:     Revision 1.5  2003/01/31 14:49:00  rammi   History:     Unset RM_STATIC flag in realloc to avoid warning on free   History:   History:     Revision 1.4  2002/04/22 17:39:34  rammi   History:     Added output of BREAK_GENERATION environment variable when used   History:   History:     Revision 1.3  2002/04/22 16:28:06  rammi   History:     Finetuning of generations feature   History:   History:     Revision 1.2  2002/04/22 15:26:16  rammi   History:     Added Karl Brace's generations feature.   History:   Pre-CVS history:   		04/11/1996 (Rammi)		Changed to hashed table for faster access   		04/15/1996 (Rammi)		Included statistics		08/16/1997 (Rammi)		Automatic output of used memory on exit		08/25/1997 (Rammi)		Catching signals in critical situations (partly)		02/18/1998 (Rammi)		Testing memory before outputting statistic		Overworked signal handling in IsPossibleFilePos()		Made it unnecessary of changing all mallocs etc		to upper case		02/19/1998 (Rammi)		Little changes to compile on Alpha (64bit) without		warnings		03/10/1998 (Rammi)		Added comments.		03/24/1998 (Rammi)		Allowed compilation without WITH_FLAGS		04/07/1998 (Rammi)		All output goes to stderr..		1.11beta is released as 1.11!		05/28/1998 (Rammi)		Changed comments to english for public release		Added some more signal handling.		06/01/1998 (Rammi)		Added output of (flagged) strings in ELOQUENT mode.		Changed all names from my_... to R...		This is version 1.12!		11/13/1998 (Rammi)		Multiple defined label when using ELOQUENT mode now fixed.		Added getcwd wrapper as a prototype how to handle library		functions returning heap memory.		This is version 1.13!	        06/10/99 (Rammi)		The getcwd wrapper had a bug as Greg Silverman pointed		out (I should better have tested it!). Also fixed a		missing prototype and improved the signal handling in		rtest to allow receiving more signals while handling		one.   ===================================================================== *//* =========   INCLUDEs:   ========= */#define ALLOW_OS_CODE 1#include <stdio.h>#include <unistd.h>#include <string.h>#include <strings.h>#include <assert.h>#include <setjmp.h>#include <signal.h>#undef  MALLOC_DEBUG		/* here we need the correct malloc functions */#define RM_NEED_PROTOTYPES	/* but we want to compare prototypes */#include "rmalloc.h"/* ========   DEFINEs:   ======== *//* Actual version */#define VERSION         "1.17"/* ================================================================== *//* ============ Switch settings for different behaviours ============ *//* ============        Please set as needed              ============ *//* ================================================================== *//* This switch sets, how and when the allocated blocks are tested * on correctness. Each block is tested at least when * reallocating/freeing it. * Possible values: * 	0:		Minimum testing. Uses less memory, but *	                does not allow statistics. * 	1:		Extra testing possible by using RM_TEST *	                macro. Statistics possible. *   	2:		Testing ALL blocks on every malloc/free. *	                Statistics possible. */#ifndef RM_TEST_DEPTH#define RM_TEST_DEPTH 	1#endif/* This switch sets whether Karl's generations feature should be used * See the HTML doc for a indepth explanation of generations. * If set generations are used, otherwise no generations are included. */#define GENERATIONS#ifdef GENERATIONS/* BREAK_GENERATION_COND is the condition to find the generation  you are * interested in. * Set your debugger to the function rmalloc_generation() to find out which * function stack creates that generation. * You can either set it as a comparision directly to the number of a * generation (known from a previous run), a comparision to the function * GetBreakGenerationEnv() which reads the break generation from the environment * variable BREAK_GENERATION or don't set it so the break feature is not used. * The macro form allows for more complicated conditions, see example below. */#define BREAK_GENERATION_COND(nr) ((nr) == GetBreakGenerationEnv())/* #define BREAK_GENERATION_COND(nr) ((nr) == 125) *//* #define BREAK_GENERATION_COND(nr) ((nr) == 42  ||  (nr) == 4711) *//* The maximum number of generations you'd like to see in the statistics */#define MAX_STAT_GENERATIONS 3#endif /* GENERATIONS *//* Switch on EXTENTED alloc information. (Makes sense if an actual * error is observed such as a multiple free) *///#define ELOQUENT/* Allows setting of special flags with the RM_SET_FLAGS macro. * Needs more memory. */#define WITH_FLAGS/* Allows realloc(NULL, ...) * Posix allows this but there are some old malloc libraries * which crash on this. Switch on if you want to be compatible. *//* #define ALLOW_REALLOC_NULL *//* Allows free(NULL) * I still consider this an error in my progs because I use * NULL always as a very special value. *//* #define ALLOW_FREE_NULL *//* ================================================================== *//* ========================  Other Defines  ========================= *//* ================================================================== *//* Alignment (8 bytes are ok for virtually all machines) */#define ALIGNMENT	8/* Output message header: */#define HEAD		"<MALLOC_DEBUG>\t"/* Alignment padding: */#define ALIGN(s)	(((s+ALIGNMENT-1)/ALIGNMENT)*ALIGNMENT)/* Magic marker for block start: */#define PREV_STOP 	0x55555555/* Additional space for block begin to keep alignment: */#define START_SPACE     ALIGN(sizeof(begin))/* Additional space at end of block */#define END_SPACE       (sizeof(End))/* Overall additional space per block: */#define EXTRA_SPACE     (START_SPACE+END_SPACE)/* Hashtable size: */#define HASHSIZE	513/* Hash function: */#define HASH(p)		((((unsigned long)(p))/ALIGNMENT)%HASHSIZE)/* ==========================   STRUCTs, TYPEDEFs & ENUMs:   ========================== *//* This Information is added to the beginning of every * allocated block. */typedef struct _begin {  unsigned       StpA;		/* Magic bytes */#if RM_TEST_DEPTH > 0  struct _begin	*Next,		/* for linking in forward */	        *Prev;		/* and backward direction */#endif  const char	*File;		/* Filepos of allocation command */  size_t	 Size;		/* Size demanded */#ifdef GENERATIONS  unsigned       Generation;    /* All mallocs are numbered */#endif#ifdef WITH_FLAGS  unsigned       Flags;		/* Special flags */#endif  unsigned 	 StpB;		/* Magic bytes */} begin;/* * Global data. */typedef struct _global {  unsigned	 isInitialized;	/* Flag: already initialized? */  unsigned	 BlockCount;    /* Number of allocated blocks */} global;/* =======   CONSTs:   ======= *//* Magic block end: */static unsigned char End[] = {  0xA5, 0xA5, 0xA5, 0xA5,	/* odd */  0x5B, 0x5B, 0x5B, 0x5B,	/* odd */  0xAB, 0xAB, 0xAB, 0xAB,	/* odd */  0xAA, 0x55, 0xAA, 0x55	/* odd */};/* ========   GLOBALs:   ======== */#ifdef GENERATIONS/* The current generation. This is simply incremented which each call. */static unsigned cur_generation = 0;#endif/* =======   LOCALs:   ======= */#if RM_TEST_DEPTH > 0/* Stop marker for linked list of allocated blocks: */static begin ChainTempl = {  PREV_STOP,  &ChainTempl,  &ChainTempl,  "<Special>",  0,#ifdef GENERATIONS  0,#endif#ifdef WITH_FLAGS  0,#endif  PREV_STOP};/* Hashed linked lists: */static begin Chain[HASHSIZE];/* Global data used: */static global Global = {  0,				/* is initialized?  */  0				/* number of blocks */};#endif /* RM_TEST_DEPTH *//* Internally used longjmp target used if errors occure. */static jmp_buf   errorbuf;/* ========   FORWARD:   ======== */static int       FindBlk(const unsigned char *P);/* ===============================================================   			IMPLEMENTATION   =============================================================== *//* =============================================================================   Function:		FatalSignal	// local //   Author:		Rammi   Date:		08/25/1997   Return:		---   Parameter:		signum    signal number   Purpose:		Signal handler f?r fatal signals (SIGBUS, SIGSEGV)   ============================================================================= *///static void FatalSignal(int signum)//{//  /* --- jump to a save place --- *///  longjmp(errorbuf, signum);//}/* =============================================================================   Function:		IsPossibleFilePos	// local //   Author:		Rammi   Date:		11/30/1996   Return:		!= 0    possibly ok                        0       seems not so   Parameter:		file	possible filename			size    possible size   Purpose:		Decide whether file could be a filename and   			size a block size.   ============================================================================= */static int IsPossibleFilePos(const char *file, int size){  void   (*old_sigsegv_handler)(int) = SIG_DFL;  void   (*old_sigbus_handler)(int)  = SIG_DFL;//  char    *dp;//  int      ret;  if (setjmp(errorbuf)) {    /* uh oh, we got a kick in the ass */    signal(SIGSEGV, old_sigsegv_handler);    signal(SIGBUS,  old_sigbus_handler);    printf ("hola\n");    return 0;  }  printf ("nohola\n");//  /* --- the following is dangerous! So catch signals --- *///  old_sigsegv_handler = signal(SIGSEGV, FatalSignal);//  old_sigbus_handler  = signal(SIGBUS,  FatalSignal);////  dp  = strchr(file, ':');	/* file pos needs : */////  ret =  (dp   &&   dp-file > 3   &&   !strncmp(dp-2, ".c", 2)   &&//	  atoi(dp+1) > 0   &&   size >= 0);////  /* --- danger is over! --- *///  signal(SIGSEGV, old_sigsegv_handler);//  signal(SIGBUS,  old_sigbus_handler);////  return ret;  return 0;}#ifdef GENERATIONS/* =============================================================================   Function:		GetBreakGenerationEnv	// lokal //   Author:		Rammi   Date:		04/22/2002   Return:	        the content of the BREAK_GENERATION environment variable                        or 0   Parameter:		---   Purpose:		Return the content of the environment variable                        BREAK_GENERATION (a number indicating which is the                        generation you want to break with the debugger).   ============================================================================= */static unsigned GetBreakGenerationEnv(void){  /* The environment variable is buffered here for faster access. */  static char *breakGenerationEnv = (char *)-1;  /** The result of the conversion to unsigned is buffered here. */  static unsigned result = 0;  if (breakGenerationEnv == (char *)-1) {    /* 1st call: get the environment variable */    breakGenerationEnv = getenv("BREAK_GENERATION");    if (breakGenerationEnv != NULL) {      /* try conversion */      result = atoi(breakGenerationEnv);      fprintf(stderr,	      HEAD "Using environment variable BREAK_GENERATION=%d\n",	      result);    }  }  return result;}#endif /* GENERATIONS *//* =============================================================================   Function:		ControlBlock	// lokal //   Author:		Rammi   Date:		11/16/1995   Return:		---   Parameter:		Bkl	Pos of allocated block (original)   			file	file pos from where initial lib function				was called   Purpose:		Control integrity of block   ============================================================================= */static void ControlBlock(begin *B, const char *file){  unsigned char *p = (((unsigned char *)B)+START_SPACE);#if RM_TEST_DEPTH > 0  int DoAbort = 0;#endif  /* === the very beginning === */  if (B->StpA != PREV_STOP) {#if RM_TEST_DEPTH > 0    DoAbort = 1;#endif    fprintf(stderr, HEAD	    "Corrupted block begin (overwritten from elsewhere)\n"	    "\tshould be: %08x\n"	    "\tis:        %08x\n"#ifdef GENERATIONS	    "\tblock was allocated in %s [%u Bytes, generation %u]\n"#else	    "\tblock was allocated in %s [%u Bytes]\n"#endif	    "\terror was detected in  %s\n",	    PREV_STOP,	    B->StpA,	    B->File,	    (unsigned) B->Size,#ifdef GENERATIONS	    B->Generation,#endif	    file);  }  /* === begin of user data === */  if (B->StpB != PREV_STOP) {#if RM_TEST_DEPTH > 0    DoAbort = 1;#endif    fprintf(stderr, HEAD	    "Corrupted block begin (possibly written back)\n"	    "\tshould be: %08x\n"	    "\tis:        %08x\n"#ifdef GENERATIONS	    "\tblock was allocated in %s [%u Bytes, generation %u]\n"#else	    "\tblock was allocated in %s [%u Bytes]\n"#endif	    "\terror was detected in  %s\n",	    PREV_STOP,	    B->StpB,	    B->File,	    (unsigned) B->Size,#ifdef GENERATIONS	    B->Generation,#endif	    file);  }  /* === end of user data === */  if (memcmp(p+B->Size, &End, END_SPACE) != 0) {    unsigned char *E = (unsigned char *)(p+B->Size);    unsigned i;    int found = 0;#if RM_TEST_DEPTH > 0    DoAbort = 1;#endif    fprintf(stderr, HEAD	    "Corrupted block end (possibly written past the end)\n"	    "\tshould be:");    for (i = 0;   i < END_SPACE;   i++) {      fprintf(stderr, i%4 ? "%02x" : " %02x", End[i]);    }    fprintf(stderr,	    "\n\tis:       ");    for (i = 0;   i < END_SPACE;   i++) {      fprintf(stderr, i%sizeof(int) ? "%02x" : " %02x", E[i]);    }    fprintf(stderr, "\n"#ifdef GENERATIONS	    "\tblock was allocated in %s [%u Bytes, generation %u]\n"#else	    "\tblock was allocated in %s [%u Bytes]\n"#endif	    "\terror was detected in %s\n",	    B->File,	    (unsigned) B->Size,#ifdef GENERATIONS	    B->Generation,#endif	    file	    );#if RM_TEST_DEPTH > 0    if (!((unsigned long)E % sizeof(void *))   &&	!(*(unsigned long *)E % sizeof(void *))) {  /* because of alignment */      /* Special service: look if memory was overwritten with pointer */      if (FindBlk(*(unsigned char **)E)) {	begin *b = (begin *)((*(unsigned char **)E)-START_SPACE);	if (IsPossibleFilePos(b->File, b->Size)) {	  fprintf(stderr,		  "\tFirst %d bytes of overwritten memory can be interpreted\n"		  "\t\tas a pointer to a block "		  " allocated in:\n"#ifdef GENERATIONS		  "\t\t%s [%u Bytes, generation %u]\n",#else		  "\t\t%s [%u Bytes]\n",#endif		  (short)sizeof(void *),		  b->File,		  (unsigned short) b->Size#ifdef GENERATIONS		  , (unsigned short)b->Generation#endif		  );	  found = 1;	}      }    }    if (!found)#endif    {      /* Look, what we can find... */      int  j;      for (j = END_SPACE-1;   j >= 0;   j--) {	if (E[j] != End[j]) {	  break;	}      }      if (j >= 0   &&   !E[j]) {	/* Ends with '\0', so it's possibly a string */	if (j > 0) {	  while (--j >= 0) {	    if (!E[j]) {	      break;	    }	  }	  if (j < 0) {	    fprintf(stderr,		    "\tLooks somewhat like a too long string,\n"		    "\t\tending with \"%s\"\n",		    E);	  }	}	else {	  /* Off by one? */	  fprintf(stderr,		  "\tLooks like string allocated one byte too short\n"		  "\t\t(forgetting the nul byte)\n");	}