/*
   mem.c -- handles:
     memory allocation and deallocation
     keeping track of what memory is being used by whom

   dprintf'ized, 15nov95
*/
/*
   This file is part of the eggdrop source code
   copyright (c) 1997 Robey Pointer
   and is distributed according to the GNU general public license.
   For full details, read the top of 'main.c' or the file called
   COPYING that was distributed with this code.
*/

#define LOG_MISC 32
#define MEMTBLSIZE 25000       /* yikes! */

#ifdef EBUG_MEM
#define DEBUG
#endif

#if HAVE_CONFIG_H
#include <config.h>
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifdef MODULES
#include "mod/modvals.h"
typedef struct _module_entry {
   char * name;           /* name of the module (without .so) */
   int major;             /* major version number MUST match */
   int minor;             /* minor version number MUST be >= */
   void * hand;           /* module handle */
   void * needed;
   void * needing;
   struct _module_entry * next;
#ifdef EBUG_MEM
   int mem_work;
#endif
   module_function * funcs;
} module_entry;
extern module_entry * module_list;
#endif

extern int serv;

#ifdef DEBUG
unsigned long memused=0;
static int lastused=0;

struct {
  void *ptr;
  short size;
  char file[15];
  short line;
} memtbl[MEMTBLSIZE];
#endif

#ifdef STDC_HEADERS
#define PROTO(x) x
#define PROTO1(a,b) (a b)
#define PROTO2(a1,b1,a2,b2) (a1 b1, a2 b2) 
#define PROTO3(a1,b1,a2,b2,a3,b3) (a1 b1, a2 b2, a3 b3)
#define PROTO4(a1,b1,a2,b2,a3,b3,a4,b4) \
              (a1 b1, a2 b2, a3 b3, a4 b4)
#define PROTO5(a1,b1,a2,b2,a3,b3,a4,b4,a5,b5) \
              (a1 b1, a2 b2, a3 b3, a4 b4, a5 b5)
#define PROTO6(a1,b1,a2,b2,a3,b3,a4,b4,a5,b5,a6,b6) \
              (a1 b1, a2 b2, a3 b3, a4 b4, a5 b5, a6 b6)
#else
#define PROTO(x) ()
#define PROTO1(a,b) (b) a b;
#define PROTO2(a1,b1,a2,b2) (b1, b2) a1 b1; a2 b2; 
#define PROTO3(a1,b1,a2,b2,a3,b3) (b1, b2, b3) a1 b1; a2 b2; a3 b3;
#define PROTO4(a1,b1,a2,b2,a3,b3,a4,b4) (b1, b2, b3, b4) \
              a1 b1; a2 b2; a3 b3; a4 b4;
#define PROTO5(a1,b1,a2,b2,a3,b3,a4,b4,a5,b5) \
              (b1, b2, b3, b4, b5) \
              a1 b1; a2 b2; a3 b3; a4 b4; a5 b5;
#define PROTO6(a1,b1,a2,b2,a3,b3,a4,b4,a5,b5,a6,b6) \
              (b1, b2, b3, b4, b5, b6) \
              a1 b1; a2 b2; a3 b3; a4 b4; a5 b5; a6 b6;
#endif

#ifdef HAVE_DPRINTF 
#define dprintf dprintf_eggdrop
#endif

/* prototypes */
void mprintf();
void tprintf();
void dprintf();
void putlog();
int expected_memory();
int expmem_chan();
int expmem_chanprog();
int expmem_misc();
int expmem_fileq();
int expmem_users();
int expmem_dccutil();
int expmem_botnet();
int expmem_tcl();
int expmem_tclhash();
int expmem_net();
int expmem_blowfish();
int expmem_modules();
int expmem_assoc();
void tell_netdebug();
void debug_blowfish();
void do_module_report();

/* initialize the memory structure */
void init_mem()
{
#ifdef DEBUG
  int i;
  for (i=0; i<MEMTBLSIZE; i++) memtbl[i].ptr=NULL;
#endif
}

/* tell someone the gory memory details */
void tell_mem_status PROTO1(char *,nick)
{
#ifdef DEBUG
  float per;
  per=((lastused*1.0)/(MEMTBLSIZE*1.0))*100.0;
  mprintf(serv,"NOTICE %s :Memory table usage: %d/%d (%.1f%% full)\n",nick,
	  lastused,MEMTBLSIZE,per);
#endif
  mprintf(serv,"NOTICE %s :Think I'm using about %dk.\n",nick,
	  (int)(expected_memory()/1024));
}

void tell_mem_status_dcc PROTO1(int,idx)
{
#ifdef DEBUG
  int exp; float per;
  exp=expected_memory();  /* in main.c ? */
  per=((lastused*1.0)/(MEMTBLSIZE*1.0))*100.0;
  dprintf(idx,"Memory table: %d/%d (%.1f%% full)\n",lastused,MEMTBLSIZE,per);
  per=((exp*1.0)/(memused*1.0))*100.0;
  if (per!=100.0)
    dprintf(idx,"Memory fault: only accounting for %d/%ld (%.1f%%)\n",
	    exp,memused,per);
  dprintf(idx,"Memory table itself occupies an additional %dk static\n",
	  (int)(sizeof(memtbl)/1024));
#endif
}

void debug_mem_to_dcc PROTO1(int,idx)
{
#ifdef DEBUG
#ifdef MODULES
#define MAX_MEM 10
#else
#define MAX_MEM 12
#endif
  unsigned long exp[MAX_MEM],use[MAX_MEM],l; int i,j; char fn[20],sofar[81];
#ifdef MODULES
  module_entry * me; char * p;
#endif
  exp[0]=expmem_chan();
  exp[1]=expmem_chanprog();
  exp[2]=expmem_misc();
  exp[3]=expmem_users();
  exp[4]=expmem_net();
  exp[5]=expmem_dccutil();
  exp[6]=expmem_botnet();
  exp[7]=expmem_tcl();
  exp[8]=expmem_tclhash();
#ifndef MODULES
  exp[9]=expmem_fileq();
  exp[10]=expmem_blowfish();
  exp[11]=expmem_assoc();
#else
  exp[9]=expmem_modules(1);
  for (me=module_list;me;me=me->next) 
     me->mem_work = 0;
#endif
  for (i=0; i<MAX_MEM; i++) use[i]=0;
  for (i=0; i<lastused; i++) {
    strcpy(fn,memtbl[i].file); l=memtbl[i].size;
    if (strcasecmp(fn,"chanset.c")==0) use[0]+=l;
    else if (strcasecmp(fn,"chanprog.c")==0) use[1]+=l;
    else if (strcasecmp(fn,"misc.c")==0) use[2]+=l;
    else if (strcasecmp(fn,"userrec.c")==0) use[3]+=l;
    else if (strcasecmp(fn,"net.c")==0) use[4]+=l;
    else if (strcasecmp(fn,"dccutil.c")==0) use[5]+=l;
    else if (strcasecmp(fn,"botnet.c")==0) use[6]+=l;
    else if (strcasecmp(fn,"tcl.c")==0) use[7]+=l;
    else if (strcasecmp(fn,"tclhash.c")==0) use[8]+=l;
#ifndef MODULES
    else if (strcasecmp(fn,"fileq.c")==0) use[9]+=l;
    else if (strcasecmp(fn,"blowfish.c")==0) use[10]+=l;
    else if (strcasecmp(fn,"assoc.c")==0) use[11]+=l;
#else
    else if (strcasecmp(fn,"modules.c")==0) use[9]+=l;
    else if ((p=strchr(fn,':'))!=NULL) {
      *p = 0;
       for (me=module_list;me;me=me->next)
	 if (strcmp(fn,me->name)==0)
	   me->mem_work +=l;
      *p = ':';
    }
#endif
    else {
      if (idx<0) tprintf(-idx,"Not logging file %s!\n",fn);
      else dprintf(idx,"Not logging file %s!\n",fn);
    }
  }
  for (i=0; i<MAX_MEM; i++) {
    switch(i) {
    case 0: strcpy(fn,"chanset.c"); break;
    case 1: strcpy(fn,"chanprog.c"); break;
    case 2: strcpy(fn,"misc.c"); break;
    case 3: strcpy(fn,"userrec.c"); break;
    case 4: strcpy(fn,"net.c"); break;
    case 5: strcpy(fn,"dccutil.c"); break;
    case 6: strcpy(fn,"botnet.c"); break;
    case 7: strcpy(fn,"tcl.c"); break;
    case 8: strcpy(fn,"tclhash.c"); break;
#ifndef MODULES
    case 9: strcpy(fn,"fileq.c"); break;
    case 10: strcpy(fn,"blowfish.c"); break;
    case 11: strcpy(fn,"assoc.c"); break;
#else
    case 9: strcpy(fn,"modules.c"); break;
#endif
    }
    if (use[i]==exp[i]) {
      if (idx<0)
	tprintf(-idx,"File '%-10s' accounted for %lu/%lu (ok)\n",fn,exp[i],
		use[i]);
      else
	dprintf(idx,"File '%-10s' accounted for %lu/%lu (ok)\n",fn,exp[i],
		use[i]);
    }
    else {
      if (idx<0)
	tprintf(-idx,"File '%-10s' accounted for %lu/%lu (debug follows:)\n",
		fn,exp[i],use[i]);
      else
	dprintf(idx,"File '%-10s' accounted for %lu/%lu (debug follows:)\n",fn,
		exp[i],use[i]);
      strcpy(sofar,"   ");
      for (j=0; j<lastused; j++) 
	if (strcasecmp(memtbl[j].file,fn)==0) {
 	  sprintf(&sofar[strlen(sofar)],"%-3d:(%03X) ",memtbl[j].line,
		  memtbl[j].size);
	  if (strlen(sofar)>60) {
	    sofar[strlen(sofar)-1]=0;
	    if (idx<0) tprintf(-idx,"%s\n",sofar);
	    else dprintf(idx,"%s\n",sofar);
	    strcpy(sofar,"   ");
	  }
	}
      if (sofar[0]) {
	sofar[strlen(sofar)-1]=0;
	if (idx<0) tprintf(-idx,"%s\n",sofar);
	else dprintf(idx,"%s\n",sofar);
      }
    }
  }
#ifdef MODULES
  for (me=module_list;me;me=me->next) {
     module_function * f = me->funcs;
     int expt = 0;
     
     if ((f != NULL) && (f[MODCALL_EXPMEM] != NULL))
       expt = f[MODCALL_EXPMEM]();
     if (me->mem_work==expt) {
	dprintf(idx,"Module '%-10s' accounted for %lu/%lu (ok)\n",me->name,
		expt,me->mem_work);
     } else {
	dprintf(idx,"Module '%-10s' accounted for %lu/%lu (debug follows:)\n",
		me->name,expt,me->mem_work);
	strcpy(sofar,"   ");
	for (j=0; j<lastused; j++) {
	  strcpy(fn,memtbl[j].file);
	  if ((p=strchr(fn,':'))!=NULL) {
	     *p = 0;
	     if (strcasecmp(fn,me->name)==0) {
		sprintf(&sofar[strlen(sofar)],"%-10s/%-3d:(%03X) ", p+1,
			memtbl[j].line, memtbl[j].size);
		if (strlen(sofar)>60) {
		   sofar[strlen(sofar)-1]=0;
		   dprintf(idx,"%s\n",sofar);
		   strcpy(sofar,"   ");
		}
	     *p = ':';
	     }
	  }
	}
	if (sofar[0]) {
	   sofar[strlen(sofar)-1]=0;
	   dprintf(idx,"%s\n",sofar);
	}
     }
  }
#endif
  if (idx<0) tprintf(-idx,"--- End of debug memory list.\n");
  else dprintf(idx,"--- End of debug memory list.\n");
#else
  if (idx<0) tprintf(-idx,"Compiled without debug info.\n");
  else dprintf(idx,"Compiled without extensive memory debugging (sorry).\n");
#endif
  tell_netdebug(idx);
#ifdef MODULES
  do_module_report(idx);
#else
  debug_blowfish(idx);
#endif   
}

void *n_malloc PROTO3(int,size,char *,file,int,line)
{
  void *x; int i=0;
  x=(void *)malloc(size);
  if (x==NULL) {
    i=i;
    putlog(LOG_MISC,"*","*** FAILED MALLOC %s (%d)",file,line);
    return NULL;
  }
#ifdef DEBUG
  if (lastused==MEMTBLSIZE) {
    putlog(LOG_MISC,"*","*** MEMORY TABLE FULL: %s (%d)",file,line);
    return x;
  }
  i=lastused;
  memtbl[i].ptr=x; memtbl[i].line=line; memtbl[i].size=size;
  strcpy(memtbl[i].file,file);
  memused+=size; lastused++;
#endif
  return x;
}

void *n_realloc PROTO4(void *,ptr,int,size,char *,file,int,line)
{
  void *x; int i=0;
  x=(void *)realloc(ptr,size);
  if (x==NULL) {
    i=i;
    putlog(LOG_MISC,"*","*** FAILED REALLOC %s (%d)",file,line);
    return NULL;
  }
#ifdef DEBUG
  for (i=0; (i<lastused) && (memtbl[i].ptr!=ptr); i++);
  if (i==lastused) {
    putlog(LOG_MISC,"*","*** ATTEMPTING TO REALLOC NON-MALLOC'D PTR: %s (%d)",
	   file,line);
    return NULL;
  }
  memused-=memtbl[i].size;
  memtbl[i].ptr=x; memtbl[i].line=line; memtbl[i].size=size;
  strcpy(memtbl[i].file,file);
  memused+=size;
#endif
  return x;
}

void n_free PROTO3(void *,ptr,char *,file,int,line)
{
  int i=0;
  if (ptr==NULL) {
    putlog(LOG_MISC,"*","*** ATTEMPTING TO FREE NULL PTR: %s (%d)",file,line);
    i=i;
    return;
  }
#ifdef DEBUG
  /* give tcl builtins an escape mechanism */
  if (line) {
    for (i=0; (i<lastused) && (memtbl[i].ptr!=ptr); i++);
    if (i==lastused) {
      putlog(LOG_MISC,"*","*** ATTEMPTING TO FREE NON-MALLOC'D PTR: %s (%d)",
	     file,line);
      return;
    }
    memused-=memtbl[i].size;
    lastused--;
    memtbl[i].ptr=memtbl[lastused].ptr; memtbl[i].size=memtbl[lastused].size;
    memtbl[i].line=memtbl[lastused].line;
    strcpy(memtbl[i].file,memtbl[lastused].file);
  }
#endif
  free(ptr);
}