/*
 * (c) Copyright 1990 Conor P. Cahill (uunet!virtech!cpcahil).  
 * You may copy, distribute, and use this software as long as this
 * copyright statement is not removed.
 */
#include <stdio.h>
#include <fcntl.h>
#include "malloc.h"
#include "tostring.h"

/*
 * Function:	malloc()
 *
 * Purpose:	memory allocator
 *
 * Arguments:	size	- size of data area needed
 *
 * Returns:	pointer to allocated area, or NULL if unable
 *		to allocate addtional data.
 *
 * Narrative:
 *
 */
#ifndef lint
static
char rcs_hdr[] = "$Id: malloc.c,v 1.2 2006-07-25 10:08:36 rt Exp $";
#endif

extern int	  malloc_checking;
char		* malloc_data_start;
char		* malloc_data_end;
struct mlist 	* malloc_end;
int		  malloc_errfd = 2;
int		  malloc_errno;
int		  malloc_fatal_level = M_HANDLE_CORE;
struct mlist	  malloc_start;
int		  malloc_warn_level;
void		  malloc_memset();

char *
malloc(size)
    unsigned int	  size;
{
    char		* func = "malloc";
    char		* getenv();
    void		  malloc_fatal();
    void		  malloc_init();
    void		  malloc_split();
    void		  malloc_warning();
    unsigned int	  need;
    struct mlist	* oldptr;
    struct mlist	* ptr;
    char		* sbrk();

    /*
     * If this is the first call to malloc...
     */
    if( malloc_data_start == (char *) 0 )
    {
        malloc_init();
    }

    /*
     * If malloc chain checking is on, go do it.
     */
    if( malloc_checking )
    {
        (void) malloc_chain_check(1);
    }

    /*
     * always make sure there is at least on extra byte in the malloc
     * area so that we can verify that the user does not overrun the
     * data area.
     */
    size++;

    /*
     * Now look for a free area of memory of size bytes...
     */
    oldptr = NULL;
    for(ptr = &malloc_start; ; ptr = ptr->next)
    {
        /*
         * Since the malloc chain is a forward only chain, any
         * pointer that we get should always be positioned in 
         * memory following the previous pointer.  If this is not
         * so, we must have a corrupted chain.
         */
        if( ptr )
        {
            if( ptr<oldptr )
            {
                malloc_errno = M_CODE_CHAIN_BROKE;
                malloc_fatal(func);
                return(NULL);
            }
            oldptr = ptr;
        }
        else if( oldptr != malloc_end )
        {
            /*
             * This should never happen.  If it does, then
             * we got a real problem.
             */
            malloc_errno = M_CODE_NO_END;
            malloc_fatal(func);
            return(NULL);
        }
        

        /*
         * if this element is already in use...
         */
        if( ptr && ((ptr->flag & M_INUSE) != 0) )
        {
            continue;
        }

        /*
         * if there isn't room for this block..
         */
        if( ptr && (ptr->s.size < size) )
        {
            continue;
        }

        /*
         * If ptr is null, we have run out of memory and must sbrk more
         */
        if( ptr == NULL )
        {
            need = (size + M_SIZE) * (size > 10*1024 ? 1:2);
            if( need < M_BLOCKSIZE )
            {
                need = M_BLOCKSIZE;
            }
            else if( need & (M_BLOCKSIZE-1) )
            {
                need &= ~(M_BLOCKSIZE-1);
                need += M_BLOCKSIZE;
            }
            ptr = (struct mlist *) sbrk((int)need);
            if( ptr == (struct mlist *) -1 )
            {
                malloc_errno = M_CODE_NOMORE_MEM;
                malloc_fatal(func);
            }
            malloc_data_end = sbrk((int)0);

            ptr->prev   = oldptr;
            ptr->next   = (struct mlist *) 0;
            ptr->s.size = need - M_SIZE;
            ptr->flag  = M_MAGIC;

            oldptr->next = ptr;
            malloc_end = ptr;


        } /* if( ptr ==... */

        /*
          * Now ptr points to a memory location that can store
         * this data, so lets go to work.
         */

        ptr->r_size = size;		/* save requested size	*/
        ptr->flag |= M_INUSE;

        /*
          * split off unneeded data area in this block, if possible...
         */
        malloc_split(ptr);

        /*
         * re-adjust the requested size so that it is what the user
         * actually requested...
         */

        ptr->r_size--;

        /*
         * just to make sure that noone is misusing malloced
          * memory without initializing it, lets set it to
         * all '\01's.  We call local_memset() because memset()
         * may be checking for malloc'd ptrs and this isn't
         * a malloc'd ptr yet.
         */
        malloc_memset(ptr->data,M_FILL,(int)ptr->s.size);

        return( ptr->data);

    } /* for(... */

} /* malloc(... */

/*
 * Function:	malloc_split()
 *
 * Purpose:	to split a malloc segment if there is enough room at the
 *		end of the segment that isn't being used
 *
 * Arguments:	ptr	- pointer to segment to split
 *
 * Returns:	nothing of any use.
 *
 * Narrative:
 *		get the needed size of the module
 * 		round the size up to appropriat boundry
 *		calculate amount of left over space
 *		if there is enough left over space
 *		    create new malloc block out of remainder
 *		    if next block is free 
 *			join the two blocks together
 *		    fill new empty block with free space filler
 * 		    re-adjust pointers and size of current malloc block
 *		
 *		
 *
 * Mod History:	
 *   90/01/27	cpcahil		Initial revision.
 */
void
malloc_split(ptr)
    struct mlist		* ptr;
{
    extern struct mlist	* malloc_end;
    void			  malloc_join();
    int			  rest;
    int			  size;
    struct mlist		* tptr;

    size = ptr->r_size;

    /*
     * roundup size to the appropriate boundry
     */

    M_ROUNDUP(size);

    /*
     * figure out how much room is left in the array.
     * if there is enough room, create a new mlist 
     *     structure there.
     */

    if( ptr->s.size > size )
    {
        rest = ptr->s.size - size;
    }
    else
    {
        rest = 0;
    }
    
    if( rest > (M_SIZE+M_RND) )
    {
        tptr = (struct mlist *) (ptr->data+size);
        tptr->prev = ptr;
        tptr->next = ptr->next;
        tptr->flag = M_MAGIC;
        tptr->s.size = rest - M_SIZE;

        /*
         * If possible, join this segment with the next one
         */

        malloc_join(tptr, tptr->next,0,0);

        if( tptr->next )
        {
            tptr->next->prev = tptr;
        }

        malloc_memset(tptr->data,M_FREE_FILL, (int)tptr->s.size);

        ptr->next = tptr;
        ptr->s.size = size;

        if( malloc_end == ptr )
        {
            malloc_end = tptr;
        }
    }

} /* malloc_split(... */

/*
 * Function:	malloc_join()
 *
 * Purpose:	to join two malloc segments together (if possible)
 *
 * Arguments:	ptr	- pointer to segment to join to.
 * 		nextptr	- pointer to next segment to join to ptr.
 *
 * Returns:	nothing of any values.
 *
 * Narrative:
 *
 * Mod History:	
 *   90/01/27	cpcahil		Initial revision.
 */
void
malloc_join(ptr,nextptr, inuse_override, fill_flag)
    struct mlist	* ptr;
    struct mlist	* nextptr;
    int		  inuse_override;
    int		  fill_flag;
{
    unsigned int	  newsize;

    if( 	ptr     && ! (inuse_override || (ptr->flag & M_INUSE)) && 
        nextptr && ! (nextptr->flag & M_INUSE) &&
        ((ptr->data+ptr->s.size) == (char *) nextptr) )
    {
        if( malloc_end == nextptr )
        {
            malloc_end = ptr;
        }
        ptr->next = nextptr->next;
        newsize = nextptr->s.size + M_SIZE;

        /*
         * if we are to fill and this segment is in use,
         *   fill in with M_FILL newly added space...
          */

        if(fill_flag && (ptr->flag & M_INUSE) )
        {
            malloc_memset(ptr->data+ptr->s.size,
                      M_FILL, (int)(nextptr->s.size + M_SIZE));
        }

        ptr->s.size += newsize;
        if( ptr->next )
        {
            ptr->next->prev = ptr;
        }
    }

} /* malloc_join(... */


/*
 * The following mess is just to ensure that the versions of these functions in
 * the current library are included (to make sure that we don't accidentaly get 
 * the libc versions. (This is the lazy man's -u ld directive)
 */

void free();
int strcmp();
int memcmp();
char	* realloc();

void		(*malloc_void_funcs[])() =
{
    free,
};

int		(*malloc_int_funcs[])() =
{
    strcmp,
    memcmp,
};

char		* (*malloc_char_star_funcs[])() =
{
    realloc,
};

/*
 * This is malloc's own memset which is used without checking the parameters.
 */

void
malloc_memset(ptr,byte,len)
    char		* ptr;
    char		  byte;
    int		  len;
{

    while(len-- > 0)
    {
        *ptr++ = byte;
    }

} /* malloc_memset(... */

/*
 * Function:	malloc_fatal()
 *
 * Purpose:	to display fatal error message and take approrpriate action
 *
 * Arguments:	funcname - name of function calling this routine
 *
 * Returns:	nothing of any value
 *
 * Narrative:
 *
 * Notes:	This routine does not make use of any libc functions to build
 *		and/or disply the error message.  This is due to the fact that
 *		we are probably at a point where malloc is having a real problem
 *		and we don't want to call any function that may use malloc.
 */
void
malloc_fatal(funcname)
    char		* funcname;
{
    char		  errbuf[128];
    void		  exit();
    void		  malloc_err_handler();
    extern char	* malloc_err_strings[];
    extern int	  malloc_errno;
    extern int	  malloc_fatal_level;
    char		* s;
    char		* t;

    s = errbuf;
    t = "Fatal error: ";
    while( *s = *t++)
    {
        s++;
    }
    t = funcname;
    while( *s = *t++)
    {
        s++;
    }

    t = "(): ";
    while( *s = *t++)
    {
        s++;
    }

    t = malloc_err_strings[malloc_errno];
    while( *s = *t++)
    {
        s++;
    }

    *(s++) = '\n';

    if( write(malloc_errfd,errbuf,(unsigned)(s-errbuf)) != (s-errbuf))
    {
        (void) write(2,"I/O error to error file\n",(unsigned)24);
        exit(110);
    }
    malloc_err_handler(malloc_fatal_level);

} /* malloc_fatal(... */

/*
 * Function:	malloc_warning()
 *
 * Purpose:	to display warning error message and take approrpriate action
 *
 * Arguments:	funcname - name of function calling this routine
 *
 * Returns:	nothing of any value
 *
 * Narrative:
 *
 * Notes:	This routine does not make use of any libc functions to build
 *		and/or disply the error message.  This is due to the fact that
 *		we are probably at a point where malloc is having a real problem
 *		and we don't want to call any function that may use malloc.
 */
void
malloc_warning(funcname)
    char		* funcname;
{
    char		  errbuf[128];
    void		  exit();
    void		  malloc_err_handler();
    extern char	* malloc_err_strings[];
    extern int	  malloc_errno;
    extern int	  malloc_warn_level;
    char		* s;
    char		* t;

    s = errbuf;
    t = "Warning: ";
    while( *s = *t++)
    {
        s++;
    }
    t = funcname;
    while( *s = *t++)
    {
        s++;
    }

    t = "(): ";
    while( *s = *t++)
    {
        s++;
    }

    t = malloc_err_strings[malloc_errno];
    while( *s = *t++)
    {
        s++;
    }

    *(s++) = '\n';

    if( write(malloc_errfd,errbuf,(unsigned)(s-errbuf)) != (s-errbuf))
    {
        (void) write(2,"I/O error to error file\n",(unsigned)24);
        exit(110);
    }

    malloc_err_handler(malloc_warn_level);

} /* malloc_warning(... */

/*
 * Function:	malloc_err_handler()
 *
 * Purpose:	to take the appropriate action for warning and/or fatal 
 *		error conditions.
 *
 * Arguments:	level - error handling level 
 *
 * Returns:	nothing of any value
 *
 * Narrative:
 *
 * Notes:	This routine does not make use of any libc functions to build
 *		and/or disply the error message.  This is due to the fact that
 *		we are probably at a point where malloc is having a real problem
 *		and we don't want to call any function that may use malloc.
 */
void
malloc_err_handler(level)
{
    void		  exit();
    void		  malloc_dump();
    extern int	  malloc_errfd;

    if( level & M_HANDLE_DUMP )
    {
        malloc_dump(malloc_errfd);
    }

    switch( level & ~M_HANDLE_DUMP )
    {
        /*
         * If we are to drop a core file and exit
         */
        case M_HANDLE_ABORT:
            (void) abort();
            break;

        /*
         * If we are to exit..
         */
        case M_HANDLE_EXIT:
            exit(200);
            break;

#ifndef __MSDOS__
        /*
         * If we are to dump a core, but keep going on our merry way
         */
        case M_HANDLE_CORE:
            {
                int	  pid;

                /*
                 * fork so child can abort (and dump core)
                 */
                if( (pid = fork()) == 0 )
                {
                    (void) write(2,"Child dumping core\n",
                            (unsigned)9);
                    (void) abort();
                }

                /*
                  * wait for child to finish dumping core
                 */
                while( wait((int *)0) != pid)
                {
                }

                /*
                 * Move core file to core.pid.cnt so 
                 * multiple cores don't overwrite each
                 * other.
                 */
                if( access("core",0) == 0 )
                {
                    static int	  corecnt;
                    char	  	  filenam[32];
                    filenam[0] = 'c';
                    filenam[1] = 'o';
                    filenam[2] = 'r';
                    filenam[3] = 'e';
                    filenam[4] = '.';
                    (void)tostring(filenam+5,getpid(),
                        5, B_DEC, '0');
                    filenam[10] = '.';
                    (void)tostring(filenam+11,corecnt++,
                        3, B_DEC, '0');
                    filenam[14] = '\0';
                    (void) unlink(filenam);
                    if( link("core",filenam) == 0)
                    {
                        (void) unlink("core");
                    }
                }
            }
#endif


        /* 
         * If we are to just ignore the error and keep on processing
         */
        case M_HANDLE_IGNORE:
            break;

    } /* switch(... */

} /* malloc_err_handler(... */

