TRACE.CPP

/*++ 
 
     Copyright (c) 1996 Intel Corporation 
     Copyright 1996 - 1998 Microsoft Corporation 
     All Rights Reserved 
 
     Permission is granted to use, copy and distribute this software and 
     its documentation for any purpose and without fee, provided, that 
     the above copyright notice and this statement appear in all copies. 
     Intel makes no representations about the suitability of this 
     software for any purpose.  This software is provided "AS IS." 
 
     Intel specifically disclaims all warranties, express or implied, 
     and all liability, including consequential and other indirect 
     damages, for the use of this software, including liability for 
     infringement of any proprietary rights, and including the 
     warranties of merchantability and fitness for a particular purpose. 
     Intel does not assume any responsibility for any errors which may 
     appear in this software nor any responsibility to update it. 
 
Module Name: 
 
    TRACE.CPP : 
 
Abstract: 
 
    This module implements the traceing functions used in the winsock2 layered 
    service provider example. 
 
 
--*/ 
#define WIN32_LEAN_AND_MEAN 
#include "nowarn.h" 
 
#include <windows.h> 
#include <memory.h> 
#include <stdio.h> 
#include <stdarg.h> 
#include <io.h> 
#include <malloc.h> 
 
/* because windows.h is brain damaged and turns this one back on */ 
#pragma warning(disable: 4001) 
 
#include "trace.h" 
 
#ifdef TRACING 
 
// 
// Internal functions 
// 
BOOL  InitMemoryBuffers(VOID); 
 
// 
// Module local variables 
// 
 
// The buffers to use to format debug messages. 
LPSTR g_CurrentMessage=NULL; 
LPSTR g_PreviousMessage=NULL; 
 
// Critcal section to keep multiple thread from walking on each others output 
CRITICAL_SECTION OutputRoutine; 
 
// Where should the output go? If it is a file what is the file name 
int iTraceDestination=TRACE_TO_AUX; 
char TraceFile[] = "trace.log"; 
 
// The default output level 
DWORD debugLevel=0xFFFFFFFF; 
 
 
  
VOID 
PrintDebugString( 
                 char *Format, 
                 ... 
                 ) 
/*++ 
  Routine Description: 
 
  This routine outputs a debug messages.  Debug messages are routed 
  to a file or a debug window depnding on the value of a global 
  variable defined in this module 
 
  Arguments: 
 
  Format - A "printf()" compatable format specification. 
 
  ... - Additional arguments to "printf()" format specification. 
 
  Returns: 
 
  NONE 
 
  --*/ 
{ 
va_list ArgumentList; // argument list for varargs processing 
static HANDLE OutputFile =NULL; // file descriptor for file output 
static OFSTRUCT of; // open file struct for file output 
static int RepeatCount=0; // Count of repeated output statements 
static BOOL LogOpened = FALSE; // have we opened the file for 
                                     // output 
    static BOOL TraceInited = FALSE; 
    DWORD  BytesWritten; 
 
if (!TraceInited) 
{ 
        HANDLE InitMutex; 
        // Create the mutex to protect the rest of the init code 
        InitMutex = CreateMutex( 
            NULL,  // Use default security attributes 
            FALSE, // We don't want automatic ownership 
            "TraceMutextName"); 
        if (!InitMutex) 
        { 
            // We failed to create the mutex there is nothign else we 
            // can do so return.  This will cause the debug output to 
            // be silently lost. 
            return; 
        } //if 
 
        // Wait on mutex 
        WaitForSingleObject( InitMutex, 
                             INFINITE); 
 
        // Check to see if init is still needed 
        if (!TraceInited) 
        { 
            // Init the critical section to be used to protect the 
            // output portion of this routine. 
            InitializeCriticalSection( &OutputRoutine ); 
// Note: 
// DeleteCriticalSection will not be called on this critical section 
// we are reling on the OS to clean this one up.  We are doing this so 
// the user of this module does not have to Init/DeInit the module explicitly. 
 
            // allocate buffers to hold debug messages 
            if (InitMemoryBuffers()) 
            { 
                TraceInited = TRUE; 
            } //if 
        } //if 
 
        // Signal the mutex and delete this threads handle to the mutex 
        ReleaseMutex(InitMutex); 
        CloseHandle(InitMutex); 
} 
 
 
    // Here is where all the heavy lifting starts 
    EnterCriticalSection( &OutputRoutine ); 
 
    // print the user message to our buffer 
va_start(ArgumentList, Format); 
vsprintf(g_CurrentMessage, Format, ArgumentList); 
va_end(ArgumentList); 
 
    // Is the current debug message the same as the last debug 
    // message?  If the two messages are the same just increment the 
    // count of message repeats and return.  This keeps the system 
    // from being flooded with debug messages that may be being 
    // generated from inside a loop. 
 
if(lstrcmp(g_CurrentMessage, g_PreviousMessage)) 
{ 
if (iTraceDestination == TRACE_TO_FILE) 
{ 
            if (!LogOpened) 
            { 
                OutputFile = 
                CreateFile( TraceFile, 
                            GENERIC_WRITE,     // open for writing 
                            FILE_SHARE_WRITE,  // Share the file with others 
                            NULL,              // default security 
                            OPEN_ALWAYS,       // Use file if it exsits 
                            FILE_ATTRIBUTE_NORMAL, // Use a normal file 
                            NULL);             // No template 
 
                if (OutputFile != INVALID_HANDLE_VALUE) 
                { 
                    LogOpened = TRUE; 
                } //if 
            } //if 
 
            if (LogOpened) 
            { 
                if (RepeatCount > 0) 
                { 
                    wsprintf(g_PreviousMessage, 
 "Last Message Repeated < %d > times\n", 
 RepeatCount); 
 
                    WriteFile(OutputFile, 
                              g_PreviousMessage, 
                              lstrlen(g_PreviousMessage), 
                              &BytesWritten, 
                              NULL); 
                } //if 
 
                // Write the current message to the trace file 
                WriteFile(OutputFile, 
                          g_CurrentMessage, 
                          lstrlen(g_CurrentMessage), 
                          &BytesWritten, 
                          NULL); 
 
                // Flush debug output to file 
                FlushFileBuffers( TraceFile ); 
 
                //reset the repeat count 
                RepeatCount =0; 
            } //if 
} 
 
if( iTraceDestination == TRACE_TO_AUX) 
{ 
if(RepeatCount > 0) 
{ 
wsprintf(g_PreviousMessage, 
 "Last Message Repeated < %d > times\n", 
 RepeatCount); 
OutputDebugString(g_PreviousMessage); 
RepeatCount = 0; 
} 
            // Send message to AUX device 
OutputDebugString(g_CurrentMessage); 
} 
        // Store off this message 
lstrcpy(g_PreviousMessage, g_CurrentMessage); 
} 
else 
{ 
RepeatCount++; 
} 
    LeaveCriticalSection( &OutputRoutine ); 
} 
 
 
 
  
BOOL 
InitMemoryBuffers( 
                  VOID 
                  ) 
/*++ 
  Routine Description: 
 
  Initailizes the memory buffers used by this module. 
 
  Arguments: 
 
  NONE 
 
  Returns: 
 
  TRUE if all memory buffers are successfully created, Otherwise FALSE. 
 
  --*/ 
{ 
    BOOL ReturnCode=FALSE; 
 
    g_CurrentMessage = (LPSTR)malloc(TRACE_OUTPUT_BUFFER_SIZE); 
    if (g_CurrentMessage) 
    { 
        g_PreviousMessage = (LPSTR)malloc(TRACE_OUTPUT_BUFFER_SIZE); 
        if (g_PreviousMessage) 
        { 
            ReturnCode=TRUE; 
        } //if 
        else 
        { 
            free( g_CurrentMessage ); 
        } //else 
    } //if 
    return(ReturnCode); 
} 
 
#endif  // TRACING