#if MEM_MAN
/* a simple memory manager. All allocates and frees should go through here */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

#define MEM_MAN_MAIN

#include "mem_man.h"

#ifdef MEM_SIGNAL_HANDLER
#include <signal.h>
#endif

/*
   this module is stand alone. typically a define will occur in a C file
   like this
   
   #define malloc(x) smb_mem_malloc(x,__FILE__,__LINE__)
   #define free(x)   smb_mem_free(x,__FILE__,__LINE__)
   
   which redirects all calls to malloc and free through this module
   
   Various configuration options can be set in mem_man.h. This file also
   includes the defines above - so the complete system can be implemented
   with just one include call.
   
   
   */

extern FILE *dbf;

/*
   ACCESSING the memory manager :
   
   mem_init_memory_manager() :
   initialises internal data structures of memory manager
   
   void *malloc(size_t size) :
   allocates memory as per usual. also records lots of info
   
   int free(void *ptr) :
   frees some memory as per usual. writes errors if necessary.
   
   void *smb_mem_resize(void *ptr,size_t newsize) :
   changes the memory assignment size of a pointer. note it may return a
   different pointer than the one given. memory can be sized up or down.
   
   int smb_mem_query_size(void *ptr) :
   returns the size of the allocated memory.
   
   int smb_mem_query_real_size(void *ptr) :
   returns the actual amount of memory allocated to a pointer.
   
   char *smb_mem_query_file(void *ptr) :
   returns the name of the file where the pointer was allocated.
   
   int smb_mem_query_line(void *ptr) :
   returns the line of the file where the memory was allocated.
   
   void smb_mem_write_status(FILE *outfile) :
   writes short summary of memory stats on the stream.
   
   void smb_mem_write_verbose(FILE *outfile) :
   writes lots of info on current allocations to stream.
   
   void smb_mem_write_errors(FILE *outfile) :
   writes info on error blocks
   
   void smb_mem_write_info(void *ptr,FILE *outfile)
   writes info on one pointer to outfile
   
   int smb_mem_test(void *ptr) :
   returns true if the pointer is OK - false if it is not.
   
   void smb_mem_set_multiplier(int multiplier) :
   sets defaults amount of memory allocated to multiplier times
   amount requested.
   
   int smb_mem_total_errors(void) :
   returns the total number of error blocks
   
   void smb_mem_check_buffers(void) :
   checks all buffers for corruption. It marks them as corrupt if they are.
   
   kill -USR1 <pid> :
   this will send a signal to the memory manager to do a mem_write_verbose
   it also checks them for corruption. Note that the signal number can be
   set in the header file mem_man.h. This can also be turned off.
   
   */


void smb_mem_write_errors(FILE *outfile);
void smb_mem_write_verbose(FILE *outfile);
void smb_mem_write_status(FILE *outfile);
static void mem_check_buffers(void);


#define FREE_FAILURE 0
#define FREE_SUCCESS 1
#define FN
#define True (0==0)
#define False (!True)
#define BUF_SIZE        (MEM_CORRUPT_BUFFER * sizeof(char) * 2)
#define BUF_OFFSET      (BUF_SIZE/2)

typedef struct
{
  void *pointer;
  size_t present_size;
  size_t allocated_size;
  unsigned char status;
  short error_number;
  char file[MEM_FILE_STR_LENGTH];
  unsigned short line;
} memory_struct;

/* the order of this enum is important. everything greater than
   S_ALLOCATED is considered an error */
enum status_types {S_UNALLOCATED,S_ALLOCATED,
		     S_ERROR_UNALLOCATED,S_ERROR_FREEING,
		     S_CORRUPT_FRONT,S_CORRUPT_BACK,S_CORRUPT_FRONT_BACK};

/* here is the data memory */

static memory_struct *memory_blocks=NULL; /* these hold the allocation data */
static int mem_blocks_allocated=0; /* how many mem blocks are allocated */
static int mem_multiplier; /* this is the current multiplier mor over allocation */
static int mem_manager_initialised=False; /* has it been initialised ? */
static int last_block_allocated=0; /* a speed up method - this will contain the
			       index of the last block allocated or freed
			       to cut down searching time for a new block */


typedef struct
{
  int status;
  char *label;
} stat_str_type;

static stat_str_type stat_str_struct[] =
{
{S_UNALLOCATED,"S_UNALLOCATED"},
{S_ALLOCATED,"S_ALLOCATED"},
{S_ERROR_UNALLOCATED,"S_ERROR_UNALLOCATED"},
{S_ERROR_FREEING,"S_ERROR_FREEING"},
{S_CORRUPT_FRONT,"S_CORRUPT_FRONT"},
{S_CORRUPT_BACK,"S_CORRUPT_BACK"},
{S_CORRUPT_FRONT_BACK,"S_CORRUPT_FRONT_BACK"},
{-1,NULL}
};


#define INIT_MANAGER() if (!mem_manager_initialised) mem_init_memory_manager()

/*******************************************************************
  returns a pointer to a static string for each status
  ********************************************************************/
static char *status_to_str(int status)
{
  int i=0;
  while (stat_str_struct[i].label != NULL)
    {
      if (stat_str_struct[i].status == status)
	return(stat_str_struct[i].label);
      i++;
    }
  return(NULL);
}



#ifdef MEM_SIGNAL_HANDLER
/*******************************************************************
  this handles signals - causes a mem_write_verbose on stderr 
  ********************************************************************/
static void mem_signal_handler()
{
  mem_check_buffers();
  smb_mem_write_verbose(dbf);
  signal(MEM_SIGNAL_VECTOR,mem_signal_handler);
}
#endif

#ifdef MEM_SIGNAL_HANDLER
/*******************************************************************
  this handles error signals - causes a mem_write_verbose on stderr 
  ********************************************************************/
static void error_signal_handler()
{
  fprintf(dbf,"Received error signal!\n");
  mem_check_buffers();
  smb_mem_write_status(dbf);
  smb_mem_write_errors(dbf);
  abort();
}
#endif


/*******************************************************************
  initialise memory manager data structures
  ********************************************************************/
static void mem_init_memory_manager(void)
{
  int i;
  /* allocate the memory_blocks array */
  mem_blocks_allocated = MEM_MAX_MEM_OBJECTS;

  while (mem_blocks_allocated > 0)
    {
      memory_blocks = (memory_struct *)
	calloc(mem_blocks_allocated,sizeof(memory_struct));
      if (memory_blocks != NULL) break;
      mem_blocks_allocated /= 2;
    }

  if (memory_blocks == NULL)
    {
      fprintf(dbf,"Panic ! can't allocate mem manager blocks!\n");
      abort();
    }

  /* just loop setting status flag to unallocated */
  for (i=0;i<mem_blocks_allocated;i++)
    memory_blocks[i].status = S_UNALLOCATED;

  /* also set default mem multiplier */
  mem_multiplier = MEM_DEFAULT_MEM_MULTIPLIER;
  mem_manager_initialised=True;

#ifdef MEM_SIGNAL_HANDLER
  signal(MEM_SIGNAL_VECTOR,mem_signal_handler);
  signal(SIGSEGV,error_signal_handler);
  signal(SIGBUS,error_signal_handler);
#endif

}


/*******************************************************************
  finds first available slot in memory blocks 
  ********************************************************************/
static int mem_first_avail_slot(void)
{
  int i;
  for (i=last_block_allocated;i<mem_blocks_allocated;i++)
    if (memory_blocks[i].status == S_UNALLOCATED)
      return(last_block_allocated=i);
  for (i=0;i<last_block_allocated;i++)
    if (memory_blocks[i].status == S_UNALLOCATED)
      return(last_block_allocated=i);
  return(-1);
}


/*******************************************************************
  find which Index a pointer refers to 
  ********************************************************************/
static int mem_find_Index(void *ptr)
{
  int i;
  int start = last_block_allocated+mem_blocks_allocated/50;
  if (start > mem_blocks_allocated-1) start = mem_blocks_allocated-1;
  for (i=start;i>=0;i--)
    if ((memory_blocks[i].status == S_ALLOCATED) &&
	(memory_blocks[i].pointer == ptr))
      return(i);
  for (i=(start+1);i<mem_blocks_allocated;i++)
    if ((memory_blocks[i].status == S_ALLOCATED) &&
	(memory_blocks[i].pointer == ptr))
      return(i);
  /* it's not there! */
  return(-1);
}

/*******************************************************************
  fill the buffer areas of a mem block 
  ********************************************************************/
static void mem_fill_bytes(void *p,int size,int Index)
{
  memset(p,Index%256,size);
}

/*******************************************************************
  fill the buffer areas of a mem block 
  ********************************************************************/
static void mem_fill_buffer(int Index)
{
  char *iptr,*tailptr;
  int i;
  int seed;

  /* fill the front and back ends */
  seed = MEM_CORRUPT_SEED;
  iptr = (char *)((char *)memory_blocks[Index].pointer - BUF_OFFSET);
  tailptr = (char *)((char *)memory_blocks[Index].pointer +
		     memory_blocks[Index].present_size);

  for (i=0;i<MEM_CORRUPT_BUFFER;i++)
    {
      iptr[i] = seed;
      tailptr[i] = seed;
      seed += MEM_SEED_INCREMENT;
    }
}

/*******************************************************************
  check if a mem block is corrupt 
  ********************************************************************/
static int mem_buffer_ok(int Index)
{
  char *iptr;
  int i;
  int corrupt_front = False;
  int corrupt_back = False;
  
  /* check the front end */
  iptr = (char *)((char *)memory_blocks[Index].pointer - BUF_OFFSET);
  for (i=0;i<MEM_CORRUPT_BUFFER;i++)
    if (iptr[i] != (char)(MEM_CORRUPT_SEED + i*MEM_SEED_INCREMENT))
      corrupt_front = True;

  /* now check the tail end */
  iptr = (char *)((char *)memory_blocks[Index].pointer +
		  memory_blocks[Index].present_size);
  for (i=0;i<MEM_CORRUPT_BUFFER;i++)
    if (iptr[i] != (char)(MEM_CORRUPT_SEED + i*MEM_SEED_INCREMENT))
      corrupt_back = True;
  
  if (corrupt_front && !corrupt_back)
    memory_blocks[Index].status = S_CORRUPT_FRONT;
  if (corrupt_back && !corrupt_front)
    memory_blocks[Index].status = S_CORRUPT_BACK;
  if (corrupt_front && corrupt_back)
    memory_blocks[Index].status = S_CORRUPT_FRONT_BACK;
  if (!corrupt_front && !corrupt_back)
    return(True);
  return(False);
}


/*******************************************************************
  check all buffers for corruption 
  ********************************************************************/
static void mem_check_buffers(void)
{
  int i;
  for (i=0;i<mem_blocks_allocated;i++)
    if (memory_blocks[i].status == S_ALLOCATED)
      mem_buffer_ok(i);
}


/*******************************************************************
  record stats and alloc memory 
  ********************************************************************/
void *smb_mem_malloc(size_t size,char *file,int line)
{
  int Index;
  INIT_MANAGER();

  /* find an open spot */

  Index = mem_first_avail_slot();
  if (Index<0) return(NULL);

  /* record some info */
  memory_blocks[Index].present_size = size;
  memory_blocks[Index].allocated_size = size*mem_multiplier;
  memory_blocks[Index].line = line;
  strncpy(memory_blocks[Index].file,file,MEM_FILE_STR_LENGTH);
  memory_blocks[Index].file[MEM_FILE_STR_LENGTH-1] = 0;
  memory_blocks[Index].error_number = 0;

  /* now try and actually get the memory */
  memory_blocks[Index].pointer = malloc(size*mem_multiplier + BUF_SIZE);

  /* if that failed then try and get exactly what was actually requested */
  if (memory_blocks[Index].pointer == NULL)
    {
      memory_blocks[Index].allocated_size = size;
      memory_blocks[Index].pointer = malloc(size + BUF_SIZE);
    }

  /* if it failed then return NULL */
  if (memory_blocks[Index].pointer == NULL) return(NULL);


  /* it succeeded - set status flag and return */
  memory_blocks[Index].status = S_ALLOCATED;

  /* add an offset */
  memory_blocks[Index].pointer =
    (void *)((char *)memory_blocks[Index].pointer + BUF_OFFSET);

  /* fill the buffer appropriately */
  mem_fill_buffer(Index);

  /* and set the fill byte */
  mem_fill_bytes(memory_blocks[Index].pointer,memory_blocks[Index].present_size,Index);

  /* return the allocated memory */
  return(memory_blocks[Index].pointer);
}


/*******************************************************************
dup a string
  ********************************************************************/
char *smb_mem_strdup(char *s, char *file, int line)
{
	char *ret = (char *)smb_mem_malloc(strlen(s)+1, file, line);
	strcpy(ret, s);
	return ret;
}

/*******************************************************************
  free some memory 
  ********************************************************************/
int smb_mem_free(void *ptr,char *file,int line)
{
  int Index;
  int free_ret;
  static int count;
  INIT_MANAGER();

  if (count % 100 == 0) {
	  smb_mem_write_errors(dbf);
  }
  count++;

  Index = mem_find_Index(ptr);

  if (Index<0)			/* we are freeing a pointer that hasn't been allocated ! */
    {
      /* set up an error block */
      Index = mem_first_avail_slot();
      if (Index < 0)		/* I can't even allocate an Error! */
	{
	  fprintf(dbf,"Panic in memory manager - can't allocate error block!\n");
	  fprintf(dbf,"freeing un allocated pointer at %s(%d)\n",file,line);
	  abort();
	}
      /* fill in error block */
      memory_blocks[Index].present_size = 0;
      memory_blocks[Index].allocated_size = 0;
      memory_blocks[Index].line = line;
      strncpy(memory_blocks[Index].file,file,MEM_FILE_STR_LENGTH);
      memory_blocks[Index].file[MEM_FILE_STR_LENGTH-1] = 0;
      memory_blocks[Index].status = S_ERROR_UNALLOCATED;
      memory_blocks[Index].pointer = ptr;
      return(FREE_FAILURE);
    }

  /* it is a valid pointer - check for corruption */
  if (!mem_buffer_ok(Index))
    /* it's bad ! return an error */
    return(FREE_FAILURE);

  /* the pointer is OK - try to free it */
#ifdef MEM_FREE_RETURNS_INT
  free_ret = free((char *)ptr - BUF_OFFSET);
#else
  free((char *)ptr - BUF_OFFSET);
  free_ret = FREE_SUCCESS;
#endif


  /* if this failed then make an error block again */
  if (free_ret == FREE_FAILURE)
    {
      memory_blocks[Index].present_size = 0;
      memory_blocks[Index].allocated_size = 0;
      memory_blocks[Index].line = line;
      strncpy(memory_blocks[Index].file,file,MEM_FILE_STR_LENGTH);
      memory_blocks[Index].file[MEM_FILE_STR_LENGTH-1] = 0;
      memory_blocks[Index].status = S_ERROR_FREEING;
      memory_blocks[Index].pointer = ptr;
      memory_blocks[Index].error_number = errno;
      return(FREE_FAILURE);
    }

  /* all is OK - set status and return */
  memory_blocks[Index].status = S_UNALLOCATED;

  /* this is a speedup - if it is freed then it can be allocated again ! */
  last_block_allocated = Index;

  return(FREE_SUCCESS);
}



/*******************************************************************
  writes info on just one Index
  it must not be un allocated to do this 
  ********************************************************************/
static void mem_write_Index_info(int Index,FILE *outfile)
{
  if (memory_blocks[Index].status != S_UNALLOCATED)
    fprintf(outfile,"block %d file %s(%d) : ptr: %p size %d, alloc size %d, status %s\n",
	    Index,memory_blocks[Index].file,memory_blocks[Index].line,
	    memory_blocks[Index].pointer,
	    memory_blocks[Index].present_size,
	    memory_blocks[Index].allocated_size,
	    status_to_str(memory_blocks[Index].status));
}



/*******************************************************************
  writes info on one pointer  
  ********************************************************************/
void smb_mem_write_info(void *ptr,FILE *outfile)
{
  int Index;
  INIT_MANAGER();
  Index = mem_find_Index(ptr);
  if (Index<0) return;
  mem_write_Index_info(Index,outfile);
}




/*******************************************************************
  return the size of the mem block 
  ********************************************************************/
size_t smb_mem_query_size(void *ptr)
{
  int Index;
  INIT_MANAGER();
  Index = mem_find_Index(ptr);
  if (Index<0) return(0);
  return(memory_blocks[Index].present_size);
}

/*******************************************************************
  return the allocated size of the mem block 
  ********************************************************************/
size_t smb_mem_query_real_size(void *ptr)
{
  int Index;
  INIT_MANAGER();
  Index = mem_find_Index(ptr);
  if (Index<0) return(0);
  return(memory_blocks[Index].allocated_size);
}




/*******************************************************************
  return the file of caller of the mem block 
  ********************************************************************/
char *smb_mem_query_file(void *ptr)
{
  int Index;
  INIT_MANAGER();
  Index = mem_find_Index(ptr);
  if (Index<0) return(NULL);
  return(memory_blocks[Index].file);
}



/*******************************************************************
  return the line in the file of caller of the mem block 
  ********************************************************************/
int smb_mem_query_line(void *ptr)
{
  int Index;
  INIT_MANAGER();
  Index = mem_find_Index(ptr);
  if (Index<0) return(0);
  return(memory_blocks[Index].line);
}

/*******************************************************************
  return True if the pointer is OK
  ********************************************************************/
int smb_mem_test(void *ptr)
{
  int Index;
  INIT_MANAGER();
  Index = mem_find_Index(ptr);
  if (Index<0) return(False);

  return(mem_buffer_ok(Index));
}


/*******************************************************************
  write brief info on mem status 
  ********************************************************************/
void smb_mem_write_status(FILE *outfile)
{
  int num_allocated=0;
  int total_size=0;
  int total_alloc_size=0;
  int num_errors=0;
  int i;
  INIT_MANAGER();
  mem_check_buffers();
  for (i=0;i<mem_blocks_allocated;i++)
    switch (memory_blocks[i].status)
      {
      case S_UNALLOCATED :
	break;
      case S_ALLOCATED :
	num_allocated++;
	total_size += memory_blocks[i].present_size;
	total_alloc_size += memory_blocks[i].allocated_size;
	break;
      case S_ERROR_UNALLOCATED :
      case S_ERROR_FREEING :
      case S_CORRUPT_BACK :
      case S_CORRUPT_FRONT :
	num_errors++;
	break;
      }
  
  fprintf(outfile,
	  "Mem Manager : %d blocks, allocation %dK, real allocation %dK, %d errors\n",
	  num_allocated,(int)(total_size/1024),(int)(total_alloc_size/1024),
	  num_errors);
  fflush(outfile);
}


/*******************************************************************
  write verbose info on allocated blocks 
  ********************************************************************/
void smb_mem_write_verbose(FILE *outfile)
{
  int Index;
  /* first write a summary */
  INIT_MANAGER();
  smb_mem_write_status(outfile);
  
  /* just loop writing info on relevant indices */
  for (Index=0;Index<mem_blocks_allocated;Index++)
    if (memory_blocks[Index].status != S_UNALLOCATED)
      mem_write_Index_info(Index,outfile);
}

/*******************************************************************
  write verbose info on error blocks 
  ********************************************************************/
void smb_mem_write_errors(FILE *outfile)
{
  int Index;
  INIT_MANAGER();
  mem_check_buffers();
  /* just loop writing info on relevant indices */
  for (Index=0;Index<mem_blocks_allocated;Index++)
    if (((int)memory_blocks[Index].status) > ((int)S_ALLOCATED))
      mem_write_Index_info(Index,outfile);
}


/*******************************************************************
  sets the memory multiplier 
  ********************************************************************/
void smb_mem_set_multiplier(int multiplier)
{
  /* check it is valid */
  if (multiplier < 1) return;
  mem_multiplier = multiplier;
}

/*******************************************************************
  increases or decreases the memory assigned to a pointer 
  ********************************************************************/
void *smb_mem_resize(void *ptr,size_t newsize)
{
  int Index;
  size_t allocsize;
  void *temp_ptr;
  INIT_MANAGER();
  Index = mem_find_Index(ptr);

  /* if invalid return NULL */
  if (Index<0) 
    {
#ifdef BUG
      int Error();
      Error("Invalid mem_resize to size %d\n",newsize);
#endif
      return(NULL);
    }
  
  /* now - will it fit in the current allocation ? */
  if (newsize <= memory_blocks[Index].allocated_size)
    {
      memory_blocks[Index].present_size = newsize;
      mem_fill_buffer(Index);
      return(ptr);
    }

  /* can it be allocated ? */
  allocsize = newsize*mem_multiplier;
  temp_ptr = malloc(newsize*mem_multiplier + BUF_SIZE);
  
  /* no? try with just the size asked for */
  if (temp_ptr == NULL)
    {
      allocsize=newsize;
      temp_ptr = malloc(newsize + BUF_SIZE);
    }
  
  /* if it's still NULL give up */
  if (temp_ptr == NULL)
    return(NULL);
  
  /* copy the old data to the new memory area */
  memcpy(temp_ptr,(char *)memory_blocks[Index].pointer - BUF_OFFSET,
	 memory_blocks[Index].allocated_size + BUF_SIZE);
  
  /* fill the extra space */
  mem_fill_bytes((char *)temp_ptr + BUF_OFFSET + memory_blocks[Index].present_size,newsize - memory_blocks[Index].present_size,Index);
  
  
  /* free the old mem and set vars */
  free((char *)ptr - BUF_OFFSET);
  memory_blocks[Index].pointer = (void *)((char *)temp_ptr + BUF_OFFSET);
  memory_blocks[Index].present_size = newsize;
  memory_blocks[Index].allocated_size = allocsize;
  
  /* fill the buffer appropriately */
  mem_fill_buffer(Index);
  
  
  /* now return the new pointer */
  return((char *)temp_ptr + BUF_OFFSET);
}

#else
 void dummy_mem_man(void) {} 
#endif