Return to emalloc.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / libntp

Annotation of embedaddon/ntp/libntp/emalloc.c, revision 1.1

1.1     ! misho       1: /*
        !             2:  * emalloc - return new memory obtained from the system.  Belch if none.
        !             3:  */
        !             4: #include <config.h>
        !             5: #include "ntp_types.h"
        !             6: #include "ntp_malloc.h"
        !             7: #include "ntp_syslog.h"
        !             8: #include "ntp_stdlib.h"
        !             9: 
        !            10: 
        !            11: /*
        !            12:  * When using the debug MS CRT allocator, each allocation stores the
        !            13:  * callsite __FILE__ and __LINE__, which is then displayed at process
        !            14:  * termination, to track down leaks.  We don't want all of our
        !            15:  * allocations to show up as coming from emalloc.c, so we preserve the
        !            16:  * original callsite's source file and line using macros which pass
        !            17:  * __FILE__ and __LINE__ as parameters to these routines.
        !            18:  * Other debug malloc implementations can be used by defining
        !            19:  * EREALLOC_IMPL() as ports/winnt/include/config.h does.
        !            20:  */
        !            21: 
        !            22: void *
        !            23: ereallocz(
        !            24:        void *  ptr,
        !            25:        size_t  newsz,
        !            26:        size_t  priorsz,
        !            27:        int     zero_init
        !            28: #ifdef EREALLOC_CALLSITE               /* ntp_malloc.h */
        !            29:                         ,
        !            30:        const char *    file,
        !            31:        int             line
        !            32: #endif
        !            33:        )
        !            34: {
        !            35:        char *  mem;
        !            36:        size_t  allocsz;
        !            37: 
        !            38:        if (0 == newsz)
        !            39:                allocsz = 1;
        !            40:        else
        !            41:                allocsz = newsz;
        !            42: 
        !            43:        mem = EREALLOC_IMPL(ptr, allocsz, file, line);
        !            44:        if (NULL == mem) {
        !            45:                msyslog_term = TRUE;
        !            46: #ifndef EREALLOC_CALLSITE
        !            47:                msyslog(LOG_ERR, "fatal out of memory (%lu bytes)",
        !            48:                        (u_long)newsz);
        !            49: #else
        !            50:                msyslog(LOG_ERR,
        !            51:                        "fatal out of memory %s line %d (%lu bytes)",
        !            52:                        file, line, (u_long)newsz);
        !            53: #endif
        !            54:                exit(1);
        !            55:        }
        !            56: 
        !            57:        if (zero_init && newsz > priorsz)
        !            58:                zero_mem(mem + priorsz, newsz - priorsz);
        !            59: 
        !            60:        return mem;
        !            61: }
        !            62: 
        !            63: 
        !            64: char *
        !            65: estrdup_impl(
        !            66:        const char *    str
        !            67: #ifdef EREALLOC_CALLSITE
        !            68:                           ,
        !            69:        const char *    file,
        !            70:        int             line
        !            71: #endif
        !            72:        )
        !            73: {
        !            74:        char *  copy;
        !            75:        size_t  bytes;
        !            76: 
        !            77:        bytes = strlen(str) + 1;
        !            78:        copy = ereallocz(NULL, bytes, 0, FALSE
        !            79: #ifdef EREALLOC_CALLSITE
        !            80:                         , file, line
        !            81: #endif
        !            82:                         );
        !            83:        memcpy(copy, str, bytes);
        !            84: 
        !            85:        return copy;
        !            86: }
        !            87: 
        !            88: 
        !            89: #ifndef EREALLOC_CALLSITE
        !            90: void *
        !            91: emalloc(size_t newsz)
        !            92: {
        !            93:        return ereallocz(NULL, newsz, 0, FALSE);
        !            94: }
        !            95: #endif
        !            96: