BCI NET 2/BCI NET 2.iso/archives/programming/c/fortify.lha/zfortify.cpp

C/C++ Source or Header | 1995-02-03 | 22.1 KB | 896 lines

// ZFortify.cpp - A fortified shell for new and delete.

//     The  minimum  you  need  to  do for ZFortify is to define the symbol
// ZFORTIFY,  and  link  zfortify.o.   Each source file should also include
// "zfortify.hpp",  but  this  isn't strictly necessary.  If a file doesn't
// #include  "Fortify.hpp",  then it's allocations will still be fortified,
// however  you  will not have any source-code details in any of the output
// messages  (this will be the case for all libraries, etc, unless you have
// the source for the library and can recompile it with Fortify).
//     If  you  do  not  have  stdout  available,  you  may  wish to set an
// alternate  output  function,  or  turn  on  the  AUTOMATIC_LOGFILE.  See
// ZFortify_SetOutputFunc() and AUTOMATIC_LOGFILE, below.
//
// None  of  the  functions  in  this  file should be called directly; they
// should be called through the macros defined in ZFortify.hpp.

#ifdef ZFORTIFY
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <time.h>
#include <ctype.h>

#define  ZFORTIFY_CPP   // So ZFortify.hpp knows to not define the ZFortify macros
#include "ZFortify.hpp"

// the user's options
#include "ufortify.hpp"

struct Header
{
    char          *File;     // The sourcefile of the caller
    unsigned long  Line;     // The sourceline of the caller
    size_t         Size;     // The size of the new'd block
    struct Header *Prev;     // List pointers
    struct Header *Next;     //
    int            Scope;    // Scope level this block was allocated in
    int            Checksum; // For validating the Header structure; see ChecksumHeader()
};

// Local prototypes
static int  CheckBlock(struct Header *h, char *file, unsigned long line);
static int  CheckFortification(unsigned char *ptr, unsigned char value, size_t size);
static void SetFortification(unsigned char *ptr, unsigned char value, size_t size);
static void OutputFortification(unsigned char *ptr, unsigned char value, size_t size);
static int  IsHeaderValid(struct Header *h);
static void MakeHeaderValid(struct Header *h);
static int  ChecksumHeader(struct Header *h);
static int  IsOnList(struct Header *h);
static void OutputMemory(struct Header *h);
static void OutputHeader(struct Header *h);
static void OutputLastVerifiedPoint(void);

// The default output function
static void st_DefaultOutput(const char *String)
{
    printf(String);
}

static struct Header *st_Head = 0; // Head of alloc'd memory list
static ZFortify_OutputFuncPtr  st_Output = st_DefaultOutput; // Output function for errors
static char st_Buffer[256];       // Temporary buffer for sprintf's
static int st_Disabled = 0;       // If true, ZFortify is inactive
static int st_NewFailRate = 0;    // % of the time to false fail new

static char          *st_LastVerifiedFile = "unknown";
static unsigned long  st_LastVerifiedLine = 0;

static char             *st_Delete_File = 0;
static unsigned long  st_Delete_Line = 0;

static int            st_Scope = 0;

// operator new() - Allocates a block of memory, with extra bits for
//                  misuse protection/detection.
// Features:
//     +  Adds the new'd memory onto ZFortify's own private list.
//        (With a checksum'd header to detect corruption of the memory list)
//     +  Places sentinals on either side of the user's memory with
//        known data in them, to detect use outside of the bounds
//        of the block
//     +  Initializes the new'd memory to some "nasty" value, so code
//        can't rely on it's contents.
//     +  Can check all sentinals on every NEW.
//     +  Can generate a warning message on a NEW fail.
//     +  Can randomly "fail" at a set fail rate
void *ZFORTIFY_STORAGE
operator new(size_t size)
{
    return operator new(size, "new", 0);
}

#ifdef ZFORTIFY_PROVIDE_ARRAY_NEW

void *ZFORTIFY_STORAGE
operator new[](size_t size)
{
    return operator new(size, "new[]", 0);
}

void *ZFORTIFY_STORAGE
operator new[](size_t size, char *file, unsigned long line)
{
    return operator new(size, file, line);
}

#endif // ZFORTIFY_PROVIDE_ARRAY_NEW

void *ZFORTIFY_STORAGE
operator new(size_t size, char *file, unsigned long line)
{
    unsigned char *ptr;
    struct Header *h;

    ZFORTIFY_LOCK();

    if(st_Disabled)
    {
        ptr = (unsigned char *)malloc(size);
        ZFORTIFY_UNLOCK();
        return(ptr);
    }

#ifdef CHECK_ALL_MEMORY_ON_NEW
    ZFortify_CheckAllMemory(file, line);
#endif

    if(size == 0)
    {
#ifdef WARN_ON_ZERO_NEW
        sprintf(st_Buffer, "\nZFortify: %s.%ld\n         new(0) attempted failed\n",
                           file, line);
        st_Output(st_Buffer);
#endif

        ZFORTIFY_UNLOCK();
        return(0);
    }

    if(st_NewFailRate > 0)
    {
        if(rand() % 100 < st_NewFailRate)
        {
#ifdef WARN_ON_FALSE_FAIL
            sprintf(st_Buffer, "\nZFortify: %s.%ld\n         new(%ld) \"false\" failed\n",
                               file, line, (unsigned long)size);
            st_Output(st_Buffer);
#endif
            ZFORTIFY_UNLOCK();
            return(0);
        }
    }

#ifdef WARN_ON_SIZE_T_OVERFLOW
    {
        size_t private_size = sizeof(struct Header)
                            + ZFORTIFY_BEFORE_SIZE + size + ZFORTIFY_AFTER_SIZE;

        If(private_size < size) /* Check to see if the added baggage is larger than size_t */
        {
            sprintf(st_Buffer, "\nZFortify: %s.%ld\n         new(%ld) has overflowed size_t.\n",
                                file, line, (unsigned long)size);
            st_Output(st_Buffer);
            ZFORTIFY_UNLOCK();
            return(0);
        }
    }
#endif

    // new the memory, including the space for the header
      // and fortification buffers (well, we fake it with malloc).
    ptr = (unsigned char *)malloc(sizeof(struct Header) + ZFORTIFY_BEFORE_SIZE + size + ZFORTIFY_AFTER_SIZE);
    if(!ptr)
    {
#ifdef WARN_ON_NEW_FAIL
        sprintf(st_Buffer, "\nZFortify: %s.%ld\n         new(%ld) failed\n",
                            file, line, (unsigned long)size);
        st_Output(st_Buffer);
#endif

        ZFORTIFY_UNLOCK();
        return(0);
    }

    // Initialize and validate the header
    h = (struct Header *)ptr;

    h->Size  = size;

    h->File  = file;
    h->Line  = line;

    h->Next  = st_Head;
    h->Prev  = 0;
    h->Scope = st_Scope;

    if(st_Head)
    {
        st_Head->Prev = h;
        MakeHeaderValid(st_Head);
    }

    st_Head = h;

    MakeHeaderValid(h);

    // Initialize the fortifications
    SetFortification(ptr + sizeof(struct Header), ZFORTIFY_BEFORE_VALUE, ZFORTIFY_BEFORE_SIZE);
    SetFortification(ptr + sizeof(struct Header) + ZFORTIFY_BEFORE_SIZE + size,
                     ZFORTIFY_AFTER_VALUE, ZFORTIFY_AFTER_SIZE);

#ifdef FILL_ON_NEW
    // Fill the actual user memory
    SetFortification(ptr + sizeof(struct Header) + ZFORTIFY_BEFORE_SIZE, FILL_ON_NEW_VALUE, size);
#endif

    ZFORTIFY_UNLOCK();

    // We return the address of the user's memory, not the start of the block,
    // which points to our magic cookies
    return(ptr + sizeof(struct Header) + ZFORTIFY_BEFORE_SIZE);
}

// operator delete() - This delete must be used for all memory allocated with
//                     the ZFortify new()
//
//   Features:
//     + Pointers are validated before attempting a delete - the pointer
//       must point to a valid new'd bit of memory.
//     + Detects attempts at deleting the same block of memory twice
//     + Can clear out memory as it is freed, to prevent code from using
//       the memory after it's been freed.
//     + Checks the sentinals of the memory being freed.
//     + Can check the sentinals of all memory.
int ZFORTIFY_STORAGE
ZFortify_PreDelete(char *file, unsigned long line)
{
    // Don't change the delete source code pointer if we already have some information,
    // cause if we're doing a delete inside a delete, the highest level delete will
    // probably be the most useful.
    if(st_Delete_File == 0)
    {
        st_Delete_File = file;
        st_Delete_Line = line;
    }
    return 1;
}

void ZFORTIFY_STORAGE
operator delete(void *uptr)
{
    unsigned char *ptr = (unsigned char *)uptr - sizeof(struct Header) - ZFORTIFY_BEFORE_SIZE;
    struct Header *h = (struct Header *)ptr;
    char *file;
    unsigned long line;

    // It is defined to be harmless to delete 0
    if(uptr == 0)
        return;

    ZFORTIFY_LOCK();

    if(st_Disabled)
    {
        free(uptr);
        ZFORTIFY_UNLOCK();
        return;
    }

    if(st_Delete_File)
    {
        file = st_Delete_File;
        line = st_Delete_Line;

        st_Delete_File = 0;
    }
    else
    {
        file = "delete";
        line = 0;
    }

#ifdef CHECK_ALL_MEMORY_ON_DELETE
    ZFortify_CheckAllMemory(file, line);
#endif

#ifdef PARANOID_DELETE
    if(!IsOnList(h))
    {
        sprintf(st_Buffer,
                "\nZFortify: %s.%ld\n         Invalid pointer, corrupted header, or possible free twice\n",
                file, line);
        st_Output(st_Buffer);
        OutputLastVerifiedPoint();
        goto fail;
    }
#endif

    if(!CheckBlock(h, file, line))
        goto fail;

    // Remove the block from the list
    if(h->Prev)
    {
        if(!CheckBlock(h->Prev, file, line))
            goto fail;

        h->Prev->Next = h->Next;
        MakeHeaderValid(h->Prev);
    }
    else
        st_Head = h->Next;

    if(h->Next)
    {
        if(!CheckBlock(h->Next, file, line))
            goto fail;

        h->Next->Prev = h->Prev;
        MakeHeaderValid(h->Next);
    }

#ifdef FILL_ON_DELETE
    // Nuke out all memory that is about to be freed
    SetFortification(ptr, FILL_ON_DELETE_VALUE,
                     sizeof(struct Header) + ZFORTIFY_BEFORE_SIZE + h->Size + ZFORTIFY_AFTER_SIZE);
#endif

    // And do the actual free
    free(ptr);
    ZFORTIFY_UNLOCK();
    return;

fail:
    sprintf(st_Buffer, "         delete(%p) failed\n", uptr);
    st_Output(st_Buffer);
    ZFORTIFY_UNLOCK();
}

// ZFortify_CheckPointer() - Returns true if the uptr points to a valid
// piece of ZFortify_new()'d memory. The memory must be on the new'd
// list, and it's sentinals must be in tact.
// If anything is wrong, an error message is issued.
//
//   (Note - if ZFortify is disabled, this function always returns true).
int ZFORTIFY_STORAGE
ZFortify_CheckPointer(void *uptr, char *file, unsigned long line)
{
    unsigned char *ptr = (unsigned char *)uptr - sizeof(struct Header) - ZFORTIFY_BEFORE_SIZE;
    int r;

    if(st_Disabled)
        return(1);

    ZFORTIFY_LOCK();

    if(!IsOnList((struct Header *)ptr))
    {
        sprintf(st_Buffer, "\nZFortify: %s.%ld\n         Invalid pointer or corrupted header detected (%p)\n",
                            file, line, uptr);
        st_Output(st_Buffer);
        ZFORTIFY_UNLOCK();
        return(0);
    }

    r = CheckBlock((struct Header *)ptr, file, line);
    ZFORTIFY_UNLOCK();
    return r;
}

// ZFortify_SetOutputFunc(ZFortify_OutputFuncPtr Output) - Sets the function used to
// output all error and diagnostic messages by ZFortify. The output function
// takes a single unsigned char * argument, and must be able to handle newlines.
//     The function returns the old pointer.
ZFortify_OutputFuncPtr ZFORTIFY_STORAGE
ZFortify_SetOutputFunc(ZFortify_OutputFuncPtr Output)
{
    ZFortify_OutputFuncPtr Old = st_Output;

    st_Output = Output;

    return(Old);
}

// ZFortify_SetNewFailRate(int Percent) - ZFortify_new() will make the
// new attempt fail this Percent of the time, even if the memory is
// available. Useful to "stress-test" an application. Returns the old
//  value. The fail rate defaults to 0.
int ZFORTIFY_STORAGE
ZFortify_SetNewFailRate(int Percent)
{
    int Old = st_NewFailRate;

    st_NewFailRate = Percent;

    return(Old);
}


// ZFortify_CheckAllMemory() - Checks the sentinals of all new'd memory.
// Returns the number of blocks that failed.
//
//  (If ZFortify is disabled, this function always returns 0).
int ZFORTIFY_STORAGE
ZFortify_CheckAllMemory(char *file, unsigned long line)
{
    struct Header *curr = st_Head;
    int count = 0;

    if(st_Disabled)
        return(0);

    ZFORTIFY_LOCK();

    while(curr)
    {
        if(!CheckBlock(curr, file, line))
            count++;

        curr = curr->Next;
    }

    if(count == 0)
    {
        st_LastVerifiedFile = file;
        st_LastVerifiedLine = line;
    }

    ZFORTIFY_UNLOCK();
    return(count);
}

// ZFortify_EnterScope - enters a new ZFortify scope level.
// returns the new scope level.
int ZFORTIFY_STORAGE
ZFortify_EnterScope(char */*file*/, unsigned long /*line*/)
{
    return(++st_Scope);
}

// ZFortify_LeaveScope - leaves a ZFortify scope level,
// also prints a memory dump of all non-freed memory that was allocated
// during the scope being exited.
int ZFORTIFY_STORAGE
ZFortify_LeaveScope(char *file, unsigned long line)
{
    struct Header *curr = st_Head;
    int count = 0;
    unsigned long size = 0;

    if(st_Disabled)
        return(0);

    ZFORTIFY_LOCK();

    st_Scope--;
    while(curr)
    {
        if(curr->Scope > st_Scope)
        {
            if(count == 0)
            {
                sprintf(st_Buffer, "\nZFortify: Memory Dump at %s.%ld\n", file, line);
                st_Output(st_Buffer);
                OutputLastVerifiedPoint();
                sprintf(st_Buffer, "%11s %8s %s\n", "Address", "Size", "Allocator");
                st_Output(st_Buffer);
            }

            OutputHeader(curr);
            count++;
            size += curr->Size;
        }

        curr = curr->Next;
    }

    if(count)
    {
        sprintf(st_Buffer, "%11s %8ld bytes overhead\n", "and",
                        (unsigned long)(count * (sizeof(struct Header) + ZFORTIFY_BEFORE_SIZE + ZFORTIFY_AFTER_SIZE)));
                        st_Output(st_Buffer);

        sprintf(st_Buffer,"%11s %8ld bytes in %d blocks\n", "total", size, count);
        st_Output(st_Buffer);
    }

    ZFORTIFY_UNLOCK();
    return(count);
}

// ZFortify_OutputAllMemory() - Outputs the entire list of currently
// new'd memory. For each new'd block is output it's Address,
// Size, and the SourceFile and Line that allocated it.
//
// If there is no memory on the list, this function outputs nothing.
//
// It returns the number of blocks on the list, unless ZFortify has been
// disabled, in which case it always returns 0.
int ZFORTIFY_STORAGE
ZFortify_OutputAllMemory(char *file, unsigned long line)
{
    struct Header *curr = st_Head;
    int count = 0;
    unsigned long size = 0;

    if(st_Disabled)
        return(0);

    ZFORTIFY_LOCK();

    if(curr)
    {
        sprintf(st_Buffer, "\nZFortify: Memory Dump at %s.%ld\n", file, line);
        st_Output(st_Buffer);
        OutputLastVerifiedPoint();
        sprintf(st_Buffer, "%11s %8s %s\n", "Address", "Size", "Allocator");
        st_Output(st_Buffer);

        while(curr)
        {
            OutputHeader(curr);
            count++;
            size += curr->Size;
            curr = curr->Next;
        }

        sprintf(st_Buffer, "%11s %8ld bytes overhead\n", "and",
            (unsigned long)(count * (sizeof(struct Header) + ZFORTIFY_BEFORE_SIZE + ZFORTIFY_AFTER_SIZE)));
        st_Output(st_Buffer);

        sprintf(st_Buffer,"%11s %8ld bytes in %d blocks\n", "total", size, count);
        st_Output(st_Buffer);
    }

    ZFORTIFY_UNLOCK();
    return(count);
}

// ZFortify_DumpAllMemory(Scope) - Outputs the entire list of currently
// new'd memory within the specified scope. For each new'd block is output
// it's Address, Size, the SourceFile and Line that allocated it, a hex dump
// of the contents of the memory and an ascii dump of printable characters.
//
// If there is no memory on the list, this function outputs nothing.
//
// It returns the number of blocks on the list, unless ZFortify has been
// disabled, in which case it always returns 0.
int ZFORTIFY_STORAGE
ZFortify_DumpAllMemory(int scope, char *file, unsigned long line)
{
    struct Header *curr = st_Head;
    int count = 0;
    unsigned long size = 0;

    if(st_Disabled)
        return(0);

    ZFORTIFY_LOCK();

    while(curr)
    {
        if(curr->Scope >= scope)
        {
            if(count == 0)
            {
                sprintf(st_Buffer, "\nZFortify: Memory Dump at %s.%ld\n", file, line);
                st_Output(st_Buffer);
                OutputLastVerifiedPoint();
                sprintf(st_Buffer, "%11s %8s %s\n", "Address", "Size", "Allocator");
                st_Output(st_Buffer);
            }

            OutputHeader(curr);
            OutputMemory(curr);
            st_Output("\n");
            count++;
            size += curr->Size;
        }

        curr = curr->Next;
    }

    if(count)
    {
        sprintf(st_Buffer, "%11s %8ld bytes overhead\n", "and",
                        (unsigned long)(count * (sizeof(struct Header) + ZFORTIFY_BEFORE_SIZE + ZFORTIFY_AFTER_SIZE)));
                        st_Output(st_Buffer);

        sprintf(st_Buffer,"%11s %8ld bytes in %d blocks\n", "total", size, count);
        st_Output(st_Buffer);
    }

    ZFORTIFY_UNLOCK();
    return(count);
}

// ZFortify_Disable() - This function provides a mechanism to disable ZFortify
// without recompiling all the sourcecode. It can only be called, though,
// when there is no memory on the ZFortify new'd list. (Ideally, at the
// start of the program before any memory has been allocated). If you
// call this function when there IS memory on the ZFortify new'd list,
// it will issue an error, and ZFortify will not be disabled.
int ZFORTIFY_STORAGE
ZFortify_Disable(char *file, unsigned long line)
{
    int result;
    ZFORTIFY_LOCK();

    if(st_Head)
    {
        sprintf(st_Buffer, "ZFortify: %s.%d\n", file, line);
        st_Output(st_Buffer);
        st_Output("         ZFortify_Disable failed\n");
        st_Output("         (because there is memory on the ZFortify memory list)\n");

        ZFortify_OutputAllMemory(file, line);
        result = 0;
    }
    else
    {
        st_Disabled = 1;
        result = 1;
    }

    ZFORTIFY_UNLOCK();
    return(result);
}

// Check a block's header and fortifications.
static int
CheckBlock(struct Header *h, char *file, unsigned long line)
{
    unsigned char *ptr = (unsigned char *)h;
    int result = 1;

    if(!IsHeaderValid(h))
    {
        sprintf(st_Buffer, "\nZFortify: %s.%ld\n         Invalid pointer or corrupted header detected (%p)\n",
                            file, line, ptr + sizeof(struct Header) + ZFORTIFY_BEFORE_SIZE);
        st_Output(st_Buffer);
        OutputLastVerifiedPoint();
        return(0);
    }

    if(!CheckFortification(ptr + sizeof(struct Header), ZFORTIFY_BEFORE_VALUE, ZFORTIFY_BEFORE_SIZE))
    {
        sprintf(st_Buffer, "\nZFortify: %s.%ld\n         Memory overrun detected before block\n",
                            file, line);
        st_Output(st_Buffer);

        sprintf(st_Buffer,"         (%p,%ld,%s.%ld)\n", ptr + sizeof(struct Header) + ZFORTIFY_BEFORE_SIZE,
                          (unsigned long)h->Size, h->File, h->Line);
        st_Output(st_Buffer);

        OutputFortification(ptr + sizeof(struct Header), ZFORTIFY_BEFORE_VALUE, ZFORTIFY_BEFORE_SIZE);
        OutputLastVerifiedPoint();
        result = 0;
    }

    if(!CheckFortification(ptr + sizeof(struct Header) + ZFORTIFY_BEFORE_SIZE + h->Size,
                            ZFORTIFY_AFTER_VALUE, ZFORTIFY_AFTER_SIZE))
    {
        sprintf(st_Buffer, "\nZFortify: %s.%ld\n         Memory overrun detected after block\n",
                            file, line);
        st_Output(st_Buffer);

        sprintf(st_Buffer,"         (%p,%ld,%s.%ld)\n",
                        ptr + sizeof(struct Header) + ZFORTIFY_BEFORE_SIZE,
                        (unsigned long)h->Size, h->File, h->Line);
        st_Output(st_Buffer);

        OutputFortification(ptr + sizeof(struct Header) + ZFORTIFY_BEFORE_SIZE + h->Size,
                            ZFORTIFY_AFTER_VALUE, ZFORTIFY_AFTER_SIZE);
        OutputLastVerifiedPoint();
        result = 0;
    }

    return(result);
}

// Checks if the _size_ bytes from _ptr_ are all set to _value_
static int
CheckFortification(unsigned char *ptr, unsigned char value, size_t size)
{
    while(size--)
        if(*ptr++ != value)
            return(0);

    return(1);
}

// Set the _size_ bytes from _ptr_ to _value_.
static void
SetFortification(unsigned char *ptr, unsigned char value, size_t size)
{
    memset(ptr, value, size);
}

// Output the corrupted section of the fortification
static void
OutputFortification(unsigned char *ptr, unsigned char /*value*/, size_t size)
{
    unsigned long offset, column;
    char    ascii[17];

    st_Output("Address     Offset Data");

    offset = 0;
    column = 0;

    while(offset < size)
    {
        if(column == 0)
        {
            sprintf(st_Buffer, "\n%8p %8d ", ptr, offset);
            st_Output(st_Buffer);
        }

        sprintf(st_Buffer, "%02x ", *ptr);
        st_Output(st_Buffer);

        ascii[ column ] = isprint( *ptr ) ? char(*ptr) : char(' ');
        ascii[ column + 1 ] = '\0';

        ptr++;
        offset++;
        column++;

        if(column == 16)
        {
            st_Output( "   \"" );
            st_Output( ascii );
            st_Output( "\"" );
            column = 0;
        }
    }

    if ( column != 0 )
    {
        while ( column ++ < 16 )
        {
            st_Output( "   " );
        }
        st_Output( "   \"" );
        st_Output( ascii );
        st_Output( "\"" );
    }

    st_Output("\n");
}

// Returns true if the supplied pointer does indeed point to a real Header
static int
IsHeaderValid(struct Header *h)
{
    return(!ChecksumHeader(h));
}

// Updates the checksum to make the header valid
static void
MakeHeaderValid(struct Header *h)
{
    h->Checksum = 0;
    h->Checksum = -ChecksumHeader(h);
}

// Calculate (and return) the checksum of the header. (Including the Checksum
// variable itself. If all is well, the checksum returned by this function should
// be 0.
static int
ChecksumHeader(struct Header *h)
{
    int c, checksum, *p;

    for(c = 0, checksum = 0, p = (int *)h; c < sizeof(struct Header)/sizeof(int); c++)
        checksum += *p++;

    return(checksum);
}

// Examines the new'd list to see if the given header is on it.
static int
IsOnList(struct Header *h)
{
    struct Header *curr;

    curr = st_Head;
    while(curr)
    {
        if(curr == h)
            return(1);

        curr = curr->Next;
    }

    return(0);
}

// Output the header...
static void
OutputHeader(struct Header *h)
{
    sprintf(st_Buffer, "%11p %8ld %s.%ld (%d)\n",
                        (unsigned char*)h + sizeof(struct Header) + ZFORTIFY_BEFORE_SIZE,
                        (unsigned long)h->Size,
                        h->File, h->Line, h->Scope);
    st_Output(st_Buffer);
}

// Hex and ascii dump the memory
static void
OutputMemory(struct Header *h)
{
    OutputFortification((unsigned char*)h + sizeof(struct Header) + ZFORTIFY_BEFORE_SIZE,
                        0, h->Size);
}

static void
OutputLastVerifiedPoint()
{
    sprintf(st_Buffer, "\nLast Verified point: %s.%ld\n",
                      st_LastVerifiedFile,
                      st_LastVerifiedLine);
    st_Output(st_Buffer);
}

#ifdef AUTOMATIC_LOG_FILE
// Automatic log file stuff!

// AutoLogFile class. There can only ever be ONE of these
// instantiated! It is a static class, which means that
// it's constructor will be called at program initialization,
// and it's destructor will be called at program termination.
// We don't know if the other static class objects have been
// constructed/destructed yet, but this pretty much the best
// we can do with standard C++ language features.
class AutoLogFile
{
    static FILE *fp;
    static int   written_something;

public:
    AutoLogFile()
    {
        written_something = 0;
        ZFortify_SetOutputFunc(AutoLogFile::Output);
        ZFortify_EnterScope("Program Initialization",0);
    }

    static void Output(const char *s)
    {
        if(written_something == 0)
        {
            FIRST_ERROR_FUNCTION;
            fp = fopen(LOG_FILENAME, "w");
            if(fp)
            {
                time_t t;
                time(&t);
                fprintf(fp, "ZFortify log started at %s\n", ctime(&t));
                written_something = 1;
            }
        }

        if(fp)
        {
            fputs(s, fp);
            fflush(fp);
        }
    }

    ~AutoLogFile()
    {
        ZFortify_LeaveScope("Program Termination",0);
        if(fp)
        {
            time_t t;
            time(&t);
            fprintf(fp, "\nZFortify log closed at %s\n", ctime(&t));
            fclose(fp);
            fp = 0;
        }
    }
};

FILE *AutoLogFile::fp = 0;
int   AutoLogFile::written_something = 0;

static AutoLogFile Abracadabra;

#endif // AUTOMATIC_LOG_FILE
#endif // ZFORTIFY